[top]

any

This object is basically a type-safe version of a void*. In particular, it is a container which can contain only one object but the object may be of any type.

It is somewhat like the type_safe_union except you don't have to declare the set of possible content types beforehand. So in some sense this is like a less type-strict version of the type_safe_union.

[top]

any_decision_function

This object is a version of dlib::any that is restricted to containing elements which are some kind of function object with an operator() with the following signature: result_type operator()(const sample_type&) const

It is intended to be used to contain dlib::decision_function objects and other types which represent learned decision functions. It allows you to write code which contains and processes these decision functions without needing to know the specific types of decision functions used.

[top]

any_function

This object is a version of dlib::any that is restricted to containing elements which are some kind of function or function object.

[top]

any_trainer

This object is a version of dlib::any that is restricted to containing elements which are some kind of object with a .train() method compatible with the following signature:

 decision_function train(
      const std::vector<sample_type>& samples,
      const std::vector<scalar_type>& labels
   ) const

Where decision_function is a type capable of being stored in an any_decision_function object.

any_trainer is intended to be used to contain objects such as the svm_nu_trainer and other similar types which represent supervised machine learning algorithms. It allows you to write code which contains and processes these trainer objects without needing to know the specific types of trainer objects used.

[top]

array

This object represents a 1-Dimensional array of objects.

[top]

array2d

This object represents a 2-Dimensional array of objects.

C++ Example Programs: image_ex.cpp

[top]

binary_search_tree

This object represents a data dictionary that is built on top of some kind of binary search tree.


Implementations:

binary_search_tree_kernel_1:
This implementation is done using an AVL binary search tree. It uses the memory_manager for all memory allocations.

kernel_1a	is a typedef for binary_search_tree_kernel_1
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.

binary_search_tree_kernel_2:
This implementation is done using a red-black binary search tree. It uses the memory_manager for all memory allocations.

kernel_2a	is a typedef for binary_search_tree_kernel_2
kernel_2a_c	is a typedef for kernel_2a that checks its preconditions.

[top]

circular_buffer

This object represents a simple sliding buffer which can contain and arbitrary number of elements.

[top]

directed_graph

This object represents a directed graph which is a set of nodes with directed edges connecting various nodes.


Implementations:

directed_graph_kernel_1:
This is implemented using std::vector to contain all the nodes and edges.

kernel_1a	is a typedef for directed_graph_kernel_1
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.

[top]

enumerable

This object is an abstract class which represents an interface for iterating over all the elements of a container.

[top]

graph

This object represents a graph which is a set of nodes with undirected edges connecting various nodes.


Implementations:

graph_kernel_1:
This is implemented using std::vector to contain all the nodes and edges.

kernel_1a	is a typedef for graph_kernel_1
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.

[top]

hash_map

This object represents a hashed mapping of items of type domain onto items of type range.


Implementations:

hash_map_kernel_1:
This implementation is done using a hash_table object. It uses the memory_manager for all memory allocations.

kernel_1a	is a typedef for hash_map_kernel_1 that uses hash_table_kernel_1a
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.
kernel_1b	is a typedef for hash_map_kernel_1 that uses hash_table_kernel_2a
kernel_1b_c	is a typedef for kernel_1b that checks its preconditions.
kernel_1c	is a typedef for hash_map_kernel_1 that uses hash_table_kernel_2b
kernel_1c_c	is a typedef for kernel_1c that checks its preconditions.

[top]

hash_set

This object represents a hashed unordered and unaddressed collection of unique items.


Implementations:

hash_set_kernel_1:
This implementation is done using a hash_table object. It uses the memory_manager for all memory allocations.

kernel_1a	is a typedef for hash_set_kernel_1 that uses hash_table_kernel_1a
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.
kernel_1b	is a typedef for hash_set_kernel_1 that uses hash_table_kernel_2a
kernel_1b_c	is a typedef for kernel_1b that checks its preconditions.
kernel_1c	is a typedef for hash_set_kernel_1 that uses hash_table_kernel_2b
kernel_1c_c	is a typedef for kernel_1c that checks its preconditions.

[top]

hash_table

This object represents a data dictionary that is built on top of some kind of hash table.


Implementations:

hash_table_kernel_1:
This implementation is done using singly linked lists as hashing buckets. It uses the memory_manager for all memory allocations.

kernel_1a	is a typedef for hash_table_kernel_1.
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.

hash_table_kernel_2:
This implementation is done using binary_search_tree objects as hashing buckets. It uses the memory_manager for all memory allocations.

kernel_2a	is a typedef for hash_table_kernel_2 that uses binary_search_tree_kernel_1
kernel_2a_c	is a typedef for kernel_2a that checks its preconditions.
kernel_2b	is a typedef for hash_table_kernel_2 that uses binary_search_tree_kernel_2
kernel_2b_c	is a typedef for kernel_2b that checks its preconditions.

[top]

map

This object represents a mapping of items of type domain onto items of type range.


Implementations:

map_kernel_1:
This is implemented using the binary_search_tree component. It uses the memory_manager for all memory allocations.

kernel_1a	is a typedef for map_kernel_1 that uses binary_search_tree_kernel_1
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.
kernel_1b	is a typedef for map_kernel_1 that uses binary_search_tree_kernel_2
kernel_1b_c	is a typedef for kernel_1b that checks its preconditions.

[top]

map_pair

This object is an abstract class which represents an interface for accessing a pair from a container such as the map, hash_table, etc.

[top]

optional

This is a standard's compliant backport of std::optional that works with C++14. It includes C++23 monadic interfaces

[top]

queue

This object represents a first in first out queue.

C++ Example Programs: queue_ex.cpp

Implementations:

queue_kernel_1:
This is implemented in the obvious way using a singly linked list. It does not use the memory_manager at all.

kernel_1a	is a typedef for queue_kernel_1
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.

queue_kernel_2:
This is implemented using a singly linked list and each node in the list contains block_size (a template parameter) elements. It uses the memory_manager for all memory allocations.

kernel_2a	is a typedef for queue_kernel_2 with a block_size of 20
kernel_2a_c	is a typedef for kernel_2a that checks its preconditions.
kernel_2b	is a typedef for queue_kernel_2 with a block_size of 100
kernel_2b_c	is a typedef for kernel_2b that checks its preconditions.

Extensions to queue

[top]

reference_counter

This object represents a container for an object and provides reference counting capabilities for the object it contains.


Implementations:

reference_counter_kernel_1:
This implementation is done using pointers in the obvious way.

kernel_1a

is a typedef for reference_counter_kernel_1

[top]

reference_wrapper

This is a simple object that just holds a reference to another object. It is useful because it can serve as a kind of "copyable reference".

C++ Example Programs: thread_function_ex.cpp

[top]

remover

This is a set of interfaces which gives the ability to remove all the items in a container without actually knowing what kind of container contains them.

[top]

sequence

This object represents an ordered sequence of items, each item is associated with an integer value. The items are numbered from 0 to the number of items in the sequence minus 1.


Implementations:

sequence_kernel_1:
This is implemented as an AVL binary search tree. Accessing(or adding or removing) an element always takes O(log n) time. It uses the memory_manager for all memory allocations.

kernel_1a	is a typedef for sequence_kernel_1
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.

sequence_kernel_2:
This implementation is done using a doubly linked list in the shape of a ring. It will remember the last element accessed(or added or removed) and give O(1) access time to the elements just left and right of it. Aside from that, accessing(or adding or removing) a random element will take O(n) and in the worst case it will take time proportional to the size of the sequence/2.

It does not use the memory_manager at all.

kernel_2a	is a typedef for sequence_kernel_2
kernel_2a_c	is a typedef for kernel_2a that checks its preconditions.

Extensions to sequence

[top]

set

This object represents an unordered and unaddressed collection of unique items.


Implementations:

set_kernel_1:
This is implemented using the binary_search_tree component. It uses the memory_manager for all memory allocations.

kernel_1a	is a typedef for set_kernel_1 that uses binary_search_tree_kernel_1
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.
kernel_1b	is a typedef for set_kernel_1 that uses binary_search_tree_kernel_2
kernel_1b_c	is a typedef for kernel_1b that checks its preconditions.

Extensions to set

[top]

sliding_buffer

This object represents an array with the ability to rotate its contents left or right. Note that the size of this object is always a power of two. If you need arbitrary sized objects then use a circular_buffer.


Implementations:

sliding_buffer_kernel_1:
This object is implemented using a C style array in the obvious way. See the code for details.

kernel_1a	is a typedef for sliding_buffer_kernel_1
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.

[top]

stack

This object represents a last in first out stack.


Implementations:

stack_kernel_1:
This implementation is done in the obvious way using a singly linked list. It uses the memory_manager for all memory allocations.

kernel_1a	is a typedef for stack_kernel_1
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.

[top]

static_map

This object represents a mapping of items of type domain onto items of type range. The difference between this object and the normal map object is that it does not support adding or removing individual objects from itself. This allows implementations to focus on using less memory and achieving faster searching.


Implementations:

static_map_kernel_1:
This implementation is just a sorted array which can be searched using a binary search.

kernel_1a	is a typedef for static_map_kernel_1
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.

[top]

static_set

This object represents an unordered and unaddressed collection of items. The difference between this object and the normal set object is that it does not support adding or removing individual objects from itself. This allows implementations to focus on using less memory and achieving faster searching.


Implementations:

static_set_kernel_1:
This implementation is just a sorted array which can be searched using a binary search.

kernel_1a	is a typedef for static_set_kernel_1
kernel_1a_c	is a typedef for kernel_1a that checks its preconditions.

Extensions to static_set

[top]

std_vector_c

This object is a simple wrapper around the std::vector object. It provides an identical interface but also checks the preconditions of each member function. That is, if you violate a requires clause the dlib::fatal_error exception is thrown.

[top]

storage_heap

This object is basically a type-safe version of a void*. In particular, it is a container which can contain only one object but the object may be of any type. Importantly, this container stores the object on the heap.

This class is meant to be a lower level tool used to implement other higher level containers or APIs that depend on type erasure.

[top]

storage_sbo

This object is basically a type-safe version of a void*. In particular, it is a container which can contain only one object but the object may be of any type. This container uses the small buffer optimization to store small objects on the stack, but larger objects on the heap.

This class is meant to be a lower level tool used to implement other higher level containers or APIs that depend on type erasure.

[top]

storage_shared

This object is basically a type-safe version of a void*. In particular, it is a container which can contain only one object but the object may be of any type. This container stores the object it contains in a std::shared_ptr, and therefore has reference rather than value semantics, as well as storage on the heap.

This class is meant to be a lower level tool used to implement other higher level containers or APIs that depend on type erasure.

[top]

storage_stack

This object is basically a type-safe version of a void*. In particular, it is a container which can contain only one object but the object may be of any type. Importantly, this container stores the object on the stack.

This class is meant to be a lower level tool used to implement other higher level containers or APIs that depend on type erasure.

[top]

storage_view

This object is basically a type-safe version of a void*. In particular, it is a container which can contain only one object but the object may be of any type. This container doesn't actually store the object it contains, rather, it is a non-owning view of that object. It therefore has reference semantics just as a void* would.

This class is meant to be a lower level tool used to implement other higher level containers or APIs that depend on type erasure.

[top]

tuple

This is an implementation of a very simple templated container object. It contains between 0 and 31 objects where each object is listed explicitly in the tuple's template arguments.

Note that there is only one implementation of this object so there aren't any different kernels to choose from when you create instances of the tuple object. So for example, you could declare a tuple of 3 ints using the following statement: dlib::tuple<int,int,int> t;

[top]

type_safe_union

This object is a type safe analogue of the classic C union object. The type_safe_union, unlike a union, can contain non-POD types such as std::string.

It is also implemented without performing any heap memory allocations and instead it stores everything on the stack.

C++ Example Programs: pipe_ex_2.cpp, bridge_ex.cpp

[top]

unordered_pair

This object is very similar to the std::pair struct except unordered_pair is only capable of representing an unordered set of two items rather than an ordered list of two items like std::pair.