OILS / vendor / souffle / CompiledSouffle.h View on Github | oilshell.org

158 lines, 102 significant
1/*
2 * Souffle - A Datalog Compiler
3 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved
4 * Licensed under the Universal Permissive License v 1.0 as shown at:
5 * - https://opensource.org/licenses/UPL
6 * - <souffle root>/licenses/SOUFFLE-UPL.txt
7 */
8
9/************************************************************************
10 *
11 * @file CompiledSouffle.h
12 *
13 * Main include file for generated C++ classes of Souffle
14 *
15 ***********************************************************************/
16
17#pragma once
18
19#include "souffle/RamTypes.h"
20#include "souffle/RecordTable.h"
21#include "souffle/SignalHandler.h"
22#include "souffle/SouffleInterface.h"
23#include "souffle/SymbolTable.h"
24#include "souffle/datastructure/BTreeDelete.h"
25#include "souffle/datastructure/Brie.h"
26#include "souffle/datastructure/ConcurrentCache.h"
27#include "souffle/datastructure/EqRel.h"
28#include "souffle/datastructure/Info.h"
29#include "souffle/datastructure/Nullaries.h"
30#include "souffle/datastructure/RecordTableImpl.h"
31#include "souffle/datastructure/SymbolTableImpl.h"
32#include "souffle/datastructure/Table.h"
33#include "souffle/io/IOSystem.h"
34#include "souffle/io/WriteStream.h"
35#include "souffle/utility/EvaluatorUtil.h"
36
37#if defined(_OPENMP)
38#include <omp.h>
39#endif
40
41namespace souffle {
42
43extern "C" {
44inline souffle::SouffleProgram* getInstance(const char* p) {
45 return souffle::ProgramFactory::newInstance(p);
46}
47}
48
49/**
50 * Relation wrapper used internally in the generated Datalog program
51 */
52template <class RelType>
53class RelationWrapper : public souffle::Relation {
54public:
55 static constexpr arity_type Arity = RelType::Arity;
56 using TupleType = Tuple<RamDomain, Arity>;
57 using AttrStrSeq = std::array<const char*, Arity>;
58
59private:
60 RelType& relation;
61 SouffleProgram& program;
62 std::string name;
63 AttrStrSeq attrTypes;
64 AttrStrSeq attrNames;
65 const uint32_t id;
66 const arity_type numAuxAttribs;
67
68 // NB: internal wrapper. does not satisfy the `iterator` concept.
69 class iterator_wrapper : public iterator_base {
70 typename RelType::iterator it;
71 const Relation* relation;
72 tuple t;
73
74 public:
75 iterator_wrapper(uint32_t arg_id, const Relation* rel, typename RelType::iterator arg_it)
76 : iterator_base(arg_id), it(std::move(arg_it)), relation(rel), t(rel) {}
77 void operator++() override {
78 ++it;
79 }
80 tuple& operator*() override {
81 auto&& value = *it;
82 t.rewind();
83 for (std::size_t i = 0; i < Arity; i++)
84 t[i] = value[i];
85 return t;
86 }
87 iterator_base* clone() const override {
88 return new iterator_wrapper(*this);
89 }
90
91 protected:
92 bool equal(const iterator_base& o) const override {
93 const auto& casted = asAssert<iterator_wrapper>(o);
94 return it == casted.it;
95 }
96 };
97
98public:
99 RelationWrapper(uint32_t id, RelType& r, SouffleProgram& p, std::string name, const AttrStrSeq& t,
100 const AttrStrSeq& n, arity_type numAuxAttribs)
101 : relation(r), program(p), name(std::move(name)), attrTypes(t), attrNames(n), id(id),
102 numAuxAttribs(numAuxAttribs) {}
103
104 iterator begin() const override {
105 return iterator(mk<iterator_wrapper>(id, this, relation.begin()));
106 }
107 iterator end() const override {
108 return iterator(mk<iterator_wrapper>(id, this, relation.end()));
109 }
110
111 void insert(const tuple& arg) override {
112 TupleType t;
113 assert(&arg.getRelation() == this && "wrong relation");
114 assert(arg.size() == Arity && "wrong tuple arity");
115 for (std::size_t i = 0; i < Arity; i++) {
116 t[i] = arg[i];
117 }
118 relation.insert(t);
119 }
120 bool contains(const tuple& arg) const override {
121 TupleType t;
122 assert(arg.size() == Arity && "wrong tuple arity");
123 for (std::size_t i = 0; i < Arity; i++) {
124 t[i] = arg[i];
125 }
126 return relation.contains(t);
127 }
128 std::size_t size() const override {
129 return relation.size();
130 }
131 std::string getName() const override {
132 return name;
133 }
134 const char* getAttrType(std::size_t arg) const override {
135 assert(arg < Arity && "attribute out of bound");
136 return attrTypes[arg];
137 }
138 const char* getAttrName(std::size_t arg) const override {
139 assert(arg < Arity && "attribute out of bound");
140 return attrNames[arg];
141 }
142 arity_type getArity() const override {
143 return Arity;
144 }
145 arity_type getAuxiliaryArity() const override {
146 return numAuxAttribs;
147 }
148 SymbolTable& getSymbolTable() const override {
149 return program.getSymbolTable();
150 }
151
152 /** Eliminate all the tuples in relation*/
153 void purge() override {
154 relation.purge();
155 }
156};
157
158} // namespace souffle