|
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...
|
|
class | blaze::AlignedStorage< T > |
| POD data type with a fixed alignment.The AlignedStorage class template represents a POD data type with a fixed alignment. Via this class it is possible to enforce a specific, type-based alignment for static data types. The required alignment is evaluated based on the given data type T. In case T is a built-in, vectorizable data type, AlignedStorage enforces an alignment of 16 or 32 bytes, depending on the active SSE/AVX level. In all other cases, no specific alignment is enforced. More...
|
|
struct | blaze::AlignmentTrait< T > |
| Evaluation of the required alignment of the given data type.The AlignmentTrait class template evaluates the required alignment for the given data type. For instance, for fundamental data types that can be vectorized via SSE or AVX instructions, the proper alignment is 16 or 32 bytes, respectively. For all other data types, a multiple of the alignment chosen by the compiler is returned. The evaluated alignment can be queried via the nested value member. 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::Limits< Type > |
| Numerical limits of built-in data types.The Limits class provides numerical limits for the following built-in data types: 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 declared private and left undefined 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::Null |
| Safe C++ NULL pointer implementation.This implementation offers a remedy for the use of the NULL pointer in C++. For this, the NULL macro is replaced by an instance of the Null class, which can only be assigned and compared with pointers and pointers-to-member. Therefore the use of NULL regains the type safety it lost in C++ due to the strict C++ type system.
The NULL pointer is used exactly as before: 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 > |
| Implementation of a vector for (polymorphic) 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...
|
|
struct | blaze::SelectType< Select, T1, T2 > |
| Compile time type selection.The SelectType class template selects one of the two given types T1 and T2 depending on the Select template argument. In case the Select compile time constant expression evaluates to true, the member type definition Type is set to T1. In case Select evaluates to false, Type is set to T2. More...
|
|
struct | blaze::SizeTrait< T1, T2 > |
| Base template for the SizeTrait class.The SizeTrait class template evaluates the larger of the two given data types by use of the sizeof operator. SizeTrait defines the data types Large for the larger of the two given data types and Small for the smaller data type. In case both data types have the same size, the first given data type T1 is chosen as the large and T2 as the small data type. 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::UniqueArray< T, D > |
| Scope-limited management of dynamically allocated arrays.The UniqueArray class implements a scope-restricted, lightweight smart pointer that manages a dynamically allocated array. In contrast to other smart pointer implementations, UniqueArray is non-copyable and therefore restricted to manage arrays within a single scope, but does so so with a minimum of runtime overhead. The following example demonstrates the application of UniqueArray: More...
|
|
class | blaze::UniquePtr< T, D > |
| Scope-limited management of dynamically allocated resourses.The UniquePtr class implements a scope-restricted, lightweight smart pointer that manages a dynamically allocated resource. In contrast to other smart pointer implementations, UniquePtr is non-copyable and therefore restricted to manage resources within a single scope, but does so with a minimum of runtime overhead. The following example demonstrates the application of UniquePtr: 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...
|
|