VariableRef.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* VariableRef.h                                               (C) 2000-2024 */
/*                                                                           */
/* Classe gérant une référence sur une 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 Supprimer virtual
  virtual eDataType dataType() const;
 
  virtual void print(std::ostream& o) const;
 
  //TODO Supprimer virtual
  virtual IModule* module() const { return m_module; }
 
  //TODO Supprimer 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;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End variable Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif  
 
//TODO: a supprimer quand tous les codes inclueront directement ce fichier
#include "arcane/VariableList.h"