VariableRefScalar.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* VariableRefScalar.h                                         (C) 2000-2020 */
/*                                                                           */
/* Classe gérant une référence sur une variable scalaire.                    */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_VARIABLEREFSCALAR_H
#define ARCANE_VARIABLEREFSCALAR_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/VariableRef.h"
#include "arcane/Parallel.h"
#include "arcane/MathUtils.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
class VariableFactoryRegisterer;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template<typename DataType>
class VariableRefScalarT
: public VariableRef
{
 public:

  typedef DataType ElementType;
  typedef VariableRef BaseClass;
 
  typedef VariableScalarT<DataType> PrivatePartType;
 
  typedef VariableRefScalarT<DataType> ThatClass;
 
 public:

  explicit ARCANE_CORE_EXPORT VariableRefScalarT(const VariableBuildInfo& b);
  ARCANE_CORE_EXPORT VariableRefScalarT(const VariableRefScalarT<DataType>& rhs);
  explicit ARCANE_CORE_EXPORT VariableRefScalarT(IVariable* var);
  ARCANE_CORE_EXPORT void refersTo(const VariableRefScalarT<DataType>& rhs);
 
#ifdef ARCANE_DOTNET
 public:
#else
 protected:
#endif

  VariableRefScalarT() : m_private_part(nullptr) {}
 
 public:
 
  virtual bool isArrayVariable() const { return false; }
  virtual Integer arraySize() const { return 0; }
  virtual ARCANE_CORE_EXPORT void updateFromInternal();
 
 public:
 
  ArrayView<DataType> asArray() { return ArrayView<DataType>(1,&(m_private_part->value())); }
  ConstArrayView<DataType> asArray() const { return ConstArrayView<DataType>(1,&(m_private_part->value())); }
 
 public:
  
  void operator=(const DataType& v) { assign(v); }
  VariableRefScalarT<DataType>& operator=(const VariableRefScalarT<DataType>& v)
  {
    assign(v());
    return (*this);
  }

  void reset() { assign(DataType()); }

  const DataType& operator()() const { return m_private_part->value(); }

  const DataType& value() const { return m_private_part->value(); }

  bool isEqual(const DataType& v) const
    { return math::isEqual(m_private_part->value(),v); }

  bool isZero() const
    { return math::isZero(m_private_part->value()); }

  bool isNearlyEqual(const DataType& v) const
    { return math::isNearlyEqual(m_private_part->value(),v); }

  bool isNearlyZero() const
    { return math::isNearlyZero(m_private_part->value()); }

  ARCANE_CORE_EXPORT void assign(const DataType& v);

  ARCANE_CORE_EXPORT void reduce(Parallel::eReduceType type);
 
  ARCANE_CORE_EXPORT void swapValues(VariableRefScalarT<DataType>& rhs);
 
 protected:
  
 private:
 
  PrivatePartType* m_private_part;
 
 private:
 
  static VariableFactoryRegisterer m_auto_registerer;
  static VariableTypeInfo _buildVariableTypeInfo();
  static VariableInfo _buildVariableInfo(const VariableBuildInfo& vbi);
  static VariableRef* _autoCreate(const VariableBuildInfo& vb);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif