iceoryx_doc  1.0.1
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12]
 Ciox::posix::AccessControllerAbstraction class for the management of access control lists (ACLs)
 Ciox::concurrent::ActiveObject
 Ciox::cxx::add_const_conditionally< T, C >Conditionally add const to type T if C has the const qualifier
 Ciox::cxx::add_const_conditionally< T, const C >
 Ciox::posix::Allocator
 Ciox::cxx::always_false< uint64_t >Struct used to disable the equality operators for fixed string and char pointer; it is needed, because a simple false will be evaluated before the template is instanciated and therefore the program won't be compiled
 Ciox::cxx::newtype::AssignByValueCopy< T >
 Ciox::cxx::newtype::AssignByValueMove< T >
 Ciox::rp::AtomicRelocatablePointer< T >Minimalistic relocatable pointer that can be written and read atomically and can be stored safely in shared memory. As the basic RelocatablePointer, it must point to something in the same shared memory segment as itself since the internally used offset must be an invariant different across adress spaces. Rationale: the default RelocatablePointer cannot be used in an atomic since the copy ctor is nontrivial
 Ciox::rp::BaseRelativePointerPointer class to use when pointer and pointee are located in different shared memory segments We can have the following scenario: Pointer p is stored in segment S1 and points to object X of type T in segment S2
 Ciox::rp::BaseRelocatablePointerPointer class to use when pointer and pointee are located in the same shared memory segment We can have the following scenario: Pointer p points to object X of type T and both are stored in shared memory segment S
 Ciox::cxx::BestFittingType< Value >Get the best fitting unsigned integer type for a given value at compile time
 Ciox::cxx::internal::BestFittingTypeImpl< GreaterUint8, GreaterUint16, GreaterUint32 >Struct to find the best fitting unsigned integer type
 Ciox::cxx::internal::BestFittingTypeImpl< false, false, false >
 Ciox::cxx::internal::BestFittingTypeImpl< true, false, false >
 Ciox::cxx::internal::BestFittingTypeImpl< true, true, false >
 Ciox::concurrent::Buffer< ElementType, Capacity, index_t >
 Ciox::concurrent::Buffer< ElementType, Capacity, BufferIndex >
 Ciox::cxx::internal::call_at_index< N, T, Targs >
 Ciox::cxx::internal::call_at_index< N, T >
 CDesignPattern::Command< Arg >
 CDesignPattern::Command< void >
 Ciox::cxx::newtype::Comparable< T >
 Ciox::cxx::ConstMethodCallback< ReturnValue, Args >
 Ciox::cxx::newtype::ConstructByValueCopy< T >
 Ciox::concurrent::IndexQueue< Capacity, ValueType >::ConstructEmpty_t
 Ciox::concurrent::IndexQueue< Capacity, ValueType >::ConstructFull_t
 Ciox::cxx::convertCollection of static methods for conversion from and to string
 Ciox::cxx::newtype::Convertable< T >
 Ciox::cxx::newtype::CopyAssignable< T >
 Ciox::cxx::newtype::CopyConstructable< T >
 Ciox::posix::CreateNamedSemaphore_t
 Ciox::posix::CreateUnnamedSharedMemorySemaphore_t
 Ciox::posix::CreateUnnamedSingleProcessSemaphore_t
 CDesignPattern::Creation< DerivedClass, ErrorType >This pattern can be used if you write an abstraction where you have to throw an exception in the constructor when you for instance would like to manage a resource and the constructor was unable to acquire that resource. In this case you inherit from Creation and your class has three more static factory methods - create, placementCreate and verify. create forwards all arguments to the underlying class constructor and if the construction was successful an expected containing the type is returned, otherwise an error value which describes the error. Additionally, this class is providing two protected member variables m_isInitialized and m_errorValue. The user always has to set m_isInitialized to true when the object construction was successful otherwise one sets it to false and write the corresponding error cause in the provided m_errorValue variable which is then returned to the user
 CDesignPattern::Creation< FileLock, FileLockError >
 CDesignPattern::Creation< MemoryMap, MemoryMapError >
 CDesignPattern::Creation< MessageQueue, IpcChannelError >
 CDesignPattern::Creation< Semaphore, SemaphoreError >
 CDesignPattern::Creation< SharedMemory, SharedMemoryError >
 CDesignPattern::Creation< SharedMemoryObject, SharedMemoryObjectError >
 CDesignPattern::Creation< UnixDomainSocket, IpcChannelError >
 Ciox::concurrent::CyclicIndex< CycleLength, ValueType >Index structure that can contain logical values 0, ..., CycleLength-1 but also stores an internal cycle counter to be used in compare_exchange
 Ciox::cxx::DeadlineTimerThis offers the deadline timer functionality. It has user convenient methods to reset the timer [by default it uses the intialized duration], reset timer to a customized duration, check if the timer is active and user can also get to know about the remaining time before the timer goes off
 Ciox::cxx::newtype::DefaultConstructable< T >
 CDirectedGraph< VertexType, VERTEX_LIMIT, DEGREE_LIMIT >
 Ciox::cxx::internal::does_contain_type< TypeToCheck, T, Targs >
 Ciox::cxx::internal::does_contain_type< TypeToCheck, T >
 Ciox::units::Duration
 Ciox::cxx::error< T >Helper struct to create an expected which is signalling an error more easily
 Ciox::ErrorHandlerThis handler is needed for unit testing, special debugging cases and other corner cases where we'd like to explicitly suppress the error handling
 Ciox::cxx::ErrorTypeAdapter< T >Generic adapter to access INVALID_STATE member or value
 Ciox::cxx::expected< ErrorType >Expected implementation from the C++20 proposal with C++11. The interface is inspired by the proposal but it has changes since we are not allowed to throw an exception
 Ciox::cxx::expected< ValueType, ErrorType >Specialization of the expected class which can contain an error as well as a success value
 Cstd::false_type
 Ciox::concurrent::FiFo< ValueType, Capacity >Single pusher single pop'er thread safe fifo
 Ciox::cxx::FileReaderWrapper class for file reading operations. Tries to open a file in the constructor. Error handling strategy can be decided by means of the ErrorMode argument
 Ciox::cxx::forward_list< T, Capacity >C++11 compatible uni-directional forward list implementation
 Ciox::cxx::function_ref< SignatureType >
 Ciox::cxx::function_ref< ReturnType(ArgTypes...)>Cxx::function_ref is a non-owning reference to a callable
 Ciox::cxx::function_ref< ReturnValue(const void *, ConstMethodPointer< iox::cxx::internal::GenericClass >, Args...)>
 Ciox::cxx::function_ref< ReturnValue(void *, MethodPointer< iox::cxx::internal::GenericClass >, Args...)>
 Ciox::cxx::function_ref< void(T *const)>
 Ciox::cxx::internal::GenericClass
 Ciox::cxx::GenericRAIISimple helper class to apply the C++ RAII idiom quickly. You set 2 functions, one which is called in the constructor and another function is called in the destructor which can be useful when handling resources
 Ciox::cxx::internal::get_index_of_type< N, Type, T, Targs >
 Ciox::cxx::internal::get_index_of_type< N, Type, Type, Targs... >
 Ciox::cxx::internal::get_type_at_index< N, Index, T, Targs >
 Ciox::cxx::internal::get_type_at_index< N, N, T, Targs... >
 Ciox::cxx::internal::GetCapa< T >Struct to get capacity of fixed string/string literal
 Ciox::cxx::internal::GetCapa< char[N]>
 Ciox::cxx::internal::GetCapa< string< N > >
 Ciox::cxx::internal::GetData< T >Struct to get a pointer to the char array of the fixed string/string literal/std::string
 Ciox::cxx::internal::GetData< char[N]>
 Ciox::cxx::internal::GetData< std::string >
 Ciox::cxx::internal::GetData< string< N > >
 Ciox::cxx::internal::GetSize< T >Struct to get size of fixed string/string literal/std::string
 Ciox::cxx::internal::GetSize< char[N]>
 Ciox::cxx::internal::GetSize< std::string >
 Ciox::cxx::internal::GetSize< string< N > >
 Ciox::cxx::greater_or_equal< T, Minimum >
 Ciox::cxx::in_place_index< N >Helper struct to perform an emplacement at a predefined index in the constructor of a variant
 Ciox::cxx::in_place_type< T >Helper struct to perform an emplacement of a predefined type in in the constructor of a variant
 Ciox::concurrent::IndexQueue< Capacity, ValueType >Lockfree queue capable of storing indices 0,1,... Capacity-1
 Ciox::cxx::is_invocable< Callable, ArgTypes >Verifies whether the passed Callable type is in fact invocable with the given arguments
 Ciox::cxx::internal::IsCharArray< T >Struct to check whether an argument is a char array
 Ciox::cxx::internal::IsCharArray< char[N]>
 Ciox::cxx::internal::IsCxxString< T >Struct to check whether an argument is a cxx string
 Ciox::cxx::internal::IsCxxString< string< N > >
 Ciox::cxx::ObjectPool< T, CAPACITY >::Iterator
 Ciox::cxx::list< T, Capacity >C++11 compatible bi-directional list implementation
 Ciox::concurrent::LockFreeQueue< ElementType, Capacity >Implements a lock free queue (i.e. container with FIFO order) of elements of type T with a fixed Capacity
 Ciox::concurrent::LockFreeQueue< ElementType, MaxCapacity >
 Ciox::concurrent::LoFFLi
 Ciox::log::LogBin
 Ciox::log::LogEntry
 Ciox::log::Logger
 Ciox::log::LogHex
 Ciox::log::LogManager
 Ciox::log::LogRawBuffer
 Ciox::log::LogStream
 Ciox::cxx::MethodCallback< ReturnValue, Args >
 Ciox::cxx::newtype::MoveAssignable< T >
 Ciox::cxx::newtype::MoveConstructable< T >
 Ciox::posix::UnixDomainSocket::NoPathPrefix_t
 Ciox::cxx::not_null< T, typename >
 Ciox::cxx::nullopt_tHelper struct which is used to signal an empty optional. It is equivalent to no value
 Ciox::cxx::ObjectPool< T, CAPACITY >
 Ciox::cxx::ObjectPool< T, CAPACITY >
 Ciox::posix::OpenNamedSemaphore_t
 Ciox::cxx::optional< T >Optional implementation from the C++17 standard with C++11. The interface is analog to the C++17 standard and it can be used in factory functions which can fail
 Ciox::cxx::optional< iox::posix::Allocator >
 Ciox::cxx::optional< iox::posix::MemoryMap >
 Ciox::cxx::optional< iox::posix::SharedMemory >
 Ciox::cxx::optional< OsTimer >
 Ciox::cxx::pair< FirstType, SecondType >
 Ciox::concurrent::PeriodicTask< T >This class periodically executes a callable specified by the template parameter. This can be a struct with a operator()() overload, a cxx::function_ref<void()> or std::fuction<void()>
 Ciox::concurrent::PeriodicTaskAutoStart_tThis is a helper struct to make the immediate start of the task in the PeriodicTask ctor obvious to the user
 Ciox::concurrent::PeriodicTaskManualStart_tThis is a helper struct to make the manual start of the task with the start method obvious to the user
 Ciox::rp::PointerRepository< id_t, ptr_t, CAPACITY >Allows registration of memory segments with their start pointers and size. This class is used to resolve relative pointers in the corresponding address space of the application. Up to CAPACITY segments can be registered with MIN_ID = 1 to MAX_ID = CAPACITY - 1 id 0 is reserved and allows relative pointers to behave like normal pointers (which is equivalent to measure the offset relative to 0)
 CPolicies
 Ciox::cxx::PoorMansHeap< Interface, TypeSize, TypeAlignment >Reserves space on stack for placement new instatiation
 Ciox::cxx::PoorMansHeapType< Type >This is a proxy which must be used for the non default PoorMansHeap ctor
 Ciox::posix::PosixGroup
 Ciox::posix::PosixRights
 Ciox::posix::PosixUser
 Ciox::cxx::newtype::ProtectedConstructByValueCopy< T >
 Ciox::cxx::newtype::internal::ProtectedConstructor_t
 Ciox::concurrent::QueueAdapter< T, Capacity, Queue >
 Ciox::concurrent::QueueAdapter< T, Capacity, LockFreeQueue >
 Ciox::concurrent::QueueAdapter< T, Capacity, ResizeableLockFreeQueue >
 Ciox::cxx::range< T, Minimum, Maximum >
 Ciox::cxx::ReferenceCounter< T >Reference counter abstraction for the usage in constructs like a shared_ptr. A pointer to a memory position where the reference counter is stored is put into the constructor and then this object performs reference counting on it
 Ciox::rp::RelativePointerDataThis are the data for a relative pointer. To be able so safely be used in the shared memory and prevent torn writes/reads, the class must not be larger than 64 bits and trivially copy-able
 Ciox::cxx::internal::ReturnSuccess< ReturnValue >
 Ciox::cxx::internal::ReturnSuccess< void >
 Ciox::cxx::SerializationSimple serializer which serials every given type into the following format: (The type needs to be convertable into a string via cxx::convert::toString) LENGTH:DATALENGTH:DATA... Example: Serializes "hello", 123, 123.01 into 5:hello3:1236:123.01
 Ciox::posix::SignalGuardThe SignalGuard is a class returned by registerSignalHandler. When it goes out of scope it restores the previous signal action. Typical use case: One would like to override the signal action in main() or some C posix makes it necessary to override the standard signal action before and after the call
 Ciox::cxx::SmartC< Function, ReturnType, FunctionArguments >C function call abstraction class which performs the error handling automatically
 Ciox::concurrent::SoFi< ValueType, CapacityValue >Thread safe producer and consumer queue with a safe overflowing behavior. SoFi is designed in a FIFO Manner but prevents data loss when pushing into a full SoFi. When SoFi is full and a Sender tries to push, the data at the current read position will be returned. SoFi is a Thread safe without using locks. When the buffer is filled, new data is written starting at the beginning of the buffer and overwriting the old.The SoFi is especially designed to provide fixed capacity storage. When its capacity is exhausted, newly inserted elements will cause elements either at the beginning to be overwritten.The SoFi only allocates memory when created , capacity can be is adjusted explicitly
 Ciox::cxx::newtype::Sortable< T >
 Ciox::cxx::stack< T, Capacity >Stack implementation with a simple push pop interface
 Ciox::cxx::string< Capacity >String implementation with some adjustments in the API, because we are not allowed to throw exceptions or use heap. Please see iceoryx/iceoryx_utils/doc/fixedString.adoc for further information
 Ciox::cxx::string< 128 >
 Ciox::cxx::string< 250 >
 Ciox::cxx::string< ERRORSTRINGSIZE >
 Ciox::cxx::string< LONGEST_VALID_NAME >
 Ciox::cxx::string< MAX_IPC_CHANNEL_NAME_LENGTH >
 Ciox::cxx::string< MAX_THREAD_NAME_LENGTH >
 Ciox::cxx::string< NAME_SIZE >
 Ciox::cxx::success< T >Helper struct to create an expected which is signalling success more easily
 Ciox::cxx::success< void >Helper struct to create an error only expected which is signalling success more easily
 Ciox::cxx::internal::SumCapa< Targs >Struct to get the sum of the capacities of fixed strings/string literals
 Ciox::cxx::internal::SumCapa< T, Targs... >
 Ciox::cxx::internal::SumCapa<>
 Ciox::concurrent::TACO< T, Context, MaxNumberOfContext >TACO is an acronym for Thread Aware exChange Ownership. Exchanging data between thread needs some synchonization mechanism. This can be done with a mutex or atomics. If the data structure is larger than 64 bit or if more than one value need to be accessed in a synchronized manner, a mutex would be the only option. The TACO is a wait-free alternative to the mutex. Data can be exchanged between threads. The TACO is like a SoFi with one element, but with the possibility to read/write from multiple threads
 Ciox::posix::TimerInterface for timers on POSIX operating systems
 Ciox::concurrent::TriggerQueue< T, Capacity, QueueType >TriggerQueue is behaves exactly like a normal queue (fifo) except that this queue is threadsafe and offers a blocking push which blocks the the caller until the queue has space for at least one element which can be pushed
 Ciox::concurrent::TriggerQueue< std::function< void()>, taskQueueSize, concurrent::FiFo >
 Cstd::true_type
 Ciox::cxx::TruncateToCapacity_tStruct used to define a compile time variable which is used to distinguish between constructors with certain behavior
 Ciox::cxx::unique_ptr< T >The unique_ptr class is a heap-less unique ptr implementation, unlike the STL
 Ciox::cxx::variant< Types >Variant implementation from the C++17 standard with C++11. The interface is inspired by the C++17 standard but it has changes in get and emplace since we are not allowed to throw exceptions
 Ciox::cxx::variant< concurrent::FiFo< ValueType, Capacity >, concurrent::SoFi< ValueType, Capacity >, concurrent::ResizeableLockFreeQueue< ValueType, Capacity >, concurrent::ResizeableLockFreeQueue< ValueType, Capacity > >
 Ciox::cxx::variant< ErrorType >
 Ciox::cxx::variant< ValueType, ErrorType >
 Ciox::cxx::VariantQueue< ValueType, Capacity >Wrapper of multiple fifo's
 Ciox::cxx::vector< T, Capacity >C++11 compatible vector implementation. We needed to do some adjustments in the API since we do not use exceptions and we require a data structure which can be located fully in the shared memory
 Ciox::cxx::vector< BufferIndex, MaxCapacity >
 Ciox::cxx::vector< DirectedGraph::VertexData, VERTEX_LIMIT >
 Ciox::cxx::vector< Index_t, DEGREE_LIMIT >
 Ciox::cxx::vector< Info, 10000U >
 Ciox::cxx::vector< iox::cxx::vector, VERTEX_LIMIT >
 Ciox::cxx::vector< PermissionEntry, MaxNumOfPermissions >
 Ciox::cxx::vector< VertexType *, DEGREE_LIMIT >
 CDirectedGraph< VertexType, VERTEX_LIMIT, DEGREE_LIMIT >::VertexData
 CCAPACITY