▼NDesignPattern | |
CCreation | 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 |
CCommand | |
CCommand< void > | |
▼Niox | Building block to easily create free function for logging in a library context |
Nalgorithm | |
►Nconcurrent | |
CLockFreeQueue | Implements a lock free queue (i.e. container with FIFO order) of elements of type T with a fixed Capacity |
CResizeableLockFreeQueue | Implements a lock free queue (i.e. container with FIFO order) of elements of type T with a maximum capacity MaxCapacity. The capacity can be defined to be anything between 0 and MaxCapacity at construction time or later at runtime using setCapacity. This is even possible while concurrent push and pop operations are executed, i.e. the queue does not have to be empty. Only one thread will succeed setting its desired capacity if there are more threads trying to change the capacity at the same time (it is unpredictable which thread) |
CActiveObject | |
CFiFo | Single pusher single pop'er thread safe fifo |
CBuffer | |
CCyclicIndex | Index structure that can contain logical values 0, ..., CycleLength-1 but also stores an internal cycle counter to be used in compare_exchange |
►CIndexQueue | Lockfree queue capable of storing indices 0,1,... Capacity-1 |
CConstructEmpty_t | |
CConstructFull_t | |
CLoFFLi | |
CPeriodicTaskAutoStart_t | This is a helper struct to make the immediate start of the task in the PeriodicTask ctor obvious to the user |
CPeriodicTaskManualStart_t | This is a helper struct to make the manual start of the task with the start method obvious to the user |
CPeriodicTask | 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()> |
CSoFi | 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 |
CTACO | 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 |
CQueueAdapter | |
CQueueAdapter< T, Capacity, LockFreeQueue > | |
CQueueAdapter< T, Capacity, ResizeableLockFreeQueue > | |
CTriggerQueue | 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 |
►Ncxx | |
►Ninternal | |
CHasInvalidStateMember | Type trait which verifies whether the passed type T has INVALID_STATE std::true_type overload chosen when INVALID_STATE is present, otherwise std::false_type |
CIsOptional | Type trait which verifies whether the passed type T is of type cxx::optional |
CBestFittingTypeImpl | Struct to find the best fitting unsigned integer type |
CBestFittingTypeImpl< false, false, false > | |
CBestFittingTypeImpl< true, false, false > | |
CBestFittingTypeImpl< true, true, false > | |
CGenericClass | |
CHasInvalidStateMember< T, iox::cxx::void_t< decltype(T::INVALID_STATE)> > | |
CIsOptional< iox::cxx::optional< T > > | |
CReturnSuccess | |
CReturnSuccess< void > | |
CGetCapa | Struct to get capacity of fixed string/string literal |
CGetCapa< string< N > > | |
CGetCapa< char[N]> | |
CGetSize | Struct to get size of fixed string/string literal/std::string |
CGetSize< string< N > > | |
CGetSize< char[N]> | |
CGetSize< std::string > | |
CGetData | Struct to get a pointer to the char array of the fixed string/string literal/std::string |
CGetData< string< N > > | |
CGetData< char[N]> | |
CGetData< std::string > | |
CSumCapa | Struct to get the sum of the capacities of fixed strings/string literals |
CSumCapa<> | |
CSumCapa< T, Targs... > | |
CIsCharArray | Struct to check whether an argument is a char array |
CIsCharArray< char[N]> | |
CIsCxxString | Struct to check whether an argument is a cxx string |
CIsCxxString< string< N > > | |
Cdoes_contain_type | |
Cdoes_contain_type< TypeToCheck, T > | |
Cget_index_of_type | |
Cget_index_of_type< N, Type, Type, Targs... > | |
Cget_type_at_index | |
Cget_type_at_index< N, N, T, Targs... > | |
Ccall_at_index | |
Ccall_at_index< N, T > | |
►Nnewtype | |
►Ninternal | |
CProtectedConstructor_t | |
CCopyAssignable | |
CMoveAssignable | |
CAssignByValueCopy | |
CAssignByValueMove | |
CComparable | |
CCopyConstructable | |
CMoveConstructable | |
CConstructByValueCopy | |
CDefaultConstructable | |
CConvertable | |
CProtectedConstructByValueCopy | |
CSortable | |
Nset | |
Cconvert | Collection of static methods for conversion from and to string |
CDeadlineTimer | This 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 |
CErrorTypeAdapter | Generic adapter to access INVALID_STATE member or value |
Csuccess | Helper struct to create an expected which is signalling success more easily |
Csuccess< void > | Helper struct to create an error only expected which is signalling success more easily |
Cerror | Helper struct to create an expected which is signalling an error more easily |
Cexpected< 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 |
Cexpected< ValueType, ErrorType > | Specialization of the expected class which can contain an error as well as a success value |
Cexpected< void, ErrorType > | |
Cforward_list | C++11 compatible uni-directional forward list implementation |
Cfunction_ref | |
Cis_function_ref | |
Cis_function_ref< function_ref< Targs... > > | |
Cfunction_ref< ReturnType(ArgTypes...)> | Cxx::function_ref is a non-owning reference to a callable |
CGenericRAII | Simple 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 |
Cnot_null | |
Cgreater_or_equal | |
Crange | |
CBestFittingType | Get the best fitting unsigned integer type for a given value at compile time |
Clist | C++11 compatible bi-directional list implementation |
CConstMethodCallback | |
CMethodCallback | |
CNewType | Implementation of the haskell NewType pattern: https://wiki.haskell.org/Newtype Lets say you would like to have an index which is in the end an integer but with certain restraints. The users should be forced to set it when they are creating it but afterwards it should be immutable. You would like to be able to compare the type as well as to sort it so that it can be stored in a map for instance. An example could be that you would like to have an index class with those properties and some additional methods. Then you can inherit from NewType and add your methods |
Cnullopt_t | Helper struct which is used to signal an empty optional. It is equivalent to no value |
Coptional | 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 |
CPoorMansHeapType | This is a proxy which must be used for the non default PoorMansHeap ctor |
CPoorMansHeap | Reserves space on stack for placement new instatiation |
CSerialization | Simple 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 |
CSmartC | C function call abstraction class which performs the error handling automatically |
Cstack | Stack implementation with a simple push pop interface |
CTruncateToCapacity_t | Struct used to define a compile time variable which is used to distinguish between constructors with certain behavior |
Cstring | 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 |
Cadd_const_conditionally | Conditionally add const to type T if C has the const qualifier |
Cadd_const_conditionally< T, const C > | |
Cis_invocable | Verifies whether the passed Callable type is in fact invocable with the given arguments |
Chas_signature | Verfies the signature ReturnType(ArgTypes...) of the provided Callable type |
Chas_signature< Callable, ReturnType(ArgTypes...), typename std::enable_if< std::is_convertible< typename std::result_of< Callable(ArgTypes...)>::type, ReturnType >::value, void >::type > | |
Cunique_ptr | The unique_ptr class is a heap-less unique ptr implementation, unlike the STL |
Cin_place_index | Helper struct to perform an emplacement at a predefined index in the constructor of a variant |
Cin_place_type | Helper struct to perform an emplacement of a predefined type in in the constructor of a variant |
Cvariant | 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 |
CVariantQueue | Wrapper of multiple fifo's |
Cvector | 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 |
Cpair | |
CReferenceCounter | 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 |
Calways_false | 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 |
CFileReader | Wrapper 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 |
►CObjectPool | |
CIterator | |
►Nlog | |
Nffbb | |
CLogEntry | |
CLogger | |
CLogManager | |
CLogHex | |
CLogHex8 | |
CLogHex16 | |
CLogHex32 | |
CLogHex64 | |
CLogBin | |
CLogBin8 | |
CLogBin16 | |
CLogBin32 | |
CLogBin64 | |
CLogRawBuffer | |
CLogStream | |
►Nposix | |
CAccessController | Abstraction class for the management of access control lists (ACLs) |
CMessageQueue | Wrapper class for posix message queue |
CAllocator | |
CMemoryMap | |
CSharedMemory | |
CSharedMemoryObject | |
►CUnixDomainSocket | Wrapper class for unix domain socket |
CNoPathPrefix_t | |
CFileLock | Posix file lock C++ wrapping class Following RAII, the lock is acquired on creation and released on destruction. Releasing the locks works even if the process crashes with a segfault or using SIGKILL. 'lslocks' can be used to display all system-wide locks (see man page) |
CPosixRights | |
CPosixGroup | |
CPosixUser | |
CCreateUnnamedSingleProcessSemaphore_t | |
CCreateUnnamedSharedMemorySemaphore_t | |
CCreateNamedSemaphore_t | |
COpenNamedSemaphore_t | |
CSemaphore | Posix semaphore C++ Wrapping class |
CSignalGuard | The 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 |
CTimer | Interface for timers on POSIX operating systems |
►Nrp | |
CAtomicRelocatablePointer | 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 |
CBaseRelativePointer | Pointer 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 |
CBaseRelocatablePointer | Pointer 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 |
CPointerRepository | 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) |
CRelativePointer | Typed version so we can use operator-> |
CRelativePointerData | This 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 |
CRelocatablePointer | Typed version so we can use operator-> |
►Nunits | |
CDuration | |
CErrorHandler | This handler is needed for unit testing, special debugging cases and other corner cases where we'd like to explicitly suppress the error handling |