ItemGroup.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemGroup.h                                                 (C) 2000-2025 */
/*                                                                           */
/* Mesh entity groups.                                                       */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_ITEMGROUP_H
#define ARCANE_ITEMGROUP_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/AutoRef.h"
#include "arcane/utils/Iterator.h"
 
#include "arcane/core/ItemGroupImpl.h"
#include "arcane/core/ItemTypes.h"
#include "arcane/core/ItemEnumerator.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ItemVectorView;
class IVariableSynchronizer;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
//NOTE: the more complete documentation is in ItemGroup.cc

class ARCANE_CORE_EXPORT ItemGroup
{
 public:

  ItemGroup();

  // TODO: this constructor should be explicit to avoid implicit conversions
  // but we haven't added it yet for compatibility reasons
  /*explicit*/ ItemGroup(ItemGroupImpl* prv);
  ItemGroup(const ItemGroup& from)
  : m_impl(from.m_impl)
  {}

  ItemGroup& operator=(const ItemGroup& from) = default;

  typedef ItemEnumerator const_iter;
 
 public:

  inline bool null() const
  {
    return m_impl->null();
  }

  inline const String& name() const
  {
    return m_impl->name();
  }

  inline const String& fullName() const
  {
    return m_impl->fullName();
  }

  inline Integer size() const
  {
    m_impl->_checkNeedUpdateNoPadding();
    return m_impl->size();
  }

  inline bool empty() const
  {
    m_impl->_checkNeedUpdateNoPadding();
    return m_impl->empty();
  }

  inline eItemKind itemKind() const { return m_impl->itemKind(); }
 
 public:

  ItemGroupImpl* internal() const { return m_impl.get(); }

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

  IMesh* mesh() const { return m_impl->mesh(); }
 
 public:
 
  // Items in the group owned by the subdomain
  ItemGroup own() const;
 
  // Items in the group not owned by the subdomain
  ItemGroup ghost() const;

  bool isOwn() const;

  void setOwn(bool v);
 
  // Items in the group lying on the boundary between two subdomains
  // Implemented for faces only
  ItemGroup interface() const;

  NodeGroup nodeGroup() const;

  EdgeGroup edgeGroup() const;

  FaceGroup faceGroup() const;

  CellGroup cellGroup() const;

  FaceGroup innerFaceGroup() const;

  FaceGroup outerFaceGroup() const;

  CellGroup activeCellGroup() const;

  CellGroup ownActiveCellGroup() const;

  CellGroup levelCellGroup(const Integer& level) const;

  CellGroup ownLevelCellGroup(const Integer& level) const;

  FaceGroup activeFaceGroup() const;

  FaceGroup ownActiveFaceGroup() const;

  FaceGroup innerActiveFaceGroup() const;

  FaceGroup outerActiveFaceGroup() const;


  ItemGroup createSubGroup(const String& suffix, IItemFamily* family, ItemGroupComputeFunctor* functor) const;

  ItemGroup findSubGroup(const String& suffix) const;

  bool isLocalToSubDomain() const
  {
    return m_impl->isLocalToSubDomain();
  }

  void setLocalToSubDomain(bool v)
  {
    m_impl->setLocalToSubDomain(v);
  }

  void invalidate(bool force_recompute = false) { m_impl->invalidate(force_recompute); }

  void addItems(Int32ConstArrayView items_local_id, bool check_if_present = true);

  void removeItems(Int32ConstArrayView items_local_id, bool check_if_present = true);

  void setItems(Int32ConstArrayView items_local_id);

  void setItems(Int32ConstArrayView items_local_id, bool do_sort);

  void checkValid();

  void clear();

  void applyOperation(IItemOperationByBasicType* operation) const;

  ItemVectorView view() const;

  bool isAllItems() const;

  Int64 timestamp() const
  {
    return m_impl->timestamp();
  }

  void incrementTimestamp() const;

  SharedPtrT<GroupIndexTable> localIdToIndex() const
  {
    return m_impl->localIdToIndex();
  }

  IVariableSynchronizer* synchronizer() const;

  bool isAutoComputed() const;

  bool hasSynchronizer() const;

  bool checkIsSorted() const;

  ItemVectorView _paddedView() const;

  ItemVectorView _unpaddedView() const;
 
 public:

  ItemGroupImplInternal* _internalApi() const;
 
 public:

  ItemEnumerator enumerator() const;
 
 private:
 
  template <typename T>
  friend class SimdItemEnumeratorContainerTraits;
  ItemEnumerator _simdEnumerator() const;
 
 protected:

  AutoRefT<ItemGroupImpl> m_impl;
 
 protected:

  static ItemGroupImpl* _check(ItemGroupImpl* impl, eItemKind ik)
  {
    return impl->itemKind() == ik ? impl : ItemGroupImpl::checkSharedNull();
  }
 
  ItemVectorView _view(bool do_padding) const;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

inline bool
operator==(const ItemGroup& g1, const ItemGroup& g2)
{
  return g1.internal() == g2.internal();
}

inline bool
operator<(const ItemGroup& g1, const ItemGroup& g2)
{
  return g1.internal() < g2.internal();
}

inline bool
operator!=(const ItemGroup& g1, const ItemGroup& g2)
{
  return g1.internal() != g2.internal();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <typename T>
class ItemGroupT
: public ItemGroup
{
 public:

  typedef ItemGroupT<T> ThatClass;
  typedef ItemTraitsT<T> TraitsType;
 
  typedef typename TraitsType::ItemType ItemType;
 
  typedef const ItemType* const_iterator;
  typedef ItemType* iterator;
  typedef ItemType value_type;
  typedef const ItemType& const_reference;
 
 public:
 
  inline ItemGroupT() = default;
  inline explicit ItemGroupT(ItemGroupImpl* from)
  : ItemGroup(_check(from, TraitsType::kind()))
  {}
  inline ItemGroupT(const ItemGroup& from)
  : ItemGroup(_check(from.internal(), TraitsType::kind()))
  {}
  inline ItemGroupT(const ItemGroupT<T>& from)
  : ItemGroup(from)
  {}
  inline const ItemGroupT<T>& operator=(const ItemGroupT<T>& from)
  {
    m_impl = from.internal();
    return (*this);
  }
  inline const ItemGroupT<T>& operator=(const ItemGroup& from)
  {
    _assign(from);
    return (*this);
  }
 
 public:
 
  ThatClass own() const
  {
    return ThatClass(ItemGroup::own());
  }
 
  ItemEnumeratorT<T> enumerator() const
  {
    return ItemEnumeratorT<T>::fromItemEnumerator(ItemGroup::enumerator());
  }
 
 protected:
 
  void _assign(const ItemGroup& from)
  {
    m_impl = _check(from.internal(), TraitsType::kind());
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif