| ▼NUtopia | |
| ►N_Metaprogramming_helpers | |
| Capply_impl | Prototype for apply_impl |
| Capply_impl< Metafunc, Tuplelike, std::index_sequence< idxs... > > | Metafunction which applies an arbitrary metafunction to a tuplelike object - backend implementation |
| ►NDataIO | |
| ►N_DMUtils | |
| Call_callable | Metafunction for use with boost hana, check if all T are callable types |
| ►NDefault | |
| CAlwaysDecider | Decider which always returns true |
| CCompositeDecider | Combines a number of deciders; returns true if any of them is true |
| CDecider | Common interface for all deciders (and triggers, for that matter). Every decider/Trigger must inherit from this, and implement its virtual functions 'bool operator()(Model&)' and 'void set_from_cfg(const Config&)' |
| CDefaultExecutionProcess | Functor representing what is considered the most widely used execution process for writing data |
| CIntervalDecider | A decider that returns true when within certain time intervals |
| COnceDecider | Decider which only returns true at a certain time |
| CDataManager | Manage different tasks of writing out data from a source in a uniform yet flexible way. This is a class which, when being supplied with appropriate callables, manages their execution |
| CDataManagerFactory | Factory function which produces a Datamanager of type Default::DefaultDataManager<Model> from a config and argumets from which to construct writetasks |
| CDataManagerTraits | Type traits for the DataManager This allows to specify custom types for the DataManager. Usually, you only need to touch this if you do not want to use the defaults or if you want to need to explicitly specify a common base class because it cannot be deduced automatically |
| CDatasetDescriptor | Descriptor for a dataset. Contains: path: string giving the path of the dataset in its group or file with_time_postfix: whether the current model time is appended to the dataset path dataset_capacity: vector giving capacity of the dataset per dimension dataset_chunksize: vector giving chunksize per dimension of the dataset dataset_compression: integer giving compression strength (0 to 10) |
| CHDFAttribute | Class for hdf5 attribute, which can be attached to groups and datasets |
| CHDFBufferFactory | Class which turns non-vector or plain-array containers into vectors. If the value_types are containers themselves, these are turned into vectors as well, because HDF5 cannot write something else |
| CHDFDataset | Class representing a HDFDataset, wich reads and writes data and attributes |
| CHDFDataspace | Class that wraps an HDF5 dataspace and takes care of managing its resources |
| CHDFFile | Class representing a HDF5 file |
| CHDFGroup | Class represting a HDFGroup, an object analogous to a folder for HDFFiles |
| CHDFIdentifier | Wrapper class around an hdf5 identifier, used to manage reference counts of the object this identifier refers to |
| CHDFObject | Common base class for all HDF5 classes in the DATAIO Module i.e., for all classes that wrap HDF5-C-Library functionality like HDFDataset, HDFGroup, HDFFile. This class is not intendet as something to be used independently, but only as a base class to be inherited from |
| CHDFType | Class which handles the conversion of C-types into hdf5types |
| Cis_callable | Test whether an object is callable |
| CMonitor | The Monitor monitors entries that are emitted if a given time has passed |
| CMonitorManager | The MonitorManager manages the monitor entries and MonitorTimer |
| CMonitorTimer | The MonitorTimer keeps track of the time when to emit monitor data |
| CTaskFactory | Functor for building a writetask from arguments |
| CWriteTask | Encapsulate a task for writing data to a destination. Containes a callable 'writer' responisible for writing data to a held dataset. Contains a callabel 'build_dataset' which builds or opens a dataset for writing to in a held HDFGroup. A WriteTask is bound to a group for its entire lifetime |
| ►NItertools | Tools for iterating over collections |
| Czip | A range defined by instances of ZipIterator |
| CZipIterator | Iterator over an arbitrary number of collections |
| ►NModels | |
| ►NContDisease | |
| CContDisease | Contagious disease model on a grid |
| CInfectionContParams | Parameters specifying the infection control |
| CParams | Parameters of the ContDisease |
| CState | The full cell struct for the ContDisease model |
| ►NCopyMeBare | |
| CCopyMeBare | The CopyMeBare Model; the bare-basics a model needs |
| ►NCopyMeGraph | |
| CCopyMeGraph | The CopyMeGraph Model; a good start for a graph-based model |
| CEdgeState | The edge state |
| CVertexState | The vertex state |
| ►NCopyMeGrid | |
| CCellState | The type of a cell's state |
| CCopyMeGrid | The CopyMeGrid Model; a good start for a CA-based model |
| ►NDummy | |
| CDummy | Dummy model with simple update rule |
| ►NEnvironment | |
| ►NFuncBundle | |
| CFuncBundle | A bundle wrapping a (iterative) function with metadata |
| CParamFuncBundle | A bundle wrapping a (iterative) function with metadata |
| CRuleFuncBundle | A bundle wrapping a (rule-)function with metadata |
| CBaseEnvCellState | Base type for environment cell states |
| CBaseEnvParam | Base type for environment parameter |
| CDummyEnvCellState | Dummy type for environment cell states |
| CDummyEnvParam | Dummy type for environment parameter |
| ►CEnvironment | The Environment model provides a non-uniform, dynamic parameter background |
| CDummyCellManager | A dummy CellManager type that is used in standalone mode |
| ►NForestFire | |
| CForestFire | The ForestFire model |
| CParam | ForestFire model parameter struct |
| CState | The full cell struct for the ForestFire model |
| ►NGameOfLife | |
| CCellState | The type of a cell's state |
| CGameOfLife | The GameOfLife Model |
| ►NGeomorphology | |
| CGeomorphology | A very simple geomorphology model |
| CGeomorphologyCell | The full cell struct for the Geomorphology model |
| ►NHdfBench | |
| CHdfBenchModel | The HdfBench Model |
| ►NOpinionet | |
| ►NRevision | |
| CTestNetworkD | |
| CTestNetworkU | |
| ►NUtils | |
| CInfrastructure | |
| CTestNetworkD | |
| CTestNetworkD_small | |
| CTestNetworkU | |
| CAgent | Each node in the network accomodates a single agent |
| CEdge | Each network edge has a weight representing an interaction probability |
| COpinionet | The Opinionet model class |
| ►NPredatorPrey | |
| CPredatorParams | Struct that holds all predator-specific parameters |
| CPredatorPrey | PredatorPrey Model on grid cells |
| CPreyParams | Struct that holds all prey-species specific parameters |
| CSpeciesBaseParams | Struct that holds all species-specific parameters |
| CSpeciesParams | The parameter of all species |
| CSpeciesState | Struct that holds all species states |
| CState | Cell State struct |
| ►NPredatorPreyPlant | |
| CPlantParams | The parameters characterizing plants |
| CPlantState | Struct that holds all plant characterising states |
| CPredatorParams | Struct that holds all predator-specific parameters |
| CPredatorPreyPlant | PredatorPreyPlant Model on grid cells |
| CPreyParams | Struct that holds all prey-species specific parameters |
| CSpeciesBaseParams | Struct that holds all species-specific parameters |
| CSpeciesParams | The parameter of all species |
| CState | Cell state, combining states for predator, prey and plant species |
| ►NSandPile | |
| CSandPile | The SandPile Model |
| CState | Cell State for the SandPile model |
| ►NSEIRD | |
| CCounters | A struct holding counters for state transitions and other global counters |
| CExposureContParams | Parameters specifying the exposure control |
| CImmunityContParams | Parameters specifying the immunity control |
| CParams | Parameters of the SEIRD |
| CSEIRD | SEIRD model on a grid |
| CState | The full cell struct for the SEIRD model |
| CTransmitContParams | Parameters specifying the transmit control |
| ►NSimpleEG | |
| CCellState | The type of the cell state for the SimpleEG model |
| CSimpleEG | Simple model of evolutionary games on grids |
| ►NSimpleFlocking | |
| CAgentState | An agent's state |
| CInfrastructure | |
| CSimpleFlocking | The SimpleFlocking Model |
| ►NVegetation | |
| CCellState | State of a cell in the Vegetation model, consisting only of plant mass |
| CVegetation | A very simple vegetation model |
| ►NTestTools | |
| CBaseInfrastructure | A base class for an infrastructure fixture |
| CLocationInfo | Bundles and handles file location information: file path and line number |
| ►NUtils | |
| Capply | Apply the metafunction 'Metafunc' to a tuplelike type 'Tuplelike' |
| Cget_size | Return the size of a Type T containing other types at compile time. If no object for which an overload exists is passed, the get_size::value defaults to 1, indicating a scalar. If you want to have another type to be usable with get_size, provide an overload for it as shown by the various overloads existing for get_size already |
| Cget_size< arma::fmat::fixed< N, M > > | Overload of get_size for armadillo type |
| Cget_size< arma::frowvec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< arma::fvec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< arma::imat::fixed< N, M > > | Overload of get_size for armadillo type |
| Cget_size< arma::irowvec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< arma::ivec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< arma::mat::fixed< N, M > > | Overload of get_size for armadillo type |
| Cget_size< arma::rowvec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< arma::s32_mat::fixed< N, M > > | Overload of get_size for armadillo type |
| Cget_size< arma::s32_rowvec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< arma::s32_vec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< arma::u32_mat::fixed< N, M > > | Overload of get_size for armadillo type |
| Cget_size< arma::u32_rowvec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< arma::u32_vec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< arma::umat::fixed< N, M > > | Overload of get_size for armadillo type |
| Cget_size< arma::urowvec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< arma::uvec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< arma::vec::fixed< N > > | Overload of get_size for armadillo type |
| Cget_size< boost::hana::tuple< Ts... > > | Overload for hana tuples |
| Cget_size< std::array< T, N > > | Overload for std::array |
| Cget_size< std::pair< A, B > > | Overload for std::pair |
| Cget_size< std::tuple< Ts... > > | Overload for std::tuple |
| Chas_edge_descriptor | Check if a type T has a edge descriptor |
| Chas_edge_descriptor< T, std::void_t< typename T::edge_descriptor > > | Check if a type T has an edge descriptor |
| Chas_static_size | Determine if type T is tuple_like, i.e., has a compile time constant size which is smaller than std::numeric_limits< std::size_t >::max() = 18446744073709551615. This size is unreasonable and hence used to check invalidity |
| Chas_static_size_base | Determine if type T is 'tuplelike'. This is not intended to be used explicitly, refer to 'has_static_size', which serves this purpose |
| Chas_static_size_base< T, std::numeric_limits< std::size_t >::max() > | Determine if type T is 'tuplelike' - specialization for scalars. This is not intended to be used explicitly, refer to 'has_static_size', which serves this purpose |
| Chas_vertex_descriptor | Check if a type T has a vertex descriptor |
| Chas_vertex_descriptor< T, std::void_t< typename T::vertex_descriptor > > | Check if a type T has a vertex descriptor |
| Cis_array_like | Check if a given type is homogeneous and has a size which is a compile time constant. The most common type which fulfils these requirements is std::array, hence the name 'is_array_like'. For a new type to be considered array_like, this functor has to be overloaded together with get_size |
| Cis_array_like< T, std::void_t< std::enable_if_t< get_size_v< T > !=std::numeric_limits< std::size_t >::max() and is_container_v< T > >, int > > | Check if a given type is a container and has a size which is a compile time constant. The most common type which fulfils these requirements is std::array, hence the name 'is_array_like'. For a new type to be considered array_like, this functor has to be overloaded together with get_size |
| Cis_associative_container | Check if a type T is an associative container type, i.e. a container type T that defines T::key_type and T::key_compare. Check out https://en.cppreference.com/w/cpp/named_req/AssociativeContainer for more details |
| Cis_associative_container< T, std::void_t< std::enable_if_t< is_container_v< T >, int >, typename T::key_type, typename T::key_compare > > | Check if a type T is an associative container type, i.e. a container type T that defines T::key_type and T::key_compare. Check out https://en.cppreference.com/w/cpp/named_req/AssociativeContainer for more details |
| Cis_callable | Check if a type T is callable, i.e., if it has |
| ►Cis_callable< T, std::void_t< std::enable_if_t< std::is_class_v< std::decay_t< T > >, T > > > | Determines if the type T implements a call operator with arbitrary signature |
| CCheck | |
| CDerived | |
| CFallback | |
| Cis_container | Check if a type is a container type, which does not include string types |
| Cis_container< T, std::void_t< std::enable_if_t< is_iterable_v< remove_qualifier_t< T > > and not is_string_v< remove_qualifier_t< T > >, int > > > | Check if a type T is a container type. A container for us is every iterable that is not a string |
| Cis_graph | Check if some type T is a graph by checking if it has edge - and vertex_descriptors |
| Cis_graph< T, std::void_t< std::enable_if_t< has_edge_descriptor_v< T > and has_vertex_descriptor_v< T >, int > > > | Check if some type T is a graph by checking if it has edge_- and vertex_descriptors |
| Cis_iterable | Check if a type T is iterable, i.e., if it defines T::iterable |
| Cis_iterable< T, std::void_t< typename T::iterator > > | Check if a type T is iterable, i.e., if it defines T::iterable |
| Cis_linear_container | Check if a type T is a linear container. A linear container for us is any type T that is a container and neither an associative nor an unordered associative container |
| Cis_linear_container< T, std::void_t< std::enable_if_t< not is_associative_container_v< T > and not is_unordered_associative_container_v< T > and is_container_v< T >, int > > > | Check if a type T is a linear container. A linear container for us is any type T that is a container and neither an associative nor an unordered associative container |
| Cis_random_access_container | Check if a type T is a random access container, i.e., any container type T that has an iterator tagged with std::random_access_iterator_tag |
| Cis_random_access_container< T, std::void_t< std::enable_if_t< is_linear_container_v< T > and std::is_convertible_v< typename std::iterator_traits< typename T::iterator >::iterator_category, std::random_access_iterator_tag > > > > | Check if a type T is a random access container, i.e., any container type T that has an iterator tagged with std::random_access_iterator_tag |
| Cis_string | Check if a type T is a string-like type, i.e. std::basic_string, const char*, char*, or basic_string_view |
| Cis_string< char * > | Overload of is_string for pure char* |
| Cis_string< const char * > | Overload of is_string for pure const char* |
| Cis_string< std::basic_string< Ts... > > | Overload of is_string for basic_string |
| Cis_string< std::basic_string_view< Ts... > > | Overload of is_string for basic_string_view |
| Cis_unordered_associative_container | Check if a type T is an unordered associative container type, i.e. a container type T that defines T::key_type, T::value_type and T::hasher. Check out https://en.cppreference.com/w/cpp/named_req/UnorderedAssociativeContainer for more details |
| Cis_unordered_associative_container< T, std::void_t< std::enable_if_t< is_container_v< T >, int >, typename T::key_type, typename T::value_type, typename T::hasher > > | Check if a type T is an unordered associative container type, i.e. a container type T that defines T::key_type, T::value_type and T::hasher. Check out https://en.cppreference.com/w/cpp/named_req/UnorderedAssociativeContainer for more details |
| CNothing | Represent a type that does nothing and represents nothing, hence can be used in metaprogramming whenever no action is desired |
| Cremove_pointer | Helper function for removing pointer qualifiers from a type recursivly This is the recursion base case |
| Cremove_pointer< T, std::enable_if_t< std::is_array_v< T >, std::void_t<> > > | Oveload of remove_pointer metafunction for array types (stack allocated) |
| Cremove_pointer< T, std::enable_if_t< std::is_pointer_v< T >, std::void_t<> > > | Helper function for removing pointer qualifiers from a type recursivly Provides a member type definition called 'type' which is equal to T if the first template argument is of type T* or T** or T***.. |
| Cremove_qualifier | Function for removing the qualifiers from a type T. Qualifiers are 'const', 'volative', pointer, reference or any legal combination thereof |
| CAgent | An agent is a slightly specialized state container |
| CAgent< Traits, Space, std::enable_if_t< Traits::mode !=Update::sync > > | Agent specialization for asynchronous update |
| CAgent< Traits, Space, std::enable_if_t< Traits::mode==Update::sync > > | Agent Specialisation for synchronous update |
| CAgentManager | The agent manager manages the agents living in a model |
| CCell | A cell is a slightly specialized state container |
| CCellManager | Manages a physical space, its grid discretization, and cells on that grid |
| CDefaultTag | |
| CEmptyTag | |
| CEntity | An entity is a slightly specialized state container |
| CEntityTraits | The entity traits struct gathers types to be used for specializing an entity |
| CException | The base exception class to derive Utopia-specific exceptions from |
| CGotSignal | An exception for when the program should end due to handling of a signal |
| CGraphEntity | A graph entity is a slightly specialized state container |
| CGrid | The base class for all grid discretizations used by the CellManager |
| CHexagonalGrid | A grid discretization using hexagonal cells |
| Cis_agent_manager | Metafunction to determine whether a Manager is an AgentManager |
| Cis_cell_manager | Metafunction to determine whether a Manager is a CellManager |
| CKeyError | For access to a dict-like structure with a bad key |
| CModel | Base class interface for Models using the CRT Pattern |
| CModelTypes | Wrapper struct for defining model class data types |
| CNoCustomLinks | Default struct for EntityTraits; use this one if there are no custom links |
| COutOfSpace | An exception class for invalid positions in Utopia::Space |
| CParallelExecution | Static information on the status of parallel execution |
| CPseudoParent | A class to use at the top level of the model hierarchy as a mock parent |
| Crule_invoke_result | Helper class for checking rule signatures and return types |
| CSpace | The Space bundles properties about the physical space a model resides in |
| CSquareGrid | A grid discretization using square cells |
| CStateContainer | Container for states |
| CStateContainer< StateType, Update::async > | State Container specialization for async states |
| CStateContainer< StateType, Update::manual > | A very simple, default constructible container with public members |
| CStateContainer< StateType, Update::sync > | State Container specialization for sync states |
| CTriangularGrid | A grid discretization using triangular cells |
| CEnvCellState | A non-abstract EnvCellState, derived from the base class |
| CEnvParam | A non-abstract EnvParam, derived from the base class |
