Item.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Item.h                                                      (C) 2000-2025 */
/*                                                                           */
/* Informations sur les éléments du maillage.                                */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_ITEM_H
#define ARCANE_CORE_ITEM_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/ItemTypes.h"
#include "arcane/core/ItemInternal.h"
#include "arcane/core/ItemLocalId.h"
 
#include <atomic>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
// Macro pour vérifier en mode Check que les conversions entre les
// les genres d'entités sont correctes.
#ifdef ARCANE_CHECK
#define ARCANE_CHECK_KIND(type) _checkKind(type())
#else
#define ARCANE_CHECK_KIND(type)
#endif
 
#ifdef ARCANE_CHECK
#define ARCANE_WANT_ITEM_STAT
#endif
 
#ifdef ARCANE_WANT_ITEM_STAT
#define ARCANE_ITEM_ADD_STAT(var) ++var
#else
#define ARCANE_ITEM_ADD_STAT(var)
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT Item
{
  // Pour accéder aux constructeurs privés
  friend class ItemEnumeratorBaseT<Item>;
  friend class ItemConnectedEnumeratorBaseT<Item>;
  friend class ItemVector;
  friend class ItemVectorView;
  friend class ItemVectorViewConstIterator;
  friend class ItemConnectedListViewConstIterator;
  friend class SimdItem;
  friend class SimdItemEnumeratorBase;
  friend class ItemInfoListView;
  friend class ItemLocalIdToItemConverter;
  template<typename ItemType> friend class ItemLocalIdToItemConverterT;
  friend class ItemPairEnumerator;
  template<int Extent> friend class ItemConnectedListView;
  template<typename ItemType> friend class ItemEnumeratorBaseT;
 
  // Pour accéder à _internal()
  friend class ItemCompatibility;
 
 public:
 
  typedef ItemInternal* ItemInternalPtr;
  
  typedef ItemLocalId LocalIdType;
 
  using ItemBase = impl::ItemBase;
 
 public:

   */
  class Index
  {
    // TODO Rendre obsolète lorsqu'on aura supprimer
    // les classes dérivées qui sont obsolètes.
    // On ne peut pas le faire avant car cela génère trop
    // d'avertissements de compilation.
   public:
    Index() : m_local_id(NULL_ITEM_LOCAL_ID){}
    explicit Index(Int32 id) : m_local_id(id){}
    Index(Item item) : m_local_id(item.localId()){}
    operator ItemLocalId() const { return ItemLocalId{m_local_id}; }
   public:
    Int32 localId() const { return m_local_id; }
   private:
    Int32 m_local_id;
  };
 
 public:

  enum
  {
    Unknown ARCANE_DEPRECATED_REASON("Use 'IT_NullType' instead") = IT_NullType, 
    Vertex ARCANE_DEPRECATED_REASON("Use 'IT_Vertex' instead") = IT_Vertex, 
    Bar2 ARCANE_DEPRECATED_REASON("Use 'IT_Line2' instead") = IT_Line2, 
    Tri3 ARCANE_DEPRECATED_REASON("Use 'IT_Triangle3' instead") = IT_Triangle3, 
    Quad4 ARCANE_DEPRECATED_REASON("Use 'IT_Quad4' instead") = IT_Quad4, 
    Pentagon5 ARCANE_DEPRECATED_REASON("Use 'IT_Pentagon5' instead") = IT_Pentagon5, 
    Hexagon6 ARCANE_DEPRECATED_REASON("Use 'IT_Hexagon6' instead") = IT_Hexagon6, 
    Tetra ARCANE_DEPRECATED_REASON("Use 'IT_Tetraedron4' instead") = IT_Tetraedron4, 
    Pyramid ARCANE_DEPRECATED_REASON("Use 'IT_Pyramid5' instead") = IT_Pyramid5, 
    Penta ARCANE_DEPRECATED_REASON("Use 'IT_Pentaedron6' instead") = IT_Pentaedron6, 
    Hexa ARCANE_DEPRECATED_REASON("Use 'IT_Hexaedron8' instead") = IT_Hexaedron8, 
    Wedge7 ARCANE_DEPRECATED_REASON("Use 'IT_Heptaedron10' instead") = IT_Heptaedron10, 
    Wedge8 ARCANE_DEPRECATED_REASON("Use 'IT_Octaedron12' instead") = IT_Octaedron12 
    // Réduit au minimum pour compatibilité.
  };

  static const Int32 NULL_ELEMENT = NULL_ITEM_ID;

  ARCCORE_DEPRECATED_2021("Use ItemTypeMng::typeName() instead")
  static String typeName(Int32 type);
 
 protected:

  constexpr ARCCORE_HOST_DEVICE Item(Int32 local_id,ItemSharedInfo* shared_info)
  : m_shared_info(shared_info), m_local_id(local_id) {}
 
 public:

  //! Création d'une entité de maillage nulle
  Item() = default;

  //ARCANE_DEPRECATED_REASON("Remove this overload")
  Item(ItemInternal* ainternal)
  {
    ARCANE_CHECK_PTR(ainternal);
    m_shared_info = ainternal->m_shared_info;
    m_local_id  = ainternal->m_local_id;
    ARCANE_ITEM_ADD_STAT(m_nb_created_from_internal);
  }
 
  // NOTE: Pour le constructeur suivant; il est indispensable d'utiliser
  // const& pour éviter une ambiguité avec le constructeur par recopie
  constexpr ARCCORE_HOST_DEVICE Item(const ItemBase& abase)
  : m_shared_info(abase.m_shared_info)
  , m_local_id(abase.m_local_id)
  {
  }

  Item(const ItemInternalPtr* internals,Int32 local_id)
  : Item(local_id,internals[local_id]->m_shared_info)
  {
    ARCANE_ITEM_ADD_STAT(m_nb_created_from_internalptr);
  }

  Item& operator=(ItemInternal* ainternal)
  {
    _set(ainternal);
    return (*this);
  }
 
 public:

  constexpr bool null() const { return m_local_id==NULL_ITEM_ID; }

  constexpr Int32 localId() const { return m_local_id; }

  constexpr ItemLocalId itemLocalId() const { return ItemLocalId{ m_local_id }; }

  ItemUniqueId uniqueId() const
  {
#ifdef ARCANE_CHECK
    if (m_local_id!=NULL_ITEM_LOCAL_ID)
      arcaneCheckAt((Integer)m_local_id,m_shared_info->m_unique_ids.size());
#endif
    // Ne pas utiliser l'accesseur normal car ce tableau peut etre utilise pour la maille
    // nulle et dans ce cas m_local_id vaut NULL_ITEM_LOCAL_ID (qui est negatif)
    // ce qui provoque une exception pour debordement de tableau.
    return ItemUniqueId(m_shared_info->m_unique_ids.data()[m_local_id]);
  }

  Int32 owner() const { return m_shared_info->_ownerV2(m_local_id); }

  Int16 type() const { return m_shared_info->_typeId(m_local_id); }

  ItemTypeId itemTypeId() const { return ItemTypeId(type()); }

  IItemFamily* itemFamily() const { return m_shared_info->m_item_family; }

  eItemKind kind() const { return m_shared_info->m_item_kind; }

  bool isOwn() const { return (_flags() & ItemFlags::II_Own)!=0; }

  bool isShared() const { return (_flags() & ItemFlags::II_Shared)!=0; }

  inline ItemWithNodes toItemWithNodes() const;
  inline Node toNode() const;
  inline Cell toCell() const;
  inline Edge toEdge() const;
  inline Face toFace() const;
  inline Particle toParticle() const;
  inline DoF toDoF() const;

  Int32 nbParent() const { return _nbParent(); }

  Item parent(Int32 i) const { return m_shared_info->_parentV2(m_local_id,i); }

  Item parent() const { return m_shared_info->_parentV2(m_local_id,0); }
 
 public:

  bool isItemWithNodes() const
  {
    eItemKind ik = kind();
    return (ik==IK_Unknown || ik==IK_Edge || ik==IK_Face || ik==IK_Cell );
  }

  bool isNode() const
  {
    eItemKind ik = kind();
    return (ik==IK_Unknown || ik==IK_Node);
  }

  bool isCell() const
  {
    eItemKind ik = kind();
    return (ik==IK_Unknown || ik==IK_Cell);
  }

  bool isEdge() const
  {
    eItemKind ik = kind();
    return (ik==IK_Unknown || ik==IK_Edge);
  }

  bool isFace() const
  {
    eItemKind ik = kind();
    return (ik==IK_Unknown || ik==IK_Face);
  }

  bool isParticle() const
  {
    eItemKind ik = kind();
    return (ik==IK_Unknown || ik==IK_Particle);
  }

  bool isDoF() const
  {
    eItemKind ik = kind();
    return (ik==IK_Unknown || ik==IK_DoF);
  }

  bool hasFlags(Int32 flags) const { return (_flags() & flags); }

  Int32 flags() const { return m_shared_info->_flagsV2(m_local_id); }
 
 public:

  ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane. use itemBase() or mutableItemBase() instead")
  ItemInternal* internal() const
  {
    if (m_local_id!=NULL_ITEM_LOCAL_ID)
      return m_shared_info->m_items_internal[m_local_id];
    return ItemInternal::nullItem();
  }
 
 public:

  impl::ItemBase itemBase() const
  {
    return impl::ItemBase(m_local_id,m_shared_info);
  }

  impl::MutableItemBase mutableItemBase() const
  {
    return impl::MutableItemBase(m_local_id,m_shared_info);
  }

  const ItemTypeInfo* typeInfo() const { return m_shared_info->typeInfoFromId(type()); }
 
 public:
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  Item* operator->() { return this; }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  const Item* operator->() const { return this; }
 
 private:

  ItemSharedInfo* m_shared_info = ItemSharedInfo::nullItemSharedInfoPointer;
 
 protected:

  Int32 m_local_id = NULL_ITEM_LOCAL_ID;
 
 protected:
 
  void _checkKind(bool is_valid) const
  {
    if (!is_valid)
      _badConversion();
  }
  void _badConversion() const;
  void _set(ItemInternal* ainternal)
  {
    _setFromInternal(ainternal);
  }
  void _set(const Item& rhs)
  {
    _setFromItem(rhs);
  }
 
 protected:

  Int32 _flags() const { return m_shared_info->_flagsV2(m_local_id); }
  Integer _nbNode() const { return _connectivity()->_nbNodeV2(m_local_id); }
  Integer _nbEdge() const { return _connectivity()->_nbEdgeV2(m_local_id); }
  Integer _nbFace() const { return _connectivity()->_nbFaceV2(m_local_id); }
  Integer _nbCell() const { return _connectivity()->_nbCellV2(m_local_id); }
  Int32 _nbHParent() const { return _connectivity()->_nbHParentV2(m_local_id); }
  Int32 _nbHChildren() const { return _connectivity()->_nbHChildrenV2(m_local_id); }
  Integer _nbParent() const { return m_shared_info->nbParent(); }
  NodeLocalId _nodeId(Int32 index) const { return NodeLocalId(_connectivity()->_nodeLocalIdV2(m_local_id,index)); }
  EdgeLocalId _edgeId(Int32 index) const { return EdgeLocalId(_connectivity()->_edgeLocalIdV2(m_local_id,index)); }
  FaceLocalId _faceId(Int32 index) const { return FaceLocalId(_connectivity()->_faceLocalIdV2(m_local_id,index)); }
  CellLocalId _cellId(Int32 index) const { return CellLocalId(_connectivity()->_cellLocalIdV2(m_local_id,index)); }
  Int32 _hParentId(Int32 index) const { return _connectivity()->_hParentLocalIdV2(m_local_id,index); }
  Int32 _hChildId(Int32 index) const { return _connectivity()->_hChildLocalIdV2(m_local_id,index); }
  impl::ItemIndexedListView<DynExtent> _nodeList() const { return _connectivity()->nodeList(m_local_id); }
  impl::ItemIndexedListView<DynExtent> _edgeList() const { return _connectivity()->edgeList(m_local_id); }
  impl::ItemIndexedListView<DynExtent> _faceList() const { return _connectivity()->faceList(m_local_id); }
  impl::ItemIndexedListView<DynExtent> _cellList() const { return _connectivity()->cellList(m_local_id); }
  NodeLocalIdView _nodeIds() const { return _connectivity()->nodeLocalIdsView(m_local_id); }
  EdgeLocalIdView _edgeIds() const { return _connectivity()->edgeLocalIdsView(m_local_id); }
  FaceLocalIdView _faceIds() const { return _connectivity()->faceLocalIdsView(m_local_id); }
  CellLocalIdView _cellIds() const { return _connectivity()->cellLocalIdsView(m_local_id); }
 
  inline Node _node(Int32 index) const;
  inline Edge _edge(Int32 index) const;
  inline Face _face(Int32 index) const;
  inline Cell _cell(Int32 index) const;
 
  ItemBase _hParentBase(Int32 index) const { return _connectivity()->hParentBase(m_local_id, index, m_shared_info); }
  ItemBase _hChildBase(Int32 index) const { return _connectivity()->hChildBase(m_local_id, index, m_shared_info); }
  ItemBase _toItemBase() const { return ItemBase(m_local_id,m_shared_info); }

  Int32 _nbLinearNode() const { return itemBase()._nbLinearNode(); }
 
 private:
 
  ItemInternalConnectivityList* _connectivity() const
  {
    return m_shared_info->m_connectivity;
  }
  void _setFromInternal(ItemBase* rhs)
  {
    ARCANE_ITEM_ADD_STAT(m_nb_set_from_internal);
    m_local_id = rhs->m_local_id;
    m_shared_info = rhs->m_shared_info;
  }
  void _setFromItem(const Item& rhs)
  {
    m_local_id = rhs.m_local_id;
    m_shared_info = rhs.m_shared_info;
  }
 
 public:
 
  static void dumpStats(ITraceMng* tm);
  static void resetStats();
 
 private:
 
  static std::atomic<int> m_nb_created_from_internal;
  static std::atomic<int> m_nb_created_from_internalptr;
  static std::atomic<int> m_nb_set_from_internal;
 
 private:
 
  ItemInternal* _internal() const
  {
    if (m_local_id!=NULL_ITEM_LOCAL_ID)
      return m_shared_info->m_items_internal[m_local_id];
    return ItemInternal::nullItem();
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
inline bool
operator==(const Item& item1,const Item& item2)
{
  return item1.localId()==item2.localId();
}

inline bool
operator!=(const Item& item1,const Item& item2)
{
  return item1.localId()!=item2.localId();
}

inline bool
operator<(const Item& item1,const Item& item2)
{
  return item1.localId()<item2.localId();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/ItemVectorView.h"
#include "arcane/ItemConnectedListView.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT Node
: public Item
{
  using ThatClass = Node;
  // Pour accéder aux constructeurs privés
  friend class ItemEnumeratorBaseT<ThatClass>;
  friend class ItemConnectedEnumeratorBaseT<ThatClass>;
  friend class ItemVectorT<ThatClass>;
  friend class ItemVectorViewT<ThatClass>;
  friend class ItemConnectedListViewT<ThatClass>;
  friend class ItemVectorViewConstIteratorT<ThatClass>;
  friend class ItemConnectedListViewConstIteratorT<ThatClass>;
  friend class SimdItemT<ThatClass>;
  friend class ItemInfoListViewT<ThatClass>;
  friend class ItemLocalIdToItemConverterT<ThatClass>;
 
 public:
  
  class ARCANE_DEPRECATED_REASON("Y2024: Use NodeLocalId instead") Index
  : public Item::Index
  {
   public:
    typedef Item::Index Base;
   public:
    explicit Index(Int32 id) : Base(id){}
    Index(Node item) : Base(item){}
    operator NodeLocalId() const { return NodeLocalId{localId()}; }
  };
 
 protected:

  Node(Int32 local_id,ItemSharedInfo* shared_info)
  : Item(local_id,shared_info) {}
 
 public:

  typedef NodeLocalId LocalIdType;

  Node() = default;

  Node(ItemInternal* ainternal) : Item(ainternal)
  { ARCANE_CHECK_KIND(isNode); }

  Node(const ItemBase& abase) : Item(abase)
  { ARCANE_CHECK_KIND(isNode); }

  explicit Node(const Item& aitem) : Item(aitem)
  { ARCANE_CHECK_KIND(isNode); }

  Node(const ItemInternalPtr* internals,Int32 local_id) : Item(internals,local_id)
  { ARCANE_CHECK_KIND(isNode); }

  Node& operator=(ItemInternal* ainternal)
  {
    _set(ainternal);
    return (*this);
  }
 
 public:

  NodeLocalId itemLocalId() const { return NodeLocalId{ m_local_id }; }

  Int32 nbEdge() const { return _nbEdge(); }

  Int32 nbFace() const { return _nbFace(); }

  Int32 nbCell() const { return _nbCell(); }

  inline Edge edge(Int32 i) const;

  inline Face face(Int32 i) const;

  inline Cell cell(Int32 i) const;

  EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }

  FaceLocalId faceId(Int32 i) const { return _faceId(i); }

  CellLocalId cellId(Int32 i) const { return _cellId(i); }

  EdgeConnectedListViewType edges() const { return _edgeList(); }

  FaceConnectedListViewType faces() const { return _faceList(); }

  CellConnectedListViewType cells() const { return _cellList(); }

  EdgeLocalIdView edgeIds() const { return _edgeIds(); }

  FaceLocalIdView faceIds() const { return _faceIds(); }

  CellLocalIdView cellIds() const { return _cellIds(); }
 
  // AMR

  CellVectorView _internalActiveCells(Int32Array& local_ids) const
  {
    return _toItemBase()._internalActiveCells2(local_ids);
  }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  Node* operator->() { return this; }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  const Node* operator->() const { return this; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline Node Item::
_node(Int32 index) const
{
  return Node(_connectivity()->nodeBase(m_local_id,index));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT ItemWithNodes
: public Item
{
  using ThatClass = ItemWithNodes;
  // Pour accéder aux constructeurs privés
  friend class ItemEnumeratorBaseT<ThatClass>;
  friend class ItemConnectedEnumeratorBaseT<ThatClass>;
  friend class ItemVectorT<ThatClass>;
  friend class ItemVectorViewT<ThatClass>;
  friend class ItemConnectedListViewT<ThatClass>;
  friend class ItemVectorViewConstIteratorT<ThatClass>;
  friend class ItemConnectedListViewConstIteratorT<ThatClass>;
  friend class SimdItemT<ThatClass>;
  friend class ItemInfoListViewT<ThatClass>;
  friend class ItemLocalIdToItemConverterT<ThatClass>;
 
 protected:

  ItemWithNodes(Int32 local_id,ItemSharedInfo* shared_info)
  : Item(local_id,shared_info) {}
 
 public:
  
  ItemWithNodes() = default;

  ItemWithNodes(ItemInternal* ainternal) : Item(ainternal)
  { ARCANE_CHECK_KIND(isItemWithNodes); }

  ItemWithNodes(const ItemBase& abase) : Item(abase)
  { ARCANE_CHECK_KIND(isItemWithNodes); }

  explicit ItemWithNodes(const Item& aitem) : Item(aitem)
  { ARCANE_CHECK_KIND(isItemWithNodes); }

  ItemWithNodes(const ItemInternalPtr* internals,Int32 local_id)
  : Item(internals,local_id)
  { ARCANE_CHECK_KIND(isItemWithNodes); }

  ItemWithNodes& operator=(ItemInternal* ainternal)
  {
    _set(ainternal);
    return (*this);
  }
 
 public:

  Int32 nbNode() const { return _nbNode(); }

  Node node(Int32 i) const { return _node(i); }

  NodeConnectedListViewType nodes() const { return _nodeList(); }

  NodeLocalIdView nodeIds() const { return _nodeIds(); }

  NodeLocalId nodeId(Int32 index) const { return _nodeId(index); }

  Int32 nbLinearNode() const { return _nbLinearNode(); }
 
 public:
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  ItemWithNodes* operator->() { return this; }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  const ItemWithNodes* operator->() const { return this; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT Edge
: public ItemWithNodes
{
  using ThatClass = Edge;
  // Pour accéder aux constructeurs privés
  friend class ItemEnumeratorBaseT<ThatClass>;
  friend class ItemConnectedEnumeratorBaseT<ThatClass>;
  friend class ItemVectorT<ThatClass>;
  friend class ItemVectorViewT<ThatClass>;
  friend class ItemConnectedListViewT<ThatClass>;
  friend class ItemVectorViewConstIteratorT<ThatClass>;
  friend class ItemConnectedListViewConstIteratorT<ThatClass>;
  friend class SimdItemT<ThatClass>;
  friend class ItemInfoListViewT<ThatClass>;
  friend class ItemLocalIdToItemConverterT<ThatClass>;
 
 public:

  class ARCANE_DEPRECATED_REASON("Y2024: Use EdgeLocalId instead") Index
  : public Item::Index
  {
   public:
    typedef Item::Index Base;
   public:
    explicit Index(Int32 id) : Base(id){}
    Index(Edge item) : Base(item){}
    operator EdgeLocalId() const { return EdgeLocalId{localId()}; }
  };
 
  private:

  Edge(Int32 local_id,ItemSharedInfo* shared_info)
  : ItemWithNodes(local_id,shared_info) {}
 
 public:

  typedef EdgeLocalId LocalIdType;

  Edge() = default;

  Edge(ItemInternal* ainternal) : ItemWithNodes(ainternal)
  { ARCANE_CHECK_KIND(isEdge); }

  Edge(const ItemBase& abase) : ItemWithNodes(abase)
  { ARCANE_CHECK_KIND(isEdge); }

  explicit Edge(const Item& aitem) : ItemWithNodes(aitem)
  { ARCANE_CHECK_KIND(isEdge); }

  Edge(const ItemInternalPtr* internals,Int32 local_id)
  : ItemWithNodes(internals,local_id)
  { ARCANE_CHECK_KIND(isEdge); }

  Edge& operator=(ItemInternal* ainternal)
  {
    _set(ainternal);
    return (*this);
  }
 
 public:

  EdgeLocalId itemLocalId() const { return EdgeLocalId{ m_local_id }; }

  Int32 nbNode() const { return 2; }

  Int32 nbFace() const { return _nbFace(); }

  Int32 nbCell() const { return _nbCell(); }

  inline Cell cell(Int32 i) const;

  CellConnectedListViewType cells() const { return _cellList(); }

  CellLocalId cellId(Int32 i) const { return _cellId(i); }

  CellLocalIdView cellIds() const { return _cellIds(); }

  inline Face face(Int32 i) const;

  FaceConnectedListViewType faces() const { return _faceList(); }

  FaceLocalId faceId(Int32 i) const { return _faceId(i); }

  FaceLocalIdView faceIds() const { return _faceIds(); }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  Edge* operator->() { return this; }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  const Edge* operator->() const { return this; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline Edge Item::
_edge(Int32 index) const
{
  return Edge(_connectivity()->edgeBase(m_local_id,index));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT Face
: public ItemWithNodes
{
  using ThatClass = Face;
  // Pour accéder aux constructeurs privés
  friend class ItemEnumeratorBaseT<ThatClass>;
  friend class ItemConnectedEnumeratorBaseT<ThatClass>;
  friend class ItemVectorT<ThatClass>;
  friend class ItemVectorViewT<ThatClass>;
  friend class ItemConnectedListViewT<ThatClass>;
  friend class ItemVectorViewConstIteratorT<ThatClass>;
  friend class ItemConnectedListViewConstIteratorT<ThatClass>;
  friend class SimdItemT<ThatClass>;
  friend class ItemInfoListViewT<ThatClass>;
  friend class ItemLocalIdToItemConverterT<ThatClass>;
 
 public:

  class ARCANE_DEPRECATED_REASON("Y2024: Use FaceLocalId instead") Index
  : public Item::Index
  {
   public:
    typedef Item::Index Base;
   public:
    explicit Index(Int32 id) : Base(id){}
    Index(Face item) : Base(item){}
    operator FaceLocalId() const { return FaceLocalId{localId()}; }
  };
 
 private:

  Face(Int32 local_id,ItemSharedInfo* shared_info)
  : ItemWithNodes(local_id,shared_info) {}
 
 public:

  typedef FaceLocalId LocalIdType;

  Face() = default;

  Face(ItemInternal* ainternal) : ItemWithNodes(ainternal)
  { ARCANE_CHECK_KIND(isFace); }

  Face(const ItemBase& abase) : ItemWithNodes(abase)
  { ARCANE_CHECK_KIND(isFace); }

  explicit Face(const Item& aitem) : ItemWithNodes(aitem)
  { ARCANE_CHECK_KIND(isFace); }

  Face(const ItemInternalPtr* internals,Int32 local_id)
  : ItemWithNodes(internals,local_id)
  { ARCANE_CHECK_KIND(isFace); }

  Face& operator=(ItemInternal* ainternal)
  {
    _set(ainternal);
    return (*this);
  }
 
 public:

  FaceLocalId itemLocalId() const { return FaceLocalId{ m_local_id }; }

  Int32 nbCell() const { return _nbCell(); }

  inline Cell cell(Int32 i) const;

  CellConnectedListViewType cells() const { return _cellList(); }

  CellLocalId cellId(Int32 i) const { return _cellId(i); }

  CellLocalIdView cellIds() const { return _cellIds(); }

  bool isSubDomainBoundary() const { return (_flags() & ItemFlags::II_Boundary)!=0; }

  ARCANE_DEPRECATED_118 bool isBoundary() const { return isSubDomainBoundary(); }

  bool isSubDomainBoundaryOutside() const
  {
    return isSubDomainBoundary() && (_flags() & ItemFlags::II_HasBackCell);
  }

  ARCANE_DEPRECATED_118 bool isBoundaryOutside() const
  {
    return isSubDomainBoundaryOutside();
  }

  inline Cell boundaryCell() const;

  inline Cell backCell() const;

  CellLocalId backCellId() const { return CellLocalId(_toItemBase().backCellId()); }

  inline Cell frontCell() const;

  CellLocalId frontCellId() const { return CellLocalId(_toItemBase().frontCellId()); }

  inline Cell oppositeCell(Cell cell) const;

  CellLocalId oppositeCellId(CellLocalId cell_id) const
  {
    ARCANE_ASSERT((backCellId()==cell_id || frontCellId()==cell_id),("cell is not connected to the face"));
    return (backCellId()==cell_id) ? frontCellId() : backCellId();
  }

  Face masterFace() const { return _toItemBase().masterFace(); }

  bool isMasterFace() const { return _toItemBase().isMasterFace(); }

  bool isSlaveFace() const { return _toItemBase().isSlaveFace(); }

  bool isTiedFace() const { return isSlaveFace() || isMasterFace(); }

  FaceConnectedListViewType slaveFaces() const
  {
    if (_toItemBase().isMasterFace())
      return _faceList();
    return FaceConnectedListViewType();
  }
 
 public:

  Int32 nbEdge() const { return _nbEdge(); }

  Edge edge(Int32 i) const { return _edge(i); }

  EdgeConnectedListViewType edges() const { return _edgeList(); }

  EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }

  EdgeLocalIdView edgeIds() const { return _edgeIds(); }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  Face* operator->() { return this; }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  const Face* operator->() const { return this; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline Face Item::
_face(Int32 index) const
{
  return Face(_connectivity()->faceBase(m_local_id,index));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT Cell
: public ItemWithNodes
{
  using ThatClass = Cell;
  // Pour accéder aux constructeurs privés
  friend class ItemEnumeratorBaseT<ThatClass>;
  friend class ItemConnectedEnumeratorBaseT<ThatClass>;
  friend class ItemVectorT<ThatClass>;
  friend class ItemVectorViewT<ThatClass>;
  friend class ItemConnectedListViewT<ThatClass>;
  friend class ItemVectorViewConstIteratorT<ThatClass>;
  friend class ItemConnectedListViewConstIteratorT<ThatClass>;
  friend class SimdItemT<ThatClass>;
  friend class ItemInfoListViewT<ThatClass>;
  friend class ItemLocalIdToItemConverterT<ThatClass>;
 
 public:
  
  class ARCANE_DEPRECATED_REASON("Y2024: Use CellLocalId instead") Index
  : public Item::Index
  {
   public:
    typedef Item::Index Base;
   public:
    explicit Index(Int32 id) : Base(id){}
    Index(Cell item) : Base(item){}
    operator CellLocalId() const { return CellLocalId{localId()}; }
  };
 
 private:

  Cell(Int32 local_id,ItemSharedInfo* shared_info)
  : ItemWithNodes(local_id,shared_info) {}
 
 public:

  typedef CellLocalId LocalIdType;

  Cell() = default;

  Cell(ItemInternal* ainternal) : ItemWithNodes(ainternal)
  { ARCANE_CHECK_KIND(isCell); }

  Cell(const ItemBase& abase) : ItemWithNodes(abase)
  { ARCANE_CHECK_KIND(isCell); }

  explicit Cell(const Item& aitem) : ItemWithNodes(aitem)
  { ARCANE_CHECK_KIND(isCell); }

  Cell(const ItemInternalPtr* internals,Int32 local_id)
  : ItemWithNodes(internals,local_id)
  { ARCANE_CHECK_KIND(isCell); }

  Cell& operator=(ItemInternal* ainternal)
  {
    _set(ainternal);
    return (*this);
  }
 
 public:

  CellLocalId itemLocalId() const { return CellLocalId{ m_local_id }; }

  Int32 nbFace() const { return _nbFace(); }

  Face face(Int32 i) const { return _face(i); }

  FaceConnectedListViewType faces() const { return _faceList(); }

  FaceLocalId faceId(Int32 i) const { return _faceId(i); }

  FaceLocalIdView faceIds() const { return _faceIds(); }

  Int32 nbEdge() const { return _nbEdge(); }

  Edge edge(Int32 i) const { return _edge(i); }

  EdgeLocalId edgeId(Int32 i) const { return _edgeId(i); }

  EdgeConnectedListViewType edges() const { return _edgeList(); }

  EdgeLocalIdView edgeIds() const { return _edgeIds(); }

  Cell hParent() const { return Cell(_hParentBase(0)); }

  Int32 nbHParent() const { return _nbHParent(); }

  Int32 nbHChildren() const { return _nbHChildren(); }

  Cell hChild(Int32 i) const { return Cell(_hChildBase(i)); }

  Cell topHParent() const { return Cell(_toItemBase().topHParentBase()); }

  bool isActive() const { return _toItemBase().isActive(); }
 
  bool isSubactive() const { return _toItemBase().isSubactive(); }

  bool isAncestor() const { return _toItemBase().isAncestor(); }

  bool hasHChildren() const { return _toItemBase().hasHChildren(); }

  Int32 level() const
  {
    if (this->_nbHParent() == 0)
      return 0;
    return (this->_hParentBase(0).level() + 1);
  }

  Int32 whichChildAmI(const ItemInternal* iitem) const
  {
    return _toItemBase().whichChildAmI(iitem->localId());
  }

  Int32 whichChildAmI(CellLocalId local_id) const
  {
    return _toItemBase().whichChildAmI(local_id);
  }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  Cell* operator->() { return this; }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  const Cell* operator->() const { return this; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline Cell Item::
_cell(Int32 index) const
{
  return Cell(_connectivity()->cellBase(m_local_id,index));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class Particle
: public Item
{
  using ThatClass = Particle;
  // Pour accéder aux constructeurs privés
  friend class ItemEnumeratorBaseT<ThatClass>;
  friend class ItemConnectedEnumeratorBaseT<ThatClass>;
  friend class ItemVectorT<ThatClass>;
  friend class ItemVectorViewT<ThatClass>;
  friend class ItemConnectedListViewT<ThatClass>;
  friend class ItemVectorViewConstIteratorT<ThatClass>;
  friend class ItemConnectedListViewConstIteratorT<ThatClass>;
  friend class SimdItemT<ThatClass>;
  friend class ItemInfoListViewT<ThatClass>;
  friend class ItemLocalIdToItemConverterT<ThatClass>;
 
 private:

  Particle(Int32 local_id,ItemSharedInfo* shared_info)
  : Item(local_id,shared_info) {}
 
 public:
  
  typedef ParticleLocalId LocalIdType;

  Particle() = default;

  Particle(ItemInternal* ainternal) : Item(ainternal)
  { ARCANE_CHECK_KIND(isParticle); }

  Particle(const ItemBase& abase) : Item(abase)
  { ARCANE_CHECK_KIND(isParticle); }

  explicit Particle(const Item& aitem) : Item(aitem)
  { ARCANE_CHECK_KIND(isParticle); }

  Particle(const ItemInternalPtr* internals,Int32 local_id)
  : Item(internals,local_id)
  { ARCANE_CHECK_KIND(isParticle); }

  Particle& operator=(ItemInternal* ainternal)
  {
    _set(ainternal);
    return (*this);
  }
 
 public:

  ParticleLocalId itemLocalId() const { return ParticleLocalId{ m_local_id }; }

  Cell cell() const { return _cell(0); }

  CellLocalId cellId() const { return _cellId(0); }

  bool hasCell() const { return (_cellId(0).localId()!=NULL_ITEM_LOCAL_ID); }

  Cell cellOrNull() const
  {
    Int32 cell_local_id = _cellId(0).localId();
    if (cell_local_id==NULL_ITEM_LOCAL_ID)
      return Cell();
    return _cell(0);
  }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  Particle* operator->() { return this; }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  const Particle* operator->() const { return this; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class DoF
: public Item
{
  using ThatClass = DoF;
  // Pour accéder aux constructeurs privés
  friend class ItemEnumeratorBaseT<ThatClass>;
  friend class ItemConnectedEnumeratorBaseT<ThatClass>;
  friend class ItemVectorT<ThatClass>;
  friend class ItemVectorViewT<ThatClass>;
  friend class ItemConnectedListViewT<ThatClass>;
  friend class ItemVectorViewConstIteratorT<ThatClass>;
  friend class ItemConnectedListViewConstIteratorT<ThatClass>;
  friend class SimdItemT<ThatClass>;
  friend class ItemInfoListViewT<ThatClass>;
  friend class ItemLocalIdToItemConverterT<ThatClass>;
 
 private:

  DoF(Int32 local_id,ItemSharedInfo* shared_info)
  : Item(local_id,shared_info) {}
 
 
 public:
 
  using LocalIdType = DoFLocalId;

  DoF() = default;

  DoF(ItemInternal* ainternal) : Item(ainternal)
  { ARCANE_CHECK_KIND(isDoF); }

  DoF(const ItemBase& abase) : Item(abase)
  { ARCANE_CHECK_KIND(isDoF); }

  explicit DoF(const Item& aitem) : Item(aitem)
  { ARCANE_CHECK_KIND(isDoF); }

  DoF(const ItemInternalPtr* internals,Int32 local_id)
  : Item(internals,local_id)
  { ARCANE_CHECK_KIND(isDoF); }

  DoF& operator=(ItemInternal* ainternal)
  {
    _set(ainternal);
    return (*this);
  }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  DoF* operator->() { return this; }
 
  ARCANE_DEPRECATED_REASON("Y2022: Do not use this operator. Use operator '.' instead")
  const DoF* operator->() const { return this; }

  DoFLocalId itemLocalId() const { return DoFLocalId{ m_local_id }; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline Edge Node::
edge(Int32 i) const
{
  return _edge(i);
}
 
inline Face Node::
face(Int32 i) const
{
  return _face(i);
}
 
inline Cell Node::
cell(Int32 i) const
{
  return _cell(i);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline Face Edge::
face(Int32 i) const
{
  return _face(i);
}
 
inline Cell Edge::
cell(Int32 i) const
{
  return _cell(i);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline Cell Face::
boundaryCell() const
{
  return Cell(_toItemBase().boundaryCell());
}
 
inline Cell Face::
backCell() const
{
  return Cell(_toItemBase().backCell());
}
 
inline Cell Face::
frontCell() const
{
  return Cell(_toItemBase().frontCell());
}
 
inline Cell Face::
oppositeCell(Cell cell) const
{
  ARCANE_ASSERT((backCell()==cell || frontCell()==cell),("cell is not connected to the face"));
  return (backCell()==cell) ? frontCell() : backCell();
}
 
inline Cell Face::
cell(Int32 i) const
{
  return _cell(i);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline ItemWithNodes Item::
toItemWithNodes() const
{
  ARCANE_CHECK_KIND(isItemWithNodes);
  return ItemWithNodes(*this);
}
 
inline Node Item::
toNode() const
{
  ARCANE_CHECK_KIND(isNode);
  return Node(*this);
}
 
inline Edge Item::
toEdge() const
{
  ARCANE_CHECK_KIND(isEdge);
  return Edge(*this);
}
 
inline Face Item::
toFace() const
{
  ARCANE_CHECK_KIND(isFace);
  return Face(*this);
}
 
inline Cell Item::
toCell() const
{
  ARCANE_CHECK_KIND(isCell);
  return Cell(*this);
}
 
inline Particle Item::
toParticle() const
{
  ARCANE_CHECK_KIND(isParticle);
  return Particle(*this);
}
 
inline DoF Item::
toDoF() const
{
  ARCANE_CHECK_KIND(isDoF);
  return DoF(*this);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline ItemLocalId::
ItemLocalId(Item item)
: m_local_id(item.localId())
{
}
 
template<typename ItemType> inline ItemLocalIdT<ItemType>::
ItemLocalIdT(ItemType item)
: ItemLocalId(item.localId())
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline Item ItemInfoListView::
operator[](ItemLocalId local_id) const
{
  return Item(local_id.localId(), m_item_shared_info);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline Item ItemInfoListView::
operator[](Int32 local_id) const
{
  return Item(local_id, m_item_shared_info);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template<typename ItemType> inline ItemType ItemInfoListViewT<ItemType>::
operator[](ItemLocalId local_id) const
{
  return ItemType(local_id.localId(), m_item_shared_info);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template<typename ItemType> inline ItemType ItemInfoListViewT<ItemType>::
operator[](Int32 local_id) const
{
  return ItemType(local_id, m_item_shared_info);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline constexpr ARCCORE_HOST_DEVICE Item ItemLocalIdToItemConverter::
operator[](ItemLocalId local_id) const
{
  return Item(local_id.localId(), m_item_shared_info);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline constexpr ARCCORE_HOST_DEVICE Item ItemLocalIdToItemConverter::
operator[](Int32 local_id) const
{
  return Item(local_id, m_item_shared_info);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template<typename ItemType_> inline constexpr ARCCORE_HOST_DEVICE ItemType_
ItemLocalIdToItemConverterT<ItemType_>::
operator[](ItemLocalIdType local_id) const
{
  return ItemType(local_id.localId(), m_item_shared_info);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template<typename ItemType_> inline constexpr ARCCORE_HOST_DEVICE ItemType_
ItemLocalIdToItemConverterT<ItemType_>::
operator[](Int32 local_id) const
{
  return ItemType(local_id, m_item_shared_info);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/ItemCompatibility.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif