ItemInternalMap.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemInternalMap.h                                           (C) 2000-2025 */
/*                                                                           */
/* Associative array of ItemInternal.                                        */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_MESH_ITEMINTERNALMAP_H
#define ARCANE_MESH_ITEMINTERNALMAP_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/HashTableMap.h"
#include "arcane/utils/CheckedConvert.h"
 
#include "arcane/mesh/MeshGlobal.h"
#include "arcane/core/ItemInternal.h"
#include "arcane/utils/HashTableMap2.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
class ItemInternal;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::mesh
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_MESH_EXPORT ItemInternalMap
{
  // For access to methods that use ItemInternal.
  friend class DynamicMeshKindInfos;
 
 private:
 
  using LegacyImpl = HashTableMapT<Int64, ItemInternal*>;
  using NewImpl = impl::HashTableMap2<Int64, ItemInternal*>;
  using BaseData = LegacyImpl::Data;
 
 public:
 
  static constexpr bool UseNewImpl = 1;
 
  class LookupData
  {
    friend ItemInternalMap;
 
   public:
 
    void setValue(ItemInternal* v)
    {
      m_value = v;
      if (m_legacy_data)
        m_legacy_data->setValue(v);
      else
        m_iter->second = v;
    }
    ItemInternal* value() const { return m_value; }
 
   private:
 
    explicit LookupData(NewImpl::iterator x)
    : m_iter(x)
    , m_value(x->second)
    {}
    explicit LookupData(BaseData* d)
    : m_legacy_data(d)
    , m_value(d->value())
    {}
    NewImpl::iterator m_iter;
    BaseData* m_legacy_data = nullptr;
    ItemInternal* m_value;
  };
 
 public:
 
  using Data ARCANE_DEPRECATED_REASON("Y2024: Data type is internal to Arcane") = LegacyImpl::Data;
 
 public:
 
  using ValueType = ItemInternal*;
 
 public:
 
  ItemInternalMap();
 
 public:

  bool add(Int64 key, ItemInternal* v)
  {
    return m_new_impl.insert(std::make_pair(key, v)).second;
  }

  void clear()
  {
    return m_new_impl.clear();
  }

  Int32 count() const
  {
    return CheckedConvert::toInt32(m_new_impl.size());
  }

  void remove(Int64 key)
  {
    auto x = m_new_impl.find(key);
    if (x == m_new_impl.end())
      _throwNotFound(key);
    m_new_impl.erase(x);
  }

  bool hasKey(Int64 key)
  {
    return (m_new_impl.find(key) != m_new_impl.end());
  }

  void resize(Int32 new_size, [[maybe_unused]] bool use_prime = false)
  {
    if (new_size > 0)
      m_new_impl.reserve(static_cast<uint64_t>(new_size), false);
  }

  void notifyUniqueIdsChanged();

  template <class Lambda> void
  eachItem(const Lambda& lambda)
  {
    for (auto [key, value] : m_new_impl)
      lambda(Arcane::impl::ItemBase(value));
  }

  Int32 nbBucket() const
  {
    return CheckedConvert::toInt32(m_new_impl.bucket_count());
  }
 
 public:

  impl::ItemBase tryFind(Int64 key) const
  {
    auto x = m_new_impl.find(key);
    return (x != m_new_impl.end()) ? x->second : impl::ItemBase{};
  }

  Int32 tryFindLocalId(Int64 key) const
  {
    auto x = m_new_impl.find(key);
    return (x != m_new_impl.end()) ? x->second->localId() : NULL_ITEM_LOCAL_ID;
  }

  impl::ItemBase findItem(Int64 uid) const
  {
    auto x = m_new_impl.find(uid);
    if (x == m_new_impl.end())
      _throwNotFound(uid);
    return x->second;
  }

  Int32 findLocalId(Int64 uid) const
  {
    auto x = m_new_impl.find(uid);
    if (x == m_new_impl.end())
      _throwNotFound(uid);
    return x->second->localId();
  }
 
  void checkValid() const;
 
 public:
 
  ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane")
  Data* lookup([[maybe_unused]] Int64 key)
  {
    _throwNotSupported("lookup");
  }
 
  ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane")
  const Data* lookup([[maybe_unused]] Int64 key) const
  {
    _throwNotSupported("lookup");
  }
 
  ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane")
  ConstArrayView<BaseData*> buckets() const
  {
    _throwNotSupported("buckets");
  }
 
  ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane")
  BaseData* lookupAdd([[maybe_unused]] Int64 id,
                      [[maybe_unused]] ItemInternal* value,
                      [[maybe_unused]] bool& is_add)
  {
    _throwNotSupported("lookupAdd(id,value,is_add)");
  }
 
  ARCANE_DEPRECATED_REASON("Y2024: This method is internal to Arcane")
  BaseData* lookupAdd([[maybe_unused]] Int64 uid)
  {
    _throwNotSupported("lookupAdd(uid)");
  }
 
  ARCANE_DEPRECATED_REASON("Y2024: Use findItem() instead")
  ItemInternal* lookupValue([[maybe_unused]] Int64 uid) const
  {
    _throwNotSupported("lookupValue");
  }
 
  ARCANE_DEPRECATED_REASON("Y2024: Use findItem() instead")
  ItemInternal* operator[]([[maybe_unused]] Int64 uid) const
  {
    _throwNotSupported("operator[]");
  }
 
 private:
 
  NewImpl m_new_impl;
 
 private:
 
  // The following three methods are only for the
  // class DynamicMeshKindInfos.

  void _changeLocalIds(ArrayView<ItemInternal*> items_internal,
                       ConstArrayView<Int32> old_to_new_local_ids);
 
  LookupData _lookupAdd(Int64 id, ItemInternal* value, bool& is_add)
  {
    auto x = m_new_impl.insert(std::make_pair(id, value));
    is_add = x.second;
    return LookupData(x.first);
  }

  ItemInternal* _tryFindItemInternal(Int64 key) const
  {
    auto x = m_new_impl.find(key);
    if (x == m_new_impl.end())
      return nullptr;
    _checkValid(key, x->second);
    return x->second;
  }
 
 private:
 
  void _throwNotFound ARCANE_NORETURN(Int64 id) const;
  void _throwNotSupported ARCANE_NORETURN(const char* func_name) const;
  void _checkValid(Int64 uid, ItemInternal* v) const;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
} // namespace Arcane::mesh
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif