ItemPairGroup.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemPairGroup.h                                             (C) 2000-2025 */
/*                                                                           */
/* Table of entity lists.                                                    */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_ITEMPAIRGROUP_H
#define ARCANE_CORE_ITEMPAIRGROUP_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/AutoRef.h"
#include "arcane/utils/Iterator.h"
#include "arcane/utils/IFunctorWithArgument.h"
 
#include "arcane/core/ItemPairGroupImpl.h"
#include "arcane/core/ItemTypes.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
//NOTE: The complete documentation is in ItemPairGroup.cc

class ARCANE_CORE_EXPORT ItemPairGroup
{
 public:

  typedef IFunctorWithArgumentT<ItemPairGroupBuilder&> CustomFunctor;
  class CustomFunctorWrapper;
 
 public:

  ItemPairGroup();
  explicit ItemPairGroup(ItemPairGroupImpl* prv);
  ItemPairGroup(const ItemGroup& group, const ItemGroup& sub_item_group,
                eItemKind link_kind);
  ItemPairGroup(const ItemGroup& group, const ItemGroup& sub_item_group,
                CustomFunctor* functor);
  ItemPairGroup(const ItemPairGroup& from)
  : m_impl(from.m_impl)
  {}
 
  const ItemPairGroup& operator=(const ItemPairGroup& from)
  {
    m_impl = from.m_impl;
    return (*this);
  }
  virtual ~ItemPairGroup() = default;
 
 public:

  inline bool null() const { return m_impl->null(); }
  inline eItemKind itemKind() const { return m_impl->itemKind(); }
  inline eItemKind subItemKind() const { return m_impl->subItemKind(); }
 
 public:

  ItemPairGroupImpl* internal() const { return m_impl.get(); }

  IItemFamily* itemFamily() const { return m_impl->itemFamily(); }

  IItemFamily* subItemFamily() const { return m_impl->subItemFamily(); }

  IMesh* mesh() const { return m_impl->mesh(); }

  const ItemGroup& itemGroup() const { return m_impl->itemGroup(); }

  const ItemGroup& subItemGroup() const { return m_impl->subItemGroup(); }
 
 public:

  void invalidate(bool force_recompute = false)
  {
    m_impl->invalidate(force_recompute);
  }

  void checkValid() { m_impl->checkValid(); }
 
 public:
 
  ItemPairEnumerator enumerator() const;
 
 protected:

  AutoRefT<ItemPairGroupImpl> m_impl;
 
 protected:

  static ItemPairGroupImpl* _check(ItemPairGroupImpl* impl, eItemKind ik, eItemKind aik)
  {
    return (impl->itemKind() == ik && impl->subItemKind() == aik) ? impl : ItemPairGroupImpl::checkSharedNull();
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

inline bool
operator==(const ItemPairGroup& g1, const ItemPairGroup& g2)
{
  return g1.internal() == g2.internal();
}

inline bool
operator!=(const ItemPairGroup& g1, const ItemPairGroup& g2)
{
  return g1.internal() != g2.internal();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <typename ItemKind, typename SubItemKind>
class ItemPairGroupT
: public ItemPairGroup
{
 public:

  typedef ItemPairGroupT<ItemKind, SubItemKind> ThatClass;
  typedef ItemTraitsT<ItemKind> TraitsType;
  typedef ItemTraitsT<SubItemKind> SubTraitsType;
 
  typedef typename TraitsType::ItemType ItemType;
  typedef typename TraitsType::ItemGroupType ItemGroupType;
  typedef typename SubTraitsType::ItemType SubItemType;
  typedef typename SubTraitsType::ItemGroupType SubItemGroupType;
 
 public:
 
  ItemPairGroupT() {}
  ItemPairGroupT(const ItemPairGroup& from)
  : ItemPairGroup(_check(from.internal(), TraitsType::kind(), SubTraitsType::kind()))
  {}
  ItemPairGroupT(const ThatClass& from)
  : ItemPairGroup(from)
  {}
  ItemPairGroupT(const ItemGroupType& group, const SubItemGroupType& sub_group,
                 eItemKind link_kind)
  : ItemPairGroup(group, sub_group, link_kind)
  {}
  ItemPairGroupT(const ItemGroupType& group, const SubItemGroupType& sub_group,
                 CustomFunctor* functor)
  : ItemPairGroup(group, sub_group, functor)
  {}
  ~ItemPairGroupT() {}
 
 public:
 
  const ThatClass& operator=(const ThatClass& from)
  {
    m_impl = from.internal();
    return (*this);
  }
  const ThatClass& operator=(const ItemPairGroup& from)
  {
    _assign(from);
    return (*this);
  }
 
 protected:
 
  void _assign(const ItemPairGroup& from)
  {
    m_impl = _check(from.internal(), TraitsType::kind(), SubTraitsType::kind());
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif