AnyItemVariable.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* AnyItemVariable.h                                           (C) 2000-2022 */
/*                                                                           */
/* Variable aggrégée de types quelconques.                                   */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_ANYITEMS_ANYITEMVARIABLE_H 
#define ARCANE_ANYITEMS_ANYITEMVARIABLE_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Exception.h"
 
#include "arcane/anyitem/AnyItemGlobal.h"
#include "arcane/anyitem/AnyItemGroup.h"
#include "arcane/anyitem/AnyItemLinkFamily.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::AnyItem
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template<typename DataType>
class Variable : public IFamilyObserver
{
public:
  
  class VariableAdder
  {
  public:
    
    VariableAdder(Variable<DataType>& variable, const ItemGroup& group) 
      : m_variable(variable)
      , m_group(group)
      , m_used(false) {}
    
    ~VariableAdder() 
    {
      ARCANE_ASSERT((m_used == true),("VariableAdder never used"));
    }
    
    template<typename K, typename T>  
    inline void operator<<(MeshVariableScalarRefT<K,T>& v) 
    {
      ARCANE_ASSERT((m_used == false),("VariableAdder already used"));
      m_variable._insertVariable(m_group,v.asArray());
      m_variable._insertInternalVariable(m_group,v.variable());
      m_used = true;
    }
    
    template<typename K, typename T> 
    inline void operator<<(MeshPartialVariableScalarRefT<K,T>& v) 
    {
      ARCANE_ASSERT((m_used == false),("VariableAdder already used"));
      m_variable._insertPartialVariable(m_group,v.asArray());
      m_variable._insertInternalVariable(m_group,v.variable());
      m_used = true;
    }
  private:
    
    Variable<DataType>& m_variable;
    
    const ItemGroup& m_group;
    
    bool m_used;
  };
  
public:
  
  Variable(const Family& family) 
    : m_family(family)
    , m_values(m_family.groupSize())
    , m_variables(m_family.groupSize()) 
  {
    // la famille enregistre les variables portées
    m_family.registerObserver(*this);
    for(Integer i = 0; i < m_family.groupSize(); ++i)
      m_variables[i] = NULL;
  }
  
  Variable(const Variable& v) 
    : m_family(v.m_family)
    , m_values(v.m_values)
    , m_variables(v.m_variables) 
  {
    // la famille enregistre les variables portées
    m_family.registerObserver(*this);
  }
  
  ~Variable() 
  {
    // la famille désenregistre la variable
    arcaneCallFunctionAndTerminateIfThrow([&]() { m_family.removeObserver(*this); });
  }
  
  inline DataType& operator[](const Group::BlockItemEnumerator& item) { 
    return m_values[item.groupIndex()][item.varIndex()];
  }
  
  inline const DataType& operator[](const Group::BlockItemEnumerator & item) const { 
    return m_values[item.groupIndex()][item.varIndex()];
  }
  
  inline DataType& operator[](const LinkFamily::LinkData & item) { 
    return m_values[item.groupIndex()][item.varIndex()];
  }
  
  inline const DataType& operator[](const LinkFamily::LinkData & item) const { 
    return m_values[item.groupIndex()][item.varIndex()];
  }

  inline VariableAdder operator[](const ItemGroup& group) 
  {
    return VariableAdder(*this,group);
  }
 
  template<typename T>
  inline VariableAdder operator[](const ItemGroupT<T>& group) 
  {
    return VariableAdder(*this,group);
  }

  inline const Family& family() const { return m_family; }

  inline ConstArrayView< IVariable* > variables() const 
  {
    return m_variables;
  } 
  
  inline ArrayView<DataType> valuesAtGroup(const Integer igrp) 
  {
    return m_values[igrp];
  }

  inline ConstArrayView<DataType> valuesAtGroup(const Integer igrp) const
  {
    return m_values[igrp];
  }

  inline void notifyFamilyIsInvalidate() {
    // Si la famille change, on invalide les variables et on retaille
    m_values.resize(m_family.groupSize());
    m_variables.resize(m_family.groupSize());
    for(Integer i = 0; i < m_family.groupSize(); ++i)
      m_variables[i] = NULL; 
  }

  inline void notifyFamilyIsIncreased() {
    // Si la famille est agrandie, on retaille simplement
    const Integer old_size = m_values.size();
    ARCANE_ASSERT((old_size < m_family.groupSize()),("Old size greater than new size!"));
    m_values.resize(m_family.groupSize());
    m_variables.resize(m_family.groupSize());
    for(Integer i = old_size; i < m_family.groupSize(); ++i)
      m_variables[i] = NULL; 
  }
  
private:
  
  inline void _insertVariable(ItemGroup group, ArrayView<DataType> v) 
  {
    if(m_family.isPartial(group))
      throw FatalErrorException(String::format("Group '{0}' defined partial",group.name())); 
    m_values[m_family.groupIndex(group)] = v;
  }
 
  inline void _insertPartialVariable(ItemGroup group, ArrayView<DataType> v) 
  {
    if(not m_family.isPartial(group))
      throw FatalErrorException(String::format("Group '{0}' not defined partial",group.name())); 
    m_values[m_family.groupIndex(group)] = v;
  }
  
  inline void _insertInternalVariable(ItemGroup group, IVariable* v) 
  {
    m_variables[m_family.groupIndex(group)] = v;
  }
 
private:
  
  const Family m_family;

  Arcane::UniqueArray< ArrayView<DataType> > m_values;

  Arcane::UniqueArray< IVariable* > m_variables;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::AnyItem
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif /* ARCANE_ANYITEMS_ANYITEMVARIABLE_H */