AnyItemFamily.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2023 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* AnyItemFamily.h                                             (C) 2000-2023 */
/*                                                                           */
/* Famille d'items de types quelconques.                                     */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_ANYITEM_ANYITEMFAMILY_H
#define ARCANE_ANYITEM_ANYITEMFAMILY_H 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include <arcane/utils/SharedPtr.h>
 
#include <set>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/FatalErrorException.h"
#include "arcane/anyitem/AnyItemGlobal.h"
#include "arcane/anyitem/AnyItemPrivate.h"
#include "arcane/anyitem/AnyItemGroup.h"
#include "arcane/anyitem/AnyItemFamilyObserver.h"
#include "arcane/ItemGroupObserver.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::AnyItem
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class FamilyInternal
{ 
private:
  typedef std::set<IFamilyObserver*> FamilyObservers;
  
public:
  
  FamilyInternal() : m_max_local_id(0) {}
  ~FamilyInternal() 
  {
    clear();
  }
  
public:
  
  FamilyInternal& operator<<(GroupBuilder builder)
  {
    ItemGroup group = builder.group();
    const Integer size = m_groups.size();
 
    if (m_groups.findGroupInfo(group.internal()) != NULL)
      throw FatalErrorException(String::format("Group '{0}' already registered",group.name()));    
    
    m_groups.resize(size+1);
    Private::GroupIndexInfo & info = m_groups[size];
    info.group = group.internal();
    info.group_index = size;
    info.local_id_offset = m_max_local_id;
    m_max_local_id += group.size();
    info.is_partial = builder.isPartial();
    info.group->attachObserver(this, newItemGroupObserverT(this, &FamilyInternal::_notifyGroupHasChanged));
    // std::cout << "Attach " << this << " observer on group " << group.name() << "\n";
 
    // On previent les observeurs
    _notifyFamilyIsIncreased();
    return *this;
  }
 
  inline bool contains(const ItemGroup& group) const 
  {
    return (m_groups.findGroupInfo(group.internal()) != NULL);
  }
  
  inline bool isPartial(const ItemGroup& group) const 
  {
    const Private::GroupIndexInfo * info = m_groups.findGroupInfo(group.internal());
    if (info == NULL)
      throw Arcane::FatalErrorException(Arcane::String::format("Group '{0}' not registered",group.name()));
    return info->is_partial;
  }
  
  // Ce groupe n'a pas besoin d'observer la famille car il partage les données
  inline Group allItems() const {
    return m_groups;
  }
  
  inline Integer groupIndex(const ItemGroup& group) const {
    const Private::GroupIndexInfo * info = m_groups.findGroupInfo(group.internal());
    if (info == NULL)
      throw FatalErrorException(String::format("Group '{0}' not registered",group.name()));
    return info->group_index;
  }
 
  inline Integer firstLocalId(const ItemGroup& group) const
  {
    const Private::GroupIndexInfo * info = m_groups.findGroupInfo(group.internal());
    if (!info)
      ARCANE_FATAL("Group '{0}' not registered",group.name());
    return info->local_id_offset;
  }
  
  template<typename AnyItemT>
  Item item(const AnyItemT & any_item) const
  {
    // NOTE GG: la valeur de group.itemInfoListView() ne change pas au cours
    // du calcul donc il est possible de la conserver comme champ de la classe.
    const Integer group_index = any_item.groupIndex();
    const Private::GroupIndexInfo & info = m_groups[group_index];
    const ItemGroupImpl & group = *(info.group);
    Integer index_in_group = any_item.localId() - info.local_id_offset;
    Item item = group.itemInfoListView()[group.itemsLocalId()[index_in_group]];
    // ARCANE_ASSERT((!info.is_partial || (item->localId() == any_item.varIndex())),("Inconsistent concrete item"));
    // ARCANE_ASSERT((item->isOwn() == any_item.m_is_own),("Inconsistent concrete item isOwn"));
    return item;
  }
 
  inline Integer groupSize() const { 
    return m_groups.size();
  }
  
 
  inline Integer maxLocalId() const {
    return m_max_local_id;
  }
 
  ItemGroup group(Integer i) const {
    return ItemGroup(m_groups[i].group);
  }
 
  void clear() {
    for(Integer igrp=0;igrp<m_groups.size();++igrp) {
      m_groups[igrp].group->detachObserver(this);
      // std::cout << "Detach " << this << " observer on group " << m_groups[igrp].group->name() << "\n";
    }
    // On efface
    m_groups.clear();
    m_max_local_id = 0;
    // On previent les observeurs
    _notifyFamilyIsInvalidate();
  }
 
  void registerObserver(IFamilyObserver& observer) const
  {
    FamilyObservers::const_iterator it = m_observers.find(&observer);
    if(it != m_observers.end())
      throw FatalErrorException("FamilyObserver already registered");
    m_observers.insert(&observer);
  }
  
  void removeObserver(IFamilyObserver& observer) const
  {
    FamilyObservers::const_iterator it = m_observers.find(&observer);
    if(it == m_observers.end())
      throw FatalErrorException("FamilyObserver not registered");
    m_observers.erase(it);
  }
 
public:
  const Private::GroupIndexInfo * findGroupInfo(ItemGroup agroup) {
    return m_groups.findGroupInfo(agroup.internal());
  }
 
private:
 
  void _notifyFamilyIsInvalidate() {
    for(FamilyObservers::iterator it = m_observers.begin(); it != m_observers.end(); ++it)
      (*it)->notifyFamilyIsInvalidate();
  }
 
  void _notifyFamilyIsIncreased() {
    for(FamilyObservers::iterator it = m_observers.begin(); it != m_observers.end(); ++it)
      (*it)->notifyFamilyIsIncreased();
  }
 
  void _notifyGroupHasChanged() {
    throw FatalErrorException(A_FUNCINFO, "Group changes while registered in AnyItem::Family");
  }
 
private:
  
  Private::GroupIndexMapping m_groups;
  
  Integer m_max_local_id;
  
  mutable FamilyObservers m_observers;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class Family
{ 
public:
  
  Family() : m_internal(new FamilyInternal) {} 
  Family(const Family& f) : m_internal(f.m_internal) {} 
  ~Family() {}
  
public:
  
  bool operator==(const Family& f) const { return m_internal == f.m_internal; }
  bool operator!=(const Family& f) const { return !operator==(f); }
  
  Family& operator=(const Family& f) 
  {
    m_internal = f.m_internal;
    return *this;
  }
 
  Family& operator<<(GroupBuilder builder)
  {
    *m_internal << builder;
    return *this;
  }
 
  inline bool contains(const ItemGroup& group) const 
  {
    return m_internal->contains(group);
  }
  
  inline bool isPartial(const ItemGroup& group) const 
  {
    return m_internal->isPartial(group);
  }
  
  inline Group allItems() {
    return m_internal->allItems();
  }
  
  inline Integer groupIndex(const ItemGroup& group) const {
    return m_internal->groupIndex(group);
  }
  
  inline Integer firstLocalId(const ItemGroup& group) const {
    return m_internal->firstLocalId(group);
  }
 
  template<typename AnyItemT>
  Item item(const AnyItemT & any_item) const {
    return m_internal->item(any_item);
  }
 
  inline Integer groupSize() const { 
    return m_internal->groupSize();
  }
  
 
  inline Integer maxLocalId() const {
    return m_internal->maxLocalId();
  }
 
  ItemGroup group(Integer i) const {
    return m_internal->group(i);
  }
 
  void clear() {
    m_internal->clear();
  }
 
  void registerObserver(IFamilyObserver& observer) const
  {
    m_internal->registerObserver(observer);
  }
  
  void removeObserver(IFamilyObserver& observer) const
  {
    m_internal->removeObserver(observer);
  }
 
  FamilyInternal * internal() const {
    return m_internal.get();
  }
 
private:
  
  SharedPtrT<FamilyInternal> m_internal;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif /* ARCANE_ANYITEM_ANYITEMFAMILY_H */