ItemVector.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemVector.h                                                (C) 2000-2024 */
/*                                                                           */
/* Vecteur d'entités de même genre.                                          */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_ITEMVECTOR_H
#define ARCANE_CORE_ITEMVECTOR_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/ItemEnumerator.h"
#include "arcane/core/ItemVectorView.h"
#include "arcane/core/IItemFamily.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT ItemVector
{
 public:
 
  using ItemType = Item;
 
 public:

  explicit ItemVector(IItemFamily* afamily);

  ItemVector(IItemFamily* afamily, Int32ConstArrayView local_ids);

  ItemVector(IItemFamily* afamily, Integer asize);

  ItemVector();
 
 public:

  operator ItemVectorView() const { return view(); }
 
 public:

  void setFamily(IItemFamily* afamily);

  void add(Int32 local_id) { m_local_ids.add(local_id); }

  void add(ConstArrayView<Int32> local_ids) { m_local_ids.addRange(local_ids); }

  void addItem(ItemLocalId local_id) { m_local_ids.add(local_id); }

  void addItem(Item item) { m_local_ids.add(item.localId()); }

  Int32 size() const { return m_local_ids.size(); }

  void reserve(Integer capacity) { m_local_ids.reserve(capacity); }

  void clear() { m_local_ids.clear(); }

  ItemVectorView view() const { return ItemVectorView(m_shared_info, m_local_ids, 0); }

  ArrayView<Int32> viewAsArray() { return m_local_ids.view(); }

  ConstArrayView<Int32> viewAsArray() const { return m_local_ids.constView(); }

  void removeAt(Int32 index) { m_local_ids.remove(index); }

  void resize(Integer new_size) { m_local_ids.resize(new_size); }

  ItemVector clone() { return ItemVector(m_family, m_local_ids.constView()); }

  Item operator[](Int32 index) const { return Item(m_local_ids[index], m_shared_info); }

  IItemFamily* family() const { return m_family; }

  ItemEnumerator enumerator() const { return ItemEnumerator(m_shared_info, m_local_ids); }
 
 protected:
 
  SharedArray<Int32> m_local_ids;
  IItemFamily* m_family = nullptr;
  ItemSharedInfo* m_shared_info = ItemSharedInfo::nullInstance();
 
 private:
 
  void _init();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <typename VectorItemType>
class ItemVectorT
: public ItemVector
{
 public:
 
  using ItemType = VectorItemType;
 
 public:

  ItemVectorT() = default;

  explicit ItemVectorT(IItemFamily* afamily)
  : ItemVector(afamily)
  {}

  ItemVectorT(IItemFamily* afamily, ConstArrayView<Int32> local_ids)
  : ItemVector(afamily, local_ids)
  {}

  ItemVectorT(const ItemVector& rhs)
  : ItemVector(rhs)
  {}

  ItemVectorT(IItemFamily* afamily, Integer asize)
  : ItemVector(afamily, asize)
  {}
 
 public:

  operator ItemVectorViewT<VectorItemType>() const { return view(); }
 
 public:

  ItemType operator[](Int32 index) const
  {
    return ItemType(m_local_ids[index], m_shared_info);
  }

  void addItem(ItemType item) { m_local_ids.add(item.localId()); }

  void addItem(ItemLocalIdT<ItemType> local_id) { m_local_ids.add(local_id); }

  ItemVectorViewT<ItemType> view() const
  {
    return ItemVectorViewT<ItemType>(m_shared_info, m_local_ids.constView(), 0);
  }

  ItemEnumeratorT<ItemType> enumerator() const
  {
    return ItemEnumeratorT<ItemType>(m_shared_info, m_local_ids);
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template <typename ItemType> inline ItemVectorViewT<ItemType>::
ItemVectorViewT(const ItemVectorT<ItemType>& rhs)
: ItemVectorView(rhs.view())
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif