[top]any
This object is basically a typesafe 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 typestrict 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 1Dimensional array of objects.
[top]array2d
This object represents a 2Dimensional 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 redblack 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]queue
This object represents a first in first out queue.
C++ Example Programs:
queue_ex.cppImplementations: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
queue_sort
This extension gives a queue the ability to sort its contents.
More Details...Implementations:queue_sort_1:
This is a version of the QuickSort algorithm.
sort_1a  is a typedef for queue_kernel_1a extended by queue_sort_1 
sort_1a_c 
is a typedef for sort_1a that checks its preconditions.

sort_1b  is a typedef for queue_kernel_2a extended by queue_sort_1 
sort_1b_c 
is a typedef for sort_1b that checks its preconditions.

sort_1c  is a typedef for queue_kernel_2b extended by queue_sort_1 
sort_1c_c 
is a typedef for sort_1c that checks its preconditions.

[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]scoped_ptr
This is a implementation of the scoped_ptr class found in the Boost C++
library. It is a simple smart pointer class which guarantees that the
pointer contained within it will always be deleted.
The class does not permit copying and so does not do any kind of
reference counting. Thus it is very simple and quite fast.
[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
sequence_compare
This extension gives sequences the ability to compare themselves using
operator< and operator==. Thus they can be used in the other container classes
that require this ability. (maps, sets, etc.)
More Details...Implementations:sequence_compare_1:
The implementation is obvious. Click on the sequence_compare_1 link if you want to see.
compare_1a  is a typedef for sequence_kernel_1a extended by sequence_compare_1 
compare_1a_c 
is a typedef for compare_1a that checks its preconditions.

compare_1b  is a typedef for sequence_kernel_2a extended by sequence_compare_1 
compare_1b_c 
is a typedef for compare_1b that checks its preconditions.

sequence_sort
This extension gives a sequence the ability to sort its contents.
More Details...Implementations:sequence_sort_1:
This is a version of the QuickSort algorithm and it sorts sequences of less
than 30 elements with a selection sort. This implementation is fastest when
used with sequence_kernel_2 and fairly slow when used with sequence_kernel_1
sort_1a  is a typedef for sequence_kernel_2a extended by sequence_sort_1 
sort_1a_c 
is a typedef for sort_1a that checks its preconditions.

sequence_sort_2:
This is a version of the QuickSort algorithm. This implementation of sort is
the best to use with sequence_kernel_1 objects but gives extremely poor performance
with sequence_kernel_2 objects.
sort_2a  is a typedef for sequence_kernel_1a extended by sequence_sort_2 
sort_2a_c 
is a typedef for sort_2a that checks its preconditions.

[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
set_compare
This extension gives sets the ability to compare themselves using operator< and
operator==. Thus they can be used in the other container classes that require
this ability. (maps, sets, etc.)
More Details...Implementations:set_compare_1:
The implementation is obvious. Click on the set_compare_1 link if you want to see.
compare_1a  is a typedef for set_kernel_1a extended by set_compare_1 
compare_1a_c 
is a typedef for compare_1a that checks its preconditions.

compare_1b  is a typedef for set_kernel_1b extended by set_compare_1 
compare_1b_c 
is a typedef for compare_1b that checks its preconditions.

[top]shared_ptr
This object represents a reference counted smart pointer. Each shared_ptr
contains a pointer to some object and when the last shared_ptr that points
to the object is destructed or reset() then the object is guaranteed to be
deleted.
This is an implementation of the std::tr1::shared_ptr template from the
document ISO/IEC PDTR 19768, Proposed Draft Technical Report on C++
Library Extensions. The only deviation from that document is that this
shared_ptr is declared inside the dlib namespace rather than std::tr1.
[top]shared_ptr_thread_safe
This object represents a reference counted smart pointer just like
shared_ptr except that it is threadsafe.
[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
static_set_compare
This extension gives static_sets the ability to compare themselves using operator< and
operator==. Thus they can be used in the other container classes that require
this ability. (maps, static_sets, etc.)
More Details...Implementations:static_set_compare_1:
The implementation is obvious. Click on the static_set_compare_1 link if you want to see.
compare_1a  is a typedef for static_set_kernel_1a extended by static_set_compare_1 
compare_1a_c 
is a typedef for compare_1a that checks its preconditions.

[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]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 nonPOD 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.
[top]weak_ptr
The weak_ptr class template stores a weak reference to an object that is
already managed by a shared_ptr. To access the object, a weak_ptr can
be converted to a shared_ptr using the member function lock().
This is an implementation of the std::tr1::weak_ptr template from the
document ISO/IEC PDTR 19768, Proposed Draft Technical Report on C++
Library Extensions. The only deviation from that document is that this
shared_ptr is declared inside the dlib namespace rather than std::tr1.