ItemPairGroupImpl.cc

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemPairGroupImpl.cc                                        (C) 2000-2021 */
/*                                                                           */
/* Implementation of an array of lists of entities.                          */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ArcanePrecomp.h"
 
#include "arcane/utils/Array.h"
#include "arcane/utils/IFunctor.h"
 
#include "arcane/core/ItemGroupObserver.h"
#include "arcane/core/ItemPairGroupImpl.h"
#include "arcane/core/ItemPairGroup.h"
#include "arcane/core/IItemFamily.h"
#include "arcane/core/ItemGroup.h"
#include "arcane/core/IMesh.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ItemPairGroupImplNull
: public ItemPairGroupImpl
{
 public:
 
  ItemPairGroupImplNull()
  : ItemPairGroupImpl()
  {}
  virtual ~ItemPairGroupImplNull() {} 
 
 public:
 private:
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ItemPairGroupImplPrivate
{
 public:
 
  ItemPairGroupImplPrivate();
  ItemPairGroupImplPrivate(const ItemGroup& group, const ItemGroup& sub_group);
  ~ItemPairGroupImplPrivate();
 
 public:
 
  inline bool null() const { return m_is_null; }
  inline IMesh* mesh() const { return m_mesh; }
  inline eItemKind kind() const { return m_kind; }
  inline eItemKind subKind() const { return m_sub_kind; }
 
 public:
 
  IMesh* m_mesh; 
  IItemFamily* m_item_family; 
  IItemFamily* m_sub_item_family; 
  ItemGroup m_item_group;
  ItemGroup m_sub_item_group;
  bool m_is_null; 
  eItemKind m_kind; 
  eItemKind m_sub_kind;
  bool m_need_recompute; 
 
  UniqueArray<Int64> m_indexes;
  UniqueArray<Int32> m_sub_items_local_id;
  IFunctor* m_compute_functor;
 
 public:
 
  void invalidate() { m_need_recompute = true; }
 
 private:
 
  void _init();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemPairGroupImplPrivate::
ItemPairGroupImplPrivate()
: m_mesh(nullptr)
, m_item_family(nullptr)
, m_sub_item_family(nullptr)
, m_is_null(true)
, m_kind(IK_Unknown)
, m_sub_kind(IK_Unknown)
, m_need_recompute(false)
, m_compute_functor(nullptr)
{
  _init();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemPairGroupImplPrivate::
ItemPairGroupImplPrivate(const ItemGroup& group, const ItemGroup& sub_group)
: m_mesh(group.mesh())
, m_item_family(group.itemFamily())
, m_sub_item_family(sub_group.itemFamily())
, m_item_group(group)
, m_sub_item_group(sub_group)
, m_is_null(false)
, m_kind(group.itemKind())
, m_sub_kind(sub_group.itemKind())
, m_need_recompute(false)
, m_compute_functor(nullptr)
{
  _init();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemPairGroupImplPrivate::
~ItemPairGroupImplPrivate()
{
  delete m_compute_functor;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ItemPairGroupImplPrivate::
_init()
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemPairGroupImpl* ItemPairGroupImpl::shared_null = 0;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemPairGroupImpl* ItemPairGroupImpl::
checkSharedNull()
{
  if (!shared_null) {
    shared_null = new ItemPairGroupImplNull();
    shared_null->addRef();
  }
  return shared_null;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemPairGroupImpl::
ItemPairGroupImpl(const ItemGroup& group, const ItemGroup& sub_group)
: m_p(new ItemPairGroupImplPrivate(group, sub_group))
{
  m_p->m_item_group.internal()->attachObserver(this, newItemGroupObserverT(m_p, &ItemPairGroupImplPrivate::invalidate));
  m_p->m_sub_item_group.internal()->attachObserver(this, newItemGroupObserverT(m_p, &ItemPairGroupImplPrivate::invalidate));
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemPairGroupImpl::
ItemPairGroupImpl()
: m_p(new ItemPairGroupImplPrivate())
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ItemPairGroupImpl::
~ItemPairGroupImpl()
{
  m_p->m_item_group.internal()->detachObserver(this);
  m_p->m_sub_item_group.internal()->detachObserver(this);
  delete m_p;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

void ItemPairGroupImpl::
deleteMe()
{
  delete this;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ItemPairGroupImpl::
addRef()
{
  SharedReference::addRef();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ItemPairGroupImpl::
removeRef()
{
  SharedReference::removeRef();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IMesh* ItemPairGroupImpl::
mesh() const
{
  return m_p->mesh();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IItemFamily* ItemPairGroupImpl::
itemFamily() const
{
  return m_p->m_item_family;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
IItemFamily* ItemPairGroupImpl::
subItemFamily() const
{
  return m_p->m_sub_item_family;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool ItemPairGroupImpl::
null() const
{
  return m_p->null();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
eItemKind ItemPairGroupImpl::
itemKind() const
{
  return m_p->kind();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
eItemKind ItemPairGroupImpl::
subItemKind() const
{
  return m_p->subKind();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
const ItemGroup& ItemPairGroupImpl::
itemGroup() const
{
  return m_p->m_item_group;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
const ItemGroup& ItemPairGroupImpl::
subItemGroup() const
{
  return m_p->m_sub_item_group;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ItemPairGroupImpl::
checkValid()
{
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ItemPairGroupImpl::
invalidate(bool force_recompute)
{
  m_p->m_need_recompute = true;
  if (force_recompute)
    checkNeedUpdate();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
bool ItemPairGroupImpl::
checkNeedUpdate()
{
  if (m_p->m_need_recompute) {
    m_p->m_need_recompute = false;
    if (m_p->m_compute_functor)
      m_p->m_compute_functor->executeFunctor();
    return true;
  }
  return false;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Array<Int64>& ItemPairGroupImpl::
unguardedIndexes() const
{
  return m_p->m_indexes;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Array<Int32>& ItemPairGroupImpl::
unguardedLocalIds() const
{
  return m_p->m_sub_items_local_id;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ArrayView<Int64> ItemPairGroupImpl::
indexes()
{
  checkNeedUpdate();
  return m_p->m_indexes;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
Span<const Int32> ItemPairGroupImpl::
subItemsLocalId()
{
  checkNeedUpdate();
  return m_p->m_sub_items_local_id;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
void ItemPairGroupImpl::
setComputeFunctor(IFunctor* functor)
{
  delete m_p->m_compute_functor;
  m_p->m_compute_functor = functor;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/