| ►Csouffle::ram::AbstractAggregate | Abstract class for aggregation |
| ►Csouffle::ram::Aggregate | Aggregation function applied on some relation |
| Csouffle::ram::ParallelAggregate | Parallel Aggregation function applied on some relation |
| ►Csouffle::ram::IndexAggregate | Indexed aggregation on a relation. The index allows us to iterate over a restricted range |
| Csouffle::ram::ParallelIndexAggregate | Aggregate over values of a relation using an index in parallel |
| ►Csouffle::ram::AbstractChoice | Abstract class for a choice operation |
| ►Csouffle::ram::Choice | Find a tuple in a relation such that a given condition holds |
| Csouffle::ram::ParallelChoice | Find a tuple in a relation such that a given condition holds in parallel |
| ►Csouffle::ram::IndexChoice | Use an index to find a tuple in a relation such that a given condition holds |
| Csouffle::ram::ParallelIndexChoice | Use an index to find a tuple in a relation such that a given condition holds in parallel |
| ►Csouffle::ram::AbstractLog | Abstract class for logging |
| Csouffle::ram::DebugInfo | Debug statement |
| Csouffle::ram::LogRelationTimer | Execution time logger for a statement |
| Csouffle::ram::LogTimer | Execution time logger for a statement |
| ►Csouffle::ram::AbstractParallel | Abstract class for parallel operation |
| Csouffle::ram::ParallelAggregate | Parallel Aggregation function applied on some relation |
| Csouffle::ram::ParallelChoice | Find a tuple in a relation such that a given condition holds in parallel |
| Csouffle::ram::ParallelIndexAggregate | Aggregate over values of a relation using an index in parallel |
| Csouffle::ram::ParallelIndexChoice | Use an index to find a tuple in a relation such that a given condition holds in parallel |
| Csouffle::ram::ParallelIndexScan | Search for tuples of a relation matching a criteria |
| Csouffle::ram::ParallelScan | Iterate all tuples of a relation in parallel |
| ►Csouffle::interpreter::AbstractParallel | Node that utilizes parallel execution should inherit from this class. Enable node with its own view context for parallel execution |
| Csouffle::interpreter::ParallelAggregate | |
| Csouffle::interpreter::ParallelChoice | |
| Csouffle::interpreter::ParallelIndexAggregate | |
| Csouffle::interpreter::ParallelIndexChoice | |
| Csouffle::interpreter::ParallelIndexScan | |
| Csouffle::interpreter::ParallelScan | |
| Csouffle::interpreter::Query | |
| Csouffle::ast::analysis::all_type_factory | A factory for computing sets of types covering all potential types |
| ►Csouffle::ram::analysis::Analysis | Abstract class for a RAM Analysis |
| Csouffle::ram::analysis::ComplexityAnalysis | A Ram Analysis for determining the number of relational operations in a condition / expression |
| Csouffle::ram::analysis::IndexAnalysis | |
| Csouffle::ram::analysis::LevelAnalysis | A Ram Analysis for determining the level of a expression/condition |
| Csouffle::ram::analysis::RelationAnalysis | A RAM Analysis for finding relations by name |
| ►Csouffle::ast::analysis::Analysis | Abstract class for a AST Analysis |
| Csouffle::ast::analysis::AuxiliaryArityAnalysis | Determine the auxiliary arity for relations |
| Csouffle::ast::analysis::ClauseNormalisationAnalysis | |
| Csouffle::ast::analysis::ComponentLookupAnalysis | |
| Csouffle::ast::analysis::FunctorAnalysis | |
| Csouffle::ast::analysis::IOTypeAnalysis | |
| Csouffle::ast::analysis::PolymorphicObjectsAnalysis | |
| Csouffle::ast::analysis::PrecedenceGraphAnalysis | Analysis pass computing the precedence graph of the relations of the datalog progam |
| Csouffle::ast::analysis::ProfileUseAnalysis | Analysis that loads profile data and has a profile query interface |
| Csouffle::ast::analysis::RecursiveClausesAnalysis | Analysis pass identifying clauses which are recursive |
| Csouffle::ast::analysis::RedundantRelationsAnalysis | Analysis pass identifying relations which do not contribute to the computation of the output relations |
| Csouffle::ast::analysis::RelationDetailCacheAnalysis | Analysis pass mapping identifiers with relations and clauses |
| Csouffle::ast::analysis::RelationScheduleAnalysis | Analysis pass computing a schedule for computing relations |
| Csouffle::ast::analysis::SCCGraphAnalysis | Analysis pass computing the strongly connected component (SCC) graph for the datalog program |
| Csouffle::ast::analysis::SumTypeBranchesAnalysis | |
| Csouffle::ast::analysis::TopologicallySortedSCCGraphAnalysis | Analysis pass computing a topologically sorted strongly connected component (SCC) graph |
| Csouffle::ast::analysis::TypeAnalysis | |
| Csouffle::ast::analysis::TypeEnvironmentAnalysis | |
| Csouffle::ast::analysis::Assignment< Var > | An assignment maps a list of variables to values of their respective property space |
| Csouffle::ast::analysis::Assignment< AnalysisVar > | |
| Csouffle::ast::analysis::Assignment< TypeVar > | |
| ►Csouffle::ast::ast_visitor_tag | A tag type required for the is_ast_visitor type trait to identify AstVisitors |
| Csouffle::ast::Visitor< R, Params > | The generic base type of all AstVisitors realizing the dispatching of visitor calls |
| ►Csouffle::ast::Visitor< void > | |
| ►Csouffle::ast::analysis::ConstraintAnalysis< TypeVar > | |
| Csouffle::ast::analysis::TypeConstraintsAnalysis | Constraint analysis framework for types |
| Csouffle::ast::analysis::ConstraintAnalysis< AnalysisVar > | A base class for ConstraintAnalysis collecting constraints for an analysis by visiting every node of a given AST |
| Csouffle::ast::detail::LambdaVisitor< R, N > | A specialized visitor wrapping a lambda function – an auxiliary type required for visitor convenience functions |
| Csouffle::ast::transform::TypeCheckerImpl | |
| Csouffle::ast2ram::AstToRamTranslator | Main class for the AST->RAM translator |
| Csouffle::profile::Atom | |
| ►Csouffle::detail::btree< Key, Comparator, Allocator, blockSize, SearchStrategy, isSet, WeakComparator, Updater >::base | The base type of all node types containing essential book-keeping information |
| ►Csouffle::detail::btree< Key, Comparator, Allocator, blockSize, SearchStrategy, isSet, WeakComparator, Updater >::node | The actual, generic node implementation covering the operations for both, inner and leaf nodes |
| Csouffle::detail::btree< Key, Comparator, Allocator, blockSize, SearchStrategy, isSet, WeakComparator, Updater >::inner_node | The data type representing inner nodes of the b-tree |
| Csouffle::detail::btree< Key, Comparator, Allocator, blockSize, SearchStrategy, isSet, WeakComparator, Updater >::leaf_node | The data type representing leaf nodes of the b-tree |
| Csouffle::BaseTable< K, V > | |
| ►Csouffle::BaseTable< std::string, std::string > | |
| Csouffle::MainConfig | |
| Csouffle::ast::BindingStore | |
| ►Csouffle::interpreter::BinRelOperation | Operation that involves with two relations should inherit from this class. E.g. Swap, Extend |
| Csouffle::interpreter::Extend | |
| Csouffle::interpreter::Swap | |
| Csouffle::Table< T, blockSize >::Block | |
| Csouffle::ast::analysis::AlgebraicDataType::Branch | |
| Csouffle::detail::btree< Key, Comparator, Allocator, blockSize, SearchStrategy, isSet, WeakComparator, Updater > | The actual implementation of a b-tree data structure |
| ►Csouffle::detail::btree< Key, Comparator, Allocator, blockSize, SearchStrategy, isSet, Comparator, detail::updater< Key > > | |
| Csouffle::detail::LambdaBTree< Key, Comparator, Allocator, blockSize, SearchStrategy, isSet, Functor, WeakComparator, Updater > | The actual implementation of a b-tree data structure |
| ►Csouffle::detail::btree< Key, detail::comparator< Key >, std::allocator< Key >, 256, typename souffle::detail::default_strategy< Key >::type, false, detail::comparator< Key >, souffle::detail::updater< Key > > | |
| Csouffle::btree_multiset< Key, Comparator, Allocator, blockSize, SearchStrategy, WeakComparator, Updater > | A b-tree based multi-set implementation |
| ►Csouffle::detail::btree< Key, detail::comparator< Key >, std::allocator< Key >, 256, typename souffle::detail::default_strategy< Key >::type, true, detail::comparator< Key >, souffle::detail::updater< Key > > | |
| Csouffle::btree_set< Key, Comparator, Allocator, blockSize, SearchStrategy, WeakComparator, Updater > | A b-tree based set implementation |
| ►Csouffle::detail::btree< Key, detail::comparator< Key >, std::allocator< Key >, blockSize, typename detail::default_strategy< Key >::type, isSet, detail::comparator< Key >, detail::updater< Key > > | |
| ►Csouffle::detail::LambdaBTree< Key, detail::comparator< Key >, std::allocator< Key >, 256, typename detail::default_strategy< Key >::type, true, Functor > | |
| Csouffle::LambdaBTreeSet< Key, Functor, Comparator, Allocator, blockSize, SearchStrategy > | A b-tree based set implementation |
| ►Csouffle::detail::btree< PairStore, EqrelMapComparator< PairStore >, std::allocator< PairStore >, blockSize, typename detail::default_strategy< PairStore >::type, isSet, EqrelMapComparator< PairStore >, detail::updater< PairStore > > | |
| ►Csouffle::detail::LambdaBTree< PairStore, EqrelMapComparator< PairStore >, std::allocator< PairStore >, 256, typename detail::default_strategy< PairStore >::type, true, std::function< parent_t(PairStore &)> > | |
| Csouffle::LambdaBTreeSet< PairStore, std::function< parent_t(PairStore &)>, EqrelMapComparator< PairStore > > | |
| ►Csouffle::detail::btree< StorePair, souffle::EqrelMapComparator< StorePair >, std::allocator< StorePair >, blockSize, typename detail::default_strategy< StorePair >::type, isSet, souffle::EqrelMapComparator< StorePair >, detail::updater< StorePair > > | |
| ►Csouffle::detail::LambdaBTree< StorePair, souffle::EqrelMapComparator< StorePair >, std::allocator< StorePair >, 256, typename detail::default_strategy< StorePair >::type, true, std::function< StatesBucket(StorePair &)> > | |
| Csouffle::LambdaBTreeSet< StorePair, std::function< StatesBucket(StorePair &)>, souffle::EqrelMapComparator< StorePair > > | |
| Csouffle::detail::btree< Key, Comparator, Allocator, blockSize, SearchStrategy, isSet, WeakComparator, Updater >::btree_operation_hints< size > | A collection of operation hints speeding up some of the involved operations by exploiting temporal locality |
| Csouffle::CacheAccessCounter | Cache hits/misses |
| Csouffle::SparseArray< T, BITS, merge_op, copy_op >::Cell | The value stored in a single cell of a inner or leaf node |
| ►Csouffle::profile::CellInterface | |
| Csouffle::profile::Cell< T > | |
| Csouffle::profile::Cell< double > | |
| Csouffle::profile::Cell< long > | |
| Csouffle::profile::Cell< std::chrono::microseconds > | |
| Csouffle::profile::Cell< void > | |
| ►Csouffle::ast2ram::ClauseTranslator | |
| Csouffle::ast2ram::ProvenanceClauseTranslator | |
| Csouffle::profile::Cli | |
| Csouffle::CmdOptions | A utility class for parsing command line arguments within generated query programs |
| Csouffle::comp_deref< T > | A functor class supporting the values pointers are pointing to |
| Csouffle::interpreter::index_utils::comparator< Columns > | |
| Csouffle::detail::comparator< T > | A generic comparator implementation as it is used by a b-tree based on types that can be less-than and equality comparable |
| Csouffle::interpreter::index_utils::comparator< First, Rest... > | |
| Csouffle::detail::comparator< Key > | |
| Csouffle::interpreter::index_utils::comparator<> | |
| ►Csouffle::interpreter::ConditionalOperation | Encode a conditional operation for the interpreter node. E.g. Exit, Filter |
| ►Csouffle::interpreter::Aggregate | |
| ►Csouffle::interpreter::IndexAggregate | |
| Csouffle::interpreter::ParallelIndexAggregate | |
| Csouffle::interpreter::ParallelAggregate | |
| Csouffle::interpreter::Break | |
| ►Csouffle::interpreter::Choice | |
| ►Csouffle::interpreter::IndexChoice | |
| Csouffle::interpreter::ParallelIndexChoice | |
| Csouffle::interpreter::ParallelChoice | |
| Csouffle::interpreter::Filter | |
| Csouffle::ConstConstraint | Constant constraints for values in query command |
| ►Csouffle::ast::analysis::Constraint< Var > | A generic base class for constraints on variables |
| Csouffle::ast::BinaryConstraint | Binary constraint class |
| Csouffle::ast::BooleanConstraint | Boolean constraint class |
| Csouffle::t_nullaries::context | |
| Csouffle::t_info< Arity_ >::context | |
| Csouffle::interpreter::Context | Evaluation context for Interpreter operations |
| Ctinyformat::detail::convertToInt< T, convertible > | |
| Ctinyformat::detail::convertToInt< T, true > | |
| Csouffle::evaluator::lxor_infix::curry< A > | |
| Csouffle::profile::DataComparator | |
| Csouffle::DebugReport | Class representing a HTML report, consisting of a list of sections |
| Csouffle::DebugReportSection | Class representing a section of a HTML report |
| Csouffle::ast::analysis::detail::default_bottom_factory< T > | |
| Csouffle::detail::brie::default_factory< T > | A templated functor to obtain default values for unspecified elements of sparse array instances |
| Csouffle::ast::analysis::detail::default_meet_op< T, meet_assign_op > | |
| Csouffle::detail::brie::default_merge< T > | A operation to be utilized by the sparse map when merging elements associated to different values |
| CDefines | ExecutionPlan |
| Csouffle::deref< T > | A functor dereferencing a given type |
| Csouffle::deref_less< T, C > | A functor comparing the dereferenced value of a pointer type utilizing a given comparator |
| Csouffle::Diagnostic | |
| Csouffle::DiagnosticMessage | |
| Csouffle::DisjointSet | Structure that emulates a Disjoint Set, i.e |
| Csouffle::interpreter::Engine | This class translate the RAM Program into executable format and interpreter it |
| Csouffle::EqrelMapComparator< StorePair > | |
| Csouffle::EqrelMapComparator< PairStore > | |
| Csouffle::Equivalence | Equivalence class for variables in query command |
| Csouffle::EquivalenceRelation< TupleType > | |
| Csouffle::EquivalenceRelation< Arity > | |
| Csouffle::ErrorReport | |
| ►Csouffle::profile::EventProcessor | Abstract Class for EventProcessor |
| Csouffle::profile::ConfigProcessor | Config entry processor |
| Csouffle::profile::FrequencyAtomProcessor | Frequency Atom Processor |
| Csouffle::profile::NonRecursiveRelationNumberProcessor | Non-Recursive Relation Number Profile Event Processor |
| Csouffle::profile::NonRecursiveRelationTimingProcessor | Non-Recursive Relation Number Profile Event Processor |
| Csouffle::profile::NonRecursiveRuleNumberProcessor | Non-Recursive Rule Number Profile Event Processor |
| Csouffle::profile::NonRecursiveRuleTimingProcessor | Non-Recursive Rule Timing Profile Event Processor |
| Csouffle::profile::ProgramResourceUtilisationProcessor | Program Resource Utilisation Event Processor |
| Csouffle::profile::ProgramRuntimeProcessor | Program Run Event Processor |
| Csouffle::profile::ProgramTimepointProcessor | Program Run Event Processor |
| Csouffle::profile::RecursiveRelationCopyTimingProcessor | Recursive Relation Copy Timing Profile Event Processor |
| Csouffle::profile::RecursiveRelationNumberProcessor | Recursive Relation Timing Profile Event Processor |
| Csouffle::profile::RecursiveRelationTimingProcessor | Recursive Relation Timing Profile Event Processor |
| Csouffle::profile::RecursiveRuleNumberProcessor | Recursive Rule Number Profile Event Processor |
| Csouffle::profile::RecursiveRuleTimingProcessor | Recursive Rule Timing Profile Event Processor |
| Csouffle::profile::RelationIOTimingProcessor | Recursive Relation Copy Timing Profile Event Processor |
| Csouffle::profile::RelationReadsProcessor | Reads Processor |
| Csouffle::profile::TextProcessor | Text entry processor |
| Csouffle::profile::EventProcessorSingleton | Event Processor Singleton |
| Csouffle::Explain | |
| Csouffle::ExplainConfig | |
| ►Csouffle::ExplainProvenance | |
| Csouffle::ExplainProvenanceImpl | |
| Csouffle::interpreter::index_utils::extend< Index, column > | |
| Csouffle::interpreter::index_utils::extend< index< Columns... >, Col > | |
| Ctinyformat::detail::is_convertible< T1, T2 >::fail | |
| ►Cfalse_type | |
| Csouffle::detail::is_printable< T, filter > | A type trait to check whether a given type is printable |
| Csouffle::profile::Cell< void > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::has_size_and_data< typename, typename > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::is_complete< typename, typename > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::is_container_element_type_compatible< typename, typename, typename > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::is_span< typename > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::is_std_array< typename > | |
| Csouffle::SparseArray< T, BITS, merge_op, copy_op >::FirstInfoSnapshot | A struct summarizing the state of the first node reference |
| Csouffle::detail::brie::fix_binding< Len, Pos, Dim > | A functor initializing an iterator upon creation to reference the first element exhibiting a given prefix within a given Trie |
| Csouffle::detail::brie::fix_binding< 0, Dim, Dim > | |
| Csouffle::detail::brie::fix_binding< 0, Pos, Dim > | |
| Csouffle::detail::brie::fix_first< Pos, Dim > | A functor initializing an iterator upon creation to reference the first element in the associated Trie |
| Csouffle::detail::brie::fix_first< Dim, Dim > | |
| Csouffle::detail::brie::fix_first_nested< Dim > | |
| Csouffle::detail::brie::fix_lower_bound< Dim > | A functor initializing an iterator upon creation to reference the first element within a given Trie being not less than a given value |
| Csouffle::detail::brie::fix_upper_bound< Dim > | A functor initializing an iterator upon creation to reference the first element within a given Trie being greater than a given value |
| Ctinyformat::detail::FormatArg | |
| ►Ctinyformat::FormatList | List of template arguments format(), held in a type-opaque way |
| Ctinyformat::detail::FormatListN< N > | |
| Ctinyformat::detail::FormatListN< 0 > | |
| Ctinyformat::detail::formatValueAsType< T, fmtT, convertible > | |
| Ctinyformat::detail::formatValueAsType< T, fmtT, true > | |
| ►Cforward_non_output_iterator_traits | |
| Cstd::iterator_traits< SparseArrayIter< A > > | |
| Cstd::iterator_traits< SparseBitMapIter< A > > | |
| Cstd::iterator_traits< TrieIterator< A, IterCore > > | |
| Csouffle::detail::brie::forward_non_output_iterator_traits< A > | |
| ►Cfstream | |
| Csouffle::TempFileStream | |
| Csouffle::interpreter::index_utils::get_full_index< arity > | |
| Csouffle::interpreter::index_utils::get_full_index< 0 > | |
| Csouffle::detail::brie::get_nested_iter_core< Level > | A functor extracting a reference to a nested iterator core from an enclosing iterator core |
| Csouffle::detail::brie::get_nested_iter_core< 0 > | |
| Csouffle::Global | |
| Csouffle::Graph< Vertex, Compare > | A simple graph structure for graph-based operations |
| Csouffle::Graph< const souffle::ast::Relation *, souffle::ast::NameComparison > | |
| Cstd::hash< tuple< A, B > > | |
| Csouffle::ram::analysis::SearchSignature::Hasher | |
| Csouffle::detail::brie::TrieBase< Dim, Derived >::hint_statistics | |
| Csouffle::detail::btree< Key, Comparator, Allocator, blockSize, SearchStrategy, isSet, WeakComparator, Updater >::hint_statistics | |
| CHoistAggregatesTransformer | Pushes one Aggregate as far up the loop nest as possible |
| Csouffle::profile::HtmlGenerator | |
| Csouffle::id< T > | A functor representing the identity function for a generic type T |
| Csouffle::detail::brie::identity< T > | A functor representing the identity function |
| Csouffle::interpreter::index< Columns > | The index class is utilized as a template-meta-programming structure to specify and realize indices |
| Csouffle::interpreter::Index< _Arity, Structure > | An index is an abstraction of a data structure |
| Csouffle::interpreter::Index< 0, Structure > | A partial specialize template for nullary indexes |
| ►Csouffle::interpreter::Index< 2, Eqrel > | |
| Csouffle::interpreter::EqrelIndex | For EqrelIndex we do inheritence since EqrelIndex only diff with one extra function |
| Csouffle::profile::InputReader | |
| Csouffle::IntrinsicFunctorInfo | |
| ►Cios | |
| ►Csouffle::gzfstream::internal::gzfstream | |
| Csouffle::gzfstream::igzfstream | |
| Csouffle::gzfstream::ogzfstream | |
| Csouffle::IOSystem | |
| ►Csouffle::ast::detail::is_ast_visitor< T > | A type trait determining whether a given type is a visitor or not |
| Csouffle::ast::detail::is_ast_visitor< const T > | |
| Csouffle::ast::detail::is_ast_visitor< T & > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::is_container< C, U > | |
| ►Cis_convertible | |
| CTCB_SPAN_NAMESPACE_NAME::detail::is_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 > | |
| Ctinyformat::detail::is_convertible< T1, T2 > | |
| ►Cis_pointer | |
| Csouffle::IsPtrLike< A > | |
| ►Csouffle::ram::detail::is_ram_visitor< T > | A type trait determining whether a given type is a visitor or not |
| Csouffle::ram::detail::is_ram_visitor< const T > | |
| Csouffle::ram::detail::is_ram_visitor< T & > | |
| Ctinyformat::detail::is_wchar< T > | |
| Ctinyformat::detail::is_wchar< const wchar_t * > | |
| Ctinyformat::detail::is_wchar< const wchar_t[n]> | |
| Ctinyformat::detail::is_wchar< wchar_t * > | |
| Ctinyformat::detail::is_wchar< wchar_t[n]> | |
| ►Cistream | |
| Csouffle::gzfstream::igzfstream | |
| Csouffle::profile::Iteration | |
| Csouffle::EquivalenceRelation< TupleType >::iterator | |
| Csouffle::interpreter::RelationWrapper::Iterator | The iterator interface |
| Csouffle::Relation::iterator | Wrapper class for abstract iterator |
| ►Citerator | |
| Csouffle::interpreter::Index< 0, Structure >::iterator | |
| Csouffle::IterDerefWrapper< Iter, T > | A wrapper for an iterator obtaining pointers of a certain type, dereferencing values before forwarding them to the consumer |
| Csouffle::PiggyList< T >::iterator | |
| Csouffle::SingleValueIterator< T > | An iterator to be utilized if there is only a single element to iterate over |
| Csouffle::t_info< Arity_ >::iterator | |
| Csouffle::Table< T, blockSize >::iterator | |
| Csouffle::t_nullaries::iterator | |
| Csouffle::detail::btree< Key, Comparator, Allocator, blockSize, SearchStrategy, isSet, WeakComparator, Updater >::iterator | The iterator type to be utilized for scanning through btree instances |
| ►Csouffle::interpreter::RelationWrapper::iterator_base | A virtualized iterator class that can be used by the Proginterface |
| Csouffle::interpreter::Relation< _Arity, Structure >::iterator_base | |
| ►Csouffle::Relation::iterator_base | Abstract iterator class |
| Csouffle::interpreter::RelInterface::iterator_base | Iterator wrapper class |
| ►Citerator_base | |
| Csouffle::RelationWrapper< RelType >::iterator_wrapper | |
| Csouffle::detail::brie::TrieTypes< Dim >::iterator_core | |
| Csouffle::detail::brie::TrieTypes< 1u >::iterator_core | The iterator core of this level contributing to the construction of a composed trie iterator |
| Csouffle::detail::joined_sequence< Iter, Printer > | 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 |
| Cjson11::Json | |
| ►Cjson11::JsonValue | |
| Cjson11::Value< tag, T > | |
| ►Cjson11::Value< Json::ARRAY, Json::array > | |
| Cjson11::JsonArray | |
| ►Cjson11::Value< Json::BOOL, bool > | |
| Cjson11::JsonBoolean | |
| ►Cjson11::Value< Json::NUL, NullStruct > | |
| Cjson11::JsonNull | |
| ►Cjson11::Value< Json::NUMBER, double > | |
| Cjson11::JsonDouble | |
| ►Cjson11::Value< Json::NUMBER, long long > | |
| Cjson11::JsonInt | |
| ►Cjson11::Value< Json::OBJECT, Json::object > | |
| Cjson11::JsonObject | |
| ►Cjson11::Value< Json::STRING, std::string > | |
| Cjson11::JsonString | |
| Csouffle::detail::lambda_traits_helper< T > | |
| ►Csouffle::detail::lambda_traits_helper< decltype(&Lambda::operator())> | |
| Csouffle::lambda_traits< Lambda > | A type trait enabling the deduction of type properties of lambdas |
| Csouffle::detail::lambda_traits_helper< R()> | |
| Csouffle::detail::lambda_traits_helper< R(A0)> | |
| Csouffle::detail::lambda_traits_helper< R(A0, A1)> | |
| ►Csouffle::detail::lambda_traits_helper< R(Args...)> | |
| ►Csouffle::detail::lambda_traits_helper< R(C::*)(Args...)> | |
| Csouffle::detail::lambda_traits_helper< R(C::*)(Args...) const > | |
| Csouffle::Lock::Lease | |
| Csouffle::OptimisticReadWriteLock::Lease | |
| Csouffle::RuleBody::literal | |
| Csouffle::ast2ram::Location | |
| Csouffle::Lock | A small utility class for implementing simple locks |
| Csouffle::Logger | The class utilized to times for the souffle profiling tool |
| Csouffle::LogStatement | |
| Csouffle::LRUCache< T, size > | An Least-Recently-Used cache for arbitrary element types |
| Csouffle::LRUCache< node *, 1 > | |
| Csouffle::LRUCache< T, 0 > | |
| Csouffle::LRUCache< T, 1 > | |
| Csouffle::evaluator::lxor_infix | |
| Csouffle::MainOption | |
| ►Csouffle::ram::analysis::MaxMatching | |
| Csouffle::ram::analysis::test::TestMaxMatching | |
| Csouffle::SparseBitMap< BITS >::merge_op | |
| ►Csouffle::ram::analysis::MinIndexSelection | |
| Csouffle::ram::TestAutoIndex | |
| Csouffle::detail::multiplying_printer< T > | A utility class required for the implementation of the times function |
| Csouffle::ast::NameComparison | Comparator for relations |
| Csouffle::detail::brie::TrieTypes< Dim >::nested_trie_cloner | |
| Csouffle::detail::brie::TrieTypes< Dim >::nested_trie_merger | |
| ►Csouffle::interpreter::NestedOperation | Encode a nested operation for the interpreter node. E.g. Loop, IndexScan |
| Csouffle::interpreter::Aggregate | |
| Csouffle::interpreter::Break | |
| Csouffle::interpreter::Choice | |
| Csouffle::interpreter::Filter | |
| ►Csouffle::interpreter::Scan | |
| ►Csouffle::interpreter::IndexScan | |
| Csouffle::interpreter::ParallelIndexScan | |
| Csouffle::interpreter::ParallelScan | |
| Csouffle::interpreter::UnpackRecord | |
| ►Csouffle::ram::Node | Node is a superclass for all RAM IR classes |
| ►Csouffle::ram::Condition | Abstract class for conditions and boolean values in RAM |
| ►Csouffle::ram::AbstractExistenceCheck | Abstract existence check for a tuple in a relation |
| Csouffle::ram::ExistenceCheck | Existence check for a tuple(-pattern) in a relation |
| Csouffle::ram::ProvenanceExistenceCheck | Provenance Existence check for a relation |
| Csouffle::ram::Conjunction | A conjunction of conditions |
| Csouffle::ram::Constraint | Evaluates a binary constraint with respect to two Expressions |
| Csouffle::ram::EmptinessCheck | Emptiness check for a relation |
| Csouffle::ram::False | |
| Csouffle::ram::Negation | Negates a given condition |
| Csouffle::ram::True | False value condition |
| ►Csouffle::ram::Expression | Abstract class for describing scalar values in RAM |
| ►Csouffle::ram::AbstractOperator | Abstract class for an operator/functor |
| Csouffle::ram::IntrinsicOperator | Operator that represents an intrinsic (built-in) functor |
| Csouffle::ram::UserDefinedOperator | Operator that represents an extrinsic (user-defined) functor |
| Csouffle::ram::AutoIncrement | Increment a counter and return its value |
| ►Csouffle::ram::Constant | Represents a Ram Constant |
| Csouffle::ram::FloatConstant | Represents a float constant |
| Csouffle::ram::SignedConstant | Represents a signed constant |
| Csouffle::ram::UnsignedConstant | Represents a unsigned constant |
| Csouffle::ram::PackRecord | Packs a record's arguments into a reference |
| Csouffle::ram::RelationSize | Returns the numbers of tuples in a relation |
| Csouffle::ram::SubroutineArgument | Access argument of a subroutine |
| Csouffle::ram::TupleElement | Access element from the current tuple in a tuple environment |
| Csouffle::ram::UndefValue | An undefined expression |
| ►Csouffle::ram::Operation | Abstract class for a relational algebra operation |
| ►Csouffle::ram::NestedOperation | Abstract class for a nesting operations in a loop-nest |
| ►Csouffle::ram::AbstractConditional | Abstract conditional statement |
| Csouffle::ram::Break | Breaks out of the loop if a condition holds |
| Csouffle::ram::Filter | Checks whether a given condition holds |
| ►Csouffle::ram::TupleOperation | Abstract class for relation searches and lookups |
| Csouffle::ram::NestedIntrinsicOperator | Effectively identical to IntrinsicOperator, except it can produce multiple results |
| ►Csouffle::ram::RelationOperation | Abstract class for operations on relations |
| Csouffle::ram::Aggregate | Aggregation function applied on some relation |
| Csouffle::ram::Choice | Find a tuple in a relation such that a given condition holds |
| ►Csouffle::ram::IndexOperation | |
| Csouffle::ram::IndexAggregate | Indexed aggregation on a relation. The index allows us to iterate over a restricted range |
| Csouffle::ram::IndexChoice | Use an index to find a tuple in a relation such that a given condition holds |
| ►Csouffle::ram::IndexScan | Search for tuples of a relation matching a criteria |
| Csouffle::ram::ParallelIndexScan | Search for tuples of a relation matching a criteria |
| ►Csouffle::ram::Scan | Iterate all tuples of a relation |
| Csouffle::ram::ParallelScan | Iterate all tuples of a relation in parallel |
| Csouffle::ram::UnpackRecord | Record lookup |
| Csouffle::ram::Project | Project a result into the target relation |
| Csouffle::ram::SubroutineReturn | A statement for returning from a ram subroutine |
| Csouffle::ram::Program | RAM program relation declaration and functions |
| ►Csouffle::ram::Relation | An abstract class for performing indexed operations |
| Csouffle::synthesiser::BrieRelation | |
| Csouffle::synthesiser::DirectRelation | |
| Csouffle::synthesiser::EqrelRelation | |
| Csouffle::synthesiser::IndirectRelation | |
| Csouffle::synthesiser::InfoRelation | |
| Csouffle::synthesiser::NullaryRelation | |
| ►Csouffle::ram::Statement | Abstract class for RAM statements |
| ►Csouffle::ram::BinRelationStatement | Abstract class for a binary relation |
| Csouffle::ram::Extend | Extend equivalence relation |
| Csouffle::ram::Swap | Swap operation with respect to two relations |
| Csouffle::ram::Call | Call a subroutine |
| Csouffle::ram::DebugInfo | Debug statement |
| Csouffle::ram::Exit | Exit statement for a loop |
| ►Csouffle::ram::ListStatement | Abstract class for a list of RAM statements |
| Csouffle::ram::Parallel | Parallel block of statements |
| Csouffle::ram::Sequence | Sequence of RAM statements |
| Csouffle::ram::LogTimer | Execution time logger for a statement |
| Csouffle::ram::Loop | Execute statement until statement terminates loop via an exit statement |
| Csouffle::ram::Query | A relational algebra query |
| ►Csouffle::ram::RelationStatement | RAM Statements with a single relation |
| Csouffle::ram::Clear | Delete tuples of a relation |
| Csouffle::ram::IO | I/O statement for a relation |
| Csouffle::ram::LogRelationTimer | Execution time logger for a statement |
| Csouffle::ram::LogSize | Log relation size and a logging message |
| ►Csouffle::ast::Node | Abstract class for syntactic elements in an input program |
| ►Csouffle::ast::Argument | An abstract class for arguments |
| Csouffle::ast::Aggregator | Defines the aggregator class |
| ►Csouffle::ast::Constant | Abstract constant class |
| Csouffle::ast::NilConstant | Defines the nil constant |
| Csouffle::ast::NumericConstant | Numeric Constant |
| Csouffle::ast::StringConstant | String constant class |
| Csouffle::ast::Counter | Counter functor (incrementing a value after each invocation) |
| Csouffle::ast::SubroutineArgument | Defines the argument class for subrountines |
| ►Csouffle::ast::Term | Defines an abstract term class used for functors and other constructors |
| Csouffle::ast::BranchInit | Initialization of ADT instance |
| ►Csouffle::ast::Functor | Abstract functor class |
| Csouffle::ast::IntrinsicFunctor | Intrinsic Functor class for functors are in-built |
| Csouffle::ast::UserDefinedFunctor | User-Defined functor class |
| Csouffle::ast::RecordInit | Defines a record initialization class |
| Csouffle::ast::TypeCast | Defines a type cast class for expressions |
| Csouffle::ast::UnnamedVariable | Unnamed variable class |
| Csouffle::ast::Variable | Named variable class |
| Csouffle::ast::Attribute | Attribute class |
| Csouffle::ast::BranchDeclaration | Wrapper for the single branch declaration (product type) inside ADT declaration |
| Csouffle::ast::Clause | Intermediate representation of a horn clause |
| Csouffle::ast::Component | Component class |
| Csouffle::ast::ComponentInit | Component initialization class |
| Csouffle::ast::ComponentType | Component type of a component |
| Csouffle::ast::Directive | Directive has a type (e.g. input/output/printsize/limitsize), qualified relation name, and a key value map for storing parameters of the directive |
| Csouffle::ast::ExecutionOrder | An execution order for atoms within a clause; one or more execution orders form a plan |
| Csouffle::ast::ExecutionPlan | |
| Csouffle::ast::FunctorDeclaration | User-defined functor declaration |
| ►Csouffle::ast::Literal | Defines an abstract class for literals in a horn clause |
| Csouffle::ast::Atom | An atom class |
| Csouffle::ast::Constraint | Abstract class for AST constraints |
| ►Csouffle::ast::Negation | Negation of an atom negated atom |
| Csouffle::ast::ProvenanceNegation | Subclass of Literal that represents a negated atom, * e.g., !parent(x,y) |
| Csouffle::ast::Pragma | Representation of a global option |
| Csouffle::ast::Program | The program class consists of relations, clauses and types |
| Csouffle::ast::Relation | Defines a relation with a name, attributes, qualifiers, and internal representation |
| Csouffle::ast::Type | An abstract base class for types |
| Csouffle::SparseArray< T, BITS, merge_op, copy_op >::Node | The node type of the internally maintained tree |
| ►Csouffle::interpreter::Node | This is a shadow node for a ram::Node that is enriched for with local information so that the interpreter is executing quickly |
| Csouffle::interpreter::Aggregate | |
| Csouffle::interpreter::AutoIncrement | |
| ►Csouffle::interpreter::BinaryNode | Binary node represents interpreter node with two children |
| Csouffle::interpreter::Conjunction | |
| Csouffle::interpreter::Constraint | |
| Csouffle::interpreter::Break | |
| Csouffle::interpreter::Call | |
| Csouffle::interpreter::Choice | |
| Csouffle::interpreter::Clear | |
| ►Csouffle::interpreter::CompoundNode | Compound node represents interpreter node with a list of children |
| Csouffle::interpreter::IntrinsicOperator | |
| Csouffle::interpreter::NestedIntrinsicOperator | |
| Csouffle::interpreter::PackRecord | |
| Csouffle::interpreter::Parallel | |
| Csouffle::interpreter::Sequence | |
| Csouffle::interpreter::SubroutineReturn | |
| Csouffle::interpreter::UserDefinedOperator | |
| Csouffle::interpreter::Constant | |
| Csouffle::interpreter::EmptinessCheck | |
| Csouffle::interpreter::ExistenceCheck | |
| Csouffle::interpreter::Extend | |
| Csouffle::interpreter::False | |
| Csouffle::interpreter::Filter | |
| Csouffle::interpreter::IO | |
| Csouffle::interpreter::LogSize | |
| Csouffle::interpreter::Project | |
| Csouffle::interpreter::RelationSize | |
| Csouffle::interpreter::Scan | |
| Csouffle::interpreter::SubroutineArgument | |
| Csouffle::interpreter::Swap | |
| Csouffle::interpreter::True | |
| Csouffle::interpreter::TupleElement | |
| ►Csouffle::interpreter::UnaryNode | Unary node represents interpreter node with a single child |
| Csouffle::interpreter::DebugInfo | |
| Csouffle::interpreter::Exit | |
| Csouffle::interpreter::LogRelationTimer | |
| Csouffle::interpreter::LogTimer | |
| Csouffle::interpreter::Loop | |
| Csouffle::interpreter::Negation | |
| Csouffle::interpreter::ProvenanceExistenceCheck | |
| Csouffle::interpreter::Query | |
| Csouffle::interpreter::TupleOperation | |
| Csouffle::interpreter::UnpackRecord | |
| ►Csouffle::ast::NodeMapper | An abstract class for manipulating AST Nodes by substitution |
| Csouffle::ast::detail::LambdaNodeMapper< Lambda > | A special NodeMapper wrapping a lambda conducting node transformations |
| ►Csouffle::ram::NodeMapper | An abstract class for manipulating RAM Nodes by substitution |
| Csouffle::ram::LambdaNodeMapper< Lambda > | A special NodeMapper wrapping a lambda conducting node transformations |
| Csouffle::ast::analysis::NormalisedClause | |
| Csouffle::ast::analysis::NormalisedClause::NormalisedClauseElement | |
| Csouffle::ast::transform::NullableVector< T > | |
| Cjson11::NullStruct | |
| Csouffle::SparseArray< T, BITS, merge_op, copy_op >::op_context | A struct to be utilized as a local, temporal context by client code to speed up the execution of various operations (optional parameter) |
| Csouffle::detail::brie::TrieTypes< Dim >::op_context | |
| Csouffle::EquivalenceRelation< TupleType >::operation_hints | A collection of operation hints speeding up some of the involved operations by exploiting temporal locality |
| Csouffle::OptimisticReadWriteLock | A 'sequential' non-locking implementation for an optimistic r/w lock |
| Csouffle::interpreter::Order | An order to be enforced for storing tuples within indexes |
| Csouffle::interpreter::NodeGenerator::OrderingContext | This class help generator reordering tuple access based on the index oder |
| ►Costream | |
| Csouffle::gzfstream::ogzfstream | |
| Csouffle::profile::OutputProcessor | |
| Csouffle::ParserDriver | |
| Csouffle::PiggyList< T > | |
| Csouffle::PiggyList< std::atomic< block_t > > | |
| Csouffle::SrcLocation::Point | A class locating a single point in an input file |
| Csouffle::detail::print< Extractor > | A generic element printer |
| ►Csouffle::detail::print< deref< T > > | |
| Csouffle::print_deref< T > | A functor printing elements after dereferencing it |
| Csouffle::ast::analysis::Problem< Var > | A problem is a list of constraints for which a solution is desired |
| Csouffle::ast::analysis::Problem< AnalysisVar > | |
| Csouffle::ast::analysis::Problem< TypeVar > | |
| Csouffle::ProfileEventSingleton | Profile Event Singleton |
| Csouffle::ProfileEventSingleton::ProfileTimer | Profile Timer |
| Csouffle::ProgramFactory | Abstract program factory class |
| Csouffle::profile::ProgramRun | |
| Csouffle::ast::analysis::property_space< T, meet_assign_op, bottom_factory, meet_op > | A MPL type for defining a property space |
| ►Csouffle::ast::analysis::property_space< std::set< T >, detail::set_meet_assign_op< T > > | |
| Csouffle::ast::analysis::set_property_space< T > | A property space for set-based properties based on sub-set lattices |
| ►Csouffle::ast::analysis::property_space< TypeSet, sub_type, all_type_factory > | |
| Csouffle::ast::analysis::type_lattice | The type lattice forming the property space for the Type analysis |
| Csouffle::interpreter::ProvenanceUpdater< Arity > | |
| Csouffle::ast::QualifiedName | Qualified Name class defines fully/partially qualified names to identify objects in components |
| ►Csouffle::ram::ram_visitor_tag | A tag type required for the is_ram_visitor type trait to identify RamVisitors |
| Csouffle::ram::Visitor< R, Params > | The generic base type of all RamVisitors realizing the dispatching of visitor calls |
| ►Csouffle::ram::Visitor< Own< Node > > | |
| Csouffle::interpreter::NodeGenerator | |
| ►Csouffle::ram::Visitor< void > | |
| Csouffle::ram::detail::LambdaVisitor< R, N > | A specialized visitor wrapping a lambda function – an auxiliary type required for visitor convenience functions |
| CRamIndexAnalyis | |
| Csouffle::RandomInsertPiggyList< T > | A PiggyList that allows insertAt functionality |
| Csouffle::RandomInsertPiggyList< SparseDomain > | |
| Csouffle::RandomInsertPiggyList< value_type > | |
| Csouffle::range< Iter > | A utility class enabling representation of ranges by pairing two iterator instances marking lower and upper boundaries |
| Csouffle::range< souffle::detail::brie::TrieIterator > | |
| Csouffle::profile::Reader | |
| ►Csouffle::ReadStreamFactory | |
| Csouffle::ReadCinCSVFactory | |
| Csouffle::ReadCinJSONFactory | |
| Csouffle::ReadFileCSVFactory | |
| Csouffle::ReadFileJSONFactory | |
| Csouffle::ReadSQLiteFactory | |
| Csouffle::ReadWriteLock | |
| Csouffle::RecordMap::RecordHash | Hash function for unordered record map |
| Csouffle::RecordMap | Bidirectional mappping between records and record references |
| Csouffle::RecordTable | |
| Csouffle::profile::Relation | |
| ►Csouffle::Relation | Object-oriented wrapper class for Souffle's templatized relations |
| Csouffle::interpreter::RelInterface | Wrapper class for interpreter relations |
| Csouffle::RelationWrapper< RelType > | Relation wrapper used internally in the generated Datalog program |
| Csouffle::synthesiser::Relation | |
| Csouffle::ast::analysis::RelationScheduleAnalysisStep | 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 |
| ►Csouffle::interpreter::RelationWrapper | Wrapper for InterpreterRelation |
| ►Csouffle::interpreter::Relation< 2, Eqrel > | |
| Csouffle::interpreter::EqrelRelation | |
| Csouffle::interpreter::Relation< _Arity, Structure > | A relation, composed of a collection of indexes |
| 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 |
| Csouffle::test::reserver< C > | |
| Csouffle::test::reserver< std::unordered_set< A, B, C, D > > | |
| Csouffle::reverse< A > | Use to range-for iterate in reverse |
| Csouffle::SparseArray< T, BITS, merge_op, copy_op >::RootInfo | A struct describing all the information required by the container class to manage the wrapped up tree |
| Csouffle::SparseArray< T, BITS, merge_op, copy_op >::RootInfoSnapshot | A struct to cover a snapshot of the root node state |
| Csouffle::profile::Row | |
| Csouffle::profile::Rule | |
| Csouffle::RuleBody | |
| Csouffle::scanner_data | |
| Csouffle::ScreenBuffer | |
| ►Csouffle::detail::search_strategy | A common base class for search strategies in b-trees |
| Csouffle::detail::binary_search | A binary search strategy for looking up keys in b-tree nodes |
| Csouffle::detail::linear_search | A linear search strategy for looking up keys in b-tree nodes |
| Csouffle::ram::analysis::MinIndexSelection::SearchComparator | |
| Csouffle::ram::analysis::SearchSignature | Search signature of a RAM operation; each bit represents an attribute of a relation |
| Csouffle::ast::transform::SemanticCheckerImpl | |
| Csouffle::SerialisationStream< readOnlyTables > | |
| ►Csouffle::SerialisationStream< false > | |
| ►Csouffle::ReadStream | |
| ►Csouffle::ReadStreamCSV | |
| Csouffle::ReadFileCSV | |
| ►Csouffle::ReadStreamJSON | |
| Csouffle::ReadFileJSON | |
| Csouffle::ReadStreamSQLite | |
| ►Csouffle::SerialisationStream< true > | |
| ►Csouffle::WriteStream | |
| Csouffle::WriteCoutPrintSize | |
| ►Csouffle::WriteStreamCSV | |
| Csouffle::WriteCoutCSV | |
| Csouffle::WriteFileCSV | |
| ►Csouffle::WriteStreamJSON | |
| Csouffle::WriteCoutJSON | |
| Csouffle::WriteFileJSON | |
| Csouffle::WriteStreamSQLite | |
| Csouffle::ast::analysis::detail::set_meet_assign_op< T > | A meet operator for set-based property spaces based on the sub-set lattices |
| Csouffle::SignalHandler | Class SignalHandler captures signals and reports the context where the signal occurs |
| ►Csouffle::ast::SipsMetric | 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 |
| Csouffle::ast::AllBoundSips | Goal: Prioritise atoms with all arguments bound |
| Csouffle::ast::DeltaInputSips | Goal: prioritise (1) all-bound, then (2) deltas, then (3) input, and then (4) left-most |
| Csouffle::ast::DeltaSips | Goal: prioritise (1) all-bound, then (2) deltas, and then (3) left-most |
| Csouffle::ast::InputSips | Goal: prioritise (1) all-bound, then (2) input, and then (3) left-most |
| Csouffle::ast::LeastFreeSips | Goal: choose the atom with the least number of unbound arguments |
| Csouffle::ast::LeastFreeVarsSips | Goal: choose the atom with the least amount of unbound variables |
| Csouffle::ast::MaxBoundSips | Goal: prioritise (1) all-bound, then (2) max number of bound vars, then (3) left-most |
| Csouffle::ast::MaxRatioSips | Goal: prioritise max ratio of bound args |
| Csouffle::ast::NaiveSips | Goal: Prioritise (1) all bound, then (2) atoms with at least one bound argument, then (3) left-most |
| Csouffle::ast::ProfileUseSips | Goal: reorder based on the given profiling information Metric: cost(atom_R) = log(|atom_R|) * #free/#args |
| Csouffle::ast::StrictSips | Goal: Always choose the left-most atom |
| ►Csouffle::SouffleProgram | Abstract base class for generated Datalog programs |
| Csouffle::interpreter::ProgInterface | Implementation of SouffleProgram interface for an interpreter instance |
| CTCB_SPAN_NAMESPACE_NAME::span< ElementType, Extent > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::span_storage< E, S > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::span_storage< E, dynamic_extent > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::span_storage< ElementType, Extent > | |
| Csouffle::SparseArray< T, BITS, merge_op, copy_op > | A sparse array simulates an array associating to every element of uint32_t an element of a generic type T |
| Csouffle::SparseArray< value_t, 4, merge_op > | |
| Csouffle::detail::brie::SparseArrayIter< SparseArray > | Iterator type for souffle::SparseArray |
| Csouffle::SparseBitMap< BITS > | A sparse bit-map is a bit map virtually assigning a bit value to every value if the uint32_t domain |
| Csouffle::detail::brie::SparseBitMapIter< SparseBitMap > | Iterator type for souffle::SparseArray |
| Csouffle::SparseDisjointSet< SparseDomain > | |
| Csouffle::SparseDisjointSet< value_type > | |
| Csouffle::SpinLock | A 'sequential' non-locking implementation for a spin lock |
| Csouffle::SrcLocation | A class describing a range in an input file |
| Cjson11::Statics | |
| Csouffle::detail::strategy_selection< S > | A template-meta class to select search strategies for b-trees depending on the key type |
| ►Csouffle::detail::strategy_selection< binary_search > | |
| ►Csouffle::detail::binary | |
| Csouffle::detail::default_strategy< PairStore > | |
| Csouffle::detail::default_strategy< StorePair > | |
| Csouffle::detail::default_strategy< Key > | |
| ►Csouffle::detail::strategy_selection< linear_search > | |
| ►Csouffle::detail::linear | |
| Csouffle::detail::default_strategy< int > | |
| Csouffle::detail::default_strategy< std::tuple< Ts... > > | |
| ►Cstreambuf | |
| Csouffle::gzfstream::internal::gzfstreambuf | |
| Csouffle::ast::analysis::sub_type | An implementation of a meet operation between sets of types computing the set of pair-wise greatest common subtypes |
| Ctinyformat::detail::is_convertible< T1, T2 >::succeed | |
| Csouffle::interpreter::SuperInstruction | This class encodes information for a super-instruction, which is used to eliminate Number and TupleElement in index/project/existence operation |
| ►Csouffle::interpreter::SuperOperation | Node that utilizes the super instruction optimization should inherit from this class. E.g. ExistenceCheck, Project |
| Csouffle::interpreter::ExistenceCheck | |
| Csouffle::interpreter::IndexAggregate | |
| Csouffle::interpreter::IndexChoice | |
| Csouffle::interpreter::IndexScan | |
| Csouffle::interpreter::Project | |
| Csouffle::interpreter::ProvenanceExistenceCheck | |
| CSWIGSouffleProgram | Abstract base class for generated Datalog programs |
| Csouffle::SymbolTable | |
| Csouffle::synthesiser::Synthesiser | A RAM synthesiser: synthesises a C++ program from a RAM program |
| Csouffle::t_info< Arity_ > | Info relations |
| Csouffle::t_nullaries | Nullary relations |
| Csouffle::Table< T, blockSize > | |
| Csouffle::profile::Table | |
| CTestCase::test_result | Checks condition |
| CTestCase | |
| ►Csouffle::ram::transform::Transformer | @Class Transformer @Brief abstract transformer class for a translation unit |
| Csouffle::ram::transform::ChoiceConversionTransformer | Convert (Scan/If)/(IndexScan/If) operaitons to (Choice)/(IndexChoice) operations |
| Csouffle::ram::transform::CollapseFiltersTransformer | Transforms consecutive filters into a single filter containing a conjunction |
| Csouffle::ram::transform::EliminateDuplicatesTransformer | Eliminates duplicated conjunctive terms |
| Csouffle::ram::transform::ExpandFilterTransformer | Transforms Conjunctions into consecutive filter operations |
| Csouffle::ram::transform::HoistAggregateTransformer | |
| Csouffle::ram::transform::HoistConditionsTransformer | Hosts conditions in a loop-nest to the most-outer/semantically-correct loop |
| Csouffle::ram::transform::IfConversionTransformer | Convert IndexScan operations to Filter/Existence Checks |
| Csouffle::ram::transform::IndexedInequalityTransformer | Removes Inequalities from Indexed Operations and replaces them with a Filter Operation and empty Indexed Operations are coverted to their Non-Indexed semantic equivalent |
| Csouffle::ram::transform::MakeIndexTransformer | Make indexable operations to indexed operations |
| ►Csouffle::ram::transform::MetaTransformer | @Class MetaTransformer @Brief Abstract class to identifier meta transformer |
| Csouffle::ram::transform::ConditionalTransformer | @Class ConditionalTransformer @Brief Composite conditional transformer |
| Csouffle::ram::transform::LoopTransformer | @Class LoopTransformer @Brief Composite loop transformer |
| Csouffle::ram::transform::TransformerSequence | @Class TransformerSequence @Brief Composite sequence transformer |
| Csouffle::ram::transform::ParallelTransformer | Transforms Choice/IndexChoice/IndexScan/Scan into parallel versions |
| Csouffle::ram::transform::ReorderConditionsTransformer | Reorders conjunctive terms depending on cost, i.e., cheap terms should be executed first |
| Csouffle::ram::transform::ReorderFilterBreak | |
| Csouffle::ram::transform::ReportIndexTransformer | |
| Csouffle::ram::transform::TupleIdTransformer | Ordering tupleIds in TupleOperation operations correctly |
| ►Csouffle::ast::transform::Transformer | |
| Csouffle::ast::transform::AddNullariesToAtomlessAggregatesTransformer | Transformation pass to add artificial nullary atom (+Tautology()) to aggregate bodies that have no atoms |
| Csouffle::ast::transform::ComponentChecker | |
| Csouffle::ast::transform::ComponentInstantiationTransformer | |
| Csouffle::ast::transform::ExecutionPlanChecker | |
| Csouffle::ast::transform::FoldAnonymousRecords | Transformation pass that removes (binary) constraints on the anonymous records |
| Csouffle::ast::transform::GroundedTermsChecker | |
| Csouffle::ast::transform::GroundWitnessesTransformer | Apply a grounding so that the witness of a selection aggregate (min/max) can be transferred to the outer scope |
| Csouffle::ast::transform::InlineRelationsTransformer | Transformation pass to inline marked relations |
| Csouffle::ast::transform::IOAttributesTransformer | Transformation pass to set attribute names and types in IO operations |
| Csouffle::ast::transform::IODefaultsTransformer | Transformation pass to set defaults for IO operations |
| Csouffle::ast::transform::MagicSetTransformer::AdornDatabaseTransformer | Database adornment |
| Csouffle::ast::transform::MagicSetTransformer::LabelDatabaseTransformer::NegativeLabellingTransformer | Runs the first stage of the labelling algorithm |
| Csouffle::ast::transform::MagicSetTransformer::LabelDatabaseTransformer::PositiveLabellingTransformer | Runs the second stage of the labelling algorithm |
| Csouffle::ast::transform::MagicSetTransformer::MagicSetCoreTransformer | Core section of the magic set transformer |
| Csouffle::ast::transform::MagicSetTransformer::NormaliseDatabaseTransformer | Database normaliser for MST |
| Csouffle::ast::transform::MaterializeAggregationQueriesTransformer | Transformation pass to create artificial relations for bodies of aggregation functions consisting of more than a single atom |
| Csouffle::ast::transform::MaterializeSingletonAggregationTransformer | Replaces literals containing single-valued aggregates with a synthesised relation |
| ►Csouffle::ast::transform::MetaTransformer | Transformer that coordinates other sub-transformations |
| Csouffle::ast::transform::ConditionalTransformer | Transformer that executes a sub-transformer iff a condition holds |
| Csouffle::ast::transform::DebugReporter | 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 |
| Csouffle::ast::transform::FixpointTransformer | Transformer that repeatedly executes a sub-transformer until no changes are made |
| Csouffle::ast::transform::NullTransformer | Transformer that does absolutely nothing |
| ►Csouffle::ast::transform::PipelineTransformer | Transformer that holds an arbitrary number of sub-transformations |
| Csouffle::ast::transform::MagicSetTransformer | Magic Set Transformation |
| Csouffle::ast::transform::MagicSetTransformer::LabelDatabaseTransformer | Database labeller |
| Csouffle::ast::transform::WhileTransformer | Transformer that repeatedly executes a sub-transformer while a condition is met |
| Csouffle::ast::transform::MinimiseProgramTransformer | Transformation pass to remove equivalent rules |
| Csouffle::ast::transform::NameUnnamedVariablesTransformer | Transformation pass to replace unnamed variables with singletons |
| Csouffle::ast::transform::NormaliseMultiResultFunctorsTransformer | Uniquely names all appearances of ranges |
| Csouffle::ast::transform::PartitionBodyLiteralsTransformer | Transformation pass to move literals into new clauses if they are independent of remaining literals |
| Csouffle::ast::transform::PragmaChecker | |
| Csouffle::ast::transform::ProvenanceTransformer | Transformation pass to add provenance information |
| Csouffle::ast::transform::ReduceExistentialsTransformer | Transformation pass to reduce unnecessary computation for relations that only appear in the form A(_,...,_) |
| Csouffle::ast::transform::RemoveBooleanConstraintsTransformer | Transformation pass to remove constant boolean constraints Should be called after any transformation that may generate boolean constraints |
| Csouffle::ast::transform::RemoveEmptyRelationsTransformer | Transformation pass to remove all empty relations and rules that use empty relations |
| Csouffle::ast::transform::RemoveRedundantRelationsTransformer | Transformation pass to remove relations which are redundant (do not contribute to output) |
| Csouffle::ast::transform::RemoveRedundantSumsTransformer | Transformation pass to remove expressions of the form sum k : { .. |
| Csouffle::ast::transform::RemoveRelationCopiesTransformer | Transformation pass to replaces copy of relations by their origin |
| Csouffle::ast::transform::ReorderLiteralsTransformer | Transformation pass to reorder body literals |
| Csouffle::ast::transform::ReplaceSingletonVariablesTransformer | Transformation pass to replace singleton variables with unnamed variables |
| Csouffle::ast::transform::ResolveAliasesTransformer | Transformation pass to eliminate grounded aliases |
| Csouffle::ast::transform::ResolveAnonymousRecordAliasesTransformer | Transformer resolving aliases for anonymous records |
| Csouffle::ast::transform::SemanticChecker | |
| Csouffle::ast::transform::SimplifyAggregateTargetExpressionTransformer | Transformation pass to rename aggregation variables to make them unique |
| Csouffle::ast::transform::TypeChecker | |
| Csouffle::ast::transform::UniqueAggregationVariablesTransformer | Transformation pass to rename aggregation variables to make them unique |
| Csouffle::ast::TranslationUnit | Translation unit class for the translation pipeline |
| Csouffle::ram::TranslationUnit | Translating a RAM program |
| ►Csouffle::TreeNode | |
| Csouffle::InnerNode | |
| Csouffle::LeafNode | |
| Csouffle::Trie< Dim > | |
| Csouffle::detail::brie::TrieBase< Dim, Derived > | A base class for the Trie implementation allowing various specializations of the Trie template to inherit common functionality |
| ►Csouffle::detail::brie::TrieBase< 1u, Trie< 1u > > | |
| Csouffle::Trie< 1u > | A template specialization for tries representing a set |
| Csouffle::detail::brie::TrieIterator< Value, IterCore > | An iterator over the stored entries |
| Csouffle::detail::brie::TrieTypes< Dim > | |
| Csouffle::detail::brie::TrieTypes< 1u > | |
| ►Ctrue_type | |
| Csouffle::detail::declval< std::ostream & >()<< std::declval< T >()), void >::type > | A type trait to check whether a given type is printable |
| Csouffle::IsPtrLike< Own< A > > | |
| Csouffle::IsPtrLike< std::shared_ptr< A > > | |
| Csouffle::IsPtrLike< std::weak_ptr< A > > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::has_size_and_data< T, void_t< decltype(detail::size(std::declval< T >())), decltype(detail::data(std::declval< T >()))> > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::is_complete< T, decltype(sizeof(T))> | |
| CTCB_SPAN_NAMESPACE_NAME::detail::is_span< span< T, S > > | |
| CTCB_SPAN_NAMESPACE_NAME::detail::is_std_array< std::array< T, N > > | |
| Csouffle::profile::Tui | |
| Csouffle::tuple | Defines a tuple for the OO interface such that relations with varying columns can be accessed |
| Csouffle::SouffleProgram::tuple_insert< Tuple, N > | Helper function for the wrapper function Relation::insert() and Relation::contains() |
| Csouffle::SouffleProgram::tuple_insert< Tuple, 1 > | Helper function for the wrapper function Relation::insert() and Relation::contains() for the first element of the tuple |
| ►Csouffle::ast::analysis::Type | An abstract base class for types to be covered within a type environment |
| Csouffle::ast::AlgebraicDataType | Combination of types using sums and products |
| Csouffle::ast::analysis::AlgebraicDataType | Aggregates types using sums and products |
| Csouffle::ast::analysis::ConstantType | Representing the type assigned to a constant |
| Csouffle::ast::analysis::RecordType | A record type combining a list of fields into a new, aggregated type |
| ►Csouffle::ast::analysis::SubsetType | A type being a subset of another type |
| Csouffle::ast::analysis::PrimitiveType | PrimitiveType = Number/Unsigned/Float/Symbol The class representing pre-built, concrete types |
| Csouffle::ast::analysis::UnionType | A union type combining a list of types into a new, aggregated type |
| Csouffle::ast::RecordType | Record type class for record type declarations |
| Csouffle::ast::SubsetType | Defines subset type class |
| Csouffle::ast::UnionType | The union type class |
| CTypeAttribute | Type attribute class |
| Csouffle::ast::analysis::TypeBinding | 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> .. |
| Csouffle::ast::transform::TypeDeclarationChecker | |
| Csouffle::ast::analysis::TypeEnvironment | A type environment is a set of types |
| Csouffle::ast::analysis::TypeSet | A collection to represent sets of types |
| ►Csouffle::ast::analysis::TypeVisitor< R > | A visitor for Types |
| Csouffle::ast::analysis::VisitOnceTypeVisitor< R > | A visitor for types visiting each type only once (effectively breaking recursive cycles) |
| Csouffle::detail::updater< T > | The default non-updater |
| Csouffle::detail::updater< Key > | |
| Csouffle::detail::updater< PairStore > | |
| Csouffle::detail::updater< StorePair > | |
| Csouffle::profile::Tui::Usage | |
| Csouffle::ast2ram::ValueIndex | |
| Csouffle::ast::analysis::Variable< Id, PropertySpace > | A variable to be utilized within constraints to be handled by the constraint solver |
| ►Csouffle::ast::analysis::Variable< const Argument *, PropertySpace > | |
| Csouffle::ast::analysis::ConstraintAnalysisVar< PropertySpace > | A variable type to be utilized by AST constraint analysis |
| Csouffle::interpreter::ViewContext | This class contains information for views (Hints) creation for ram::Query and ram::Parallel operation |
| ►Csouffle::interpreter::ViewOperation | Operation that utilizes the index view from underlying relation should inherit from this class |
| Csouffle::interpreter::ExistenceCheck | |
| Csouffle::interpreter::IndexAggregate | |
| Csouffle::interpreter::IndexChoice | |
| Csouffle::interpreter::IndexScan | |
| Csouffle::interpreter::ProvenanceExistenceCheck | |
| ►Csouffle::interpreter::ViewWrapper | A dummy wrapper for indexViews |
| Csouffle::interpreter::Index< _Arity, Structure >::View | A view on a relation caching local access patterns (not thread safe!) |
| Csouffle::interpreter::Index< 0, Structure >::View | |
| ►Csouffle::WriteStreamFactory | |
| Csouffle::WriteCoutCSVFactory | |
| Csouffle::WriteCoutJSONFactory | |
| Csouffle::WriteCoutPrintSizeFactory | |
| Csouffle::WriteFileCSVFactory | |
| Csouffle::WriteFileJSONFactory | |
| Csouffle::WriteSQLiteFactory | |
| Carray | |
| Carray< std::atomic< value_type * >, maxContainers > | |
| CComparator | |
| Cconst bool | |
| Cconst long long | |
| CEqrelMapComparator< StorePair > | |
| Cmap< TypeVar, value_type > | |
| Cobject | |
| Ctype | |
| Ctype | |
| CVecOwn< souffle::interpreter::Index > | |
