| ▼NqStroika_Foundation_Characters_FMT_PREFIX_ | |
| Cformatter< Stroika::Foundation::Characters::String, wchar_t > | |
| Cformatter< T, wchar_t > | |
| ▼NSamples | |
| ▼NService | |
| CSampleAppServiceRep | |
| ▼NStroika | |
| ▼NFoundation | |
| ►NCache | |
| ►NFactory | |
| CLRUCache_NoHash | |
| CLRUCache_WithHash | |
| ►NStatistics | |
| CStats_Basic | |
| CStats_Null | |
| ►NTimedCacheSupport | |
| CDefaultTraits | |
| CBloomFilter | Bloom filter is a probablistic set, which returns either "probably in set" or "definitely not in set" |
| CCallerStalenessCache | |
| CLRUCache | LRUCache implements a simple least-recently-used caching strategy, with optional hashing (of keys) to make it faster |
| CMemoizer | Cache the results of expensive computations transparently |
| CSynchronizedCallerStalenessCache | Simple wrapper on CallerStalenessCache (with the same API) - but internally synchronized in a way that is more performant than using RWSyncrhonzied<CallerStalenessCache<...>> |
| CSynchronizedLRUCache | Simple wrapper on LRUCache (with the same API) - but internally synchronized in a way that is more performant than using RWSyncrhonzied<LRUCache<...>> |
| CSynchronizedTimedCache | |
| CTimedCache | Keep track of a bunch of objects, each with an associated 'freshness' which meet a TimedCache-associated minimal reshness limit |
| ►NCharacters | |
| ►NFloatConversion | |
| CPrecision | |
| CToStringOptions | |
| ►NPlatform | |
| ►NWindows | |
| CSmartBSTR | |
| ►CCharacter | |
| CEqualsComparer | |
| CThreeWayComparer | |
| CCharacterEncodingException |
- An error occurred encoding or decoding a character
|
| CCharset | |
| CCodeCvt | CodeCvt unifies byte <-> unicode conversions, vaguely inspired by (and wraps) std::codecvt, as well as UTFConvert etc, to map between span<bytes> and a span<UNICODE code-point> |
| CCodePageNotSupportedException | |
| CFormatString | Roughly equivalent to std::wformat_string, except that it can be constructed from 'char' string, and if 'char' require ASCII characters for format string |
| CLatin1 | |
| CRegularExpression | RegularExpression is a compiled regular expression which can be used to match on a String class |
| CRegularExpressionMatch | |
| ►CString | String is like std::u32string, except it is much easier to use, often much more space efficient, and more easily interoperates with other string types |
| C_IRep | |
| CEqualsComparer | |
| CLessComparer | Very similar to ThreeWayComparer but returns true if less |
| CPeekSpanData | Summary data for raw contents of rep - each rep will support at least one of these span forms |
| CStringBuilder | Similar to String, but intended to more efficiently construct a String. Mutable type (String is largely immutable) |
| CStringBuilder_Options | Rarely used directly - defaults generally fine |
| CStringCombiner | StringCombiner is a simple function object used to combine two strings visually - used in Iterable<>::Join () |
| CToStringFormatter | |
| ►CUTFConvert | UTFConvert is designed to provide mappings between various UTF encodings of UNICODE characters |
| CConversionResult | |
| ►NCommon | |
| ►NPlatform | |
| ►NWindows | |
| CRegistryKey | |
| CCase | |
| CComparisonRelationDeclaration | |
| CComparisonRelationDeclarationBase | |
| CConvertibleFrom | |
| CConvertibleTo | |
| CCountedValue | |
| CDefaultNames | |
| CEmpty | |
| CEmptyObjectForSideEffects | |
| CEqualsComparerAdapter | Use this to wrap any basic comparer, and produce an Equals comparer |
| CExtendableProperty | ExtendableProperty is a Property which has callbacks associated with it, to be notified when it is accessed or updated |
| CFunctionTraits | Extract the number of arguments, return type, and each individual argument type from a lambda or simple function object |
| CGUID | |
| CIdentity | Function object whose action is to map its argument, back to the same value it started with (identity function) |
| CInOrderComparerAdapter | Use this to wrap any basic comparer, and produce a Less comparer |
| CKeyValuePair | |
| CLazyType | |
| COptionalThreeWayComparer | ThreeWayComparer for optional types, like builtin one, except this lets you pass in explicit 'T' comparer for the T in optional<T> |
| CProperty | |
| CReadOnlyProperty | |
| CScopedUseLocale | |
| Csubstitution_failure | |
| Csubstitution_succeeded | |
| CThreeWayComparerAdapter | Use this to wrap a basic (ITotallyOrderingComparer) comparer, and produce a Three-Way comparer |
| CVersion | |
| CWriteOnlyProperty | |
| ►NContainers | |
| ►NAdapters | |
| CAdder | Utility for generic code that wishes to add something to a somewhat arbitrary container, where the ordering of the addition is undefined/doesn't matter (whatever makes sense by default for that container) |
| ►NConcrete | |
| CAssociation_Array | Association_Array<KEY_TYPE, MAPPED_VALUE_TYPE, TRAITS> is an Array-based concrete implementation of the Association<KEY_TYPE, MAPPED_VALUE_TYPE, typename TRAITS::AssociationTraitsType> container pattern |
| CAssociation_LinkedList | Association_LinkedList<KEY_TYPE, MAPPED_VALUE_TYPE, TRAITS> is an LinkedList-based concrete implementation of the Association<KEY_TYPE, MAPPED_VALUE_TYPE, typename TRAITS::AssociationTraitsType> container pattern |
| CBijection_LinkedList | Bijection_LinkedList<DOMAIN_TYPE, RANGE_TYPE> is an LinkedList-based concrete implementation of the Bijection<DOMAIN_TYPE, RANGE_TYPE> container pattern |
| CCollection_Array | Collection_Array<T> is an Array-based concrete implementation of the Collection<T> container pattern |
| CCollection_LinkedList | Collection_LinkedList<T> is an LinkedList-based concrete implementation of the Collection<T> container pattern |
| CCollection_stdforward_list | Collection_stdforward_list<T> is an std::forward_list (singly linked list)-based concrete implementation of the Collection<T> container pattern |
| CDenseDataHyperRectangle_Vector | DenseDataHyperRectangle_Vector<T, INDEXES...> is an Dense Vector-based concrete implementation of the DenseDataHyperRectangle<T> container pattern |
| CDeque_DoublyLinkedList | Deque_DoublyLinkedList<T> is an Array-based concrete implementation of the Deque<T> container pattern |
| CKeyedCollection_Array | KeyedCollection_Array<T> is an Array-based concrete implementation of the KeyedCollection<T> container pattern |
| ►CKeyedCollection_HashTable | KeyedCollection_HashTable<T,KEY_TYPE> is a HashTable based concrete implementation of the KeyedCollection<T,KEY_TYPE> container pattern |
| CElementEqualsComparer | |
| CElementHash | |
| CKeyedCollection_LinkedList | KeyedCollection_LinkedList<T> is an LinkedList-based concrete implementation of the KeyedCollection<T> container pattern |
| CMapping_Array | Mapping_Array<KEY_TYPE, MAPPED_VALUE_TYPE, TRAITS> is an Array-based concrete implementation of the Mapping<KEY_TYPE, MAPPED_VALUE_TYPE, typename TRAITS::MappingTraitsType> container pattern |
| CMapping_HashTable | Mapping_HashTable<KEY_TYPE, MAPPED_VALUE_TYPE, TRAITS> is a HashTable based concrete implementation of the Mapping<KEY_TYPE, MAPPED_VALUE_TYPE> container pattern |
| CMapping_LinkedList | Mapping_LinkedList<KEY_TYPE, MAPPED_VALUE_TYPE, TRAITS> is an LinkedList-based concrete implementation of the Mapping<KEY_TYPE, MAPPED_VALUE_TYPE, typename TRAITS::MappingTraitsType> container pattern |
| CMultiSet_Array | |
| CMultiSet_LinkedList | |
| CQueue_Array | Queue_Array<T> is an Array-based concrete implementation of the Queue<T> container pattern |
| CQueue_DoublyLinkedList | Queue_DoublyLinkedList<T> is an Array-based concrete implementation of the Queue<T> container pattern |
| CSequence_Array | Sequence_Array<T> is an Array-based concrete implementation of the Sequence<T> container pattern |
| CSequence_ChunckedArray | Sequence_SparseSortedMapping<T> is a sparse-Array-based concrete implementation of the Sequence<T> container pattern |
| CSequence_DoublyLinkedList | Sequence_DoublyLinkedList<T> is an Array-based concrete implementation of the Sequence<T> container pattern |
| CSequence_LinkedList | Sequence_LinkedList<T> is a LinkedList-based concrete implementation of the Sequence<T> container pattern |
| CSequence_SparseSortedMapping | Sequence_SparseSortedMapping<T> is a sparse-Array-based concrete implementation of the Sequence<T> container pattern |
| CSequence_stdvector | Sequence_stdvector<T> is an std::vector-based concrete implementation of the Sequence<T> container pattern |
| CSet_Array | Set_Array<T> is an Array-based concrete implementation of the Set<T> container pattern |
| CSet_LinkedList | Set_LinkedList<T> is an LinkedList-based concrete implementation of the Set<T> container pattern |
| CSortedAssociation_SkipList | SortedAssociation_SkipList<KEY_TYPE,MAPPED_VALUE_TYPE> is an SkipList-based concrete implementation of the SortedAssociation<KEY_TYPE,MAPPED_VALUE_TYPE> container pattern |
| CSortedAssociation_stdmultimap | SortedAssociation_stdmultimap<KEY_TYPE,MAPPED_VALUE_TYPE> is an std::map-based concrete implementation of the SortedAssociation<KEY_TYPE,MAPPED_VALUE_TYPE> container pattern |
| CSortedCollection_LinkedList | SortedCollection_LinkedList<T> is an LinkedList-based concrete implementation of the SortedCollection<T> container pattern |
| CSortedCollection_SkipList | SortedCollection_SkipList<T> is an SkipList-based concrete implementation of the SortedCollection<T> container pattern |
| CSortedCollection_stdmultiset | SortedCollection_stdmultiset<T> is an stdmultiset-based concrete implementation of the SortedCollection<T> container pattern |
| CSortedKeyedCollection_SkipList | SortedKeyedCollection_SkipList<T, KEY_TYPE, TRAITS> is an SkipList-based concrete implementation of the SortedKeyedCollection<T, KEY_TYPE, TRAITS> container pattern |
| ►CSortedKeyedCollection_stdset | SortedKeyedCollection_stdset<KEY_TYPE,MAPPED_VALUE_TYPE> is an std::map-based concrete implementation of the SortedKeyedCollection<KEY_TYPE,MAPPED_VALUE_TYPE> container pattern |
| CSetInOrderComparer | SetInOrderComparer is the COMPARER passed to the STL set. It intrinsically uses the provided extractor and key comparer |
| CSortedMapping_SkipList | SortedMapping_SkipList<KEY_TYPE, MAPPED_VALUE_TYPE, TRAITS> is an SkipList-based concrete implementation of the Mapping<KEY_TYPE, MAPPED_VALUE_TYPE, typename TRAITS::MappingTraitsType> container pattern |
| CSortedMapping_stdmap | SortedMapping_stdmap<KEY_TYPE,MAPPED_VALUE_TYPE> is an std::map-based concrete implementation of the SortedMapping<KEY_TYPE,MAPPED_VALUE_TYPE> container pattern |
| CSortedMultiSet_SkipList | |
| CSortedMultiSet_stdmap | |
| CSortedSet_SkipList | SortedSet_SkipList<T> is an std::set-based concrete implementation of the SortedSet<T> container pattern |
| CSortedSet_stdset | SortedSet_stdset<T> is an std::set-based concrete implementation of the SortedSet<T> container pattern |
| CSparseDataHyperRectangle_stdmap | SparseDataHyperRectangle_stdmap<T, INDEXES...> is an Dense Vector-based concrete implementation of the SparseDataHyperRectangle<T> container pattern |
| CStack_LinkedList | Stack_LinkedList<T> is an LinkedList-based concrete implementation of the Stack<T> container pattern |
| ►NDataStructures | |
| ►NHashTable_Support | |
| CDefaultTraits | |
| CLinearProbingTag | Used internally to select HashTable implementation strategies. NOT YET IMPLEMENTED OR THOUGHT OUT (see https://en.wikipedia.org/wiki/Linear_probing) - tricky part is delete |
| CSeparateChainingOptions | Use as LAYOUT_OPTIONS for HashTable DefaultTraits<> template |
| CSeparateChainingTag | Used internally to select HashTable implementation strategies. Callers dont use directly, but use SeparateChainingOptions<> |
| ►NSkipList_Support | |
| CDefaultTraits | |
| ►CArray | Very similar to std::vector<T> |
| CBackwardIterator | |
| CForwardIterator | |
| CIteratorBase | |
| CDoublyLinkedList | |
| ►CHashTable | Implement hash table support in a lightweight standard template library style. Use traits to describe various choices about hashtable layout (separate chaining vs linear probing) etc |
| CForwardIterator | |
| CLinkedList | |
| CSkipList | |
| ►CSTLContainerWrapper | |
| CForwardIterator | |
| ►NDefaultTraits | |
| CMultiSet | |
| CSortedAssociation | |
| ►NFactory | |
| ►CAssociation_Factory | Singleton factory object - Used to create the default backend implementation of a Association<> container; typically not called directly |
| CHints | |
| ►CBijection_Factory | Singleton factory object - Used to create the default backend implementation of a Bijection<> container; typically not used directly |
| CHints | |
| ►CCollection_Factory | Singleton factory object - Used to create the default backend implementation of a Collection<> container; typically not called directly |
| CHints | |
| ►CDenseDataHyperRectangle_Factory | Singleton factory object - Used to create the default backend implementation of a DenseDataHyperRectangle<> container |
| CHints | |
| ►CDeque_Factory | Singleton factory object - Used to create the default backend implementation of a Deque<> container; typically not called directly |
| CHints | |
| ►CKeyedCollection_Factory | Singleton factory object - Used to create the default backend implementation of a KeyedCollection<> container; typically not called directly |
| CHints | |
| ►CMapping_Factory | Singleton factory object - Used to create the default backend implementation of a Mapping<> container; typically not called directly |
| CHints | |
| ►CMultiSet_Factory | Singleton factory object - Used to create the default backend implementation of a MultiSet<> container; typically not called directly |
| CHints | |
| ►CQueue_Factory | Singleton factory object - Used to create the default backend implementation of a Queue<> container; typically not called directly |
| CHints | |
| ►CSequence_Factory | Singleton factory object - Used to create the default backend implementation of a Sequence<> container; typically not called directly |
| CHints | |
| ►CSet_Factory | Singleton factory object - Used to create the default backend implementation of a Set<> container; typically not called directly |
| CHints | |
| ►CSortedAssociation_Factory | Singleton factory object - Used to create the default backend implementation of a SortedAssociation<> container; typically not called directly |
| CHints | |
| ►CSortedCollection_Factory | Singleton factory object - Used to create the default backend implementation of a SortedCollection<> container |
| CHints | |
| ►CSortedKeyedCollection_Factory | Singleton factory object - Used to create the default backend implementation of a Collection<> container; typically not called directly |
| CHints | |
| ►CSortedMapping_Factory | Singleton factory object - Used to create the default backend implementation of a SortedMapping<> container; typically not called directly |
| CHints | |
| ►CSortedMultiSet_Factory | Singleton factory object - Used to create the default backend implementation of a SortedMultiSet<> container; typically not called directly |
| CHints | |
| ►CSortedSet_Factory | Singleton factory object - Used to create the default backend implementation of a SortedSet<> container; typically not called directly |
| CHints | |
| CSparseDataHyperRectangle_Factory | Singleton factory object - Used to create the default backend implementation of a SparseDataHyperRectangle<> container; typically not called directly |
| ►CStack_Factory | Singleton factory object - Used to create the default backend implementation of a Stack<> container; typically not called directly |
| CHints | |
| ►NLockFreeDataStructures | |
| Cforward_list | Lock-free, threadsafe singly linked list implementation (patterned after std::forward_list) - INTERNALLY SYNCHRONIZED |
| ►NPrivate | |
| CArrayBasedContainer | ArrayBasedContainer is a Stroika implementation detail, but its public methods are fair game and fully supported (as used in subclasses) |
| CArrayBasedContainerIRep | Impl detail for array based container support (see ArrayBasedContainer docs on bool USING_IREP) |
| CArrayBasedContainerRepImpl | CRTP applied when ArrayBasedContainerIRep used |
| CHashTableBasedContainer | HashTableBasedContainer is a Stroika implementation detail, but its public methods are fair game and fully supported (as used in subclasses) |
| CHashTableBasedContainerIRep | Impl detail for array based container support |
| CHashTableBasedContainerRepImpl | CRTP applied when HashTableBasedContainerIRep used |
| CIteratorImplHelper_ | Helper to wrap a low level 'DataStructure Container Iterator' into a 'Stroika' Iterator::IRep iterator |
| CSkipListBasedContainer | SkipListBasedContainer is a Stroika implementation detail, but its public methods are fair game and fully supported (as used in subclasses) |
| CSkipListBasedContainerIRep | Impl detail for array based container support (see SkipListBasedContainer docs on bool USING_IREP) |
| CSkipListBasedContainerRepImpl | CRTP applied when SkipListBasedContainerIRep used |
| CStdVectorBasedContainer | StdVectorBasedContainer is a Stroika implementation detail, but its public methods are fair game and fully supported (as used in subclasses) |
| ►CAssociation | An Association pairs key values with (possibly multiple or none) mapped_type values. Like Mapping<>, but allowing multiple items associated with 'key' |
| C_IRep | Implementation detail for Association<T> implementors |
| CEqualsComparer | Compare Associations<>s for equality |
| ►CBijection | Bijection allows for the bijective (1-1) association of two elements |
| C_IRep | Implementation detail for Bijection<T> implementors |
| ►CCollection | A Collection<T> is a container to manage an un-ordered collection of items, without equality defined for T |
| C_IRep | Implementation detail for Collection<T> implementors |
| ►CDataHyperRectangle | |
| C_IRep | Implementation detail for DataHyperRectangle<T, INDEXES...> implementors |
| CDenseDataHyperRectangle | |
| ►CDeque | |
| C_IRep | Implementation detail for Deque<T> implementors |
| ►CKeyedCollection | Cross between Mapping<KEY, T> and Collection<T> and Set<T> |
| C_IRep | Implementation detail for KeyedCollection<KEY_TYPE, T, TRAITS> implementors |
| CEqualsComparer | |
| CKeyedCollection_DefaultTraits | |
| ►CMapping | |
| C_IRep | Implementation detail for Mapping<T> implementors |
| CEqualsComparer | Compare Mappings<>s for equality. Note this can be costly, as the Mappings are not necessarily in the same order |
| CMultiSet | |
| ►CQueue | A Queue is a first-in-first-out (FIFO) data structure, where elements are arranged in well-ordered fashion, from HEAD to TAIL |
| C_IRep | Implementation detail for Queue<T> implementors |
| ►CSequence | A generalization of a vector: a container whose elements are keyed by the natural numbers |
| C_IRep | Implementation detail for Sequence<T> implementors |
| ►CSet | Set<T> is a container of T, where once an item is added, additionally adds () do nothing |
| C_IRep | Implementation detail for Set<T> implementors |
| CEqualsComparer | Compare Set<>s or Iterable<>s for equality |
| ►CSortedAssociation | |
| C_IRep | Implementation detail for SortedAssociation<T> implementors |
| ►CSortedCollection | A SortedCollection is a Collection<T> which remains sorted (iteration produces items sorted) even as you add and remove entries |
| C_IRep | Implementation detail for SortedCollection<T> implementors |
| ►CSortedKeyedCollection | A SortedKeyedCollection is a KeyedCollection<T> which remains sorted (iteration produces items sorted) even as you add and remove entries |
| C_IRep | Implementation detail for SortedKeyedCollection<T, TRAITS> implementors |
| ►CSortedMapping | |
| C_IRep | Implementation detail for SortedMapping<T> implementors |
| ►CSortedMultiSet | |
| C_IRep | Implementation detail for SortedMultiSet<T, TRAITS> implementors |
| ►CSortedSet | |
| C_IRep | Implementation detail for SortedSet<T> implementors |
| CSparseDataHyperRectangle | |
| ►CStack | |
| C_IRep | Implementation detail for Stack<T> implementors |
| ►NCryptography | |
| ►NDigest | |
| ►NAlgorithm | |
| CCRC32 | |
| CDigesterAlgorithm | DigesterAlgorithm is specialized for each algorithm; generally don't use this directly, but use the wrapper Digest::IncrementalDigester<> (or Digest::Digester or Digest::ComputeDigest) |
| CDigesterAlgorithm< CRC32 > | Windowing digester (code to do the digest algorithm) for the CRC32 algorithm |
| CDigesterAlgorithm< Jenkins > | Windowing digester (code to do the digest algorithm) for the Jenkins algorithm |
| CDigesterAlgorithm< MD5 > | Windowing digester (code to do the digest algorithm) for the MD5 algorithm |
| CDigesterDefaultTraitsForAlgorithm | |
| CDigesterDefaultTraitsForAlgorithm< CRC32 > | |
| CDigesterDefaultTraitsForAlgorithm< Jenkins > | |
| CDigesterDefaultTraitsForAlgorithm< MD5 > | |
| CDigesterDefaultTraitsForAlgorithm< SuperFastHash > | |
| CIDigestAlgorithm | |
| CIDigester | |
| CJenkins | |
| CMD5 | |
| CSuperFastHash | |
| CDigester | Digester<ALGORITHM> is a function-object way to access the digest algorithm. Its generally almost the same as calling ComputeDigest (just a little more complicated) - but works with overloading properly (which is why it exists) - when you make a separate choice of algorithm from where you call |
| CHash | Simple wrapper on (cryptographic) digest algorithms with fewer knobs, and easier construcion- mimicing std::hash<T> |
| CIncrementalDigester | IncrementalDigester<ALGORITHM> () is the low level way to call Digest algorithms, appropriate for streamed sources of data (because it a stateful object you can call Write on multiple times before extracting the digest) |
| CSystemHashDigester | Use std::hash<T> to digest a type t. AKA stdhash_Digester |
| ►NPKI | |
| ►NCertificate | |
| CSelfSignedCertParams | Data used to create a self-signed certificate |
| CSubjectInfo | |
| ►NSSL | |
| ►NServerContext | |
| COptions | |
| ►NDatabase | |
| ►NDocument | |
| ►NCollection | |
| CIRep | |
| CPtr | |
| ►NConnection | |
| CIRep | |
| CPtr | |
| ►NFilterElements | |
| CFieldName | |
| CValue | |
| ►NObjectCollection | |
| CPtr | |
| ►NTrivialDocumentDB | |
| ►COptions | |
| CFilesystemStorage | |
| CMemoryStorage | |
| CEngineProperties | EngineProperties captures the features associated with a given database engine (being talked to through a Document::Connection::Ptr) |
| CFilter | |
| CProjection | Define a (simple) projection on a document, subsetting the fields of that document |
| ►CTransaction | |
| CIRep | |
| ►NSQL | |
| ►NConnection | |
| CIRep | |
| CPtr | |
| ►NORM | |
| ►NSchema | |
| CField | Provide enough information about a field of a c++ VariantValue object to map it to a field in the SQL database |
| CTableConnection | TableConnection<T> wraps a database Connection::Ptr with information to map c++ objects to/from SQL database objects, and provides a series of common, building block queries (CRUD) |
| CEngineProperties | EngineProperties captures the features associated with a given database engine (being talked to through a SQL::Connection::Ptr) |
| ►CStatement | |
| CColumnDescription | |
| CIRep | |
| CParameterDescription | |
| ►CTransaction | |
| CIRep | |
| CException | |
| CNoDataException | |
| ►NDataExchange | |
| ►NArchive | |
| CReader | |
| ►NCompression | FILE DEPRECATED |
| CIRep | |
| CReader | |
| ►NJSON | |
| CJWT | JSON Web Token - a cryptographically signed set of claims - see https://datatracker.ietf.org/doc/html/rfc7519 |
| ►CPointerType | |
| CContext | |
| ►NStructuredStreamEvents | |
| ►NObjectReader | |
| CContext | |
| CIConsumerDelegateToContext | |
| CIElementConsumer | |
| CIgnoreNodeReader | |
| CListOfObjectsReader | |
| COptionalTypesReader | Reader for optional<X> types - typically just use AddCommonType<optional<T>> () - but use this if you need to parameterize |
| CRangeReader | |
| CReadDownToReader | |
| CRegistry | |
| CRepeatedElementReader_DefaultTraits | |
| CStructFieldInfo | |
| CIConsumer | |
| CName | |
| ►NVariant | |
| ►NCharacterDelimitedLines | |
| CReader | This COULD be easily used to read CSV files, or tab-delimited files, for example |
| CWriter | This COULD be easily used to read CSV files, or tab-delimited files, for example |
| ►NFormURLEncoded | |
| CReader | Read a stream into an Association (or VariantValue) - following https://url.spec.whatwg.org/#application/x-www-form-urlencoded |
| CWriter | Association (or VariantValue) to the output stream - following https://url.spec.whatwg.org/#application/x-www-form-urlencoded |
| ►NINI | |
| CProfile | |
| CReader | Reader for INI format files |
| CSection | |
| ►NJSON | |
| CReader | |
| CWriter | |
| ►NXML | |
| CReader | |
| CWriter | |
| CReader | Abstract class specifying interface for readers that map a source like XML or JSON to a VariantValue objects |
| CWriter | Abstract class specifying interface for writers VariantValue objects to serialized formats like JSON, CSV, XML, etc |
| ►NXML | |
| ►NDOM | |
| ►NDocument | |
| CPtr | Document::Ptr is create with Document::New, and is a smart pointer to a DOM document object |
| ►NElement | |
| CIRep | |
| CPtr | |
| ►NNode | |
| CIRep | |
| CPtr | Node::Ptr is a smart pointer to a Node::IRep |
| ►NXPath | |
| CExpression | |
| CXPathExpressionNotSupported | |
| CSerializationOptions | |
| ►NProviders | |
| ►NLibXML2 | |
| CProvider | |
| ►NXerces | |
| CProvider | |
| CIProvider | |
| ►NResource | |
| CDefinition | |
| CName | |
| CResolverPtr | |
| ►NSchema | |
| CIRep | |
| CPtr | |
| CNamespaceDefinitions | Used to specify default namespace, and any n: prefixes applicable to elements |
| CNameWithNamespace | |
| CSerializationConfiguration | |
| CAtom | An Atom is like a String, except that its much cheaper to copy/store/compare, and the semantics of compare are queer |
| CAtomManager_Default | |
| CBadFormatException | |
| CDefaultConstructForRead | Algorithm used by ObjectOrientedMapper to construct an empty object to read (before fill in fields) |
| CDefaultSerializer | Function object which serializes type T to a BLOB (or BLOB like) object |
| CInternetMediaType | |
| CInternetMediaTypeNotSupportedException | |
| ►CInternetMediaTypeRegistry | |
| CIBackendRep | For OS facilities not updatable - or controllable - just usable |
| CIFrontendRep_ | Alternative to IBackendRep - which can be updated/amended |
| COverrideRecord | |
| ►CObjectVariantMapper | ObjectVariantMapper can be used to map C++ types to and from variant-union types, which can be transparently mapped into and out of XML, JSON, etc |
| COptionalSerializerOptions | |
| CRangeSerializerOptions | |
| CStructFieldInfo | |
| CTypeMappingDetails | |
| COptionsFile | |
| CStructFieldMetaInfo | |
| CTypedBLOB | TypedBLOB is a named tuple<Memory::BLOB, optional<InternetMediaType>> - with friendlier names, and serialization properties |
| ►CVariantValue | Simple variant-value (case variant union) object, with (variant) basic types analogous to a value in any weakly typed language (like JavaScript, Lisp, etc) |
| CEqualsComparer | Compares values as if first normalized with Normalize () method |
| CThreeWayComparer | Compares values as if first normalized with Normalize () method |
| ►NDebug | |
| ►NVisualizations | |
| CStringRep | |
| CAssertExternallySynchronizedMutex | NOT a real mutex - just a debugging infrastructure support tool so in debug builds can be assured threadsafe, which is syntactically used like a mutex, for SIMILAR reasons in similar places |
| CTimingTrace | |
| CTraceContextBumper | |
| CTraceContextSuppressor | |
| ►NExecution | |
| ►NPlatform | |
| ►NPOSIX | |
| CScopedBlockCurrentThreadSignal | |
| CSemWaitableEvent | |
| ►NWindows | |
| CCriticalSectionMutex | |
| CCriticalSectionRecursiveMutex | |
| ►NPrivate_ | |
| ►NActivities_ | |
| CAsStringObj_ | |
| ►NResources | |
| ►NConcrete | |
| CCompiledResourceManager | |
| CElfResourceManager | |
| CWindowsResourceManager | |
| CAccessor | |
| CManager | |
| ►NThread | Thread is a namespace for Stroika thread code, |
| CCleanupPtr | |
| CConfiguration | EXPERIMENTAL SUPPORT FOR THREAD STACK (and maybe other) settings |
| CIndexRegistrar | |
| CPtr | Thread::Ptr is a (unsynchronized) smart pointer referencing an internally synchronized std::thread object (rep), with special feautres, including cancelation |
| CSuppressInterruptionInContext | |
| ►NWaitForIOReady_Support | |
| CEventFD | |
| CAbortableMutex | |
| CActivity | |
| CBlockingQueue | |
| ►CCommandLine | |
| COption | |
| CConditionVariable | |
| CDeclareActivity | |
| CDLLLoader | |
| CException | Exception<> is a replacement (subclass) for any std c++ exception class (e.g. the default 'std::exception'), which adds UNICODE String support |
| CExceptionStringHelper | |
| CFeatureNotSupportedException | |
| CFunction | |
| ►CIntervalTimer | Manage interval timers - like the javascript setIntervalTimer API |
| CAdder | Adder adds the given function object to the (for now default; later optionally explicit) IntervalTimer manager, and when its destroyed, the timer is removed |
| ►CManager | |
| CActivator | Having explicit activator object allows for users to control the starting/stopping of facility in a managed fashion |
| CDefaultRep | |
| CRegisteredTask | |
| CInvalidCommandLineArgument | |
| CLazyEvalActivity | |
| CLazyInitialized | Value-object, where the value construction is delayed until first needed (can be handy to avoid c++ include/initializer deadly embrace) |
| ►CLogger | A simple/portable wrapper on syslog/log4j/WindowsEventlog, with features like throttling, de-duping, varargs, etc |
| CActivator | |
| CModuleGetterSetter | Helper to define synchronized, lazy constructed, module initialization (intended to work with DataExchange::OptionFile) |
| CNestedException | NestedException contains a new higher level error message (typically based on argument basedOnException) and preserves the original exception (which you can use to get its message, with Characters::ToString (fBasedOnException) |
| CNullMutex | |
| COperationNotSupportedException | |
| ►CPIDLoop | |
| CControlParams | |
| ►CProcessRunner | Run the given command, and optionally support stdin/stdout/stderr as streams (either sync with Run, RunInBackground) |
| CBackgroundProcess | |
| CException | |
| CProcessResultType | |
| CStringOptions | Run () options for mapping Strings - what code page converters to use |
| ►CProgressMonitor | |
| CCurrentTaskInfo | |
| CUpdater | |
| CRuntimeErrorException | |
| CSharedStaticData | |
| CSignalHandler | |
| ►CSignalHandlerRegistry | |
| CSafeSignalsManager | |
| CSilentException | |
| CSpinLock | |
| ►CSynchronized | Wrap any object with Synchronized<> and it can be used similarly to the base type, but safely in a thread safe manner, from multiple threads. This is similar to std::atomic |
| CReadableReference | |
| CSynchronized_Traits | |
| CSystemErrorException | |
| ►CThreadPool | |
| CQMax | |
| CStatistics | |
| CTimedLockGuard | |
| CTimeOutException | |
| CUpdatableWaitForIOReady | Simple wrapper on WaitForIOReady (POSIX select/poll/etc API) - except it allows for the list if polled descriptors to be updated dynamically from any thread, and have that automatically wakeup any waiters to restart waiting |
| CUserCanceledException | |
| CWaitableEvent | |
| CWaitForIOReady | |
| CWhenTimeExceeded | |
| ►NIO | |
| ►NFileSystem | |
| CAppTmpFileManager | |
| CDirectoryIterable | |
| CDirectoryIterator | |
| CDiskInfoType | |
| CException | |
| CMemoryMappedFileReader | |
| CMountedFilesystemType | |
| CPtr | |
| CScopedTmpDir | |
| CScopedTmpFile | |
| CThroughTmpFileWriter | Utility to atomically update/write a file |
| ►NNetwork | |
| ►NConnectionlessSocket | ConnectionlessSocket is typically a UDP socket you use for packet oriented communications (ie not tcp/streams) |
| CPtr | |
| ►NConnectionOrientedMasterSocket | |
| CPtr | |
| ►NConnectionOrientedStreamSocket | ConnectionOrientedStreamSocket is typically a tcp stream, either setup with Connect, or ConnectionOrientedMasterSocket::Accept () |
| CPtr | |
| ►NHTTP | |
| ►NMessageStartTextInputStreamBinaryAdapter | |
| CPtr | |
| ►CCacheControl | |
| CMaxStale | |
| CClientErrorException | ClientErrorException is to capture exceptions caused by a bad (e.g ill-formed) request |
| CContentEncoding | Content coding values indicate an encoding transformation that has been or can be applied to an entity. Content codings are primarily used to allow a document to be compressed or otherwise usefully transformed without losing the identity of its underlying media type and without loss of information. Frequently, the entity is stored in coded form, transmitted directly, and only decoded by the recipient |
| CCookie | Object representing an HTTP cookie - from https://tools.ietf.org/html/rfc6265 |
| CCookieList | |
| CETag | |
| CException | |
| CHeaders | Roughly equivalent to Association<String,String>, except that the class is smart about certain keys and will automatically fold them together |
| CIfNoneMatch | |
| CKeepAlive | |
| CRequest | |
| CResponse | |
| CTransferEncoding | Transfer-Encoding is a hop-by-hop header, that is applied to a message between two nodes, not to a resource itself. Each segment of a multi-node connection can use different Transfer-Encoding values. If you want to compress data over the whole connection, use the end-to-end Content-Encoding header instead |
| ►NInternetProtocol | |
| ►NICMP | |
| ►NV4 | |
| CDestinationUnreachableException | |
| CTTLExpiredException | |
| ►NPlatform | |
| ►NWindows | |
| CWinSock | |
| ►NSocket | |
| CPtr | Smart pointer wrapper (like shared_ptr <_IRep>) |
| ►NSystemFirewall | |
| CManager | |
| CRule | |
| ►NTransfer | |
| ►NCache | |
| CElement | |
| CEvalContext | |
| ►NConnection | |
| CPtr | |
| CConnectionPool | |
| CRequest | |
| ►CResponse | |
| CSSLResultInfo | |
| ►NUniformResourceIdentification | |
| CAuthority | Authority is roughly the part of a URL where you say the hostname (and portnumber etc) - part just after // |
| CHost | |
| CPCTEncodeOptions | |
| CQuery | |
| CSchemeType | |
| CUserInfo | |
| CCIDR | |
| CDNS | |
| ►CInterface | |
| CWirelessInfo | |
| CInternetAddress | |
| CLinkMonitor | |
| ►CNeighborsMonitor | Monitor - either immediately or in the background fetches a list of network neighbors (1 hop away network devices). Also fetches their hardware address (so like 'arp' kind of but may employ other means) |
| CNeighbor | |
| CSocketAddress | |
| CSystemInterfacesMgr | |
| CURI | |
| ►NMath | |
| ►NOptimization | |
| ►NDownhillSimplexMinimization | |
| COptions | |
| CResults | |
| ►NReBin | |
| CBasicDataDescriptor | |
| CUpdatableDataDescriptor | |
| CAngle | |
| CCommonStatistics | |
| ►NMemory | |
| CAbstractGeneralPurposeAllocator | |
| ►CBLOB | |
| C_IRep | |
| CBlockAllocationUseGlobalAllocatorHelper | |
| CBlockAllocationUseHelper | |
| CBlockAllocator | |
| Cenable_shared_from_this | |
| CGlobalAllocationStatistics | |
| CInheritAndUseBlockAllocationIfAppropriate | |
| CInlineBuffer | Logically halfway between std::array and std::vector; Smart 'direct memory array' - which when needed automatically switches to heap based so can grow - BUF_SIZE is number of T elements allocated inline |
| CLeakTrackingGeneralPurposeAllocator | |
| CManuallyBlockAllocated | ManuallyBlockAllocated<T> is a simple wrapper on BlockAllocator<T>. If qStroika_Foundation_Memory_PreferBlockAllocation defined, this will use block allocation for a given type - at a given call |
| CSharedByValue | SharedByValue is a utility class to implement Copy-On-Write (aka COW) - sort of halfway between unique_ptr and shared_ptr |
| CSharedByValue_CopyByDefault | SharedByValue_CopyByDefault is the default template parameter for copying SharedByValue |
| CSharedByValue_Traits | SharedByValue_Traits is a utility struct to provide parameterized support for SharedByValue<> |
| CSimpleAllocator_CallLIBCMallocFree | |
| CSimpleAllocator_CallLIBCNewDelete | |
| CSimpleSizeCountingGeneralPurposeAllocator | |
| CSTLAllocator | |
| ►NStreams | |
| ►NBufferedInputStream | |
| CPtr | |
| ►NBufferedOutputStream | |
| CPtr | |
| ►NInputOutputStream | |
| CPtr | InputOutputStream is single stream object that acts much as a InputStream::Ptr and an OutputStream::Ptr |
| ►NInputStream | |
| CIRep | |
| CPtr | InputStream<>::Ptr is Smart pointer (with abstract Rep) class defining the interface to reading from a Stream source of data |
| ►NMemoryStream | |
| CPtr | |
| ►NOutputStream | |
| CIRep | Abstract interface for output stream object. Don't call directly (use Ptr usually) - but use directly mostly to implement new output stream types |
| CPtr | OutputStream<>::Ptr is Smart pointer to a stream-based sink of data |
| ►NSharedMemoryStream | |
| COptions | Options to configure a new SharedMemoryStream; defaults should always work fine, but options can allow for better performance (at a loss of some functionality) |
| CPtr | |
| CEOFException |
- the stream ended prematurely, so that the requested operation could not be completed
|
| CEWouldBlock |
- a read (typically) or write operation would have blocked, and the XXX flag was passed to a Stream read
|
| CInputStreamDelegationHelper | |
| CIRep | |
| CPtr | A Streams::Ptr<ELEMENT_TYPE> is a smart-pointer to a stream of elements of type T |
| CStreamReader | StreamReader is an non-essential Stream utility, adding simplicity of use for a common use case, and a significant performance boost |
| ►NTime | |
| CAppStartZeroedClock | |
| ►CDate | |
| CReferencePoint | |
| CDayOfMonth | Simple wrapper on std::chrono::day, with some helpful validation properties (assures constructed 'ok'). But not necessary to use - use just 'day' in most places |
| CDayOfWeek | Simple wrapper on std::chrono::weekday, with some helpful validation properties (assures constructed 'ok'). But not necessary to use - use just 'weekday' in most places |
| CDuration | Duration is a chrono::duration<double> (= |
| CMonthOfYear | Simple wrapper on std::chrono::month, with some helpful validation properties (assures constructed 'ok'). But not necessary to use - use just 'month' in most places |
| CStdCPctxTraits | This defines undefined but important properties of the x (read/write date) format string in stdc++ time_get/time_put |
| CTimeOfDay | |
| CTimezone | |
| CTimeZoneInformationType | |
| CYear | Simple wrapper on std::chrono::year, with some helpful validation properties (assures constructed 'ok'). But not necessary to use - use just 'year' in most places |
| ►NTraversal | |
| ►NRangeTraits | |
| CDefault | |
| CDefault< Time::DateTime > | |
| CDefault< Time::Duration > | |
| CDefault_Arithmetic | |
| CDefault_Enum | |
| CDefault_Integral | |
| CDefaultBounds | |
| CDefaultDifferenceTypes | |
| CDefaultOpenness | This defines the default openness for a given type T, except for specializaitons. This is used by Explict<>, and indirectly by Range<> itself. Generally its eClosed, by default, except for the upper bound on floating point Ranges. The reason for this exception on floating point, is that its often helpful to have a series of ranges that form a partition, and that works out more easily with half-open intervals |
| CExplicit | |
| CExplicitBounds | |
| CExplicitDifferenceTypes | |
| CExplicitOpenness | |
| CExplicitOpennessAndDifferenceType | |
| CDefaultIteratorTraits | |
| CDelegatedIterator | |
| CDirectPushMapEngine | |
| CDiscreteRange | A DiscreteRange is a Range where the underlying endpoints are integral (discrete, not continuous); this implies you can iterate over the members of the range, and its endpoints are closed |
| ►CDisjointDiscreteRange | |
| CFindHints | |
| CDisjointRange | A DisjointRange is NOT a range, but a collection of non-overlapping (except at the edges) Ranges. It its BOUNDs (GetBounds) form a Range |
| CFunctionalApplicationContext | |
| ►CIterable | Iterable<T> is a base class for containers which easily produce an Iterator<T> to traverse them |
| C_IRep | Implementation detail for iterator implementors |
| C_SafeReadRepAccessor | |
| C_SafeReadWriteRepAccessor | |
| CSequentialEqualsComparer | |
| CSequentialThreeWayComparer | |
| CIterableFromIterator | |
| ►CIterator | An Iterator<T> is a copyable object which allows traversing the contents of some container. It is like an std::const_iterator |
| CIRep | Implementation detail for iterator implementors |
| CRange | |
| ▼NFrameworks | |
| ►NAuth | |
| ►NOAuth | |
| CClientConfiguration | |
| CFetcher | Simple wrapper on IO::Network::Transfer to do fetching (more configurability to do) |
| CProviderConfiguration | Track configuration data about stuff that differentiates different OAuth providers - what URLs to use, base url, relative off that URLs for login/upgrade token/refresh etc. ALL very prelim at this stage |
| CTokenRequest | |
| CTokenResponse | |
| CCurrentIdentityAuthInterceptor | Interceptor added to WebServer::ConnectionManager to translate Authorization: headers (parse them) into thread_local ID variable accessible by webservice methods |
| ►CCurrentIdentityManager | Static/thread_local storage of the some notion of identity, which can be used to 'pass data' to functions without explicit parameters |
| CEstablish | Sets the current ID to argument value - |
| ►NLed | |
| CColor | |
| CColoredUniformHidableTextMarkerOwner | |
| CFlavorPackageExternalizer | |
| CFlavorPackageInternalizer | |
| CFontSpecification | |
| ►CHidableTextMarkerOwner | |
| CLightUnderlineHidableTextMarker | |
| CIncrementalParagraphInfo | |
| CLineBasedPartition | |
| CMarkerOwner | |
| CParagraphDatabaseRep | |
| CParagraphInfo | |
| CPen | |
| CReaderFlavorPackage | |
| CReadWriteMemBufferPackage | |
| CStandardStyledTextIOSinkStream | |
| CStandardStyledTextIOSrcStream | |
| CUniformHidableTextMarkerOwner | |
| CWordProcessorTextIOSinkStream | |
| CWordProcessorTextIOSrcStream | |
| CWriterFlavorPackage | |
| ►NModbus | |
| CIModbusService | |
| CModbusRegisterDescriptor | |
| ►NNetworkMonitor | |
| ►NPing | |
| CPinger | |
| ►NService | |
| ►CMain | |
| CCommandArgs | |
| CIApplicationRep | |
| CIServiceIntegrationRep | |
| CLoggerServiceWrapper | |
| CRunNoFrillsService | |
| ►NSystemPerformance | |
| ►NInstruments | |
| ►NCPU | |
| CInstrument | |
| COptions | |
| ►NFilesystem | |
| CDiskInfoType | |
| CInfo | |
| CInstrument | |
| CIOStatsType | |
| CMountedFilesystemInfoType | |
| COptions | |
| ►NMemory | |
| ►CInfo | |
| CPagingDetailsType | |
| CPhysicalRAMDetailsType | |
| CVirtualMemoryDetailsType | |
| CInstrument | |
| COptions | |
| ►NNetwork | |
| CInfo | |
| CInstrument | |
| CIOStatistics | |
| COptions | |
| ►NProcess | |
| CInstrument | |
| ►CProcessType | |
| CTCPStats | |
| ►NSupport | |
| CContext | |
| CInstrumentRep_COMMON | |
| CWMICollector | |
| CCapturer | |
| CCaptureSet | |
| ►CInstrument | An Instrument is a stateful object from which you can Capture () a series of measurements about a system |
| CICaptureContext | |
| CIRep | |
| CMeasurement | |
| CMeasurementSet | |
| ►NTest | |
| ►NArchtypeClasses | |
| CAsIntsEqualsComparer | |
| CAsIntsLessComparer | |
| CAsIntsThreeWayComparer | |
| COnlyCopyableMoveable | |
| COnlyCopyableMoveableAndTotallyOrdered | |
| COnlyDefaultConstructibleAndMoveable | |
| ►NUPnP | |
| ►NSSDP | |
| ►NClient | |
| CCachingListener | |
| CListener | |
| ►NServer | |
| CBasicServer | Handle the multicast part of UPnP SSDP - listening for searches and sending periodic notifications |
| CPeriodicNotifier | |
| CSearchResponder | |
| CDevice | |
| ►CDeviceDescription | |
| CIcon | |
| ►NWebServer | |
| ►CConnection | A Connection object represents the state (and socket) for an ongoing, active, HTTP Connection, managed by the ConnectionManager class |
| CStats | |
| ►CConnectionManager | |
| COptions | ConnectionManager::Options specify things like default headers, caching policies, binding flags (not bindings), thread count |
| ►CStatistics | |
| CConnectionStatistics | |
| CCORSOptions | |
| CFileSystemRequestHandler | |
| CILogHandler | |
| ►CInterceptor | |
| C_IRep | |
| CInterceptorChain | |
| CMessage | |
| CRequest | This represents a HTTP request object for the WebServer module |
| CRequestHandler | |
| CRoute | |
| CRouter | |
| ►NWebService | |
| ►NJSONRPC | |
| CRequest | |
| CResponse | |
| ►NServer | |
| ►NObjectRequestHandler | |
| CContext | Not directly instantiated, but to receive context arguments in callbacks |
| CFactory | ObjectRequestHandler::Factory is a way to construct a WebServer::RequestHandler from an ObjectVariantMapper object and a lambda taking in/out params of objects |
| COptions | Options for ObjectRequestHandler - mostly the ObjectVariantMapper, but also a few others depending on situation |
| ►NVariantValue | |
| CExtractArgumentsAsVariantValue | |
| ▼NSamples | |
| ►NHTMLUI | |
| ►NModel | |
| CAbout |
|
| CIWSAPI | : IWSAPI defines an abstract version of the web service API provided by this program |
| COperationalStatisticsMgr | |
| ▼NStroikaSample | |
| ▼NWebServices | |
| CWebServer | |
| CWSImpl | : WSImpl is the module providing the concrete C++ implementation (fully using C++ objects, exceptions etc) for the web service API |
1.9.8