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
/*!
 * \brief Tableau de listes d'entités.
 */
class ARCANE_CORE_EXPORT ItemPairGroup
{
 public:
  /*!
   * \brief Functor pour un calcul personnalisé des connectivités.
   */
  typedef IFunctorWithArgumentT<ItemPairGroupBuilder&> CustomFunctor;
  class CustomFunctorWrapper;
 public:
  //! Construit un tableau vide.
  ItemPairGroup();
  //! Construit un groupe à partir de la représentation interne \a prv
  ItemPairGroup(ItemPairGroupImpl* prv);
  /*!
   * \brief Construit une instance en spécifiant le voisinage via les entités
   * de genre \a link_kind.
   */
  ItemPairGroup(const ItemGroup& group,const ItemGroup& sub_item_group,
                eItemKind link_kind);
  //! Construit une instance avec un fonctor particulier.
  ItemPairGroup(const ItemGroup& group,const ItemGroup& sub_item_group,
                CustomFunctor* functor);
  //! Constructeur de recopie.
  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:
 
  //! \a true is le groupe est le groupe nul
  inline bool null() const { return m_impl->null(); }
  //! Type des entités du groupe
  inline eItemKind itemKind() const  { return m_impl->itemKind(); }
  //! Type des sous-entités du groupe
  inline eItemKind subItemKind() const  { return m_impl->subItemKind(); }
 
 public:
 
  /*!
   * \brief Retourne l'implémentation du groupe.
   *
   * \warning Cette méthode retourne un pointeur sur la représentation
   * interne du groupe et ne doit pas être utilisée
   * en dehors d'Arcane.
   */
  ItemPairGroupImpl* internal() const { return m_impl.get(); }
 
  //! Famille d'entité à laquelle appartient ce groupe (0 pour une liste nulle)
  IItemFamily* itemFamily() const { return m_impl->itemFamily(); }
 
  //! Famille d'entité à laquelle appartient ce groupe (0 pour une liste nulle)
  IItemFamily* subItemFamily() const { return m_impl->subItemFamily(); }
 
  //! Maillage auquel appartient cette liste (0 pour une liste nulle)
  IMesh* mesh() const { return m_impl->mesh(); }
 
  //! Groupe des items initiaux
  const ItemGroup& itemGroup() const { return m_impl->itemGroup(); }
 
  //! Groupe des items finaux (après rebond)
  const ItemGroup& subItemGroup() const { return m_impl->subItemGroup(); }
 
 public:
 
  /*! \brief Invalide la liste.
   */
  void invalidate(bool force_recompute=false)
  {
    m_impl->invalidate(force_recompute);
  }
 
  //! Vérification interne de la validité du groupe
  void checkValid() { m_impl->checkValid(); }
 
 public:
 
  ItemPairEnumerator enumerator() const;
 
 protected:
 
  //! Représentation interne du groupe.
  AutoRefT<ItemPairGroupImpl> m_impl;
 
 protected:
 
  //! Retourne le groupe \a impl s'il est du genre \a kt, le groupe nul sinon
  static ItemPairGroupImpl* _check(ItemPairGroupImpl* impl,eItemKind ik,eItemKind aik)
  {
    return (impl->itemKind()==ik && impl->subItemKind()==aik) ? impl : ItemPairGroupImpl::checkSharedNull();
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Compare les références de deux groupes.
 * \retval true si \a g1 et \a g2 réfèrent au même groupe,
 * \retval false sinon.
 */
inline bool
operator==(const ItemPairGroup& g1,const ItemPairGroup& g2)
{
  return g1.internal()==g2.internal();
}
 
/*!
 * \brief Compare les références de deux groupes.
 * \retval true si \a g1 et \a g2 ne réfèrent pas au même groupe,
 * \retval false sinon.
 */
inline bool
operator!=(const ItemPairGroup& g1,const ItemPairGroup& g2)
{
  return g1.internal()!=g2.internal();
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*!
 * \brief Référence à un groupe d'un genre donné.
 */
template<typename ItemKind,typename SubItemKind>
class ItemPairGroupT
: public ItemPairGroup
{
 public:
 
  //! Type de cette classe
  typedef ItemPairGroupT<ItemKind,SubItemKind> ThatClass;
  //! Type de la classe contenant les caractéristiques de l'entité
  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