Item.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Item.h                                                      (C) 2000-2024 */
/*                                                                           */
/* 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 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:
 
  Item(Int32 local_id,ItemSharedInfo* shared_info)
  : m_shared_info(shared_info), m_local_id(local_id) {}
 
 public:
 
  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
  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);
  }
 
 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); }
 
 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>;
 
 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>;
 
 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); }
 
  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>;
 
 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>;
 
 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>;
 
 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>;
 
 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>;
 
 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);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/ItemCompatibility.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif