versions/0.1.0/core_8h_source.html

#ifndef CORE_H

#define CORE_H


#include "algorithms.h"

#include "allocator.h"

#include "array.h"

#include "autoPtr.h"

#include "baseArray.h"

#include "baseList.h"

#include "bitSet.h"

#include "blocksList.h"

#include "chain.h"

#include "cloneable.h"

#include "comparable.h"

#include "comparator.h"

#include "config.h"

#include "container.h"

#include "containerAdapter.h"

#include "couple.h"

#include "deleter.h"

#include "deque.h"

#include "doubleDirectionIterator.h"

#include "error.h"

#include "filter.h"

#include "filterStream.h"

#include "forwardChain.h"

#include "hash.h"

#include "iterable.h"

#include "iterationStream.h"

#include "iterator.h"

#include "map.h"

#include "maps.h"

#include "maths.h"

#include "ownerPtr.h"

#include "printable.h"

#include "prique.h"

#include "queue.h"

#include "randomAccessIterator.h"

#include "RBTree.h"

#include "refCntPtr.h"

#include "serial.h"

#include "set.h"

#include "singleDirectionIterator.h"

#include "stack.h"

#include "stepIterator.h"

#include "transform.h"

#include "transformStream.h"

#include "tuple.h"

#include "types.h"

#include "vector.h"

#include "wrapper.h"


#endif //CORE_H

RBTree.h
Red-Black Tree implementation header.

algorithms.h
Standard algorithm implementations for iterator-based containers.

allocator.h
Memory allocation interface and implementations.

array.h
Provides the array class for a fixed-size container with random access.

autoPtr.h
Base class for reference-counted smart pointers.

baseArray.h
Provides a base class for fixed-size serial containers.

baseList.h
Provides a base class for variable-size serial containers.

bitSet.h
BitSet class declaration.

blocksList.h
A block-based list implementation.

chain.h
Non-cyclic doubly linked list implementation.

cloneable.h
Abstract base class for cloneable objects.

comparable.h
Interface for objects that can be compared.

comparator.h
Comparator base class and concrete comparator classes.

config.h
Platform-independent integer and floating-point type definitions.

containerAdapter.h
Base class for container adapters with common interfaces.

container.h
Abstract base class for container types.

couple.h
Generic pair container implementation.

deleter.h
Default deleters for resource management.

deque.h
Double-ended queue (deque) container adapter implementation.

doubleDirectionIterator.h
Double-direction iterator base class.

error.h
Custom exception classes and callback validation utilities.

filterStream.h
Composite filter operations with logical chaining.

filter.h
Filter base class and derived filter classes for various matching operations.

forwardChain.h
Non-cyclic singly linked list implementation.

hash.h
Provides a generic hashing utility and a base interface for hashable types.

iterable.h
Base interface for iterable container types.

iterationStream.h
Provides functionality for an iteration stream.

iterator.h
Defines the iterator class for traversing and manipulating container elements.

map.h
Abstract base class for map-like container implementations.

maps.h
Implementation of hashMap container.

maths.h
Mathematical utilities and constants.

ownerPtr.h
Exclusive-ownership smart pointer implementation.

printable.h
Interface for polymorphic string formatting and output.

prique.h
Priority queue container implementation.

queue.h
Queue container adapter implementation.

randomAccessIterator.h
Base class for random-access iterators.

refCntPtr.h
Reference-counted smart pointer hierarchy.

serial.h
Defines an abstract base class for sequential containers with index-based access.

set.h
Abstract base class for set container implementations.

singleDirectionIterator.h
Single-direction iterator base class.

stack.h
Stack container adapter implementation.

stepIterator.h
Step iterator base class for single-step iterators.

transformStream.h
Transform pipeline composition and execution.

transform.h
Transformation classes for various operations on elements.

tuple.h
Heterogeneous tuple container implementation.

types.h
Core type system foundations and concept definitions.

vector.h
Dynamic array container with automatic resizing.

wrapper.h
Abstract polymorphic container with value encapsulation and navigation support.