| ►Njson11 | |
| CJson | |
| CJsonArray | |
| CJsonBoolean | |
| CJsonDouble | |
| CJsonInt | |
| CJsonNull | |
| CJsonObject | |
| CJsonString | |
| CJsonValue | |
| CNullStruct | |
| CStatics | |
| CValue | |
| ►Nsouffle | |
| ►Nast | |
| ►Nanalysis | |
| ►Ndetail | |
| Cdefault_bottom_factory | |
| Cdefault_meet_op | |
| Cset_meet_assign_op | A meet operator for set-based property spaces based on the sub-set lattices |
| ►CAlgebraicDataType | Aggregates types using sums and products |
| CBranch | |
| Call_type_factory | A factory for computing sets of types covering all potential types |
| CAnalysis | Abstract class for a AST Analysis |
| CAssignment | An assignment maps a list of variables to values of their respective property space |
| CAuxiliaryArityAnalysis | Determine the auxiliary arity for relations |
| CClauseNormalisationAnalysis | |
| CComponentLookupAnalysis | |
| CConstantType | Representing the type assigned to a constant |
| CConstraint | A generic base class for constraints on variables |
| CConstraintAnalysis | A base class for ConstraintAnalysis collecting constraints for an analysis by visiting every node of a given AST |
| CConstraintAnalysisVar | A variable type to be utilized by AST constraint analysis |
| CFunctorAnalysis | |
| CIOTypeAnalysis | |
| ►CNormalisedClause | |
| CNormalisedClauseElement | |
| CPolymorphicObjectsAnalysis | |
| CPrecedenceGraphAnalysis | Analysis pass computing the precedence graph of the relations of the datalog progam |
| CPrimitiveType | PrimitiveType = Number/Unsigned/Float/Symbol The class representing pre-built, concrete types |
| CProblem | A problem is a list of constraints for which a solution is desired |
| CProfileUseAnalysis | Analysis that loads profile data and has a profile query interface |
| Cproperty_space | A MPL type for defining a property space |
| CRecordType | A record type combining a list of fields into a new, aggregated type |
| CRecursiveClausesAnalysis | Analysis pass identifying clauses which are recursive |
| CRedundantRelationsAnalysis | Analysis pass identifying relations which do not contribute to the computation of the output relations |
| CRelationDetailCacheAnalysis | Analysis pass mapping identifiers with relations and clauses |
| CRelationScheduleAnalysis | Analysis pass computing a schedule for computing relations |
| CRelationScheduleAnalysisStep | A single step in a relation schedule, consisting of the relations computed in the step and the relations that are no longer required at that step |
| CSCCGraphAnalysis | Analysis pass computing the strongly connected component (SCC) graph for the datalog program |
| Cset_property_space | A property space for set-based properties based on sub-set lattices |
| Csub_type | An implementation of a meet operation between sets of types computing the set of pair-wise greatest common subtypes |
| CSubsetType | A type being a subset of another type |
| CSumTypeBranchesAnalysis | |
| CTopologicallySortedSCCGraphAnalysis | Analysis pass computing a topologically sorted strongly connected component (SCC) graph |
| CType | An abstract base class for types to be covered within a type environment |
| Ctype_lattice | The type lattice forming the property space for the Type analysis |
| CTypeAnalysis | |
| CTypeBinding | Class that encapsulates std::map of types binding that comes from .init c = Comp<MyType> Type binding in this example would be T->MyType if the component code is .comp Comp<T> .. |
| CTypeConstraintsAnalysis | Constraint analysis framework for types |
| CTypeEnvironment | A type environment is a set of types |
| CTypeEnvironmentAnalysis | |
| CTypeSet | A collection to represent sets of types |
| CTypeVisitor | A visitor for Types |
| CUnionType | A union type combining a list of types into a new, aggregated type |
| CVariable | A variable to be utilized within constraints to be handled by the constraint solver |
| CVisitOnceTypeVisitor | A visitor for types visiting each type only once (effectively breaking recursive cycles) |
| ►Ndetail | |
| Cis_ast_visitor | A type trait determining whether a given type is a visitor or not |
| Cis_ast_visitor< const T > | |
| Cis_ast_visitor< T & > | |
| CLambdaNodeMapper | A special NodeMapper wrapping a lambda conducting node transformations |
| CLambdaVisitor | A specialized visitor wrapping a lambda function – an auxiliary type required for visitor convenience functions |
| ►Ntransform | |
| CAddNullariesToAtomlessAggregatesTransformer | Transformation pass to add artificial nullary atom (+Tautology()) to aggregate bodies that have no atoms |
| CComponentChecker | |
| CComponentInstantiationTransformer | |
| CConditionalTransformer | Transformer that executes a sub-transformer iff a condition holds |
| CDebugReporter | Transformation pass which wraps another transformation pass and generates a debug report section for the stage after applying the wrapped transformer, and adds it to the translation unit's debug report |
| CExecutionPlanChecker | |
| CFixpointTransformer | Transformer that repeatedly executes a sub-transformer until no changes are made |
| CFoldAnonymousRecords | Transformation pass that removes (binary) constraints on the anonymous records |
| CGroundedTermsChecker | |
| CGroundWitnessesTransformer | Apply a grounding so that the witness of a selection aggregate (min/max) can be transferred to the outer scope |
| CInlineRelationsTransformer | Transformation pass to inline marked relations |
| CIOAttributesTransformer | Transformation pass to set attribute names and types in IO operations |
| CIODefaultsTransformer | Transformation pass to set defaults for IO operations |
| ►CMagicSetTransformer | Magic Set Transformation |
| CAdornDatabaseTransformer | Database adornment |
| ►CLabelDatabaseTransformer | Database labeller |
| CNegativeLabellingTransformer | Runs the first stage of the labelling algorithm |
| CPositiveLabellingTransformer | Runs the second stage of the labelling algorithm |
| CMagicSetCoreTransformer | Core section of the magic set transformer |
| CNormaliseDatabaseTransformer | Database normaliser for MST |
| CMaterializeAggregationQueriesTransformer | Transformation pass to create artificial relations for bodies of aggregation functions consisting of more than a single atom |
| CMaterializeSingletonAggregationTransformer | Replaces literals containing single-valued aggregates with a synthesised relation |
| CMetaTransformer | Transformer that coordinates other sub-transformations |
| CMinimiseProgramTransformer | Transformation pass to remove equivalent rules |
| CNameUnnamedVariablesTransformer | Transformation pass to replace unnamed variables with singletons |
| CNormaliseMultiResultFunctorsTransformer | Uniquely names all appearances of ranges |
| CNullableVector | |
| CNullTransformer | Transformer that does absolutely nothing |
| CPartitionBodyLiteralsTransformer | Transformation pass to move literals into new clauses if they are independent of remaining literals |
| CPipelineTransformer | Transformer that holds an arbitrary number of sub-transformations |
| CPragmaChecker | |
| CProvenanceTransformer | Transformation pass to add provenance information |
| CReduceExistentialsTransformer | Transformation pass to reduce unnecessary computation for relations that only appear in the form A(_,...,_) |
| CRemoveBooleanConstraintsTransformer | Transformation pass to remove constant boolean constraints Should be called after any transformation that may generate boolean constraints |
| CRemoveEmptyRelationsTransformer | Transformation pass to remove all empty relations and rules that use empty relations |
| CRemoveRedundantRelationsTransformer | Transformation pass to remove relations which are redundant (do not contribute to output) |
| CRemoveRedundantSumsTransformer | Transformation pass to remove expressions of the form sum k : { .. |
| CRemoveRelationCopiesTransformer | Transformation pass to replaces copy of relations by their origin |
| CReorderLiteralsTransformer | Transformation pass to reorder body literals |
| CReplaceSingletonVariablesTransformer | Transformation pass to replace singleton variables with unnamed variables |
| CResolveAliasesTransformer | Transformation pass to eliminate grounded aliases |
| CResolveAnonymousRecordAliasesTransformer | Transformer resolving aliases for anonymous records |
| CSemanticChecker | |
| CSemanticCheckerImpl | |
| CSimplifyAggregateTargetExpressionTransformer | Transformation pass to rename aggregation variables to make them unique |
| CTransformer | |
| CTypeChecker | |
| CTypeCheckerImpl | |
| CTypeDeclarationChecker | |
| CUniqueAggregationVariablesTransformer | Transformation pass to rename aggregation variables to make them unique |
| CWhileTransformer | Transformer that repeatedly executes a sub-transformer while a condition is met |
| CAggregator | Defines the aggregator class |
| CAlgebraicDataType | Combination of types using sums and products |
| CAllBoundSips | Goal: Prioritise atoms with all arguments bound |
| CArgument | An abstract class for arguments |
| Cast_visitor_tag | A tag type required for the is_ast_visitor type trait to identify AstVisitors |
| CAtom | An atom class |
| CAttribute | Attribute class |
| CBinaryConstraint | Binary constraint class |
| CBindingStore | |
| CBooleanConstraint | Boolean constraint class |
| CBranchDeclaration | Wrapper for the single branch declaration (product type) inside ADT declaration |
| CBranchInit | Initialization of ADT instance |
| CClause | Intermediate representation of a horn clause |
| CComponent | Component class |
| CComponentInit | Component initialization class |
| CComponentType | Component type of a component |
| CConstant | Abstract constant class |
| CConstraint | Abstract class for AST constraints |
| CCounter | Counter functor (incrementing a value after each invocation) |
| CDeltaInputSips | Goal: prioritise (1) all-bound, then (2) deltas, then (3) input, and then (4) left-most |
| CDeltaSips | Goal: prioritise (1) all-bound, then (2) deltas, and then (3) left-most |
| CDirective | Directive has a type (e.g. input/output/printsize/limitsize), qualified relation name, and a key value map for storing parameters of the directive |
| CExecutionOrder | An execution order for atoms within a clause; one or more execution orders form a plan |
| CExecutionPlan | |
| CFunctor | Abstract functor class |
| CFunctorDeclaration | User-defined functor declaration |
| CInputSips | Goal: prioritise (1) all-bound, then (2) input, and then (3) left-most |
| CIntrinsicFunctor | Intrinsic Functor class for functors are in-built |
| CLeastFreeSips | Goal: choose the atom with the least number of unbound arguments |
| CLeastFreeVarsSips | Goal: choose the atom with the least amount of unbound variables |
| CLiteral | Defines an abstract class for literals in a horn clause |
| CMaxBoundSips | Goal: prioritise (1) all-bound, then (2) max number of bound vars, then (3) left-most |
| CMaxRatioSips | Goal: prioritise max ratio of bound args |
| CNaiveSips | Goal: Prioritise (1) all bound, then (2) atoms with at least one bound argument, then (3) left-most |
| CNameComparison | Comparator for relations |
| CNegation | Negation of an atom negated atom |
| CNilConstant | Defines the nil constant |
| CNode | Abstract class for syntactic elements in an input program |
| CNodeMapper | An abstract class for manipulating AST Nodes by substitution |
| CNumericConstant | Numeric Constant |
| CPragma | Representation of a global option |
| CProfileUseSips | Goal: reorder based on the given profiling information Metric: cost(atom_R) = log(|atom_R|) * #free/#args |
| CProgram | The program class consists of relations, clauses and types |
| CProvenanceNegation | Subclass of Literal that represents a negated atom, * e.g., !parent(x,y) |
| CQualifiedName | Qualified Name class defines fully/partially qualified names to identify objects in components |
| CRecordInit | Defines a record initialization class |
| CRecordType | Record type class for record type declarations |
| CRelation | Defines a relation with a name, attributes, qualifiers, and internal representation |
| CSipsMetric | Class for SIPS cost-metric functions Each subclass represents a different heuristic used for evaluating the cost of choosing an atom next in the schedule |
| CStrictSips | Goal: Always choose the left-most atom |
| CStringConstant | String constant class |
| CSubroutineArgument | Defines the argument class for subrountines |
| CSubsetType | Defines subset type class |
| CTerm | Defines an abstract term class used for functors and other constructors |
| CTranslationUnit | Translation unit class for the translation pipeline |
| CType | An abstract base class for types |
| CTypeCast | Defines a type cast class for expressions |
| CUnionType | The union type class |
| CUnnamedVariable | Unnamed variable class |
| CUserDefinedFunctor | User-Defined functor class |
| CVariable | Named variable class |
| CVisitor | The generic base type of all AstVisitors realizing the dispatching of visitor calls |
| ►Nast2ram | |
| CAstToRamTranslator | Main class for the AST->RAM translator |
| CClauseTranslator | |
| CLocation | |
| CProvenanceClauseTranslator | |
| CValueIndex | |
| ►Ndetail | |
| ►Nbrie | |
| Cdefault_factory | A templated functor to obtain default values for unspecified elements of sparse array instances |
| Cdefault_merge | A operation to be utilized by the sparse map when merging elements associated to different values |
| Cfix_binding | A functor initializing an iterator upon creation to reference the first element exhibiting a given prefix within a given Trie |
| Cfix_binding< 0, Dim, Dim > | |
| Cfix_binding< 0, Pos, Dim > | |
| Cfix_first | A functor initializing an iterator upon creation to reference the first element in the associated Trie |
| Cfix_first< Dim, Dim > | |
| Cfix_first_nested | |
| Cfix_lower_bound | A functor initializing an iterator upon creation to reference the first element within a given Trie being not less than a given value |
| Cfix_upper_bound | A functor initializing an iterator upon creation to reference the first element within a given Trie being greater than a given value |
| Cforward_non_output_iterator_traits | |
| Cget_nested_iter_core | A functor extracting a reference to a nested iterator core from an enclosing iterator core |
| Cget_nested_iter_core< 0 > | |
| Cidentity | A functor representing the identity function |
| CSparseArrayIter | Iterator type for souffle::SparseArray |
| CSparseBitMapIter | Iterator type for souffle::SparseArray |
| ►CTrieBase | A base class for the Trie implementation allowing various specializations of the Trie template to inherit common functionality |
| Chint_statistics | |
| CTrieIterator | An iterator over the stored entries |
| ►CTrieTypes | |
| Citerator_core | |
| Cnested_trie_cloner | |
| Cnested_trie_merger | |
| Cop_context | |
| ►CTrieTypes< 1u > | |
| Citerator_core | The iterator core of this level contributing to the construction of a composed trie iterator |
| Cbinary | |
| Cbinary_search | A binary search strategy for looking up keys in b-tree nodes |
| ►Cbtree | The actual implementation of a b-tree data structure |
| Cbase | The base type of all node types containing essential book-keeping information |
| Cbtree_operation_hints | A collection of operation hints speeding up some of the involved operations by exploiting temporal locality |
| Chint_statistics | |
| Cinner_node | The data type representing inner nodes of the b-tree |
| Citerator | The iterator type to be utilized for scanning through btree instances |
| Cleaf_node | The data type representing leaf nodes of the b-tree |
| Cnode | The actual, generic node implementation covering the operations for both, inner and leaf nodes |
| Ccomparator | A generic comparator implementation as it is used by a b-tree based on types that can be less-than and equality comparable |
| Cdeclval< std::ostream & >()<< std::declval< T >()), void >::type > | A type trait to check whether a given type is printable |
| Cdefault_strategy | |
| Cdefault_strategy< int > | |
| Cdefault_strategy< std::tuple< Ts... > > | |
| Cis_printable | A type trait to check whether a given type is printable |
| Cjoined_sequence | A auxiliary class to be returned by the join function aggregating the information required to print a list of elements as well as the implementation of the printing itself |
| Clambda_traits_helper | |
| Clambda_traits_helper< R()> | |
| Clambda_traits_helper< R(A0)> | |
| Clambda_traits_helper< R(A0, A1)> | |
| Clambda_traits_helper< R(Args...)> | |
| Clambda_traits_helper< R(C::*)(Args...) const > | |
| Clambda_traits_helper< R(C::*)(Args...)> | |
| CLambdaBTree | The actual implementation of a b-tree data structure |
| Clinear | |
| Clinear_search | A linear search strategy for looking up keys in b-tree nodes |
| Cmultiplying_printer | A utility class required for the implementation of the times function |
| Cprint | A generic element printer |
| Csearch_strategy | A common base class for search strategies in b-trees |
| Cstrategy_selection | A template-meta class to select search strategies for b-trees depending on the key type |
| Cupdater | The default non-updater |
| ►Nevaluator | |
| ►Clxor_infix | |
| Ccurry | |
| ►Ngzfstream | |
| ►Ninternal | |
| Cgzfstream | |
| Cgzfstreambuf | |
| Cigzfstream | |
| Cogzfstream | |
| ►Ninterpreter | |
| ►Nindex_utils | A namespace enclosing utilities required by indices |
| Ccomparator | |
| Ccomparator< First, Rest... > | |
| Ccomparator<> | |
| Cextend | |
| Cextend< index< Columns... >, Col > | |
| Cget_full_index | |
| Cget_full_index< 0 > | |
| CAbstractParallel | Node that utilizes parallel execution should inherit from this class. Enable node with its own view context for parallel execution |
| CAggregate | |
| CAutoIncrement | |
| CBinaryNode | Binary node represents interpreter node with two children |
| CBinRelOperation | Operation that involves with two relations should inherit from this class. E.g. Swap, Extend |
| CBreak | |
| CCall | |
| CChoice | |
| CClear | |
| CCompoundNode | Compound node represents interpreter node with a list of children |
| CConditionalOperation | Encode a conditional operation for the interpreter node. E.g. Exit, Filter |
| CConjunction | |
| CConstant | |
| CConstraint | |
| CContext | Evaluation context for Interpreter operations |
| CDebugInfo | |
| CEmptinessCheck | |
| CEngine | This class translate the RAM Program into executable format and interpreter it |
| CEqrelIndex | For EqrelIndex we do inheritence since EqrelIndex only diff with one extra function |
| CEqrelRelation | |
| CExistenceCheck | |
| CExit | |
| CExtend | |
| CFalse | |
| CFilter | |
| Cindex | The index class is utilized as a template-meta-programming structure to specify and realize indices |
| ►CIndex | An index is an abstraction of a data structure |
| CView | A view on a relation caching local access patterns (not thread safe!) |
| ►CIndex< 0, Structure > | A partial specialize template for nullary indexes |
| Citerator | |
| CView | |
| CIndexAggregate | |
| CIndexChoice | |
| CIndexScan | |
| CIntrinsicOperator | |
| CIO | |
| CLogRelationTimer | |
| CLogSize | |
| CLogTimer | |
| CLoop | |
| CNegation | |
| CNestedIntrinsicOperator | |
| CNestedOperation | Encode a nested operation for the interpreter node. E.g. Loop, IndexScan |
| CNode | This is a shadow node for a ram::Node that is enriched for with local information so that the interpreter is executing quickly |
| ►CNodeGenerator | |
| COrderingContext | This class help generator reordering tuple access based on the index oder |
| COrder | An order to be enforced for storing tuples within indexes |
| CPackRecord | |
| CParallel | |
| CParallelAggregate | |
| CParallelChoice | |
| CParallelIndexAggregate | |
| CParallelIndexChoice | |
| CParallelIndexScan | |
| CParallelScan | |
| CProgInterface | Implementation of SouffleProgram interface for an interpreter instance |
| CProject | |
| CProvenanceExistenceCheck | |
| CProvenanceUpdater | |
| CQuery | |
| ►CRelation | A relation, composed of a collection of indexes |
| Citerator_base | |
| CRelationSize | |
| ►CRelationWrapper | Wrapper for InterpreterRelation |
| CIterator | The iterator interface |
| Citerator_base | A virtualized iterator class that can be used by the Proginterface |
| ►CRelInterface | Wrapper class for interpreter relations |
| Citerator_base | Iterator wrapper class |
| CScan | |
| CSequence | |
| CSubroutineArgument | |
| CSubroutineReturn | |
| CSuperInstruction | This class encodes information for a super-instruction, which is used to eliminate Number and TupleElement in index/project/existence operation |
| CSuperOperation | Node that utilizes the super instruction optimization should inherit from this class. E.g. ExistenceCheck, Project |
| CSwap | |
| CTrue | |
| CTupleElement | |
| CTupleOperation | |
| CUnaryNode | Unary node represents interpreter node with a single child |
| CUnpackRecord | |
| CUserDefinedOperator | |
| CViewContext | This class contains information for views (Hints) creation for ram::Query and ram::Parallel operation |
| CViewOperation | Operation that utilizes the index view from underlying relation should inherit from this class |
| CViewWrapper | A dummy wrapper for indexViews |
| ►Nprofile | |
| CAtom | |
| CCell | |
| CCell< double > | |
| CCell< long > | |
| CCell< std::chrono::microseconds > | |
| CCell< void > | |
| CCellInterface | |
| CCli | |
| CConfigProcessor | Config entry processor |
| CDataComparator | |
| CEventProcessor | Abstract Class for EventProcessor |
| CEventProcessorSingleton | Event Processor Singleton |
| CFrequencyAtomProcessor | Frequency Atom Processor |
| CHtmlGenerator | |
| CInputReader | |
| CIteration | |
| CNonRecursiveRelationNumberProcessor | Non-Recursive Relation Number Profile Event Processor |
| CNonRecursiveRelationTimingProcessor | Non-Recursive Relation Number Profile Event Processor |
| CNonRecursiveRuleNumberProcessor | Non-Recursive Rule Number Profile Event Processor |
| CNonRecursiveRuleTimingProcessor | Non-Recursive Rule Timing Profile Event Processor |
| COutputProcessor | |
| CProgramResourceUtilisationProcessor | Program Resource Utilisation Event Processor |
| CProgramRun | |
| CProgramRuntimeProcessor | Program Run Event Processor |
| CProgramTimepointProcessor | Program Run Event Processor |
| CReader | |
| CRecursiveRelationCopyTimingProcessor | Recursive Relation Copy Timing Profile Event Processor |
| CRecursiveRelationNumberProcessor | Recursive Relation Timing Profile Event Processor |
| CRecursiveRelationTimingProcessor | Recursive Relation Timing Profile Event Processor |
| CRecursiveRuleNumberProcessor | Recursive Rule Number Profile Event Processor |
| CRecursiveRuleTimingProcessor | Recursive Rule Timing Profile Event Processor |
| CRelation | |
| CRelationIOTimingProcessor | Recursive Relation Copy Timing Profile Event Processor |
| CRelationReadsProcessor | Reads Processor |
| CRow | |
| CRule | |
| CTable | |
| CTextProcessor | Text entry processor |
| ►CTui | |
| CUsage | |
| ►Nram | |
| ►Nanalysis | |
| ►Ntest | |
| CTestMaxMatching | |
| CAnalysis | Abstract class for a RAM Analysis |
| CComplexityAnalysis | A Ram Analysis for determining the number of relational operations in a condition / expression |
| CIndexAnalysis | |
| CLevelAnalysis | A Ram Analysis for determining the level of a expression/condition |
| CMaxMatching | |
| ►CMinIndexSelection | |
| CSearchComparator | |
| CRelationAnalysis | A RAM Analysis for finding relations by name |
| ►CSearchSignature | Search signature of a RAM operation; each bit represents an attribute of a relation |
| CHasher | |
| ►Ndetail | |
| Cis_ram_visitor | A type trait determining whether a given type is a visitor or not |
| Cis_ram_visitor< const T > | |
| Cis_ram_visitor< T & > | |
| CLambdaVisitor | A specialized visitor wrapping a lambda function – an auxiliary type required for visitor convenience functions |
| ►Ntransform | |
| CChoiceConversionTransformer | Convert (Scan/If)/(IndexScan/If) operaitons to (Choice)/(IndexChoice) operations |
| CCollapseFiltersTransformer | Transforms consecutive filters into a single filter containing a conjunction |
| CConditionalTransformer | @Class ConditionalTransformer @Brief Composite conditional transformer |
| CEliminateDuplicatesTransformer | Eliminates duplicated conjunctive terms |
| CExpandFilterTransformer | Transforms Conjunctions into consecutive filter operations |
| CHoistAggregateTransformer | |
| CHoistConditionsTransformer | Hosts conditions in a loop-nest to the most-outer/semantically-correct loop |
| CIfConversionTransformer | Convert IndexScan operations to Filter/Existence Checks |
| CIndexedInequalityTransformer | Removes Inequalities from Indexed Operations and replaces them with a Filter Operation and empty Indexed Operations are coverted to their Non-Indexed semantic equivalent |
| CLoopTransformer | @Class LoopTransformer @Brief Composite loop transformer |
| CMakeIndexTransformer | Make indexable operations to indexed operations |
| CMetaTransformer | @Class MetaTransformer @Brief Abstract class to identifier meta transformer |
| CParallelTransformer | Transforms Choice/IndexChoice/IndexScan/Scan into parallel versions |
| CReorderConditionsTransformer | Reorders conjunctive terms depending on cost, i.e., cheap terms should be executed first |
| CReorderFilterBreak | |
| CReportIndexTransformer | |
| CTransformer | @Class Transformer @Brief abstract transformer class for a translation unit |
| CTransformerSequence | @Class TransformerSequence @Brief Composite sequence transformer |
| CTupleIdTransformer | Ordering tupleIds in TupleOperation operations correctly |
| CAbstractAggregate | Abstract class for aggregation |
| CAbstractChoice | Abstract class for a choice operation |
| CAbstractConditional | Abstract conditional statement |
| CAbstractExistenceCheck | Abstract existence check for a tuple in a relation |
| CAbstractLog | Abstract class for logging |
| CAbstractOperator | Abstract class for an operator/functor |
| CAbstractParallel | Abstract class for parallel operation |
| CAggregate | Aggregation function applied on some relation |
| CAutoIncrement | Increment a counter and return its value |
| CBinRelationStatement | Abstract class for a binary relation |
| CBreak | Breaks out of the loop if a condition holds |
| CCall | Call a subroutine |
| CChoice | Find a tuple in a relation such that a given condition holds |
| CClear | Delete tuples of a relation |
| CCondition | Abstract class for conditions and boolean values in RAM |
| CConjunction | A conjunction of conditions |
| CConstant | Represents a Ram Constant |
| CConstraint | Evaluates a binary constraint with respect to two Expressions |
| CDebugInfo | Debug statement |
| CEmptinessCheck | Emptiness check for a relation |
| CExistenceCheck | Existence check for a tuple(-pattern) in a relation |
| CExit | Exit statement for a loop |
| CExpression | Abstract class for describing scalar values in RAM |
| CExtend | Extend equivalence relation |
| CFalse | |
| CFilter | Checks whether a given condition holds |
| CFloatConstant | Represents a float constant |
| CIndexAggregate | Indexed aggregation on a relation. The index allows us to iterate over a restricted range |
| CIndexChoice | Use an index to find a tuple in a relation such that a given condition holds |
| CIndexOperation | |
| CIndexScan | Search for tuples of a relation matching a criteria |
| CIntrinsicOperator | Operator that represents an intrinsic (built-in) functor |
| CIO | I/O statement for a relation |
| CLambdaNodeMapper | A special NodeMapper wrapping a lambda conducting node transformations |
| CListStatement | Abstract class for a list of RAM statements |
| CLogRelationTimer | Execution time logger for a statement |
| CLogSize | Log relation size and a logging message |
| CLogTimer | Execution time logger for a statement |
| CLoop | Execute statement until statement terminates loop via an exit statement |
| CNegation | Negates a given condition |
| CNestedIntrinsicOperator | Effectively identical to IntrinsicOperator, except it can produce multiple results |
| CNestedOperation | Abstract class for a nesting operations in a loop-nest |
| CNode | Node is a superclass for all RAM IR classes |
| CNodeMapper | An abstract class for manipulating RAM Nodes by substitution |
| COperation | Abstract class for a relational algebra operation |
| CPackRecord | Packs a record's arguments into a reference |
| CParallel | Parallel block of statements |
| CParallelAggregate | Parallel Aggregation function applied on some relation |
| CParallelChoice | Find a tuple in a relation such that a given condition holds in parallel |
| CParallelIndexAggregate | Aggregate over values of a relation using an index in parallel |
| CParallelIndexChoice | Use an index to find a tuple in a relation such that a given condition holds in parallel |
| CParallelIndexScan | Search for tuples of a relation matching a criteria |
| CParallelScan | Iterate all tuples of a relation in parallel |
| CProgram | RAM program relation declaration and functions |
| CProject | Project a result into the target relation |
| CProvenanceExistenceCheck | Provenance Existence check for a relation |
| CQuery | A relational algebra query |
| Cram_visitor_tag | A tag type required for the is_ram_visitor type trait to identify RamVisitors |
| CRelation | An abstract class for performing indexed operations |
| CRelationOperation | Abstract class for operations on relations |
| CRelationSize | Returns the numbers of tuples in a relation |
| CRelationStatement | RAM Statements with a single relation |
| CScan | Iterate all tuples of a relation |
| CSequence | Sequence of RAM statements |
| CSignedConstant | Represents a signed constant |
| CStatement | Abstract class for RAM statements |
| CSubroutineArgument | Access argument of a subroutine |
| CSubroutineReturn | A statement for returning from a ram subroutine |
| CSwap | Swap operation with respect to two relations |
| CTestAutoIndex | |
| CTranslationUnit | Translating a RAM program |
| CTrue | False value condition |
| CTupleElement | Access element from the current tuple in a tuple environment |
| CTupleOperation | Abstract class for relation searches and lookups |
| CUndefValue | An undefined expression |
| CUnpackRecord | Record lookup |
| CUnsignedConstant | Represents a unsigned constant |
| CUserDefinedOperator | Operator that represents an extrinsic (user-defined) functor |
| CVisitor | The generic base type of all RamVisitors realizing the dispatching of visitor calls |
| ►Nsynthesiser | Souffle - A Datalog Compiler Copyright (c) 2013, 2015, Oracle and/or its affiliates |
| CBrieRelation | |
| CDirectRelation | |
| CEqrelRelation | |
| CIndirectRelation | |
| CInfoRelation | |
| CNullaryRelation | |
| CRelation | |
| CSynthesiser | A RAM synthesiser: synthesises a C++ program from a RAM program |
| ►Ntest | |
| Creserver | |
| Creserver< std::unordered_set< A, B, C, D > > | |
| CBaseTable | |
| Cbtree_multiset | A b-tree based multi-set implementation |
| Cbtree_set | A b-tree based set implementation |
| CCacheAccessCounter | Cache hits/misses |
| CCmdOptions | A utility class for parsing command line arguments within generated query programs |
| Ccomp_deref | A functor class supporting the values pointers are pointing to |
| CConstConstraint | Constant constraints for values in query command |
| CDebugReport | Class representing a HTML report, consisting of a list of sections |
| CDebugReportSection | Class representing a section of a HTML report |
| Cderef | A functor dereferencing a given type |
| Cderef_less | A functor comparing the dereferenced value of a pointer type utilizing a given comparator |
| CDiagnostic | |
| CDiagnosticMessage | |
| CDisjointSet | Structure that emulates a Disjoint Set, i.e |
| CEqrelMapComparator | |
| CEquivalence | Equivalence class for variables in query command |
| ►CEquivalenceRelation | |
| Citerator | |
| Coperation_hints | A collection of operation hints speeding up some of the involved operations by exploiting temporal locality |
| CErrorReport | |
| CExplain | |
| CExplainConfig | |
| CExplainProvenance | |
| CExplainProvenanceImpl | |
| CGlobal | |
| CGraph | A simple graph structure for graph-based operations |
| Cid | A functor representing the identity function for a generic type T |
| CInnerNode | |
| CIntrinsicFunctorInfo | |
| CIOSystem | |
| CIsPtrLike | |
| CIsPtrLike< Own< A > > | |
| CIsPtrLike< std::shared_ptr< A > > | |
| CIsPtrLike< std::weak_ptr< A > > | |
| CIterDerefWrapper | A wrapper for an iterator obtaining pointers of a certain type, dereferencing values before forwarding them to the consumer |
| Clambda_traits | A type trait enabling the deduction of type properties of lambdas |
| CLambdaBTreeSet | A b-tree based set implementation |
| CLeafNode | |
| ►CLock | A small utility class for implementing simple locks |
| CLease | |
| CLogger | The class utilized to times for the souffle profiling tool |
| CLogStatement | |
| CLRUCache | An Least-Recently-Used cache for arbitrary element types |
| CLRUCache< T, 0 > | |
| CLRUCache< T, 1 > | |
| CMainConfig | |
| CMainOption | |
| ►COptimisticReadWriteLock | A 'sequential' non-locking implementation for an optimistic r/w lock |
| CLease | |
| CParserDriver | |
| ►CPiggyList | |
| Citerator | |
| Cprint_deref | A functor printing elements after dereferencing it |
| ►CProfileEventSingleton | Profile Event Singleton |
| CProfileTimer | Profile Timer |
| CProgramFactory | Abstract program factory class |
| CRandomInsertPiggyList | A PiggyList that allows insertAt functionality |
| Crange | A utility class enabling representation of ranges by pairing two iterator instances marking lower and upper boundaries |
| CReadCinCSVFactory | |
| CReadCinJSONFactory | |
| CReadFileCSV | |
| CReadFileCSVFactory | |
| CReadFileJSON | |
| CReadFileJSONFactory | |
| CReadSQLiteFactory | |
| CReadStream | |
| CReadStreamCSV | |
| CReadStreamFactory | |
| CReadStreamJSON | |
| CReadStreamSQLite | |
| CReadWriteLock | |
| ►CRecordMap | Bidirectional mappping between records and record references |
| CRecordHash | Hash function for unordered record map |
| CRecordTable | |
| ►CRelation | Object-oriented wrapper class for Souffle's templatized relations |
| Citerator | Wrapper class for abstract iterator |
| Citerator_base | Abstract iterator class |
| ►CRelationWrapper | Relation wrapper used internally in the generated Datalog program |
| Citerator_wrapper | |
| Creverse | Use to range-for iterate in reverse |
| ►CRuleBody | |
| Cliteral | |
| Cscanner_data | |
| CScreenBuffer | |
| CSerialisationStream | |
| CSignalHandler | Class SignalHandler captures signals and reports the context where the signal occurs |
| CSingleValueIterator | An iterator to be utilized if there is only a single element to iterate over |
| ►CSouffleProgram | Abstract base class for generated Datalog programs |
| Ctuple_insert | Helper function for the wrapper function Relation::insert() and Relation::contains() |
| Ctuple_insert< Tuple, 1 > | Helper function for the wrapper function Relation::insert() and Relation::contains() for the first element of the tuple |
| ►CSparseArray | A sparse array simulates an array associating to every element of uint32_t an element of a generic type T |
| CCell | The value stored in a single cell of a inner or leaf node |
| CFirstInfoSnapshot | A struct summarizing the state of the first node reference |
| CNode | The node type of the internally maintained tree |
| Cop_context | A struct to be utilized as a local, temporal context by client code to speed up the execution of various operations (optional parameter) |
| CRootInfo | A struct describing all the information required by the container class to manage the wrapped up tree |
| CRootInfoSnapshot | A struct to cover a snapshot of the root node state |
| ►CSparseBitMap | A sparse bit-map is a bit map virtually assigning a bit value to every value if the uint32_t domain |
| Cmerge_op | |
| CSparseDisjointSet | |
| CSpinLock | A 'sequential' non-locking implementation for a spin lock |
| ►CSrcLocation | A class describing a range in an input file |
| CPoint | A class locating a single point in an input file |
| CSymbolTable | |
| ►Ct_info | Info relations |
| Ccontext | |
| Citerator | |
| ►Ct_nullaries | Nullary relations |
| Ccontext | |
| Citerator | |
| ►CTable | |
| CBlock | |
| Citerator | |
| CTempFileStream | |
| CTreeNode | |
| CTrie | |
| CTrie< 1u > | A template specialization for tries representing a set |
| Ctuple | Defines a tuple for the OO interface such that relations with varying columns can be accessed |
| CWriteCoutCSV | |
| CWriteCoutCSVFactory | |
| CWriteCoutJSON | |
| CWriteCoutJSONFactory | |
| CWriteCoutPrintSize | |
| CWriteCoutPrintSizeFactory | |
| CWriteFileCSV | |
| CWriteFileCSVFactory | |
| CWriteFileJSON | |
| CWriteFileJSONFactory | |
| CWriteSQLiteFactory | |
| CWriteStream | |
| CWriteStreamCSV | |
| CWriteStreamFactory | |
| CWriteStreamJSON | |
| CWriteStreamSQLite | |
| ►Nstd | |
| Chash< tuple< A, B > > | |
| Citerator_traits< SparseArrayIter< A > > | |
| Citerator_traits< SparseBitMapIter< A > > | |
| Citerator_traits< TrieIterator< A, IterCore > > | |
| ►NTCB_SPAN_NAMESPACE_NAME | |
| ►Ndetail | |
| Chas_size_and_data | |
| Chas_size_and_data< T, void_t< decltype(detail::size(std::declval< T >())), decltype(detail::data(std::declval< T >()))> > | |
| Cis_complete | |
| Cis_complete< T, decltype(sizeof(T))> | |
| Cis_container | |
| Cis_container_element_type_compatible | |
| Cis_container_element_type_compatible< T, E, typename std::enable_if< !std::is_same< typename std::remove_cv< decltype(detail::data(std::declval< T >()))>::type, void >::value >::type > | |
| Cis_span | |
| Cis_span< span< T, S > > | |
| Cis_std_array | |
| Cis_std_array< std::array< T, N > > | |
| Cspan_storage | |
| Cspan_storage< E, dynamic_extent > | |
| Cspan | |
| ►Ntinyformat | |
| ►Ndetail | |
| CconvertToInt | |
| CconvertToInt< T, true > | |
| CFormatArg | |
| CFormatListN | |
| CFormatListN< 0 > | |
| CformatValueAsType | |
| CformatValueAsType< T, fmtT, true > | |
| ►Cis_convertible | |
| Cfail | |
| Csucceed | |
| Cis_wchar | |
| Cis_wchar< const wchar_t * > | |
| Cis_wchar< const wchar_t[n]> | |
| Cis_wchar< wchar_t * > | |
| Cis_wchar< wchar_t[n]> | |
| CFormatList | List of template arguments format(), held in a type-opaque way |
| CDefines | ExecutionPlan |
| Cforward_non_output_iterator_traits | |
| CHoistAggregatesTransformer | Pushes one Aggregate as far up the loop nest as possible |
| Citerator_base | |
| CRamIndexAnalyis | |
| CReorderBreak | Reorder filter-break nesting to a break-filter nesting |
| CReportIndexSetsTransformer | Does not transform the program but reports on the index sets if the debug-report flag is enabled |
| CSWIGSouffleProgram | Abstract base class for generated Datalog programs |
| ►CTestCase | |
| Ctest_result | Checks condition |
| CTypeAttribute | Type attribute class |
