| ►Ctcp::AbstractMessage | Base class for messages which can be sent, received and processed by the Tcp-classes. |
| ►Ctcp::Message | Contains a data stream which can be sent and received by the Tcp classes |
| Ctcp::ServerMessage | Is a special Tcp message for the Server. The socket is included so that the server knows to whom it should send the data. |
| ►Ctcp::ServerAcceptMessage | A special Tcp message, with which the ServerAcceptReceiver can register a new Client. |
| Ctcp::ServerMessage | Is a special Tcp message for the Server. The socket is included so that the server knows to whom it should send the data. |
| Cglo::AllSetIndexInfo | For transmitting index information. |
| Cglo::AllSetIteratorResult | BasePersistent objects can be queried from the database. If the BasePersistent object is locked, the ObjID should still be delivered. This is the class for the response object. |
| Cglo::TableReaderInterface::AllSetObjectStrIndexIteratorItem | Objects of this type are managed in the m_pAllSetObjectStrIndexIteratorMap to ensure that an AllSet with index can be reopened in method TableReaderInterface::setTransactionIndexPool(TransactionIndexPool*). |
| Cglo::AllSetStruct | Is needed to transfer AllSet information in a OrderMsg |
| ►Cptl::ATDVList | Abstract superclass for template lists that include a pointer to objects or objects as copies in the list. |
| Cptl::TDVList< ini::Line > | |
| Cptl::TDVList< T_DATA > | Template list class for pointers to objects |
| Cglo::AttributeID | This class reflects a unique ID of a class information attribute |
| ►Cptl::AVDVList | Base class for void-pointer lists |
| Cptl::VDVList | A void-pointer list |
| Cglo::Base | This class is the interface to the persistent objects. Here "objects" can be registered, saved, requested, deleted, locked, released etc |
| Cglo::BaseFitter | If there is something wrong with a GlobalObjects database, or if it needs to be handled otherwise, the object of this class is the right place to go.
Here you can repair and copy over |
| Cglo::BaseMaker | Generated using the SchemaInterface, data tables, C++ header and source files etc. |
| ►Cglo::BaseRecordAttribute | Base class for the individual attributes of a Record |
| Cglo::BlobRecordAttribute | Class for the blob attributes of a Record |
| Cglo::BoolRecordAttribute | Class for the bool attributes of a Record |
| ►Cglo::FNumRecordAttribute | Represents as superclass all floating point number attributes of a persistent object. |
| Cglo::DoubleRecordAttribute | Class for the double attributes of a Record |
| Cglo::FloatRecordAttribute | Class for the float attributes of a Record |
| Cglo::LongDoubleRecordAttribute | Class for the long double attributes of a Record |
| ►Cglo::IDRecordAttribute | Superclass for ObjID and ObjID reference attributes of a Record. |
| ►Cglo::APointerRecordAttribute | Abstract class for pointer and embeddet attributes of a Record. |
| Cglo::EmbeddedRecordAttribute | Class for the embedded persistent object attributes of a Record. Represents an attribute of the derived type of Persistent. The embedded object is generally loaded with the owning object. |
| Cglo::PoRefRecordAttribute | Class for pointers to persistent object attributes of a Record. Represents an attribute of the derived type of Persistent. The referenced object is generally loaded together with the owner object. |
| Cglo::StdShrdPoRefRecordAttribute | A class for a std::shared_ptr on persistent object attributes of a Record. Represents an attribute of type 'std::shared_ptr<MyPersClass>' and MyPersClass is a persistent object. The referenced object is generally loaded together with the owner object. |
| Cglo::ObjIDRecordAttribute | A class for the object ID attributes of a Record. Represents an attribute of type 'ObjID'. |
| Cglo::OdRefRecordAttribute | Class for the on-demand reference attributes of a Record. Represents an attribute of type 'TOndemand<MyPersClass>' and MyPersClass is a persistent object. The referenced object is generally not automatically loaded with the owning object. |
| ►Cglo::INumRecordAttribute | Represents as superclass all integer attributes of a Record. |
| Cglo::CharRecordAttribute | Class for the char attributes of a Record. Represents an attribute of type 'char' of a Record. |
| Cglo::DateTimeRecordAttribute | Class for the DateTime attributes of a Record. Represents an attribute of the type 'std::time_t' of a persistent object. |
| Cglo::IntRecordAttribute | Class for the integer attributes of a Record. Represents an attribute of the type 'int' of a persistent object. |
| Cglo::LongLongRecordAttribute | Class for the long long attributes of a Record. Represents an attribute of the type 'long long' of a persistent object. |
| Cglo::LongRecordAttribute | Class for the long attributes of a Record. Represents an attribute of the type 'long' of a persistent object. |
| Cglo::ShortRecordAttribute | Class for the short attributes of a Record. Represents an attribute of the type 'short' of a persistent object. |
| Cglo::UCharRecordAttribute | Class for the unsigned char attributes of a Record. Represents an attribute of the type 'unsigned char' of a persistent object. |
| Cglo::UIntRecordAttribute | Class for the unsigned integrer attributes of a Record. Represents an attribute of the type 'unsigned int' of a persistent object. |
| Cglo::ULongLongRecordAttribute | Class for the unsigned long long attributes of a Record. Represents an attribute of the type 'unsigned long long' of a persistent object. |
| Cglo::ULongRecordAttribute | Class for the unsigned long attributes of a Record. Represents an attribute of the type 'unsigned long' of a persistent object. |
| Cglo::UShortRecordAttribute | Class for the unsigned short attributes of a Record. Represents an attribute of the type 'unsigned short' of a persistent object. |
| ►Cglo::LotRecordAttribute | Base class for item container attributes of a Record. |
| Cglo::OdRefListRecordAttribute | Class for the ondemand list attributes of a Record |
| Cglo::OdRefSetRecordAttribute | Class for the ondemand set attributes of a Record |
| Cglo::PoRefListRecordAttribute | Class for the pointer list attributes of a Record |
| Cglo::PoRefSetRecordAttribute | Class for the pointer set attributes of a Record |
| ►Cglo::TypeLotRecordAttribute | Base class for string-, integer- and double-container attributes of a Record. |
| ►Cglo::DoubleLotRecordAttribute | Base class for different double-container attributes of a Record. |
| Cglo::DoubleListRecordAttribute | Class for the double-list attributes of a Record |
| Cglo::DoubleSetRecordAttribute | Class for the double-set attributes of a Record |
| Cglo::DoubleVectorRecordAttribute | Class for the double-vector attributes of a GloRecord |
| ►Cglo::IntLotRecordAttribute | Base class for different integer-container attributes of a Record. |
| Cglo::IntListRecordAttribute | Class for the integer-list attributes of a Record |
| Cglo::IntSetRecordAttribute | Class for the integer-set attributes of a Record |
| Cglo::IntVectorRecordAttribute | Class for the integer-vector attributes of a Record |
| ►Cglo::StringLotRecordAttribute | Base class for different string-container attributes of a Record. |
| Cglo::StringListRecordAttribute | Class for the string-list attributes of a Record |
| Cglo::StringSetRecordAttribute | Class for the string-set attributes of a Record |
| Cglo::StringVectorRecordAttribute | Class for the string-vector attributes of a Record |
| Cglo::StringRecordAttribute | Class for the string attributes of a Record. Represents an attribute of the type 'std::string' of a persistent object. |
| Ceut::Blob | This class allows to edit a blob (insert, copy, search etc.). |
| ►Cglo::CallBack | Superclass for the classes that are 'connected' to a Base |
| ►Cglo::AbstractBaseLot | The base class for container with persistent objects. |
| ►Cglo::BaseAllSet | Is the base class of template AllSets and the generic AllSet |
| Cglo::GenericAllSet | AllSet, which returns generic objects |
| Cglo::TAllSet< T > | AllSet, which returns objects from the database |
| ►Cglo::BaseLot | Is the base class of pointer and on-demand sets or pointer and on-demand lists. |
| ►Cglo::OndemandLot | Is the abstract base class of on-demand sets and lists. |
| ►Cglo::OndemandList | Is the base class of Template-Ondemand-List. The objects are managed in a std::list.
Objects can also be inserted multiple times and in any order. |
| Cglo::TOndemandList< T > | A type-safe list of references to persistent objects in the database (intended as an attribute for persistent objects) |
| ►Cglo::OndemandSet | Is the base class of Template-Ondemand-Set.
Objects can be inserted only once. |
| Cglo::TOndemandSet< T > | A type-safe set of references to persistent objects in the database (intended as an attribute for persistent objects).
Objects can be inserted only once |
| ►Cglo::PointerLot | Is the abstract base class of pointer sets and lists. |
| ►Cglo::PointerList | Is the base class of a template list. The persistent objects are managed in a std::list.
Objects can also be inserted multiple times and in any order. |
| Cglo::TPointerList< T > | A type-safe list of pointers to persistent objects in the database (intended as an attribute for persistent objects) |
| ►Cglo::PointerSet | Is the base class of a template set. The persistent objects are managed in a std::set.
Objects can be inserted only once. |
| Cglo::TPointerSet< T > | A type-safe set of pointers to persistent objects in the database (intended as an attribute for persistent objects).
Objects can be inserted only once |
| ►Cglo::BasePersistent | Abstract base class for Persistent and the generic GenericPersistent |
| Cglo::GenericPersistent | Generic persistent class. Does not require ObjCreator or ObjectMaker. Objects from the database can be edited without having to know their type |
| Cglo::Persistent | The base class of the persistent classes. All persistent classes must be derived from this class to be able to process their objects in the database |
| ►Cglo::Reference | The base class of a reference attribute from persistent objects to other persistent objects in the database. |
| Cglo::TOndemand< T > | A reference (as attribute) of a persistent object to another persistent object in the database |
| Ceut::FileHelper::CallBackFileDirFount | |
| Cglo::CallBackSpy | Class to access the CallBack objects of a database in memory |
| Cglo::ClassInfo | This class contains all information to store objects of a class in a database, to build objects from tables and to build tables from objects |
| ►Cglo::ClassInfoItem | Base class of a ClassInfoAttribute and a ClassInfoIndex |
| Cglo::ClassInfoAttribute | In objects of this class, the information for GlobalObjects is how a persistent class attribute is structured |
| Cglo::ClassInfoIndex | In objects of this class, the information for GlobalObjects is how an index is structured |
| Cglo::WatchNotifyManager::ClassWatch | Monitoring class for AllSets. |
| Cglo::ClientInfo | A structure to transport client data between database and client. |
| Cglo::WatchNotifyManager::ClientWatch | Monitoring class for client logins and logouts. |
| ►Cglo::WatchNotifyManager::CommunicatorCallBackIndex | Base class of a unique index for maps of derived classes of CommunicatorNotifyModes and as index for the static action lists. |
| Cglo::WatchNotifyManager::CommunicatorCallBackClassIndex | Is a unique index for maps of CommunicatorClassNotifyModes and as index for the static action lists. |
| Cglo::WatchNotifyManager::CommunicatorCallBackClientIndex | Is a unique index for maps of CommunicatorClientNotifyModes and as index for the static action lists. |
| Cglo::WatchNotifyManager::CommunicatorCallBackIndexReadWriteIndex | Is a unique index for maps from CommunicatorCallBackIndexReadWriteIndex and as index for the static action lists. |
| Cglo::WatchNotifyManager::CommunicatorCallBackObjIndex | Is a unique index for maps of CommunicatorObjNotifyModes and as index for the static action lists. |
| ►Cglo::WatchNotifyManager::CommunicatorNotifyModes | Basic class of the individual monitoring or notification modes. |
| Cglo::WatchNotifyManager::CommunicatorClassNotifyModes | Monitoring or notification mode of AllSets. |
| Cglo::WatchNotifyManager::CommunicatorClientNotifyModes | Monitoring or notification mode of client logins and logouts. |
| Cglo::WatchNotifyManager::CommunicatorIndexReadWriteNotifyModes | Monitoring or notification mode for read index, write index and reindex actions of the database |
| Cglo::WatchNotifyManager::CommunicatorObjNotifyModes | Monitoring or notification mode of objects with their dependent objects. Dependent objects are the embedded or directly loaded objects in pointers and pointer lists. |
| Cglo::LockManager::LockedObject::CommunicatorRightsRestrictions | The individual lock modes of the object with object ID from LockedObject::m_LockObjektID for a communicator |
| Cglo::TransactionManager::CommunicatorTransactionStack | The transaction stack of a client communicator for a database. |
| Ceut::CriticalSection | Is a mutex which can be queried via its lock mode. See isLocked() |
| Cglo::DataStreamer | This class encodes or decodes data for transport in a TCP packet |
| Cglo::IndexPool::DeletedObjIdTuple | Class to manage deleted objects in the IndexPool::SchemaIndex |
| Cglo::DependentObjsWithDeepMode | A structure to transport multiple object IDs with a 'depth mode'. |
| Cptl::DVElement | Element of double linked lists |
| ►CEuAPThread | Abstract superclass for threads |
| CEuEndlessPThread | Base class for a thread that executes its work endlessly until aborted |
| ►CEuPCriticalSection | Is a mutex which can be queried via its lock mode. See isLocked() |
| CEuGlobalPCriticalSection | This class is a global Critical Section and is designed as a Singelton Class |
| ►Cstd::exception | STL class |
| ►Cstd::runtime_error | STL class |
| Ceut::ErrorNException | This exception class has an integer attribute for an error number in addition to the message. |
| Cini::File | An INI file contains information for programs |
| Cglo::Forgeter< T > | Especially for GenericPersistent or derived classes of Persistent the Forget method for std::shared_ptr |
| Cglo::GenPersObjectSpy | Class to access the generic persistent objects of a database in memory |
| Cglo::ClassInfoIndex::IndexAttributeItem | Information for the index about which attribute from which class, with how many characters, belongs to the index. |
| ►Cglo::IndexPool::IndexFilter | Filters can be assigned to objects of the type ObjectStrIndexIterator, which control the iteration by an ObjectStrIndex.
This filter has an index filter expression in m_sIndexFilterValue. |
| Cglo::IndexPool::IndexComparisionFilter | Filters can be assigned to objects of the type ObjectStrIndexIterator, which control the iteration by an ObjectStrIndex.
With this structure, a filter can be defined using "<", "<=", ">", ">=", "==" and "!=". For example, if m_sIndexFilterValue has the value "123" and m_eComparisionOperator has the value GREATER_EQUAL, only all objects with an index greater than or equal to "123" will be filtered out. |
| Cglo::IndexPool::IndexRangeFilter | Filters can be assigned to objects of the type ObjectStrIndexIterator, which control the iteration by an ObjectStrIndex.
With this structure a filter can be defined by means of a range specification. For example, if m_sIndexFilterValue has the value "123" and m_sIndexFilterEndValue has the value "155", all Objects with an index lower than "123" and higher than "155" will be filtered out. Thus, only all objects with an index greater than/equal to "123" and less than/equal to "155" will be delivered in case of a query. |
| Cglo::BaseAllSet::IndexNameClassIdTuple | Tuple of IndexName and the class ID of the indexed class. |
| ►Cglo::IndexPool | IndexPool is the base class for the RealIndexPool and the TransactionIndexPool for the individual transactions |
| Cglo::RealIndexPool | The real index as opposed to the TransactionIndexPool, which is created for each transaction |
| Cglo::TransactionIndexPool | This index is generated in each transaction and changes such as saving, deleting or inserting an object are only entered here until the transaction is committed or aborted. |
| ►Cglo::IndexQueryBaseStruct | |
| Cglo::ComparisionIndexQueryStruct | Is needed to transfer index query information in a OrderMsg.
By means of this structure results can be determined using "<", "<=", ">", ">=", "==" and "!=".
For example, if the Index has the value "123" and the comparision operator has the value LESS, all objects with an index lower than "123" will be returned. |
| Cglo::IndexQueryStruct | Is needed to transfer index query information in a OrderMsg. |
| Cglo::RangeIndexQueryStruct | Is needed to transfer index query information in a OrderMsg.
By means of this structure, results can be determined by means of range specification.
For example, if m_sIndex has the value "123" and m_sRangeEndIndex has the value "155", all objects with an index greater than/equal to "123" and less than/equal to "155" will be delivered. |
| Cglo::WatchNotifyManager::IndexReadWriteWatch | Monitoring class for read-index, write-index and reindex actions of the database. |
| Cglo::Record::IndexStrNameTuple | IndexStrNameTuples hold an index as a sortable string, its name and the class ID of the class being indexed (can be a superclass of the class with the record) and whether the index is unique. |
| Cglo::LimitRecord | In objects of this class the min and max values of supported data types and their field lengths are transported in the tables. |
| ►Cini::Line | Is a comment line, but also superclass for Section and Key. |
| Cini::Key | A variable with value possibly also in a section like "Pixel=1024". Variable and value are separated by a "=". |
| Cini::Section | A section can only appear once in an INI file, is enclosed in square brackets and usually has variables with values. |
| Cini::LineFactory | This class turns lines of an INI file into objects of the types Line, Section or Key. |
| Cglo::LockManager::LockedObject | Objects can be locked. Objects of this class represent an object locked by the communicator, with possibly also locked objects like embedded objects. |
| Cglo::LockManager | Objects of this class monitor the lock state of persistent objects |
| Cglo::LockPossibleSpecification | Permitted actions in the database such as read, write and delete can be queried for an object. This is the answer. |
| Cglo::LockSpecification | To be able to lock objects, the 'lock mode' and the 'lock depth' are required as parameters. This is possible with this structure. |
| Cglo::ManagerActionVisualiser | Shows the actions of the Manager via std::cout |
| ►Cglo::WatchNotifyManager::NotifyInfo | Base class for different Notify-Infos, which are used in a order to the WatchNotifyManager. |
| Cglo::WatchNotifyManager::NotifyClientInfo | Is used for notifying information about clients in a job to the WatchNotifyManager. |
| Cglo::WatchNotifyManager::NotifyIndexReadWriteInfo | Is used for Notify-Infos to monitor the reading, writing and reindexing of the indexes in an order to the WatchNotifyManager. |
| Cglo::WatchNotifyManager::NotifyObjInfo | Is used for notifying information about objects in an order to the WatchNotifyManager. |
| Cglo::NotifyNote | Object info of the WatchNotifyManager for the watching instance.
See detailed description in the manual under "Watching / notifying persistent objects". |
| Cglo::ObjCreator | Abstract superclass for instantiation functions of persistent classes. From this class a subclass is derived for each database from a schema, which can instantiate persistent objects from the class IDs |
| Cglo::ObjectMaker | This class can instantiate a persistent object from a record or fill a persistent object and vice versa. |
| Cglo::IndexPool::ObjectStrIndex | Manages the individual string indices of a class. If this is a unique index, the ObjStrIdTuple are in a map, otherwise in a MultiMap. Then indexes in a MultiMap can be inserted as reserved, this is taken into account when inserting further. |
| Cglo::IndexPool::ObjectStrIndexIterator | Has a pointer to an ObjectStrIndex and allows iteration through this index. Is instantiated e.g. for AllSets so that they can iterate independently through StringIndexes. |
| Cglo::WatchNotifyManager::ObjectWatch | Monitoring class for objects. |
| Cglo::ObjID | An object ID consists of the class ID, a database ID and the actual unique object number (all unsigned long) |
| Cglo::IndexPool::ObjIdPosTuple | Class to manage objects in the IndexPool::TableObjIdIndex |
| Cglo::ObjIDRecordTuple | A tuple of record and object ID |
| Cglo::Manager::ObjIdWithDepends | A structure to map the object ID of a persistent object with the data records of the dependent objects (dependent means; should be saved, deleted, monitored, locked, etc.). |
| Cglo::IndexPool::ObjStrIdTuple | Class to manage objects in the IndexPool::ObjectStrIndex |
| Cglo::OpenSpecification | To open a database this info is inserted into OrderMsg. |
| Cglo::OrderMsg | This class is used to handle the communication between the application that uses GlobalObjects and GlobalObjects |
| Cglo::PersObjectSpy | Class to access the persistent objects of a database in memory |
| Cglo::PrivateBase | In this class functions for Base are encapsulated. The Base interface is not affected by any changes in functionality. |
| ►Cglo::ReaderWriterInfo | Objects of this structure transport data to objects of type TableReaderInterface and TableWriterInterface. |
| Cglo::ReaderInfo | Objects of this structure transport data to objects of type TableReaderInterface. |
| Cglo::WriterInfo | Objects of this structure transport data to objects of type TableWriterInterface. |
| Cglo::Manager::Receiver | Is the remote station or the communicator which communicates with the Manager. In multi-user operation there can be several remote stations or communicators. |
| Cglo::Record | Objects of this class transport the data from the tables into the persistent object and from these again into the tables |
| ►Ceut::RepeatingThread | Base class for a thread that executes its work endlessly until aborted |
| Cglo::CommunicaterThread | A CommunicaterThread accepts requests for its TableReaderInterface |
| ►Cglo::Communicator | Superclass of LocalThread, ClientThread and ServerThread, because they can act as senders and receivers (communicators) of requests and inherit a send and receive method for this |
| Cglo::ClientThread | Objects of this class serve as interface between Base or PrivateBase and Manager. In the documentation the LocalThread is also called client communicator, if NOT the server communicator (ServerThread) is meant |
| Cglo::LocalThread | Serves as interface between Base or PrivateBase and Manager. In the documentation the ClientThread is also referred to as the client communicator, if NOT the server communicator (ServerThread) is meant |
| Cglo::ServerThread | An object of this class serves as interface between Manager and Base or PrivateBase |
| Cglo::Manager | The object of this class is the central point of contact for actions that deal with GlobalObjects data |
| Cglo::WatchNotifyManager | Classes to monitor persistent objects and to notify the respective clients of changes |
| ►Ctcp::ReceiverTransmitter | Superclass for all Receiver and Transmitter, which communicate via a SOCKET. |
| ►Ctcp::Receiver | Superclass for all TcpReceiver that communicate via a SOCKET and deliver their receive result to their parent object. |
| ►Ctcp::DataReceiver | Superclass for all TcpReceiver that communicate via a SOCKET and deliver their receive result, a type derived from AbstractMessage, to their "owner".
Since a message can be composed (it is a stream, which may be delivered in chunks), a buffer is created here, which contains data as long as the stream is not complete. |
| Ctcp::ClientReceiver | Class that communicates with a Server via a SOCKET and delivers its receive result of type Message to its "owner", which must be a Client. You can use the method ClientReceiver::acceptMessage(AbstractMessage * pTcpMessage) to change the delivery to the "owner" in subclasses by overwriting the method. |
| ►Ctcp::ServerReceiver | Class that communicates with a Client via a SOCKET and delivers its receive result of type ServerMessage to its "owner", which must be a Server. You can use the method ServerReceiver::acceptMessage(AbstractMessage * pTcpMessage) to change the delivery to the "owner" in subclasses by overwriting the method. |
| Cglo::TcpServerReceiver | Class that communicates with a tcp::Client via a SOCKET and delivers the result of the reception of the type Message to its parent, which must be a Server. The deliver to the parent via method acceptMessage(AbstractMessage*) has been changed by overwriting, the Manager is addressed if necessary. |
| Ctcp::ServerAcceptReceiver | Accept-Receiver accepts new clients and registers them with its parent object (usually a Server or a subclass of it). |
| Ctcp::Transmitter | A class that communicates with a Client or Server via a SOCKET and expects send data of type Message. |
| ►Ctcp::TcpMain | Superclass for Client and Server, which 'learns' its know-how in the derived classes. |
| ►Ctcp::Client | A simple TCP client class, which should learn its know-how in the derived classes |
| Cglo::Client | The client, which communicates with a GloServer. |
| ►Ctcp::Server | A simple TCP server class, which should learn its know-how in the derived classes |
| Cglo::Server | The server that communicates with Client's |
| Cglo::IndexPool::SchemaIndex | Is the index manager class for a schema resp. a database. |
| Cglo::SchemaInterface | This class is the interface to a GlobalObjects schema. It contains all class information to store objects of persistent classes in a database and to build objects from tables and tables from objects |
| Cglo::Manager::SchemaMapItem | Objects of this class represent an open database. There is one object of this class for each open database. |
| ►Ctcp::Server::ServerReceiverTransmitter | Tuple of socket Receiver and Transmitter for the Server. |
| Cglo::Server::TcpServerReceiverTransmitter | A special ServerReceiverTransmitter for the Server. Its ServerReceiver is of the derived type TcpServerReceiver and this can send orders. |
| Cglo::ClassInfo::SuperClassIdInfoTuple | This parameter class is used to deliver and receive the Superclass IDs with additional information. |
| ►Cglo::TableInterface | An object of this class or subclass accesses tables and reads or writes data records (Record) and binary files (eut::Blob) |
| Cglo::TableReaderInterface | An object of this class accesses tables and reads data records (Record) and binary files (eut::Blob) |
| Cglo::TableWriterInterface | An object of this class accesses tables and writes data records (Record) and binary files (eut::Blob) into text tables resp. the file system. |
| Cglo::TableInterface::TableInterfaceTable | A file (std::fstream) and its name. |
| Cglo::IndexPool::TableObjIdIndex | Manages the object IDs (used and released) with their position in the respective tables |
| Cglo::IndexPool::TableObjIdIndexIterator | Has a pointer to a TableObjIdIndex and allows to iterate through this index. Is instantiated e.g. for AllSets so that they can iterate through indexes independently. |
| Cglo::TDVList< T_DATA > | |
| Cglo::SchemaInterface::TempGloClassInfoIndex | Structure to collect indexes from the schema file until the end of reading |
| ►Cglo::TransactionManager::TransactionBase | Base class for TransactionPoint and TransactionStep. |
| Cglo::TransactionManager::TransactionPoint | Objects of this class reflect a transaction start. |
| Cglo::TransactionManager::TransactionStep | Objects of this class reflect a record operation. |
| Cglo::TransactionManager | class to guarantee transactions |
| Cglo::ClassInfoAttribute::Type | Summarized type information for a ClassInfoAttribute. |
| Ceut::UnsignedMagicNumber | A UnsignedMagicNumber is an artificial number consisting of numbers and letters (similar to hex numbers) |
| Cglo::WatchSpecification | To be able to watch objects, the 'watching mode', the 'watching depth' and the 'notification object' must be passed as parameters. This is possible with this structure. |
1.10.0