ItemGroupImpl.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemGroupImpl.h                                             (C) 2000-2024 */
/*                                                                           */
/* Implémentation d'un groupe d'entités du maillage.                         */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_ITEMGROUPIMPL_H
#define ARCANE_ITEMGROUPIMPL_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/ItemTypes.h"
#include "arcane/SharedReference.h"
#include "arcane/utils/SharedPtr.h"
 
#include "arcane/GroupIndexTable.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
// Macro pour détecter les modifications de conception de ItemGroupImpl
#define ITEMGROUP_USE_OBSERVERS
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class IItemGroupObserver;
class IObservable;
class ItemGroupComputeFunctor;
class IMesh;
class ItemGroupInternal;
class ItemPairGroupImpl;
class GroupIndexTable;
class IVariableSynchronizer;
class ItemGroupImplInternal;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT ItemGroupImpl
: public SharedReference
{
 private:
 
  friend ItemGroup;
  class ItemSorter;
 
 public:
 
  ItemGroupImpl();
 
  ItemGroupImpl(IItemFamily* family,const String& name);
 
  ItemGroupImpl(IItemFamily* family,ItemGroupImpl* parent,const String& name);
 
  virtual ~ItemGroupImpl(); 
 
 private:
 
  static ItemGroupImpl* shared_null;
 
 public:
 
  static ItemGroupImpl* checkSharedNull();
 
 public:
 
  virtual ISharedReference& sharedReference() { return *this; }
 
 public:
 
  const String& name() const;
 
  const String& fullName() const;
 
  virtual Integer nbRef() const { return refCount(); }
 
  ItemGroupImpl* parent() const;
 
  bool null() const;
 
  bool isOwn() const;
 
  void setOwn(bool v);
 
  ItemGroupImpl* ownGroup();
 
  ItemGroupImpl* ghostGroup();
 
  // Items in the group lying on the boundary between two subdomains
  // Implemented for faces only
  ItemGroupImpl* interfaceGroup();
 
  ItemGroupImpl* nodeGroup();
 
  ItemGroupImpl* edgeGroup();
 
  ItemGroupImpl* faceGroup();
 
  ItemGroupImpl* cellGroup();
 
 
  ItemGroupImpl* createSubGroup(const String& suffix, IItemFamily* family, ItemGroupComputeFunctor* functor);
 
 
  ItemGroupImpl* findSubGroup(const String& suffix);
 
  ItemGroupImpl* innerFaceGroup();
 
  ItemGroupImpl* outerFaceGroup();
 
 
  ItemGroupImpl* activeCellGroup();
 
  ItemGroupImpl* ownActiveCellGroup();
 
  ItemGroupImpl* levelCellGroup(const Integer& level);
 
  ItemGroupImpl* ownLevelCellGroup(const Integer& level);
 
  ItemGroupImpl* activeFaceGroup();
 
  ItemGroupImpl* ownActiveFaceGroup();
 
  ItemGroupImpl* innerActiveFaceGroup();
 
  ItemGroupImpl* outerActiveFaceGroup();
 
 
  bool isLocalToSubDomain() const;
 
  void setLocalToSubDomain(bool v);
 
  IMesh* mesh() const;
 
  eItemKind itemKind() const;
 
  IItemFamily* itemFamily() const;
 
  Integer size() const;
 
  bool empty() const;
 
  void clear();
 
  ItemGroup parentGroup();
 
  void invalidate(bool force_recompute);
 
  void addItems(Int32ConstArrayView items_local_id,bool check_if_present);
 
  void setItems(Int32ConstArrayView items_local_id);
 
  void setItems(Int32ConstArrayView items_local_id,bool do_sort);
 
  void removeItems(Int32ConstArrayView items_local_id,bool check_if_present);
 
  void removeAddItems(Int32ConstArrayView removed_local_id,
                      Int32ConstArrayView added_local_id,
                      bool check_if_present);
 
  void removeSuppressedItems();
 
  void checkValid();
 
  bool checkNeedUpdate();
 
  Int32ConstArrayView itemsLocalId() const;
 
  void beginTransaction();
 
  void endTransaction();
 
  ARCANE_DEPRECATED_REASON("Y2022: Use itemInfoListView() instead")
  ItemInternalList itemsInternal() const;
 
  ItemInfoListView itemInfoListView() const;
 
  void setIsAllItems();
 
  bool isAllItems() const;
 
  void changeIds(Int32ConstArrayView old_to_new_ids);
 
  void applyOperation(IItemOperationByBasicType* operation);
 
  bool needSynchronization() const;
 
  Int64 timestamp() const;
 
  void attachObserver(const void * ref, IItemGroupObserver * obs);
 
  void detachObserver(const void * ref);
 
  bool hasInfoObserver() const;
 
  void setComputeFunctor(IFunctor* functor);
 
  bool hasComputeFunctor() const;
 
  void destroy();
 
  SharedPtrT<GroupIndexTable> localIdToIndex();
 
  IVariableSynchronizer* synchronizer();
  
  bool hasSynchronizer();
 
  bool checkIsSorted() const;
 
  bool isContigousLocalIds() const;
 
  void checkLocalIdsAreContigous() const;
 
  void shrinkMemory();
 
  Int64 capacity() const;
 
  ItemGroupImplInternal* _internalApi() const;
 
 public:
 
  ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane")
  Int32Array& unguardedItemsLocalId(const bool self_invalidate = true);
 
 
 public:
 
  static void _buildSharedNull();
  static void _destroySharedNull();
 
 private:
 
  void _initChildrenByType();
  void _computeChildrenByType();
  void _initChildrenByTypeV2();
  void _computeChildrenByTypeV2();
  void _executeExtend(const Int32ConstArrayView * info);
  void _executeReduce(const Int32ConstArrayView * info);
  void _executeCompact(const Int32ConstArrayView * info);
  void _executeReorder(const Int32ConstArrayView * info);
  void _executeInvalidate();
  void _updateNeedInfoFlag(const bool flag);
 
  void _forceInvalidate(const bool self_invalidate);
 
  void _checkUpdateSimdPadding();
  virtual void deleteMe();
 
 private:
 
 ItemGroupInternal* m_p = nullptr; 
 
 private:
 
  void _removeItems(SmallSpan<const Int32> items_local_id);
  bool _checkNeedUpdateNoPadding();
  bool _checkNeedUpdateWithPadding();
  bool _checkNeedUpdate(bool do_padding);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif