SmallVariant.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* SmallVariant.h                                              (C) 2000-2017 */
/*                                                                           */
/* Polymorphic base type.                                                    */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_DATATYPE_SMALLVARIANT_H
#define ARCANE_DATATYPE_SMALLVARIANT_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/String.h"
#include "arcane/utils/Convert.h"
#include <climits>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class SmallVariant
{
 private:
 public:
 
  enum eType
  {
    TUnknown = 0,
    TReal = 1,
    TInt32 = 2,
    TInt64 = 3,
    TBool = 4,
    TString = 5
  };
 
 public:
 
  static inline int convertFromReal(int, Real v)
  {
    if (v > Convert::toReal(INT_MAX))
      return INT_MAX;
    if (v < Convert::toReal(INT_MIN))
      return INT_MIN;
    return (int)(Convert::toDouble(v));
  }
  static inline unsigned int convertFromReal(unsigned int, Real v)
  {
    if (v > Convert::toReal(UINT_MAX))
      return UINT_MAX;
    if (v < 0.0)
      return 0;
    return (unsigned int)(Convert::toDouble(v));
  }
  static inline long convertFromReal(long, Real v)
  {
    if (v > Convert::toReal(LONG_MAX))
      return LONG_MAX;
    if (v < Convert::toReal(LONG_MIN))
      return LONG_MIN;
    return (long)(Convert::toDouble(v));
  }
  static inline unsigned long convertFromReal(unsigned long, Real v)
  {
    if (v > Convert::toReal(ULONG_MAX))
      return ULONG_MAX;
    if (v < 0.0)
      return 0;
    return (unsigned long)(Convert::toDouble(v));
  }
  static inline long long convertFromReal(long long, Real v)
  {
    if (v > Convert::toReal(LLONG_MAX))
      return LLONG_MAX;
    if (v < Convert::toReal(LLONG_MIN))
      return LLONG_MIN;
    return (long long)(Convert::toDouble(v));
  }
  static inline unsigned long long convertFromReal(unsigned long long, Real v)
  {
    if (v > Convert::toReal(ULLONG_MAX))
      return ULLONG_MAX;
    if (v < 0.0)
      return 0;
    return (unsigned long long)(Convert::toDouble(v));
  }
 
 public:
 
  SmallVariant()
  : m_real_value(0.)
  , m_int32_value(0)
  , m_int64_value(0)
  , m_bool_value(false)
  , m_sticky_type(TUnknown)
  {}
  SmallVariant(Real v)
  : m_real_value(v)
  , m_int32_value(0)
  , m_int64_value(0)
  , m_bool_value(false)
  , m_sticky_type(TReal)
  {}
  SmallVariant(Int32 v)
  : m_real_value(0.)
  , m_int32_value(v)
  , m_int64_value(0)
  , m_bool_value(false)
  , m_sticky_type(TInt32)
  {}
  SmallVariant(Int64 v)
  : m_real_value(0.)
  , m_int32_value(0)
  , m_int64_value(v)
  , m_bool_value(false)
  , m_sticky_type(TInt64)
  {}
  SmallVariant(bool v)
  : m_real_value(0.)
  , m_int32_value(0)
  , m_int64_value(v)
  , m_bool_value(v)
  , m_sticky_type(TBool)
  {}
  SmallVariant(const String& v)
  : m_real_value(0.)
  , m_int32_value(0)
  , m_int64_value(0)
  , m_bool_value(false)
  , m_string_value(v)
  , m_sticky_type(TString)
  {}
 
  void setValue(Real v)
  {
    m_real_value = v;
    m_sticky_type = TReal;
  }
  void setValue(Int32 v)
  {
    m_int32_value = v;
    m_sticky_type = TInt32;
  }
  void setValue(Int64 v)
  {
    m_int64_value = v;
    m_sticky_type = TInt64;
  }
  void setValue(const String& v)
  {
    m_string_value = v;
    m_sticky_type = TString;
  }
  void setValue(bool v)
  {
    m_bool_value = v;
    m_sticky_type = TBool;
  }
 
  void setValueAll(Real v)
  {
    m_sticky_type = TReal;
    m_real_value = v;
    m_int32_value = convertFromReal(m_int32_value, v);
    m_int64_value = convertFromReal(m_int64_value, v);
    m_bool_value = v != 0.;
    m_string_value = String::fromNumber(m_real_value);
  }
  void setValueAll(Int32 v)
  {
    m_sticky_type = TInt32;
    m_real_value = Convert::toReal(v);
    m_int32_value = v;
    m_int64_value = (Int64)(v);
    m_bool_value = v != 0;
    m_string_value = String::fromNumber(m_int32_value);
  }
  void setValueAll(Int64 v)
  {
    m_sticky_type = TInt64;
    m_real_value = Convert::toReal(v);
    m_int32_value = (Int32)(v);
    m_int64_value = v;
    m_bool_value = v != 0;
    m_string_value = String::fromNumber(m_int64_value);
  }
  void setValueAll(bool v)
  {
    m_sticky_type = TBool;
    m_real_value = Convert::toReal(v);
    m_int32_value = v ? 1 : 0;
    m_int64_value = v ? 1 : 0;
    m_bool_value = v;
    m_string_value = String::fromNumber(m_int64_value);
  }
 
  void value(bool& v) const { v = m_bool_value; }
  void value(Real& v) const { v = m_real_value; }
  void value(Int32& v) const { v = m_int32_value; }
  void value(Int64& v) const { v = m_int64_value; }
  void value(String& v) const { v = m_string_value; }
 
  bool asBool() const { return m_bool_value; }
  Real asReal() const { return m_real_value; }
  Integer asInteger() const;
  Int32 asInt32() const { return m_int32_value; }
  Int64 asInt64() const { return m_int64_value; }
  const String& asString() const { return m_string_value; }
  eType type() const { return m_sticky_type; }
 
 private:
 
  Real m_real_value; 
  Int32 m_int32_value; 
  Int64 m_int64_value; 
  bool m_bool_value; 
  String m_string_value; 
  eType m_sticky_type; 
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <class Type>
class VariantGetterT
{
 public:
 
  VariantGetterT() {}
  virtual ~VariantGetterT() {}
  static Type asType(const SmallVariant& v)
  {
    Type t;
    v.value(t);
    return t;
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif