ItemPairGroup.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 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-2018 */
/*                                                                           */
/* Tableau de listes d'entités.                                              */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_ITEMPAIRGROUP_H
#define ARCANE_ITEMPAIRGROUP_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/AutoRef.h"
#include "arcane/utils/Iterator.h"
#include "arcane/utils/IFunctorWithArgument.h"
 
#include "arcane/ItemPairGroupImpl.h"
#include "arcane/ItemTypes.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_BEGIN_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class ItemPairEnumerator;
class ItemPairGroupBuilder;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
//NOTE: la documentation complète est dans ItemPairGroup.cc
class ARCANE_CORE_EXPORT ItemPairGroup
{
 public:
  typedef IFunctorWithArgumentT<ItemPairGroupBuilder&> CustomFunctor;
  class CustomFunctorWrapper;
 public:
  ItemPairGroup();
  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() {}
 
 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());
  }
};
 
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
ARCANE_END_NAMESPACE
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif