DataTypeTraits.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* DataTypeTraits.h                                            (C) 2000-2024 */
/*                                                                           */
/* Caractéristiques d'un type de donnée.                                     */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_DATATYPE_DATATYPETRAITS_H
#define ARCANE_DATATYPE_DATATYPETRAITS_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/BasicDataType.h"
#include "arcane/utils/BFloat16.h"
#include "arcane/utils/Float16.h"
#include "arcane/utils/Float128.h"
#include "arcane/utils/Int128.h"
 
#include "arcane/core/ArcaneTypes.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class DataTypeScalarReal;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template<typename DataType>
class DataTypeTraitsT;
class Real2Proxy;
class Real3Proxy;
class Real3x3Proxy;
class Real2x2Proxy;
template<typename Type>
class BuiltInProxy;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<bool>
{
 public:
 
  typedef bool Type;
 
  typedef bool BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "Bool"; }
 
  static constexpr eDataType type() { return DT_Byte; }
 
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::Byte; }
 
  typedef BuiltInProxy<bool> ProxyType;
 
  static Type nanValue() { return 0; }
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return false; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Byte>
{
 public:
 
  typedef Byte Type;
 
  typedef Byte BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "Byte"; }
 
  static constexpr eDataType type() { return DT_Byte; }
 
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::Byte; }
 
  typedef BuiltInProxy<Byte> ProxyType;
 
  static constexpr Type nanValue() { return 0; }
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return 0; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Real>
{
 public:
 
  typedef Real Type;
 
  typedef Real BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "Real"; }
 
  static constexpr eDataType type() { return DT_Real; }
 
  // TODO: calculer automatiquement la taille
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::Float64; }
 
  typedef BuiltInProxy<Real> ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return 0.0; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Float128>
{
 public:
 
  typedef Float128 Type;
 
  typedef Float128 BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "Float128"; }
 
  static constexpr eDataType type() { return DT_Float128; }
 
  // TODO: calculer automatiquement la taille
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::Float128; }
 
  typedef BuiltInProxy<Float128> ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return Float128(0.0l); }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Float32>
{
 public:
 
  typedef Float32 Type;
 
  typedef Float32 BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "Float32"; }
 
  static constexpr eDataType type() { return DT_Float32; }
 
  // TODO: calculer automatiquement la taille
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::Float32; }
 
  typedef BuiltInProxy<Float32> ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return 0.0f; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<BFloat16>
{
 public:
 
  typedef BFloat16 Type;
 
  typedef BFloat16 BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "BFloat16"; }
 
  static constexpr eDataType type() { return DT_BFloat16; }
 
  // TODO: calculer automatiquement la taille
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::BFloat16; }
 
  typedef BuiltInProxy<BFloat16> ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return {}; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Float16>
{
 public:
 
  typedef Float16 Type;
 
  typedef Float16 BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "Float16"; }
 
  static constexpr eDataType type() { return DT_Float16; }
 
  // TODO: calculer automatiquement la taille
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::Float16; }
 
  typedef BuiltInProxy<Float16> ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return {}; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Int8>
{
 public:
 
  typedef Int8 Type;
 
  typedef Int8 BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "Int8"; }
 
  static constexpr eDataType type() { return DT_Int8; }
 
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::Int8; }
 
  typedef BuiltInProxy<Int8> ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return 0; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Int16>
{
 public:
 
  typedef Int16 Type;
 
  typedef Int16 BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "Int16"; }
 
  static constexpr eDataType type() { return DT_Int16; }
 
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::Int16; }
 
  typedef BuiltInProxy<Int32> ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return 0; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Int32>
{
 public:
 
  typedef Int32 Type;
 
  typedef Int32 BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "Int32"; }
 
  static constexpr eDataType type() { return DT_Int32; }
 
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::Int32; }
 
  typedef BuiltInProxy<Int32> ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return 0; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Int64>
{
 public:
 
  typedef Int64 Type;
 
  typedef Int64 BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "Int64"; }
 
  static constexpr eDataType type() { return DT_Int64; }
 
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::Int64; }
 
  typedef BuiltInProxy<Int64> ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return 0; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Int128>
{
 public:
 
  typedef Int128 Type;
 
  typedef Int128 BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "Int128"; }
 
  static constexpr eDataType type() { return DT_Int128; }
 
  static constexpr eBasicDataType basicDataType() { return eBasicDataType::Int128; }
 
  typedef BuiltInProxy<Int128> ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static constexpr Type defaultValue() { return 0; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<String>
{
 public:
 
  typedef String Type;
 
  typedef String BasicType;
 
  static constexpr int nbBasicType() { return 1; }
 
  static constexpr const char* name() { return "String"; }
 
  static constexpr eDataType type() { return DT_String; }
 
  typedef String ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static ARCANE_CORE_EXPORT Type defaultValue();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Real2>
{
 public:
 
  typedef Real2 Type;
 
  typedef Real BasicType;
 
  using SubscriptType = Real;
 
  static constexpr int nbBasicType() { return 2; }
 
  static constexpr const char* name() { return "Real2"; }
 
  static constexpr eDataType type() { return DT_Real2; }
 
  static constexpr eBasicDataType basicDataType() { return DataTypeTraitsT<Real>::basicDataType(); }
 
  typedef Real2Proxy ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static ARCANE_CORE_EXPORT Type defaultValue();
 
 public:
 
  static constexpr bool HasSubscriptOperator() { return true; }
  static constexpr bool HasComponentX() { return true; }
  static constexpr bool HasComponentY() { return true; }
 
  using ComponentType = Real;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Real3>
{
 public:
 
  typedef Real3 Type;
 
  typedef Real BasicType;
 
  using SubscriptType = Real;
 
  static constexpr int nbBasicType() { return 3; }
 
  static constexpr const char* name() { return "Real3"; }
 
  static constexpr eDataType type() { return DT_Real3; }
 
  static constexpr eBasicDataType basicDataType() { return DataTypeTraitsT<Real>::basicDataType(); }
 
  typedef Real3Proxy ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static ARCANE_CORE_EXPORT Type defaultValue();
 
  static constexpr bool HasSubscriptOperator() { return true; }
  static constexpr bool HasComponentX() { return true; }
  static constexpr bool HasComponentY() { return true; }
  static constexpr bool HasComponentZ() { return true; }
 
  using ComponentType = Real;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Real2x2>
{
 public:
 
  typedef Real2x2 Type;
 
  typedef Real BasicType;
 
  using SubscriptType = Real2;
 
  static constexpr int nbBasicType() { return 4; }
 
  static constexpr const char* name() { return "Real2x2"; }
 
  static constexpr eDataType type() { return DT_Real2x2; }
 
  static constexpr eBasicDataType basicDataType() { return DataTypeTraitsT<Real>::basicDataType(); }
 
  typedef Real2x2Proxy ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static ARCANE_CORE_EXPORT Type defaultValue();
 
  static constexpr bool HasSubscriptOperator() { return true; }
 
  static constexpr bool HasComponentXX() { return true; }
  static constexpr bool HasComponentYX() { return true; }
  static constexpr bool HasComponentXY() { return true; }
  static constexpr bool HasComponentYY() { return true; }
 
  static constexpr bool HasComponentX() { return true; }
  static constexpr bool HasComponentY() { return true; }
 
  using ComponentType = Real2;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<>
class DataTypeTraitsT<Real3x3>
{
 public:
 
  typedef Real3x3 Type;
 
  typedef Real BasicType;
 
  using SubscriptType = Real3;
 
  static constexpr int nbBasicType() { return 9; }
 
  static constexpr const char* name() { return "Real3x3"; }
 
  static constexpr eDataType type() { return DT_Real3x3; }
 
  static constexpr eBasicDataType basicDataType() { return DataTypeTraitsT<Real>::basicDataType(); }
 
  typedef Real3x3Proxy ProxyType;
 
  static void fillNan(ArrayView<Type> values);
 
  static ARCANE_CORE_EXPORT Type defaultValue();
 
  static constexpr bool HasSubscriptOperator() { return true; }
 
  static constexpr bool HasComponentXX() { return true; }
  static constexpr bool HasComponentYX() { return true; }
  static constexpr bool HasComponentZX() { return true; }
  static constexpr bool HasComponentXY() { return true; }
  static constexpr bool HasComponentYY() { return true; }
  static constexpr bool HasComponentZY() { return true; }
  static constexpr bool HasComponentXZ() { return true; }
  static constexpr bool HasComponentYZ() { return true; }
  static constexpr bool HasComponentZZ() { return true; }
 
  static constexpr bool HasComponentX() { return true; }
  static constexpr bool HasComponentY() { return true; }
  static constexpr bool HasComponentZ() { return true; }
 
  using ComponentType = Real3;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<int Size>
class DataTypeTraitsT<NumVector<Real,Size>>
{
 public:
 
  typedef Real Type;
 
  typedef Real BasicType;
 
  using FunctionCall1ReturnType = Real;
 
  static constexpr int nbBasicType() { return Size; }
 
  static constexpr eBasicDataType basicDataType() { return DataTypeTraitsT<Real>::basicDataType(); }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<int RowSize,int ColumnSize>
class DataTypeTraitsT<NumMatrix<Real,RowSize,ColumnSize>>
{
 public:
 
  typedef Real Type;
 
  typedef Real BasicType;
 
  using FunctionCall2ReturnType = Real;
 
  static constexpr int nbBasicType() { return RowSize * ColumnSize; }
 
  static constexpr eBasicDataType basicDataType() { return DataTypeTraitsT<Real>::basicDataType(); }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif