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::cxx::BestFittingType< Value > | Get the best fitting unsigned integer type for a given value at compile time |
Ciox::cxx::ConstMethodCallback< ReturnValue, Args > | |
Ciox::cxx::convert | Collection of static methods for conversion from and to string |
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 > | |
Ciox::posix::FileLock | 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) |
▼CDesignPattern::Creation< NamedPipe, IpcChannelError > | |
Ciox::posix::NamedPipe | |
▼CDesignPattern::Creation< Semaphore, SemaphoreError > | |
Ciox::posix::Semaphore | Posix semaphore C++ Wrapping class |
Ciox::cxx::DeadlineTimer | 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 |
Ciox::cxx::error< T > | Helper struct to create an expected which is signalling an error more easily |
Ciox::ErrorHandler | This 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::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< void, ErrorType > | |
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::cxx::is_function_pointer< T > | Check whether T is a function pointer with arbitrary signature |
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< void(T *const)> | |
Ciox::cxx::GenericRAII | 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 |
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_t | Helper struct which is used to call the in-place-construction constructor |
Ciox::cxx::in_place_type< T > | Helper struct to perform an emplacement of a predefined type in in the constructor of a variant |
Ciox::cxx::is_invocable< Callable, ArgTypes > | Verifies whether the passed Callable type is in fact invocable with the given arguments |
Ciox::cxx::is_invocable_r< ReturnType, Callable, ArgTypes > | Verifies whether the passed Callable type is in fact invocable with the given arguments and the result of the invocation is convertible to ReturnType |
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::ResizeableLockFreeQueue< ElementType, MaxCapacity > | 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) |
Ciox::concurrent::LockFreeQueue< Message_t, MAX_NUMBER_OF_MESSAGES > | |
▼Ciox::log::LogBin | |
Ciox::log::LogBin16 | |
Ciox::log::LogBin32 | |
Ciox::log::LogBin64 | |
Ciox::log::LogBin8 | |
Ciox::log::LogEntry | |
Ciox::log::Logger | |
▼Ciox::log::LogHex | |
Ciox::log::LogHex16 | |
Ciox::log::LogHex32 | |
Ciox::log::LogHex64 | |
Ciox::log::LogHex8 | |
Ciox::log::LogManager | |
Ciox::log::LogRawBuffer | |
Ciox::log::LogStream | |
Ciox::cxx::MethodCallback< ReturnValue, Args > | |
Ciox::cxx::not_null< T, typename > | |
Ciox::cxx::nullopt_t | Helper struct which is used to signal an empty optional. It is equivalent to no value |
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< OsTimer > | |
Ciox::cxx::optional< SharedMemoryObject > | |
▼CPolicies | |
Ciox::cxx::NewType< T, Policies > | 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 |
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::PosixCallBuilder< ReturnType, FunctionArguments > | |
Ciox::posix::PosixCallEvaluator< ReturnType > | Class which is created by the verificator to evaluate the result of a posix call |
Ciox::posix::PosixCallResult< T > | Result of a posix call |
Ciox::posix::PosixCallVerificator< ReturnType > | Class which verifies the return value of a posix function call |
Ciox::posix::PosixGroup | |
Ciox::posix::PosixRights | |
Ciox::posix::PosixUser | |
Ciox::cxx::range< T, Minimum, Maximum > | |
Ciox::cxx::Serialization | 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 |
Ciox::posix::SignalGuard | 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 |
Ciox::posix::SignalWatcher | The SignalWatcher waits for SIGINT and SIGTERM. One can wait until the signal has occurred or ask the watcher if it has occurred |
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 |
Ciox::cxx::string< 128 > | |
Ciox::cxx::string< FILENAME_LENGTH > | |
Ciox::cxx::string< platform::IOX_MAX_PATH_LENGTH > | |
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::posix::Timer | Interface for timers on POSIX operating systems |
▼Cstd::true_type | |
Ciox::cxx::is_function_pointer< ReturnType(*)(ArgTypes...)> | |
Ciox::cxx::TruncateToCapacity_t | Struct 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 > | |