Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

►Nhoney	Global Honeycomb namespace
►Napp	Top-level application methods
CModule	An application module, holds a task and its dependencies
CModuleRegistry	List of application modules
►Natomic	Atomic operations
COp	Methods to perform thread-safe atomic read/write operations
CSwapType	Get the smallest atomically-swappable type that is large enough to hold T
►Nbloom_filter	BloomFilter util
Chash	Functor used to generate hash. Each hashIndex for the same object must produce a unique hash
CKey	Caches multiple hashes of an object. The key can be inserted into a bloom filter and tested very quickly
►Ndebug	Debug Mode Functions
CAssertionFailure	Thrown on debug assert() failure
►Nexception	Exception util
CStd	Wrapper around std exception to allow for polymorphic throw
CUnknown
►Nfuture	Future util
CAlreadySatisfied
CAsyncSched
CAsyncSched_tag
CBroken	Exceptions
CFutureAlreadyRetrieved
CNoState
►Nhash	Data hashing functions. Produce a small fingerprint from a larger data set. Two data sets may 'collide', producing the same fingerprint
Csval	256-bit secure hash value
►Njson	Json string serialization format methods
►CConfig	Configuration for json value variant
CObjectOrdered
Cnull_t	Json null value type
CValue_	Json value variant. Provide a Config to customize the variant's bounded types
CValueError
►Nlockfree	Lock-free methods and containers
CBackoff	Exponential backoff algorithm. Backoff spins for first X ticks, then sleeps with a time that doubles every X ticks thereafter
CFreeList	Lock-free freelist, allocates re-usable objects and provides automatic storage expansion for concurrent algorithms
CFreeListAllocator
CHazardMem	Lock-free memory manager, provides safe memory reclamation for concurrent algorithms
CHazardMemConfig	Configuration interface for memory manager. Inherit this class and override types and static members
CHazardMemLink	Base link class, contains a generic Cas-able data chunk. The data chunk contains a pointer to a HazardMemNode
CHazardMemNode	Base node class, inherit from this class, add link members, and use as Node type in HazardMemConfig
►CList	Lock-free doubly-linked list
CIter_	Iterator
CIterR_	Reverse iterator
CQueue	Lock-free FIFO queue. Uses auto-expanding freelist allocator so memory is only reclaimed upon destruction
CSpscDeque	Deque that is lock-free only when used by a single producer and consumer, otherwise contention is split between front and back locks
CStack	Lock-free FILO stack. Uses auto-expanding freelist allocator so memory is only reclaimed upon destruction
CUnorderedMap	Lock-free unordered map. Uses auto-expanding freelist allocator so memory is only reclaimed upon destruction
►Nlog	Logger methods
CBufferSink	Captures records in a buffer
CFileSink	Formats record to a file stream
CSink
CStreamSink	Formats record to a stream
►Nmatrix	Matrix util
►Npriv	Matrix implementation details
CBlockTraits
CStorage	Chooses storage based on traits
CStorageAuto	Automatic (stack-compatible) dense storage
CStorageAutoArray
CStorageAutoArray< Real, Size, 16 >
CStorageBlock	Block wrapper around any constant matrix with auto / dynamic dense storage type. Fully recursive, a block can wrap a block
CStorageDense
CStorageDynamic	Dynamic (heap) dense storage
CTraits
CTraits< Block< MatrixP, Rows, Cols > >
CTraits< Block< Vec, 1, 1 > >	1x1 block traits
CTraits< Block< Vec, 1, Cols > >	Column vector block traits
CTraits< Block< Vec, Rows, 1 > >	Row vector block traits
CTraits< Matrix< Rows, Cols, Real_, Options, Alloc_ > >	(m x n)-dimensional matrix traits
CTraits< Vec< 1, Real, Options > >
CTraits< Vec< 2, Real, Options > >
CTraits< Vec< 3, Real, Options > >
CTraits< Vec< 4, Real, Options > >
CTraits< Vec< Dim, Real, Options, Alloc > >
CTraits< VecSwizCon< Dim, Real, Options > >
CTraits< VecSwizRef< Dim, Real, Options > >
CBlock	Matrix block view
CBuilder	Matrix comma initializer
CIter	Matrix element iterator
►COption	Matrix type options
CgetAlign
CsetAlign	Alignment must be a power of 2
►Nmt	Meta-programming and compile-time util
Cconditional_int	Variant of std::conditional for integers, stores result in value
Cconditional_int< true, t, f >
CelemOf	Get range element type
CFuncptr
CFuncptr< R(Args...)>	Holds a function pointer so that a functor can be called non-virtually. The functor must inherit from FuncptrBase
CFuncptr< void(Args...)>	Specialization for void return type
CFuncptrBase	Inherit to enable non-virtual functor calling
CfuncTraits	Get function type traits
Cgcd	Calc greatest common divisor of a and b
Cgcd< 0, b >
Cgcd< a, 0 >
Cidentity	Returns type T unchanged
Cis_base_of	Version of std::is_base_of that removes reference qualifiers before testing
CisCallable	Check if functor is callable with arguments
CisRange	Check if type is a range or a reference to one. A range is a type where std::begin(range) is a valid call
CisSpecializationOf	Check if T is a specialization of Template
CisSpecializationOf< Template< Param... >, Template >
Citer_endOf	Get range iterator end type
CiterOf	Get range iterator begin type
Clog2Floor	Calc log base 2 of unsigned integer, rounded down to nearest integer. Returns -1 if x is zero
Clog2Floor< 0 >
Cmax	Get maximum of all arguments
Cmax< val >
Cmax< val, vals... >
Cmin	Get minimum of all arguments
Cmin< val >
Cmin< val, vals... >
CNoCopy	Inherit to declare that class is not copyable
Ctag	Use to differentiate an overloaded function by type. Accepts dummy parameter default value: func(tag<0> = 0)
CTrue	Always returns true. Can be used to force a clause to be type dependent
CTrue_int	Variant of True for integers
CVoid	Special void type, use where void is intended but implicit members are required (default ctor, copyable, etc.)
►Nnet	Net util
CSocket	Socket class
CStreamBuf_	Automatically resizable buffer class based on ByteStreamBuf
►Nthread	Thread util
CInterrupted	Interrupted exception
CInterruptEnable	Enable / disable interrupts in the current thread's scope
CLocal	Local thread storage. Multiple threads can access one Local object, but each thread will only see its own separate "local" instance
►CPool	Spreads task execution across a pool of re-usable threads. Uses a lock-free work-stealing queue to ensure workers are never idle
CTask	All tasks must inherit from this class. std::function is not used here to avoid the operator() virtual call
►Nvec	Vec util
►Npriv	Vec implementation details
CSegment	Vector segment view
CStorage	Auto or dynamic vector storage
CStorageFields	Automatic (stack-compatible) vector storage that allows direct access to dimension fields
CStorageFieldsMixin
CStorageFieldsMixin< Real, 1, Align >
CStorageFieldsMixin< Real, 2, Align >
CStorageFieldsMixin< Real, 3, Align >
CStorageFieldsMixin< Real, 4, 16 >
CStorageFieldsMixin< Real, 4, Align >
CTraits	N-dimensional vector traits
CAlge_	Algebra
►CAllocator	Std::allocator compatible allocator
Crebind
CAllocatorObject	Objects that inherit from this class will use Alloc for new/delete ops
►CApp	Top-level application flow controller, provides entry point and run loop
CTerminated	Process terminated. Use this interrupt to exit the run loop
CAtomic
CAtomic< T *, false >	Wrapper around pointer type to make all operations atomic and sequentially consistent
CAtomic< T, false >	Wrapper around a trivially copyable type to make load/store operations atomic and sequentially consistent
CAtomic< T, true >	Wrapper around integral type to make all operations atomic and sequentially consistent
CBackSub	Back substitute to solve a linear system
CBeta_	Generate a random variate from a beta distribution
CBetaInc	Evaluate the incomplete beta function
CBinomial_	Generate a random integer variate from a binomial distribution
CBinomialNeg_	Generate a random integer variate from a negative binomial distribution
CBisect	Find the root of a function by the bisection method. ie. Finds where function returns 0
CBisectN	Find the root of a set of functions by the bisection method. ie. Finds (x,y,...) where all functions return 0
CBitOpCommon	Bit util common to any endian type. Use through class BitOp
CBitOpEndian	Bit util specific to endian type. Use through class BitOp
CBitOpEndian< static_cast< int >(Endian::big)>	Specialization for big endian
CBitOpEndian< static_cast< int >(Endian::little)>	Specialization for little endian
CBitSet_	A compact array of bits. Dynamic version of std::bitset
CBloomFilter	A space-efficient probabilistic data structure that is used to test set membership. Can be tuned to use less space at the expense of increased false positive probabilty
►CBootstrap	Monte Carlo (random-based) method to estimate the interval of confidence in a function's result, when that function operates on samples from a complex or unknown distribution
CmeanFunc	Functor to estimate the sample mean
CvarianceFunc	Functor to estimate the sample variance. This is the unbiased estimator (mean over all possible samples is the population variance)
CBuffer	A contiguous region of referenced (not owned by object) memory
CByteArray	Fixed array of N bytes
CBytes	String of bytes
CByteStream	An I/O stream into which objects may be serialized and subsequently deserialized
CByteStreamBuf	A stream I/O buffer of bytes, to be passed into ByteStream
►CChacha	ChaCha8, a cryptographically secure pseudo random number generator
CState	Generator State
CChiSqr_	Generate a random variate from a noncentral chi-square distribution
CComObject	Component object. Object that consists of a collection of components
CComponent	Base class for components. Components can only be attached to one ComObject at a time
►CComRegistry	Holds global list of all component types
CType	Component type
CCondition	Method to synchronize threads. Condition variables eliminate the need for repeated polling to check the value of some data
CConditionAny	Condition that can be used with any kind of lock. Slightly slower than the default Condition class
CConditionLock	Lock that is bound to a single condition. This is the common usage case of condition variables
CDefaultAllocator	Returns T::Allocator<T> if available, otherwise std::allocator<T>
CDefaultAllocator< T, typename mt::True< typename T::template Allocator< T > >::type >
CDefaultAllocator< T[], std::true_type >
►CDepGraph	Dependency graph. Collects nodes and builds a searchable directed graph
CIter_	Depth-first pre-order iterator over vertices
CNodeIter_	Depth-first pre-order iterator over nodes. Iterates over nodes that constitute each vertex in a vertex range
CVertex	A vertex is initially associated with one key and acts like a multi-map, storing all nodes and graph links of DepNodes matching that key
CDepNode	Dependency node for insertion into graph
CDepSched	Scheduler that serializes and parallelizes task execution given a dependency graph of tasks and a pool of threads
CDepTask	Base class of DepTask_, can be added to scheduler. Instances must be created through class DepTask_
CDepTask_	Holds a functor and dependency information, enqueue in a scheduler to run the task
Cderef_wrap	Wraps a pointer so that it behaves similar to a reference
CDiscrete_	Generate random integer variate between min and max inclusive with uniform (flat) distribution
CDiscreteGen_	Generate a random integer variate from a generalized discrete distribution
CDouble_	Defines 64-bit floating point operations and constants
CDuration	Duration represented by repetitions of a period. The period must be a ratio
CEigen	Eigendecomposition. Decomposes any square (n x n) symmetric matrix into eigenvalues and eigenvectors
CEnumElem	Base class of all generated enum classes. A single element in the enumeration. See Enumeration Classes
CEnumError
►CEnumInfo_	Run-time info about an enum class. Contains a list of elements and maps for element lookups. See Enumeration Classes for more info and examples
CElem
►CException	Base exception class. Exceptions inherited from this class provide debug info and can be thrown polymorphically (unlike standard c++ exceptions)
CMsgStream	Custom error message builder
CRaiser	Helper to raise an exception after the right side of ^ has been evaluated
CSource	Info about source where exception was thrown
Cfinalize	Functor to delete a pointer
Cfinalize< T[], std::allocator< T > >	Specialization for array
Cfinalize< void, std::allocator< void > >	Specialization for void
CFloat_	Defines floating point operations and constants
CFuture	Unique future, guarantees sole access to a future function result
CFutureBase	Base class for Future types
CFutureCommon	Mixin for common future methods
CGamma_	Generate a random variate from a gamma distribution
CGammaFunc_	Class to evaluate Gamma and related functions
CGaussian_	Generate a normally (Gaussian) distributed random variate
CHyperGeo_	Generate a random integer variate from a hypergeometric distribution
CId	Holds a name string and its hashed value for fast comparison ops. See String Identifier
CIdLiteral	Id created from a string literal at compile-time
CInterp_	Interpolation math
CIntIter	Incremental integer iterator (step size = 1). See range(int, int) to create
CIntStepIter	Integer iterator with step size. See range(int, int, int) to create
Clazy	Wraps a value so that it is calculated only when needed. A lock synchronizes access
CLinearLeastSqr	Linear least squares solver
CListener	Holds a slot that can receive signals
►CListenerList	Collection of listeners
CCallback	Callback to handle events from this class
CListenerQueue	Listener that holds queued slot for delayed processing of signals
►CLog	Logger
CRecordStream	Builds a record
CManip	Base class to hold iostream manipulator state. Inherit from this class and call Subclass::inst(ios) to attach an instance of Subclass to an iostream
CManipFunc	Helper to create a manipulator that takes arguments
CMatrix	(m x n)-dimensional matrix
CMatrix< 1, 1, Real, Options >	Matrix 1x1 vector
CMatrix< 1, Dim, Real, Options, Alloc_ >	Matrix row vector
CMatrix< 4, 4, Real, Options >	4x4 homogeneous matrix class. Supports both affine and projective operations
CMatrix< Dim, 1, Real, Options, Alloc_ >	Matrix column vector
CMatrixBase	Matrix base class
CMemPool	Memory pool
CMemPoolAllocator	MemPool allocator
CMinimize	Find a local minimum of a 1-dimensional function using "Brent's method" – bisection and inverse quadratic interpolation
CMinimizeN	Find a local minimum of an n-dimensional function using "Powell's conjugate gradient descent method"
CMonoClock	System-wide monotonic clock. High-resolution and steady-rate time since application start, can't go backwards
►CMtMapCommon	Common functions between map elem and the map tail specialization. Use through class MtMapElem
Cempty_	Check if empty at compile-time
ChasKey_	Check if key exists at compile-time
Csize_	Get size of map at compile-time
CMtMapElem	Map element in recursive list
CMtMapIter	Bidirectional iterator over map key/value pairs
CMtPair	Key/value pair. A pair can be constructed with the syntax: (key() = value)
CMutex	A thread lock where the lock is acquired by suspending thread execution until it becomes available
CNameId	Holds both a name string and its hashed value, and unlike Id the name is never compiled out
CNumeral	Numeric type information, use numeral() to get instance safely from a static context
CNumeralFloat	Numeric type info for floating point types
CNumeralInt	Numeric type info for integer types
CObject	Base class for objects
Coptional	Enables any type to be optional so it can exist in an uninitialized null state
Coptional< T & >	Specialization for references
Coptnull_t	Null optional type
Coverload_
Coverload_< Func, Funcs... >	An overloaded visitor functor
Coverload_<>
CPackagedTask	A container that wraps a function so that its result is stored in a future when invoked
CPackagedTask< R(Param...)>
CPeriodicSched	Scheduler that executes tasks periodically or after a delay given a pool of threads
►CPeriodicTask	Base class of PeriodicTask_, returned by scheduler
CCancelled	Future result when cancelled
CPeriodicTask_	Holds a functor and period information, returned by scheduler
►CPermute_	Generate all permutations of a list. A functor can be specified for fast culling of entire subtrees of undesired permutations
CIter	Iter for permutations of a list
CPoisson_	Generate a random integer variate from a poisson distribution
CPolynomial	Polynomial algorithms
CPromise	Container to hold a delayed function result
CProperty	Generic property
CProperty< vector< T > >	Generic vector property
CPropertyBase	Base class for all properties
CPropertyError
CPropertyObject	Object that contains properties
CQrd	QR Decomposition. Can be used to solve least squares problems
CQuad_	Defines 128-bit floating point operations and constants
CQuat_	Quaternion rotation class. Represents a counter-clockwise rotation of an angle about its axis
►CRandom_	Random-related methods
CDistStats
CRandomDist	Base class for all random distributions
CRandomGen	Random number generator interface
CRange_	Iterator range. See range(Iter1&&, Iter2&&) to create
►CRatio	Class to hold compile-time finite rational numbers, ie. the fraction num / den
Cadd	Operator+
Cdiv	Operator/
Cequal	Operator==
Cgreater	Operator>
CgreaterEqual	Operator>=
Cless	Operator<
ClessEqual	Operator<=
Cmul	Operator*
CnotEqual	Operator!=
Csub	Operator-
CRealBase	Base class for real number operations
CRealIter	Real number iterator. See range(Real, Real, Real) to create
Crecursive_wrap	Allows for recursive type definitions, eg. class Object : vector<recursive_wrap<Object>>
CRingIter	Ring iterator. See ringRange() to create
CScopeGuard_	Run a function at scope exit. See ScopeGuard() to create
CSharedFuture	Shared future, allows multiple access to a future function result
CSharedLock	A scoped lock that references a shared mutex. Does a shared read lock on construction and unlocks on destruction
CSharedMutex	A thread lock for shared data where there may be many readers and one writer
CSharedObj	Reference-counted object for intrusive shared pointers
CSharedPtr	Combined intrusive/non-intrusive smart pointer. Can reference and share any object automatically
CSignal	Multicast sender
CSimplexNoise	Generate smooth noise over space. Implementation of Perlin's "Simplex Noise" generator
CSimplexNoiseCommon	Methods common to all simplex noise dimensions
CSinTable	Speeds up all trig functions at the cost of precision. Precision is roughly 1 / size
CSlotBase	Multicast receiver
CSmallAllocator	Global allocator for small memory blocks. To provide a custom pool define SmallAllocator_createSingleton_ and implement SmallAllocator_createSingleton()
CSpinLock	A thread lock where the lock is acquired through a busy wait loop
CString	Unicode UTF-16 string class, wrapper around std::u16string
►CStudentT_	Generate a random variate from a Student's t-distribution
CPooledStats
CStats
CSvd	Singular Value Decomposition. Can be used to calculate the pseudo-inverse of any matrix or solve least squares problems
CSystemClock	System-wide real-time clock. Low-resolution time since Unix Epoch, can possibly go backwards if changed by OS
CThread	Thread class
CTimedMutex	A mutex that has a timed try-lock
CTimePoint	TimePoint represented by a duration since a clock's epoch time
CTransferLock	Scoped transfer of mutex ownership between two locks
CTransform_	A 3D linear transform from TRS components (translation, rotation, and scale/skew)
CTreeClone	Clone and track changes to an entire tree
►CTreeNode	Unrooted acyclic tree
CPreOrdIter_	Depth-first pre-order traversal
CTrig_	Trigonometry
CTupleIter	Wrapper around an iterator with tuple value type. When dereferenced returns I'th element
CTupleIter< Iter, I, std::bidirectional_iterator_tag >
CTupleIter< Iter, I, std::forward_iterator_tag >
CUniform_	Generate a random variate between min and max non-inclusive with uniform (flat) distribution
CUniqueLock	A scoped lock that references any lockable. Locks on construction and unlocks on destruction
CUniquePtr	Pointer to a unique, non-shared, object. Finalizer is run upon destruction (deletes object by default) if pointer is not null
►Cvariant	Multi-typed value. A variant is a value of any type from a fixed set of bounded types, the active bounded type may be changed dynamically
Csize_	Get number of bounded types at compile-time
CType	Get bounded type for id
CVariantError
CVec	N-dimensional vector
CVec< 1, Real, Options >	1D vector
CVec< 2, Real, Options >	2D vector
CVec< 3, Real, Options >	3D vector
CVec< 4, Real, Options >	4D vector
CVecBase	Vector base class
CVecSwizCon	Vector for const swizzle operators
CVecSwizCon< 2, Real, Options >	2D const swizzle vector
CVecSwizCon< 3, Real, Options >	3D const swizzle vector
CVecSwizCon< 4, Real, Options >	4D const swizzle vector
CVecSwizConBase
CVecSwizRef	Vector reference holder for mutable swizzle operators
CVecSwizRef< 2, Real, Options >	2D mutable swizzle vector
CVecSwizRef< 3, Real, Options >	3D mutable swizzle vector
CVecSwizRef< 4, Real, Options >	4D mutable swizzle vector
CVecSwizRefBase
CVegas	Monte Carlo (random-based) method to approximate the integral of a function over any number of dimensions
CWeakPtr	Point to a shared object without holding a reference. The object is accessible through a lock, which prevents unexpected destruction
CWeibull_	Generate a random integer variate from a weibull distribution
►Nstd	STL namespace
Ccommon_type< honey::Duration< Rep, Period >, honey::Duration< Rep2, Period2 > >	Get common duration between two durations. The period of the resulting duration is the greatest common divisor
Ccommon_type< honey::Ratio< Num, Den >, honey::Ratio< Num2, Den2 > >	Get common ratio between two ratios
Chash< honey::bloom_filter::Key< T, Alloc > >	Adapter for std hasher
Chash< honey::SharedPtr< T > >	Allow class to be used as key in unordered containers
Chash< honey::UniquePtr< T, Fin > >	Allow class to be used as key in unordered containers