ItemGroup.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemGroup.h                                                 (C) 2000-2024 */
/*                                                                           */
/* Groupes d'entités du maillage.                                            */
/*---------------------------------------------------------------------------*/
#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: la documentation plus complète est dans ItemGroup.cc
class ARCANE_CORE_EXPORT ItemGroup
{
 public:
  
  ItemGroup();
  // TODO: ce contructeur devrait être explicite pour éviter des conversions
  // implicites mais on le met pas encore pour des raisons de compatibilité
  /*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();
  }
  
  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