pTraits.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2011 OpenFOAM Foundation
    Copyright (C) 2020-2025 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.
 
    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.
 
    You should have received a copy of the GNU General Public License
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
Class
    Foam::pTraits
 
Description
    A traits class, which is primarily used for primitives and vector-space.
 
    All primitives need a specialised version of this class. The
    specialised versions will normally also require a conversion
    method.
 
\*---------------------------------------------------------------------------*/
 
#ifndef Foam_pTraits_H
#define Foam_pTraits_H
 
#include "direction.H"
#include <type_traits>  // For std::integral_constant, std::void_t
#include <utility>      // For declval
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
namespace Foam
{
 
/*---------------------------------------------------------------------------*\
                          Class zero_one Declaration
\*---------------------------------------------------------------------------*/
 
//- Represents 0/1 range or concept. Used for tagged dispatch or clamping
class zero_one {};
 
 
/*---------------------------------------------------------------------------*\
                           Class pTraits Declaration
\*---------------------------------------------------------------------------*/
 
// The base implementation is a pass-through to the base class.
// Accordingly it inherits all static methods (eg, typeName etc).
template<class Base>
class pTraits
:
    public Base
{
public:
 
    // Constructors
 
        //- Copy construct from base class
        explicit pTraits(const Base& obj)
        :
            Base(obj)
        {}
 
        //- Construct from Istream
        explicit pTraits(Istream& is)
        :
            Base(is)
        {}
};
 
 
/*---------------------------------------------------------------------------*\
                         Robuster generalised pTraits
\*---------------------------------------------------------------------------*/
 
//- The vector-space rank: default is 0.
template<class T, class = void>
struct pTraits_rank : std::integral_constant<Foam::direction, 0> {};
 
//- Rank of VectorSpace,
//- using the pTraits \c rank static member.
template<class T>
struct pTraits_rank
<
    T,
    std::void_t<decltype(pTraits<std::remove_cv_t<T>>::rank)>
>
:
    std::integral_constant<Foam::direction, pTraits<std::remove_cv_t<T>>::rank>
{};
 
 
//- The underlying component data type: default is pass-through.
template<class T, class = void>
struct pTraits_cmptType { typedef T type; };
 
//- The underlying component data type for vector-space (or complex).
//  Enabled when pTraits<T>:zero has a defined type (ie, exists),
//  such as for arithmetic primitives, vector-space etc. where the concept
//  of a component type also makes sense.
template<class T>
struct pTraits_cmptType
<
    T,
    std::void_t<decltype(pTraits<std::remove_cv_t<T>>::zero)>
>
{
    using type = typename pTraits<std::remove_cv_t<T>>::cmptType;
};
 
 
//- The vector-space number of components: default is 1.
template<class T, class = void>
struct pTraits_nComponents : std::integral_constant<Foam::direction, 1> {};
 
//- Number of VectorSpace components,
//- using the pTraits \c nComponents static member.
template<class T>
struct pTraits_nComponents
<
    T,
    std::void_t<decltype(std::remove_cv_t<T>::nComponents)>
>
:
    std::integral_constant
    <
        Foam::direction,
        pTraits<std::remove_cv_t<T>>::nComponents
    >
{};
 
 
//- Test for pTraits zero : default is false
template<class T, class = void>
struct pTraits_has_zero : std::false_type {};
 
//- Test for pTraits zero
template<class T>
struct pTraits_has_zero
<
    T,
    std::void_t<decltype(pTraits<std::remove_cv_t<T>>::zero)>
>
:
    std::true_type
{};
 
 
/*---------------------------------------------------------------------------*\
                              VectorSpace Traits
\*---------------------------------------------------------------------------*/
 
//- Test for VectorSpace : default is false
template<class T, class = void>
struct is_vectorspace : std::false_type {};
 
//- Test for VectorSpace : test for T::rank != 0 static member directly
//  Do not need pTraits layer since rank is defined via VectorSpace etc
template<class T>
struct is_vectorspace
<
    T,
    std::void_t<decltype(std::remove_cv_t<T>::rank)>
>
:
    std::bool_constant<std::remove_cv_t<T>::rank != 0>
{};
 
 
//- Test for VectorSpace and multiple components (eg, not sphericalTensor)
//- which means it is not rotationally invariant
template<class T, class = void>
struct is_rotational_vectorspace : std::false_type {};
 
//- Test for VectorSpace and multiple components (eg, not sphericalTensor)
//  Do not need pTraits layer since rank and nComponents are both
//  defined via VectorSpace
template<class T>
struct is_rotational_vectorspace
<
    T,
    std::void_t
    <
        decltype(std::remove_cv_t<T>::rank),
        decltype(std::remove_cv_t<T>::nComponents)
    >
>
:
    std::bool_constant
    <
        (std::remove_cv_t<T>::rank != 0)
     && (std::remove_cv_t<T>::nComponents > 1)
    >
{};
 
 
//- The is_vectorspace value of Type
template<class T>
inline constexpr bool is_vectorspace_v
    = is_vectorspace<T>::value;
 
//- The is_rotational_vectorspace value of Type
template<class T>
inline constexpr bool is_rotational_vectorspace_v
    = is_rotational_vectorspace<T>::value;
 
 
/*---------------------------------------------------------------------------*\
                               Container Traits
\*---------------------------------------------------------------------------*/
 
//- Test for containers with begin/end range iterators.
template<class T, class = void>
struct is_range : std::false_type {};
 
//- Test for list containers with begin/end range iterators.
//- \attention May yield a false positive with HashTable, HashSet etc
template<class T>
struct is_range
<
    T,
    std::void_t
    <
        decltype(std::declval<T>().begin()),
        decltype(std::declval<T>().end())
    >
>
:
    std::true_type
{};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
} // End namespace Foam
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
#endif
 
// ************************************************************************* //