ItemGroupImpl.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemGroupImpl.h                                             (C) 2000-2025 */
/*                                                                           */
/* Implementation of a mesh entity group.                                    */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_ITEMGROUPIMPL_H
#define ARCANE_ITEMGROUPIMPL_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/ItemTypes.h"
#include "arcane/core/SharedReference.h"
#include "arcane/utils/SharedPtr.h"
 
#include "arcane/core/GroupIndexTable.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
// Macro to detect design changes in 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 class ItemGroupSubPartsByType;
  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 { return isContiguousLocalIds(); }

  bool isContiguousLocalIds() const;

  void checkLocalIdsAreContigous() const { return checkLocalIdsAreContiguous(); }

  void checkLocalIdsAreContiguous() 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 _computeChildrenByType();
  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