DynamicMeshKindInfos.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* DynamicMeshKindInfos.h                                      (C) 2000-2024 */
/*                                                                           */
/* Infos de maillage pour un genre d'entité donnée.                          */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_MESH_DYNAMICMESHKINDINFOS_H
#define ARCANE_MESH_DYNAMICMESHKINDINFOS_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Array.h"
#include "arcane/utils/String.h"
#include "arcane/utils/HashTableMap.h"
#include "arcane/utils/TraceAccessor.h"
 
#include "arcane/core/ItemGroup.h"
#include "arcane/core/ItemInternal.h"
#include "arcane/core/VariableTypedef.h"
 
#include "arcane/mesh/ItemInternalMap.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
class ItemFamilyCompactInfos;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::mesh
{
class ItemFamily;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_MESH_EXPORT DynamicMeshKindInfos
: public TraceAccessor
{
 public:
 
  // TODO: a supprimer
  typedef Arcane::mesh::ItemInternalMap ItemInternalMap;
 
 private:
 
  using ItemInternalMapData = ItemInternalMap::BaseData;
 
 public:
 
  DynamicMeshKindInfos(IMesh* mesh,eItemKind kind,const String& kind_name);
  ~DynamicMeshKindInfos();
 
 public:
 
  void build();
  
 
  void finalizeMeshChanged();
 
  Integer maxUsedLocalId() const { return m_internals.size(); }
 
  void prepareForDump();
 
  void readFromDump();
 
  ItemGroup allItems() const { return m_all_group; }
  
  Int32ConstArrayView addedItems  () const { return m_added_items;  }
  Int32ConstArrayView removedItems() const { return m_removed_items;}
 
 
  ConstArrayView<ItemInternal*> itemsInternal() const { return m_internals; }
 
  ItemInternal* itemInternal(Int32 local_id) const { return m_internals[local_id]; }
 
  ItemInternal* allocOne(Int64 unique_id)
  {
    bool need_alloc = false;
    ItemInternal* next = _allocOne(need_alloc);
    if (m_has_unique_id_map)
      if (!m_items_map.add(unique_id,next))
        _badSameUniqueId(unique_id);
    return next;
  }
 
  ItemInternal* allocOne(Int64 unique_id,bool& need_alloc)
  {
    ItemInternal* next = _allocOne(need_alloc);
    if (m_has_unique_id_map)
      if (!m_items_map.add(unique_id,next))
        _badSameUniqueId(unique_id);
    return next;
  }
 
  void removeOne(ItemInternal* item)
  {
#ifdef ARCANE_CHECK
    _checkActiveItem(item);
#endif
    _setSuppressed(item);
    if (m_has_unique_id_map){
      Int64 uid = item->uniqueId().asInt64();
      if (uid != NULL_ITEM_UNIQUE_ID)
        m_items_map.remove(uid);
    }
    m_free_internals.add(item->localId());
    m_removed_items.add(item->localId());
    --m_nb_item;
  }
 
  void removeDetachedOne(ItemInternal* item)
  {
#ifdef ARCANE_CHECK
    _checkActiveItem(item);
#endif
    _setSuppressed(item);
#ifndef REMOVE_UID_ON_DETACH
    if (m_has_unique_id_map)
      m_items_map.remove(item->uniqueId().asInt64());
#endif
    m_free_internals.add(item->localId());
    m_removed_items.add(item->localId());
    --m_nb_item;
  }
 
  void detachOne(ItemInternal* item)
  {
#ifdef ARCANE_CHECK
    _checkActiveItem(item);
#endif
    // Peut-être faut-il la marquer supprimée.
    //_setSuppressed(item);
#ifdef REMOVE_UID_ON_DETACH
    if (m_has_unique_id_map)
      m_items_map.remove(item->uniqueId().asInt64());
#endif /* REMOVE_UID_ON_DETACH */
    item->setDetached(true);
  }
 
  void removeMany(Int32ConstArrayView local_ids);
 
  ItemInternal* findOrAllocOne(Int64 uid,bool& is_alloc)
  {
#ifdef ARCANE_CHECK
    if (!m_has_unique_id_map)
      _badUniqueIdMap();
#endif
    ItemInternalMap::LookupData item_data = m_items_map._lookupAdd(uid, 0, is_alloc);
    if (is_alloc){
      bool need_alloc;
      item_data.setValue(_allocOne(need_alloc));
    }
    return item_data.value();
  }
 
  ItemInternal* findOne(Int64 uid)
  {
#ifdef ARCANE_CHECK
    if (!m_has_unique_id_map)
      _badUniqueIdMap();
#endif
    return m_items_map._tryFindItemInternal(uid);
  }
 
  void checkValid();
 
  ItemInternalMap& itemsMap() { return m_items_map; }
 
  Integer nbItem() const { return m_nb_item; }
 
  eItemKind kind() const { return m_kind; }
 
  bool changed() const
  { 
    return !m_added_items.empty() || !m_removed_items.empty();
  }
 
  void beginCompactItems(ItemFamilyCompactInfos& compact_infos);
 
  ARCANE_DEPRECATED_240 Int32ConstArrayView oldToNewLocalIds() const;
 
  void clear();
  
  ARCANE_DEPRECATED_240 Int32ConstArrayView newToOldLocalIds() const;
 
  void finishCompactItems(ItemFamilyCompactInfos& compact_infos);
 
  void itemsUniqueIdToLocalId(ArrayView<Int64> ids,bool do_fatal) const;
  void itemsUniqueIdToLocalId(Int32ArrayView local_ids,
                              Int64ConstArrayView unique_ids,
                              bool do_fatal) const;
  void itemsUniqueIdToLocalId(Int32ArrayView local_ids,
                              ConstArrayView<ItemUniqueId> unique_ids,
                              bool do_fatal) const;
 
  ItemFamily* itemFamily() const
  {
    return m_item_family;
  }
 
  void setItemFamily(ItemFamily* item_family);
 
  bool hasUniqueIdMap() const
  {
    return m_has_unique_id_map;
  }
  
  void setHasUniqueIdMap(bool v);
 
  void printFreeInternals(Integer max_print);
 
 private:
 
  ItemInternal* _allocOne(bool& need_alloc)
  {
    ItemInternal* new_item = 0;
    Integer nb_free = m_free_internals.size();
    Int32 lid = 0;
    if (nb_free!=0){
      new_item = m_internals[m_free_internals.back()];
      m_free_internals.popBack();
      _setAdded(new_item);
      lid = new_item->localId();
      need_alloc = false;
    }
    else{
      Integer nb_free2 = m_free_internals_in_multi_buffer.size();
      if (nb_free2!=0){
        new_item = m_free_internals_in_multi_buffer.back();
        m_free_internals_in_multi_buffer.popBack();
      }
      else
        new_item = m_item_internals_buffer->allocOne();
      lid = m_internals.size();
      new_item->setLocalId(lid);
      m_internals.add(new_item);
      _updateItemSharedInfoInternalView();
      need_alloc = true;
    }
    m_added_items.add(lid);
    ++m_nb_item;
    return new_item;
  }
 
 private:
 
  IMesh* m_mesh; 
  ItemFamily* m_item_family; 
  eItemKind m_kind; 
  String m_kind_name; 
  String m_all_group_name; 
  ItemInternalMap m_items_map; 
  ItemGroup m_all_group; 
  Integer m_nb_item; 
  bool m_is_verbose;
  Int32UniqueArray m_added_items;
  Int32UniqueArray m_removed_items;
  bool m_use_new_finalize;
  bool m_is_first_finalize;
  bool m_has_unique_id_map;
  ItemFamilyCompactInfos* m_compact_infos;
  ItemSharedInfo* m_common_item_shared_info = nullptr;
 
 public:
  
  UniqueArray<ItemInternal*> m_internals; 
  Int32UniqueArray m_free_internals; 
  UniqueArray<ItemInternal*> m_free_internals_in_multi_buffer;
 
 private:
 
  MultiBufferT<ItemInternal>* m_item_internals_buffer;
 
 private:
 
  inline void _setSuppressed(ItemInternal* item)
  {
    int f = item->flags();
    f &= ~ItemFlags::II_Added;
    f |= ItemFlags::II_Suppressed;
    item->setFlags(f);
  }
 
  inline void _setAdded(ItemInternal* item)
  {
    int f = item->flags();
    f |= ItemFlags::II_Added;
    f &= ~ItemFlags::II_Suppressed;
    item->setFlags(f);
  }
 
  void _checkActiveItem(ItemInternal* item);
  void _dumpList();
  void _badSameUniqueId(Int64 unique_id) const;
  void _badUniqueIdMap() const;
  void _updateItemSharedInfoInternalView();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane::mesh
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif