The Library Algorithms API Wrappers Bayesian Nets Compression Containers Graph Tools Image Processing Linear Algebra Machine Learning Metaprogramming Miscellaneous Networking Optimization Parsing Help/Info Examples: C++ Assignment_Learning Base64_Encoder Bayesian_Network Bayesian_Network_From_Disk Bayesian_Network_GUI Bridge BSP Cmd_Line_Parser Compress_Stream Config_File_Reader Custom_Trainers Directory_Navigation Empirical_Kernel_Map Face_Detection FHOG_Feature_Extraction FHOG_Object_Detection Graph_Labeling GUI HTTP_Server Image IO Socket Streams IO Streams Server Kernel_Centroid Kernel_K-Means_Clustering Kernel_Ridge_Regression Kernel_RLS_Filtering Kernel_RLS_Regression KRR_Classification Learning_to_Track Linear_Manifold_Regularizer Logger Logger_Advanced Matrix Matrix_Expressions Member_Function_Pointer Model_Selection Multiclass_Classification Multithreaded_Object Neural_Network Non-Linear Least Squares Numerical_Integration Object_Detector Object_Detector_Advanced One_Class_Classifiers Online_SVM Optimization Parallel_For_Loops Pipe Pipe_2 Quantum_Computing Queue Rank_Features Relevance_Vector_Classification Relevance_Vector_Regression Running_Stats Sequence_Labeling Sequence_Segmentation Sockets Sockstreambuf Sparse_Vectors Std_C++_Allocator Structural_Support_Vector_Machines Support_Vector_Machine Support_Vector_Regression SURF SVM-Rank Threaded_Object Threads Thread_Function Thread_Pool Timer Train_Object_Detector Using_Custom_Kernels XML_Parser Examples: Python Face_Detector Linear_Assignment_Problems Sequence_Segmenter Structural_Support_Vector_Machines SVM-Rank Train_Object_Detector FAQ Home How to compile How to contribute Index Introduction License Python API Suggested Books Current Release Change Log Release Notes Version: 18.7 |
Last Modified: Aug 17, 2013
| # Metaprogramming This page documents library components that provide metaprogramming sorts of functionality. For the most part they are useful for putting design by contract checks into code or doing various kinds of clever things with templates. For example, you might have a templated function that is templated on a type T and you want to make sure that T is either a char or wchar_t type. You could place the following into your code and it would cause the compile to error out when T was set to something other than char or wchar_t. `COMPILE_TIME_ASSERT((is_same_type<T,char>::value || is_same_type<T,wchar_t>::value));` |
Objects basic_type enable_if is_array is_array2d is_built_in_scalar_type is_complex is_config_reader is_const_type is_convertible is_directed_graph is_float_type is_function is_graph is_matrix is_pair is_pointer_type is_rand is_reference_type is_same_type is_signed_type is_std_vector is_unsigned_type noncopyable promote static_switch tabs tmax tmin unsigned_type Global Functions ASSERT_ARE_NOT_SAME_TYPE ASSERT_ARE_SAME_TYPE assign_zero_if_built_in_scalar_type COMPILE_TIME_ASSERT DLIB_ASSERT DLIB_ASSERT_HAS_STANDARD_LAYOUT DLIB_CASSERT DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST DLIB_STACK_TRACE DLIB_STACK_TRACE_NAMED get_stack_trace is_same_object wrap_function _dT Other portability_macros |

[top]

# ASSERT_ARE_NOT_SAME_TYPE

This is a macro function for debugging. Its form is `ASSERT_ARE_NOT_SAME_TYPE(type1, type2)`. If type1 and type2 are the same type then the compile will fail. This is sometimes useful in validating template arguments.

`#include <dlib/assert.h>`
Detailed Documentation
[top]

# ASSERT_ARE_SAME_TYPE

This is a macro function for debugging. Its form is `ASSERT_ARE_SAME_TYPE(type1, type2)`. If type1 and type2 are not the same type then the compile will fail. This is sometimes useful in validating template arguments.

`#include <dlib/assert.h>`
Detailed Documentation
[top]

# assign_zero_if_built_in_scalar_type

This function assigns its argument the value of 0 if it is a built in scalar type according to the is_built_in_scalar_type template. If it isn't a built in scalar type then it does nothing.

This function is useful for suppressing compiler warnings about uninitialized types inside of templates that are designed to accept the built in types as well as user defined classes.

`#include <dlib/algs.h>`
Detailed Documentation
[top]

# basic_type

This is a template that takes a type and strips off any const, volatile, or reference qualifiers and gives you back the basic underlying type.

For example, promote<const int&>::type == int

`#include <dlib/algs.h>`
Detailed Documentation
[top]

# COMPILE_TIME_ASSERT

This is a macro function for debugging. Its form is `COMPILE_TIME_ASSERT(condition that should be true)`. The condition must be a compile time constant and if it is false then the compile will fail.

`#include <dlib/assert.h>`
Detailed Documentation
[top]

# DLIB_ASSERT

This is a macro function for debugging. Its form is `DLIB_ASSERT(condition that should be true,error message)`. If the condition is false DLIB_ASSERT throws an exception of type dlib::fatal_error with fatal_error::type == EBROKEN_ASSERT. An error message detailing the nature of the problem is stored in the member variable info which is of type std::string. Look in the following file for more details. The exception classes are defined here.

This macro is only enabled if _DEBUG, DEBUG or ENABLE_ASSERTS is defined. Also, if this macro is enabled then ENABLE_ASSERTS will be defined even if you didn't define it.

Note that when this macro fails and throws an exception it also calls the global C function dlib_assert_breakpoint(). This behavior makes it easy to set a debugging tool to break when DLIB_ASSERT fails by setting a breakpoint on dlib_assert_breakpoint().

`#include <dlib/assert.h>`
Detailed Documentation
[top]

# DLIB_ASSERT_HAS_STANDARD_LAYOUT

This macro is meant to cause a compiler error if a type doesn't have a simple memory layout (like a C struct). In particular, types with simple layouts are ones which can be copied via memcpy().

This was called a POD type in C++03 and in C++0x we are looking to check if it is a "standard layout type". Once we can use C++0x we can change this macro to something that uses the std::is_standard_layout type_traits class. See: http://www2.research.att.com/~bs/C++0xFAQ.html#PODs
`#include <dlib/assert.h>`
Detailed Documentation
[top]

# DLIB_CASSERT

This is a macro function that is identical to the DLIB_ASSERT macro except that it is always enabled. Even if _DEBUG, DEBUG and ENABLE_ASSERTS are not defined.

Note that when this macro fails and throws an exception it also calls the global C function dlib_assert_breakpoint(). This behavior makes it easy to set a debugging tool to break when DLIB_CASSERT fails by setting a breakpoint on dlib_assert_breakpoint().

`#include <dlib/assert.h>`
Detailed Documentation
[top]

# DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST

The DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST() macro is used to define traits templates that tell you if a class has a certain member function. For example, to make a test to see if a class has a public method with the signature void print(int) you would say:

> `DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(has_print, void, print, (int))`

Then you can check if a class, T, has this method by looking at the boolean value:

> `has_print<T>::value`

which will be true if the member function is in the T class.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# DLIB_STACK_TRACE

This is a preprocessor macro that allows you to tag a function so that dlib will keep track of it in a function call stack. That is, you will be able to see a stack trace by calling get_stack_trace if you put this macro at the top of your functions.

This macro is only enabled if DLIB_ENABLE_STACK_TRACE is defined. If it isn't defined then this macro doesn't do anything. Also note that when this macro is defined it will cause DLIB_ASSERT and DLIB_CASSERT to include a stack trace in their error messages.

`#include <dlib/assert.h>`
Detailed Documentation
[top]

# DLIB_STACK_TRACE_NAMED

This is a preprocessor macro just like DLIB_STACK_TRACE except that it allows you to supply your own string to use as the function name in the stack trace instead of the one deduced by DLIB_STACK_TRACE.

This macro is only enabled if DLIB_ENABLE_STACK_TRACE is defined.

`#include <dlib/assert.h>`
Detailed Documentation
[top]

# enable_if

This is a family of templates from the Boost C++ libraries that makes it somewhat easier to control template specialization. For the details see this page. Note that the header `dlib/enable_if.h` brings these templates into the dlib namespace.
`#include <dlib/enable_if.h>`
[top]

# get_stack_trace

This function allows you to query the current stack trace.

This macro is only enabled if DLIB_ENABLE_STACK_TRACE is defined.

`#include <dlib/assert.h>`
Detailed Documentation
[top]

# is_array

This is a template where is_array<T>::value == true when T is an array object.
`#include <dlib/is_kind.h>`
Detailed Documentation
[top]

# is_array2d

This is a template where is_array2d<T>::value == true when T is an array2d object.
`#include <dlib/is_kind.h>`
Detailed Documentation
[top]

# is_built_in_scalar_type

This is a template where is_built_in_scalar_type<T>::value == true when T is a built in scalar type such as int, char, float, etc.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# is_complex

This is a template that can be used to determine if a type is a specialization of std::complex.
`#include <dlib/matrix.h>`
Detailed Documentation
[top]

# is_config_reader

This is a template where is_config_reader<T>::value == true when T is a config_reader or config_reader_thread_safe object.
`#include <dlib/is_kind.h>`
Detailed Documentation
[top]

# is_const_type

This is a template where is_const_type<T>::value == true when T is a const type and false otherwise.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# is_convertible

This is a template that can be used to determine if one type is convertible into another type.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# is_directed_graph

This is a template where is_directed_graph<T>::value == true when T is a directed_graph object.
`#include <dlib/is_kind.h>`
Detailed Documentation
[top]

# is_float_type

This is a template where is_float_type<T>::value == true when T is a floating point type (i.e. float, double, or long double) and false otherwise.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# is_function

This is a template where is_function<T>::value == true when T is a function type.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# is_graph

This is a template where is_graph<T>::value == true when T is a graph object.
`#include <dlib/is_kind.h>`
Detailed Documentation
[top]

# is_matrix

This is a template where is_matrix<T>::value == true when T is a matrix object or some kind of matrix expression.
`#include <dlib/is_kind.h>`
Detailed Documentation
[top]

# is_pair

This is a template where is_pair<T>::value == true when T is a std::pair object.
`#include <dlib/is_kind.h>`
Detailed Documentation
[top]

# is_pointer_type

This is a template where is_pointer_type<T>::value == true when T is a pointer type and false otherwise.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# is_rand

This is a template where is_rand<T>::value == true when T is a rand object.
`#include <dlib/is_kind.h>`
Detailed Documentation
[top]

# is_reference_type

This is a template where is_reference_type<T>::value == true when T is a reference type and false otherwise.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# is_same_object

This is a templated function which checks if both of its arguments are actually references to the same object. It returns true if they are and false otherwise.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# is_same_type

This is a template where is_same_type<T,U>::value == true when T and U are the same type and false otherwise.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# is_signed_type

This is a template where is_signed_type<T>::value == true when T is a signed scalar type and false when it is an unsigned scalar type.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# is_std_vector

This is a template where is_std_vector<T>::value == true when T is a std_vector_c or std::vector object.
`#include <dlib/is_kind.h>`
Detailed Documentation
[top]

# is_unsigned_type

This is a template where is_unsigned_type<T>::value == true when T is an unsigned scalar type and false when it is a signed scalar type.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# noncopyable

This is a simple class that makes it easy to declare a non-copyable object. To use it to make your own class non-copyable just inherit from it.
`#include <dlib/noncopyable.h>`
Detailed Documentation
[top]

# portability_macros

This file #defines various macros depending on the platform being compiled under. See the file itself for the specifics.
`#include <dlib/platform.h>`
Detailed Documentation
[top]

# promote

This is a template that takes one of the built in scalar types and gives you another scalar type that should be big enough to hold sums of values from the original scalar type. The new scalar type will also always be signed.

For example, promote<uint16>::type == int32

`#include <dlib/algs.h>`
Detailed Documentation
[top]

# static_switch

To use this template you give it some number of boolean expressions and it tells you which one of them is true. If more than one of them is true then it causes a compile time error. It is useful for cases where you want to specialize a template and you want to specialize it not by the type of object it gets per say but instead according to the values of some type traits associated with the various template arguments. A simple example of this can be seen in the assign_pixel's implementation which can be found at the bottom of the dlib/pixel.h file.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# tabs

This is a template to compute the absolute value a number at compile time.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# tmax

This is a template to compute the max of two values at compile time.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# tmin

This is a template to compute the min of two values at compile time.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# unsigned_type

This is a template that allows you to obtain the unsigned version of any integral type. For example, unsigned_type<signed short>::type == unsigned short.
`#include <dlib/uintn.h>`
Detailed Documentation
[top]

# wrap_function

This is a template that allows you to turn a global function into a function object. See the specs for more details.
`#include <dlib/algs.h>`
Detailed Documentation
[top]

# _dT

This is a macro function for converting a string/character literal to either a char or wchar_t literal. Its form is `_dT(target character type,string or character literal)`
`#include <dlib/algs.h>`
Detailed Documentation