AnyItemArray.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* AnyItemArray.h                                              (C) 2000-2025 */
/*                                                                           */
/* Array of items of arbitrary types.                                        */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_ANYITEM_ANYITEMARRAY_H
#define ARCANE_CORE_ANYITEM_ANYITEMARRAY_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Array.h"
 
#include "arcane/core/IItemFamily.h"
#include "arcane/core/anyitem/AnyItemGlobal.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::AnyItem
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <typename DataType>
class Array
{
 public:
 
  Array(const Group& group)
  {
    for (Group::Enumerator e = group.enumerator(); e.hasNext(); ++e) {
      if (e.groupIndex() >= m_values.size())
        m_values.resize(e.groupIndex() + 1);
    }
    for (Group::Enumerator e = group.enumerator(); e.hasNext(); ++e) {
      m_values[e.groupIndex()].resize(e.group().itemFamily()->maxLocalId());
    }
  }

  void fill(const DataType& data)
  {
    for (Integer i = 0; i < m_values.size(); ++i) {
      m_values[i].fill(data);
    }
  }

  template <typename T>
  inline DataType& operator[](const T& item)
  {
    return m_values[item.groupIndex()][item.varIndex()];
  }
 
  // Accessor
  template <typename T>
  inline typename Arcane::UniqueArray<DataType>::ConstReferenceType operator[](const T& item) const
  {
    return m_values[item.groupIndex()][item.varIndex()];
  }
 
 private:

  Arcane::UniqueArray<Arcane::UniqueArray<DataType>> m_values;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::AnyItem
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif