Blaze 3.9
Typedefs
Aliases.h File Reference

Header file for auxiliary alias declarations. More...

#include <blaze/util/Types.h>

Go to the source code of this file.

Typedefs

template<typename T >
using blaze::AllocatorType_t = typename T::AllocatorType
 Alias declaration for nested AllocatorType type definitions. More...
 
template<typename T >
using blaze::BaseType_t = typename T::BaseType
 Alias declaration for nested BaseType type definitions. More...
 
template<typename T >
using blaze::CompositeType_t = typename T::CompositeType
 Alias declaration for nested CompositeType type definitions. More...
 
template<typename T >
using blaze::ConstIterator_t = typename T::ConstIterator
 Alias declaration for nested ConstIterator type definitions. More...
 
template<typename T >
using blaze::ConstPointer_t = typename T::ConstPointer
 Alias declaration for nested ConstPointer type definitions. More...
 
template<typename T >
using blaze::ConstReference_t = typename T::ConstReference
 Alias declaration for nested ConstReference type definitions. More...
 
template<typename T >
using blaze::ElementType_t = typename T::ElementType
 Alias declaration for nested ElementType type definitions. More...
 
template<typename T >
using blaze::Iterator_t = typename T::Iterator
 Alias declaration for nested Iterator type definitions. More...
 
template<typename T >
using blaze::LeftOperand_t = typename T::LeftOperand
 Alias declaration for nested LeftOperand type definitions. More...
 
template<typename T >
using blaze::MatrixType_t = typename T::MatrixType
 Alias declaration for nested MatrixType type definitions. More...
 
template<typename T >
using blaze::Operand_t = typename T::Operand
 Alias declaration for nested Operand type definitions. More...
 
template<typename T >
using blaze::Operation_t = typename T::Operation
 Alias declaration for nested Operation type definitions. More...
 
template<typename T >
using blaze::OppositeType_t = typename T::OppositeType
 Alias declaration for nested OppositeType type definitions. More...
 
template<typename T >
using blaze::Pointer_t = typename T::Pointer
 Alias declaration for nested Pointer type definitions. More...
 
template<typename T1 , typename T2 >
using blaze::Rebind_t = typename T1::template Rebind< T2 >::Other
 Alias declaration for nested Rebind class templates. More...
 
template<typename T1 , typename T2 >
using blaze::rebind_t = typename T1::template rebind< T2 >::other
 Alias declaration for nested rebind class templates. More...
 
template<typename T >
using blaze::Reference_t = typename T::Reference
 Alias declaration for nested Reference type definitions. More...
 
template<typename T >
using blaze::RepresentedType_t = typename T::RepresentedType
 Alias declaration for nested RepresentedType type definitions. More...
 
template<typename T , size_t... Ns>
using blaze::Resize_t = typename T::template Resize< Ns... >::Other
 Alias declaration for nested Resize class templates. More...
 
template<typename T >
using blaze::ResultType_t = typename T::ResultType
 Alias declaration for nested ResultType type definitions. More...
 
template<typename T >
using blaze::ReturnType_t = typename T::ReturnType
 Alias declaration for nested ReturnType type definitions. More...
 
template<typename T >
using blaze::RightOperand_t = typename T::RightOperand
 Alias declaration for nested RightOperand type definitions. More...
 
template<typename T >
using blaze::SIMDType_t = typename T::SIMDType
 Alias declaration for nested SIMDType type definitions. More...
 
template<typename T >
using blaze::TagType_t = typename ResultType_t< T >::TagType
 Alias declaration for nested TagType type definitions. More...
 
template<typename T >
using blaze::TransposeType_t = typename T::TransposeType
 Alias declaration for nested TransposeType type definitions. More...
 
template<typename T >
using blaze::ValueType_t = typename T::ValueType
 Alias declaration for nested ValueType type definitions. More...
 
template<typename T >
using blaze::VectorType_t = typename T::VectorType
 Alias declaration for nested VectorType type definitions. More...
 
template<typename T >
using blaze::ViewedType_t = typename T::ViewedType
 Alias declaration for nested ViewedType type definitions. More...
 

Detailed Description

Header file for auxiliary alias declarations.

Copyright (C) 2012-2020 Klaus Iglberger - All Rights Reserved

This file is part of the Blaze library. You can redistribute it and/or modify it under the terms of the New (Revised) BSD License. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

  1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
  2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
  3. Neither the names of the Blaze development group nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Typedef Documentation

◆ AllocatorType_t

template<typename T >
using blaze::AllocatorType_t = typedef typename T::AllocatorType

Alias declaration for nested AllocatorType type definitions.

The AllocatorType_t alias declaration provides a convenient shortcut to access the nested AllocatorType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::AllocatorType;
using Type2 = AllocatorType_t<T>;
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_SAME_TYPE(A, B)
Data type constraint.
Definition: SameType.h:131

◆ BaseType_t

template<typename T >
using blaze::BaseType_t = typedef typename T::BaseType

Alias declaration for nested BaseType type definitions.

The BaseType_t alias declaration provides a convenient shortcut to access the nested BaseType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::BaseType;
using Type2 = BaseType_t<T>;

◆ CompositeType_t

template<typename T >
using blaze::CompositeType_t = typedef typename T::CompositeType

Alias declaration for nested CompositeType type definitions.

The CompositeType_t alias declaration provides a convenient shortcut to access the nested CompositeType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::CompositeType;
using Type2 = CompositeType_t<T>;

◆ ConstIterator_t

template<typename T >
using blaze::ConstIterator_t = typedef typename T::ConstIterator

Alias declaration for nested ConstIterator type definitions.

The ConstIterator_t alias declaration provides a convenient shortcut to access the nested ConstIterator type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::ConstIterator;
using Type2 = ConstIterator_t<T>;

◆ ConstPointer_t

template<typename T >
using blaze::ConstPointer_t = typedef typename T::ConstPointer

Alias declaration for nested ConstPointer type definitions.

The ConstPointer_t alias declaration provides a convenient shortcut to access the nested ConstPointer type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::ConstPointer;
using Type2 = ConstPointer_t<T>;

◆ ConstReference_t

template<typename T >
using blaze::ConstReference_t = typedef typename T::ConstReference

Alias declaration for nested ConstReference type definitions.

The ConstReference_t alias declaration provides a convenient shortcut to access the nested ConstReference type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::ConstReference;
using Type2 = ConstReference_t<T>;

◆ ElementType_t

template<typename T >
using blaze::ElementType_t = typedef typename T::ElementType

Alias declaration for nested ElementType type definitions.

The ElementType_t alias declaration provides a convenient shortcut to access the nested ElementType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::ElementType;
using Type2 = ElementType_t<T>;

◆ Iterator_t

template<typename T >
using blaze::Iterator_t = typedef typename T::Iterator

Alias declaration for nested Iterator type definitions.

The Iterator_t alias declaration provides a convenient shortcut to access the nested Iterator type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::Iterator;
using Type2 = Iterator_t<T>;

◆ LeftOperand_t

template<typename T >
using blaze::LeftOperand_t = typedef typename T::LeftOperand

Alias declaration for nested LeftOperand type definitions.

The LeftOperand_t alias declaration provides a convenient shortcut to access the nested LeftOperand type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::LeftOperand;
using Type2 = LeftOperand_t<T>;

◆ MatrixType_t

template<typename T >
using blaze::MatrixType_t = typedef typename T::MatrixType

Alias declaration for nested MatrixType type definitions.

The MatrixType_t alias declaration provides a convenient shortcut to access the nested MatrixType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::MatrixType;
using Type2 = MatrixType_t<T>;

◆ Operand_t

template<typename T >
using blaze::Operand_t = typedef typename T::Operand

Alias declaration for nested Operand type definitions.

The Operand_t alias declaration provides a convenient shortcut to access the nested Operand type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::Operand;
using Type2 = Operand_t<T>;

◆ Operation_t

template<typename T >
using blaze::Operation_t = typedef typename T::Operation

Alias declaration for nested Operation type definitions.

The Operation_t alias declaration provides a convenient shortcut to access the nested Operation type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::Operation;
using Type2 = Operation_t<T>;

◆ OppositeType_t

template<typename T >
using blaze::OppositeType_t = typedef typename T::OppositeType

Alias declaration for nested OppositeType type definitions.

The OppositeType_t alias declaration provides a convenient shortcut to access the nested OppositeType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::OppositeType;
using Type2 = OppositeType_t<T>;

◆ Pointer_t

template<typename T >
using blaze::Pointer_t = typedef typename T::Pointer

Alias declaration for nested Pointer type definitions.

The Pointer_t alias declaration provides a convenient shortcut to access the nested Pointer type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::Pointer;
using Type2 = Pointer_t<T>;

◆ Rebind_t

template<typename T1 , typename T2 >
using blaze::Rebind_t = typedef typename T1::template Rebind<T2>::Other

Alias declaration for nested Rebind class templates.

The Rebind_t alias declaration provides a convenient shortcut to access the nested Rebind class template of the given type T1. The following code example shows both ways to access the nested class template:

using Type1 = typename T1::template Rebind<T2>::Other;
using Type2 = Rebind_t<T1,T2>;

◆ rebind_t

template<typename T1 , typename T2 >
using blaze::rebind_t = typedef typename T1::template rebind<T2>::other

Alias declaration for nested rebind class templates.

The rebind_t alias declaration provides a convenient shortcut to access the nested rebind class template of the given type T1. The following code example shows both ways to access the nested class template:

using Type1 = typename T1::template rebind<T2>::Other;
using Type2 = rebind_t<T1,T2>;

◆ Reference_t

template<typename T >
using blaze::Reference_t = typedef typename T::Reference

Alias declaration for nested Reference type definitions.

The Reference_t alias declaration provides a convenient shortcut to access the nested Reference type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::Reference;
using Type2 = Reference_t<T>;

◆ RepresentedType_t

template<typename T >
using blaze::RepresentedType_t = typedef typename T::RepresentedType

Alias declaration for nested RepresentedType type definitions.

The RepresentedType_t alias declaration provides a convenient shortcut to access the nested RepresentedType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::RepresentedType;
using Type2 = RepresentedType_t<T>;

◆ Resize_t

template<typename T , size_t... Ns>
using blaze::Resize_t = typedef typename T::template Resize<Ns...>::Other

Alias declaration for nested Resize class templates.

The Resize_t alias declaration provides a convenient shortcut to access the nested Resize class template of the given type T1. The following code example shows both ways to access the nested class template:

using Type1 = typename T::template Resize<N>::Other;
using Type2 = Resize_t<T,N>;

◆ ResultType_t

template<typename T >
using blaze::ResultType_t = typedef typename T::ResultType

Alias declaration for nested ResultType type definitions.

The ResultType_t alias declaration provides a convenient shortcut to access the nested ResultType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::ResultType;
using Type2 = ResultType_t<T>;

◆ ReturnType_t

template<typename T >
using blaze::ReturnType_t = typedef typename T::ReturnType

Alias declaration for nested ReturnType type definitions.

The ReturnType_t alias declaration provides a convenient shortcut to access the nested ReturnType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::ReturnType;
using Type2 = ReturnType_t<T>;

◆ RightOperand_t

template<typename T >
using blaze::RightOperand_t = typedef typename T::RightOperand

Alias declaration for nested RightOperand type definitions.

The RightOperand_t alias declaration provides a convenient shortcut to access the nested RightOperand type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::RightOperand;
using Type2 = RightOperand_t<T>;

◆ SIMDType_t

template<typename T >
using blaze::SIMDType_t = typedef typename T::SIMDType

Alias declaration for nested SIMDType type definitions.

The SIMDType_t alias declaration provides a convenient shortcut to access the nested SIMDType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::SIMDType;
using Type2 = SIMDType_t<T>;

◆ TagType_t

template<typename T >
using blaze::TagType_t = typedef typename ResultType_t<T>::TagType

Alias declaration for nested TagType type definitions.

The TagType_t alias declaration provides a convenient shortcut to access the nested TagType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::TagType;
using Type2 = TagType_t<T>;

◆ TransposeType_t

template<typename T >
using blaze::TransposeType_t = typedef typename T::TransposeType

Alias declaration for nested TransposeType type definitions.

The TransposeType_t alias declaration provides a convenient shortcut to access the nested TransposeType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::TransposeType;
using Type2 = TransposeType_t<T>;

◆ ValueType_t

template<typename T >
using blaze::ValueType_t = typedef typename T::ValueType

Alias declaration for nested ValueType type definitions.

The ValueType_t alias declaration provides a convenient shortcut to access the nested ValueType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::ValueType;
using Type2 = ValueType_t<T>;

◆ VectorType_t

template<typename T >
using blaze::VectorType_t = typedef typename T::VectorType

Alias declaration for nested VectorType type definitions.

The VectorType_t alias declaration provides a convenient shortcut to access the nested VectorType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::VectorType;
using Type2 = VectorType_t<T>;

◆ ViewedType_t

template<typename T >
using blaze::ViewedType_t = typedef typename T::ViewedType

Alias declaration for nested ViewedType type definitions.

The ViewedType_t alias declaration provides a convenient shortcut to access the nested ViewedType type definition of the given type T. The following code example shows both ways to access the nested type definition:

using Type1 = typename T::ViewedType;
using Type2 = ViewedType_t<T>;