VariableRef.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* VariableRef.h                                               (C) 2000-2025 */
/*                                                                           */
/* Class managing a reference to a variable.                                 */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_VARIABLEREF_H
#define ARCANE_CORE_VARIABLEREF_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/String.h"
 
#include "arcane/core/IVariable.h"
#include "arcane/core/VariableComputeFunction.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class IModule;
class IVariableComputeFunction;
class VariableBuildInfo;
typedef VariableBuildInfo VariableBuilder;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ARCANE_CORE_EXPORT VariableRef
{
 public:
 
  class UpdateNotifyFunctorList;
  friend class UpdateNotifyFunctorList;
 
 protected:

  explicit VariableRef(const VariableBuildInfo& vbi);
  VariableRef(const VariableRef& from);
  explicit VariableRef(IVariable* var);
  VariableRef& operator=(const VariableRef& from);
  VariableRef();
 
 public:

  virtual ~VariableRef();
 
 public:

  ISubDomain* subDomain() const;
 
 public:

  IVariableMng* variableMng() const;

  String name() const;
 
 public:
 
  //TODO Remove virtual
  virtual eDataType dataType() const;

  virtual void print(std::ostream& o) const;
 
  //TODO Remove virtual
  virtual IModule* module() const { return m_module; }
 
  //TODO Remove virtual
  virtual int property() const;

  virtual int referenceProperty() const;

  virtual void setProperty(int property);

  virtual void unsetProperty(int property);

  virtual void registerVariable();

  virtual void unregisterVariable();

  IVariable* variable() const { return m_variable; }

  virtual Integer checkIfSync(int max_print = 0);

  virtual Integer checkIfSameOnAllReplica(int max_print = 0);

  virtual void updateFromInternal();

  virtual Integer arraySize() const { return 0; }
 
 public:
 
  void setUsed(bool v) { m_variable->setUsed(v); }
  bool isUsed() const { return m_variable->isUsed(); }
 
  virtual void internalSetUsed(bool /*v*/) {}
 
 public:

  const String& assignmentStackTrace() const { return m_assignment_stack_trace; }
 
 public:


  void addTag(const String& tagname, const String& tagvalue);
  void removeTag(const String& tagname);
  bool hasTag(const String& tagname) const;
  String tagValue(const String& tagname) const;
 
 public:


  void update();

  void setUpToDate();

  Int64 modifiedTime();

  void addDependCurrentTime(const VariableRef& var);

  void addDependCurrentTime(const VariableRef& var, const TraceInfo& tinfo);

  void addDependPreviousTime(const VariableRef& var);

  void addDependPreviousTime(const VariableRef& var, const TraceInfo& tinfo);

  void removeDepend(const VariableRef& var);

  template <typename ClassType> void
  setComputeFunction(ClassType* instance, void (ClassType::*func)())
  {
    _setComputeFunction(new VariableComputeFunction(instance, func));
  }

  template <typename ClassType> void
  setComputeFunction(ClassType* instance, void (ClassType::*func)(), const TraceInfo& tinfo)
  {
    _setComputeFunction(new VariableComputeFunction(instance, func, tinfo));
  }

 
 public:

  VariableRef* previousReference();

  VariableRef* nextReference();

  void setPreviousReference(VariableRef* v);

  void setNextReference(VariableRef* v);
 
 public:
 
  static void setTraceCreation(bool v);
  static bool hasTraceCreation();
 
 protected:
 
  void _setComputeFunction(IVariableComputeFunction* v);

  void _internalInit(IVariable*);

  IVariable* _variable() const
  {
    _checkValid();
    return m_variable;
  }
 
 private:

  IVariable* m_variable = nullptr;

  IModule* m_module = nullptr;

  bool m_is_registered = false;

  int m_reference_property = 0;

  VariableRef* m_previous_reference = nullptr;

  VariableRef* m_next_reference = nullptr;

  String m_assignment_stack_trace;
 
 protected:
 
  void _executeUpdateFunctors();
 
  bool m_has_trace = false;
 
 private:
 
  void _checkValid() const
  {
#ifdef ARCANE_CHECK
    if (!m_variable)
      _throwInvalid();
#endif
  }
  void _throwInvalid() const;
  bool _checkValidPropertyChanged(int property);
  void _setAssignmentStackTrace();
 
 protected:
 
  void _internalAssignVariable(const VariableRef& var);
 
 private:
 
  static bool m_static_has_trace_creation;
  UpdateNotifyFunctorList* m_notify_functor_list = nullptr;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif
 
//TODO: to be removed when all codes include this file directly
#include "arcane/core/VariableList.h"