|
struct | blaze::AlignedAllocator< Type >::rebind< Type2 > |
| Implementation of the AlignedAllocator rebind mechanism. More...
|
|
class | blaze::AlignedAllocator< Type > |
| Allocator for type-specific aligned memory.The AlignedAllocator class template represents an implementation of the allocator concept of the standard library for the allocation of type-specific, aligned, uninitialized memory. The allocator performs its allocation via the blaze::allocate() and blaze::deallocate() functions to guarantee properly aligned memory based on the alignment restrictions of the specified type Type. For instance, in case the given type is a fundamental, built-in data type and in case SSE vectorization is possible, the returned memory is guaranteed to be at least 16-byte aligned. In case AVX is active, the memory is even guaranteed to be at least 32-byte aligned. More...
|
|
class | blaze::AlignedArray< Type, N, Alignment > |
| Implementation of a static array with a fixed alignment.The AlignedArray class template represents a static array with a guaranteed, fixed alignment. The type of the array elements, the number of elements and the alignment of the array can be specified via the three template parameters: More...
|
|
struct | blaze::DisableIfTrue< Condition, T > |
| Substitution Failure Is Not An Error (SFINAE) class.The DisableIfTrue class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail. More...
|
|
struct | blaze::DisableIf< Condition, T > |
| Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail. More...
|
|
struct | blaze::EmptyType |
| Empty data type for utility purposes. More...
|
|
struct | blaze::EnableIfTrue< Condition, T > |
| Substitution Failure Is Not An Error (SFINAE) class.The EnableIfTrue class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail. More...
|
|
struct | blaze::EnableIf< Condition, T > |
| Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail. More...
|
|
class | blaze::InputString |
| Implementation of a string wrapper.The InputString class is a wrapper class for the purpose to read input strings delimited by quotations from streams, like for instance "example input". All characters between the leading and the trailing quotation are extracted unchanged from the input stream, including whitespaces. The input string has to be in one single line. In case of input errors, the std::istream::failbit of the input stream is set. More...
|
|
struct | blaze::IntegralConstant< T, N > |
| Generic wrapper for a compile time constant integral value.The IntegralConstant class template represents a generic wrapper for a compile time constant integral value. The value of an IntegralConstant can be accessed via the nested value (which is guaranteed to be of type T), the type can be accessed via the nested type definition ValueType. More...
|
|
struct | blaze::Limits< Type > |
| Numerical limits of built-in data types.The Limits class provides numerical limits for the following built-in data types: More...
|
|
union | blaze::MemoryPool< Type, Blocksize >::FreeObject |
| A single element of the free list of the memory pool. More...
|
|
struct | blaze::MemoryPool< Type, Blocksize >::Block |
| Memory block within the memory bool. More...
|
|
class | blaze::MemoryPool< Type, Blocksize > |
| Memory pool for small objects.The memory pool efficiently improves the performance of dynamic memory allocations for small objects. By allocating a large block of memory that can be dynamically assigned to small objects, the memory allocation is reduced from a few hundred cycles to only a few cycles.
The memory pool is build from memory blocks of type Block, which hold the memory for a specified number of objects. The memory of these blocks is managed as a single free list. More...
|
|
class | blaze::NonCopyable |
| Base class for non-copyable class instances.The NonCopyable class is intended to work as a base class for non-copyable classes. Both the copy constructor and the copy assignment operator are explicitly deleted in order to prohibit copy operations of the derived classes.
. More...
|
|
class | blaze::NonCreatable |
| Base class for non-creatable (static) classes.The NonCreatable class is intended to work as a base class for non-creatable classes, i.e. classes that cannot be instantiated and exclusively offer static functions/data. Both the standard as well as the copy constructor and the copy assignment operator are declared private and left undefinded in order to prohibit the instantiation of objects of derived classes.
. More...
|
|
class | blaze::NullType |
| Utility type for generic codes.The NullType class represents an invalid or terminating data type for generic codes. For instance, the TypeList class uses the NullType as terminating data type for the type list. More...
|
|
struct | blaze::ArrayDelete |
| Array-delete policy class.The ArrayDelete policy functor class applies an array delete operation to the given argument. Note that the array delete operation is NOT permitted for inclomplete types (i.e. declared but undefined data types). The attempt to apply an ArrayDelete functor to a pointer to an array of objects of incomplete type results in a compile time error! More...
|
|
struct | blaze::ConstantGrowth< Growth > |
| Constant growth policy class.The ConstantGrowth policy class implements a constant growth strategy. It can be customized for any purpose: the Growth template argument specifies the constant increase of the given size. More...
|
|
struct | blaze::Deallocate |
| Deallocate policy class.The Deallocate deletion policy is the according deletion policy for arrays allocated via the blaze::allocate function. It uses deallocate to free the resource. Note that the delete operation is NOT permitted for inclomplete types (i.e. declared but undefined data types). The attempt to apply a PtrDelete functor to a pointer to an object of incomplete type results in a compile time error! More...
|
|
struct | blaze::DefaultDelete< Type > |
| Default C++ deletion policy class.The DefaultDelete deletion policy is the standard delete for resources allocated via the new operator. It uses delete or array delete (depending on the template argument) to free the resource: More...
|
|
struct | blaze::LinearGrowth< Growth > |
| Linear growth policy class.The LinearGrowth policy class implements a linear growth strategy. It can be customized for any purpose: the Growth template argument specifies the factor of the size growth. More...
|
|
struct | blaze::NoDelete |
| No-delete policy class. More...
|
|
struct | blaze::OptimalGrowth |
| Optimal growth policy class.The OptimalGrowth policy class implements the optimal growth strategy suggested by Andrew Koenig for the std::vector class (see Andrew Koenig's column in the September 1998 issue of JOOP (Journal of Object-Oriented Programming), or the Dr. Dobb's article 'C++ Made Easier: How Vectors Grow', 2001). It applies an exponential growth strategy using a factor of 1.5 and additionally ensures that the sizes returns are always multiples of four. More...
|
|
struct | blaze::PtrDelete |
| Pointer-delete policy class.The PtrDelete policy functor class applies a delete operation to the given argument. Note that the delete operation is NOT permitted for inclomplete types (i.e. declared but undefined data types). The attempt to apply a PtrDelete functor to a pointer to an object of incomplete type results in a compile time error! More...
|
|
class | blaze::PtrIterator< Type > |
| Implementation of an iterator for pointer vectors.The PtrIterator class follows the example of the random-access iterator classes of the STL. However, the focus of this iterator implementation is the use with (polymorphic) pointers. The implementation of the Blaze library eases the use of iterators over a range of pointers and improves the semantics on these pointers.
. More...
|
|
class | blaze::PtrVector< T, D, G >::CastIterator< C > |
| Dynamic cast iterator for polymorphic pointer vectors.The CastIterator class is part of the PtrVector class and represent a forward iterator over all elements of type C contained in a range of elements of type T, where C is a type derived from T. More...
|
|
class | blaze::PtrVector< T, D, G >::ConstCastIterator< C > |
| Dynamic cast iterator for polymorphic pointer vectors.The ConstCastIterator class is part of the PtrVector class and represent a forward iterator over all elements of type C contained in a range of elements of type T, where C is a type derived from T. The ConstCastIterator is the counterpart of CastIterator for constant vectors. More...
|
|
class | blaze::PtrVector< T, D, G > |
| Implementation of a vector for (polymorphic) pointers. More...
|
|
class | blaze::SystemClock |
| System clock of the Blaze library.The SystemClock class represents the system clock of the Blaze library. The system clock is the central timing functionality that can be used to query for the start time of the process, the current timestamp and the elapsed time since the start of the process. The following example demonstrates how the single system clock instance is acquired via the theSystemClock() functcion and how the system clock can be used: More...
|
|
class | blaze::UnsignedValue< T > |
| Implementation of a wrapper for built-in unsigned integral values.This class wraps a value of built-in unsigned integral type in order to be able to extract non-negative unsigned integral values from an input stream. More...
|
|
class | blaze::complex |
| Complex data type of the Blaze library. More...
|
|
class | blaze::size_t |
| Size type of the Blaze library. More...
|
|
class | blaze::ptrdiff_t |
| Pointer difference type of the Blaze library. More...
|
|
class | blaze::int8_t |
| 8-bit signed integer type of the Blaze library. More...
|
|
class | blaze::uint8_t |
| 8-bit unsigned integer type of the Blaze library. More...
|
|
class | blaze::int16_t |
| 16-bit signed integer type of the Blaze library. More...
|
|
class | blaze::uint16_t |
| 16-bit unsigned integer type of the Blaze library. More...
|
|
class | blaze::int32_t |
| 32-bit signed integer type of the Blaze library. More...
|
|
class | blaze::uint32_t |
| 32-bit unsigned integer type of the Blaze library. More...
|
|
class | blaze::int64_t |
| 64-bit signed integer type of the Blaze library. More...
|
|
class | blaze::uint64_t |
| 64-bit unsigned integer type of the Blaze library. More...
|
|
|
#define | BLAZE_THROW(EXCEPTION) throw EXCEPTION |
| Macro for the error reporting mechanism of the Blaze library.This macro encapsulates the default, general way of the Blaze library to report errors of any kind by throwing an exception. Also, since under certain conditions and environments it may be desirable to replace exceptions by a different error reporting mechanism this macro provides an opportunity to customize the error reporting approach. More...
|
|
#define | BLAZE_THROW_BAD_ALLOC BLAZE_THROW( std::bad_alloc() ) |
| Macro for the emission of a std::bad_alloc exception.This macro encapsulates the default way of Blaze to throw a std::bad_alloc exception. Also, since it may be desirable to replace the type of exception by a custom exception type this macro provides an opportunity to customize the behavior. More...
|
|
#define | BLAZE_THROW_LOGIC_ERROR(MESSAGE) BLAZE_THROW( std::logic_error( MESSAGE ) ) |
| Macro for the emission of a std::logic_error exception.This macro encapsulates the default way of Blaze to throw a std::logic_error exception. Also, since it may be desirable to replace the type of exception by a custom exception type this macro provides an opportunity to customize the behavior. More...
|
|
#define | BLAZE_THROW_INVALID_ARGUMENT(MESSAGE) BLAZE_THROW( std::invalid_argument( MESSAGE ) ) |
| Macro for the emission of a std::invalid_argument exception.This macro encapsulates the default way of Blaze to throw a std::invalid_argument exception. Also, since it may be desirable to replace the type of exception by a custom exception type this macro provides an opportunity to customize the behavior. More...
|
|
#define | BLAZE_THROW_LENGTH_ERROR(MESSAGE) BLAZE_THROW( std::length_error( MESSAGE ) ) |
| Macro for the emission of a std::length_error exception.This macro encapsulates the default way of Blaze to throw a std::length_error exception. Also, since it may be desirable to replace the type of exception by a custom exception type this macro provides an opportunity to customize the behavior. More...
|
|
#define | BLAZE_THROW_OUT_OF_RANGE(MESSAGE) BLAZE_THROW( std::out_of_range( MESSAGE ) ) |
| Macro for the emission of a std::out_of_range exception.This macro encapsulates the default way of Blaze to throw a std::out_of_range exception. Also, since it may be desirable to replace the type of exception by a custom exception type this macro provides an opportunity to customize the behavior. More...
|
|
#define | BLAZE_THROW_RUNTIME_ERROR(MESSAGE) BLAZE_THROW( std::runtime_error( MESSAGE ) ) |
| Macro for the emission of a std::runtime_error exception.This macro encapsulates the default way of Blaze to throw a std::runtime_error exception. Also, since it may be desirable to replace the type of exception by a custom exception type this macro provides an opportunity to customize the behavior. More...
|
|
|
template<bool Condition, typename T = void> |
using | blaze::DisableIfTrue_ = typename DisableIfTrue< Condition, T >::Type |
| Auxiliary type for the DisableIfTrue class template.The DisableIfTrue_ alias declaration provides a convenient shortcut to access the nested Type of the DisableIfTrue class template. For instance, given the type T the following two type definitions are identical: More...
|
|
template<typename Condition , typename T = void> |
using | blaze::DisableIf_ = typename DisableIf< Condition, T >::Type |
| Auxiliary type for the DisableIf class template.The DisableIf_ alias declaration provides a convenient shortcut to access the nested Type of the DisableIf class template. For instance, given the type T the following two type definitions are identical: More...
|
|
template<bool Condition, typename T = void> |
using | blaze::EnableIfTrue_ = typename EnableIfTrue< Condition, T >::Type |
| Auxiliary type for the EnableIfTrue class template.The EnableIfTrue_ alias declaration provides a convenient shortcut to access the nested Type of the EnableIfTrue class template. For instance, given the type T the following two type definitions are identical: More...
|
|
template<typename Condition , typename T = void> |
using | blaze::EnableIf_ = typename EnableIf< Condition, T >::Type |
| Auxiliary alias declaration for the EnableIf class template.The EnableIf_ alias declaration provides a convenient shortcut to access the nested Type of the EnableIf class template. For instance, given the type T the following two type definitions are identical: More...
|
|
using | blaze::FalseType = BoolConstant< false > |
| Type/value traits base class.The FalseType class is used as base class for type traits and value traits that evaluate to false.
|
|
template<bool B> |
using | blaze::BoolConstant = IntegralConstant< bool, B > |
| Generic wrapper for a compile time constant boolean value.The BoolConstant class template represents a generic wrapper for a compile time constant boolean value. The value of a BoolConstant can be accessed via the nested value (which is guaranteed to be of type bool ), the type can be accessed via the nested type definition ValueType. More...
|
|
template<bool Condition, typename T1 , typename T2 > |
using | blaze::IfTrue_ = typename IfTrue< Condition, T1, T2 >::Type |
| Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a convenient shortcut to access the nested Type of the IfTrue class template. For instance, given the types C, T1, and T2 the following two type definitions are identical: More...
|
|
template<typename T1 , typename T2 , typename T3 > |
using | blaze::If_ = typename If< T1, T2, T3 >::Type |
| Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient shortcut to access the nested Type of the If class template. For instance, given the types T1, T2, and T3 the following two type definitions are identical: More...
|
|
typedef std::shared_ptr< SystemClock > | blaze::SystemClockID |
| Handle for the system clock of the Blaze library.
|
|
typedef std::shared_ptr< const SystemClock > | blaze::ConstSystemClockID |
| Handle for the system clock of the Blaze library.
|
|
using | blaze::TrueType = BoolConstant< true > |
| Type traits base class.The TrueType class is used as base class for type traits and value traits that evaluate to true.
|
|
using | blaze::byte_t = unsigned char |
| Byte data type of the Blaze library.The byte data type is guaranteed to be an integral data type of size 1.
|
|
using | blaze::large_t = int64_t |
| The largest available signed integer data type.
|
|
using | blaze::ularge_t = uint64_t |
| The largest available unsigned integer data type.
|
|
using | blaze::id_t = ularge_t |
| Unsigned integer data type for integral IDs.
|
|