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 "iterable.h"

#include "iterationStream.h"

#include "iterator.h"

#include "maths.h"

#include "ownerPtr.h"

#include "printable.h"

#include "prique.h"

#include "queue.h"

#include "randomAccessIterator.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

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 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.

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.

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.

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
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.