IIndexManager.h

#pragma once
 
#include <memory> // for std::shared_ptr.
#include <vector>
 
#include <alien/utils/Precomp.h>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Alien
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class IIndexManager
{
 public:
  class IAbstractFamily
  {
   public:
    class Item
    {
     public:
      Item(Arccore::Int64 uniqueId, Arccore::Integer owner)
      : m_unique_id(uniqueId)
      , m_owner(owner)
      {}
 
     public:
      Arccore::Int64 uniqueId() const { return m_unique_id; }
      Arccore::Integer owner() const { return m_owner; }
 
     private:
      Arccore::Int64 m_unique_id;
      Arccore::Integer m_owner;
    };
 
   public:
    virtual ~IAbstractFamily() = default;
 
   public:
    virtual IAbstractFamily* clone() const = 0;
 
   public:
    virtual Arccore::Int32 maxLocalId() const = 0;
    virtual void uniqueIdToLocalId(Arccore::ArrayView<Arccore::Int32> localIds,
                                   Arccore::ConstArrayView<Arccore::Int64> uniqueIds) const = 0;
    virtual Item item(Arccore::Int32 localId) const = 0;
    virtual Arccore::SharedArray<Arccore::Integer> owners(
    Arccore::ConstArrayView<Arccore::Int32> localIds) const = 0;
    virtual Arccore::SharedArray<Arccore::Int64> uids(
    Arccore::ConstArrayView<Arccore::Int32> localIds) const = 0;
    virtual Arccore::SharedArray<Arccore::Int32> allLocalIds() const = 0;
  };
 
 protected:
  class EntryImpl
  {
   public:
    virtual ~EntryImpl() = default;
    virtual Arccore::ConstArrayView<Arccore::Integer> getOwnIndexes() const = 0;
    virtual Arccore::ConstArrayView<Arccore::Integer> getAllIndexes() const = 0;
    virtual Arccore::ConstArrayView<Arccore::Integer> getOwnLocalIds() const = 0;
    virtual Arccore::ConstArrayView<Arccore::Integer> getAllLocalIds() const = 0;
    virtual Arccore::String getName() const = 0;
    virtual Arccore::Integer getKind() const = 0;
    virtual const IAbstractFamily& getFamily() const = 0;
    virtual void addTag(
    const Arccore::String& tagname, const Arccore::String& tagvalue) = 0;
    virtual void removeTag(const Arccore::String& tagname) = 0;
    virtual bool hasTag(const Arccore::String& tagname) = 0;
    virtual Arccore::String tagValue(const Arccore::String& tagname) = 0;
    virtual IIndexManager* manager() const = 0;
  };
 
 public:

  class Entry
  {
   protected:
    EntryImpl* m_impl;
 
   public:
    Entry()
    : m_impl(nullptr)
    {}

    Entry(const Entry& en) = default;

    explicit Entry(EntryImpl* impl)
    : m_impl(impl)
    {}

    Entry& operator=(const Entry& en)
    {
      if (this != &en)
        m_impl = en.m_impl;
      return *this;
    }

    EntryImpl* internal() const { return m_impl; }

    bool null() const { return m_impl == nullptr; }
 
    void nullify() { m_impl = nullptr; }

    Arccore::ConstArrayView<Arccore::Integer> getOwnIndexes() const
    {
      return m_impl->getOwnIndexes();
    }

    Arccore::ConstArrayView<Arccore::Integer> getAllIndexes() const
    {
      return m_impl->getAllIndexes();
    }

    Arccore::ConstArrayView<Arccore::Integer> getOwnLocalIds() const
    {
      return m_impl->getOwnLocalIds();
    }

    Arccore::ConstArrayView<Arccore::Integer> getAllLocalIds() const
    {
      return m_impl->getAllLocalIds();
    }

    Arccore::String getName() const { return m_impl->getName(); }

    Arccore::Integer getKind() const { return m_impl->getKind(); }

    const IAbstractFamily& getFamily() const { return m_impl->getFamily(); }


    void addTag(const Arccore::String& tagname, const Arccore::String& tagvalue)
    {
      return m_impl->addTag(tagname, tagvalue);
    }

    void removeTag(const Arccore::String& tagname) { return m_impl->removeTag(tagname); }

    bool hasTag(const Arccore::String& tagname) { return m_impl->hasTag(tagname); }

    Arccore::String tagValue(const Arccore::String& tagname)
    {
      return m_impl->tagValue(tagname);
    }


    IIndexManager* manager() const { return m_impl->manager(); }
  };

  class EntryEnumeratorImpl
  {
   public:
    EntryEnumeratorImpl() = default;
    virtual ~EntryEnumeratorImpl() = default;
    virtual void moveNext() = 0;
    virtual bool hasNext() const = 0;
    virtual EntryImpl* get() const = 0;
  };


  class EntryEnumerator
  {
   protected:
    std::shared_ptr<EntryEnumeratorImpl> m_impl;
 
   public:
    EntryEnumerator(const EntryEnumerator& e) = default;

    explicit EntryEnumerator(IIndexManager const* manager)
    : m_impl(manager->enumerateEntry().m_impl)
    {}

    explicit EntryEnumerator(EntryEnumeratorImpl* impl)
    : m_impl(impl)
    {}

    void operator++() { m_impl->moveNext(); }
    bool hasNext() const { return m_impl->hasNext(); }
    Entry operator*() const { return Entry(m_impl->get()); }
    EntryImpl* operator->() const { return m_impl->get(); }
    Arccore::Integer count() const
    {
      Arccore::Integer my_size = 0;
      for (EntryEnumerator i = *this; i.hasNext(); ++i)
        ++my_size;
      return my_size;
    }
    bool null() { return m_impl == nullptr; }
  };
 
 public:
  IIndexManager() = default;

  virtual ~IIndexManager() = default;

  virtual bool isPrepared() const = 0;


  virtual void init() = 0;

  virtual void prepare() = 0;

  virtual void setTraceMng(Arccore::ITraceMng* traceMng) = 0;


  virtual void stats(Arccore::Integer& globalSize, Arccore::Integer& minLocalIndex,
                     Arccore::Integer& localSize) const = 0;


  virtual Arccore::Integer globalSize() const = 0;


  virtual Arccore::Integer minLocalIndex() const = 0;


  virtual Arccore::Integer localSize() const = 0;

  virtual EntryEnumerator enumerateEntry() const = 0;

  virtual Entry getEntry(const Arccore::String& name) const = 0;
 
  typedef Entry ScalarIndexSet;
  typedef Arccore::UniqueArray<ScalarIndexSet> VectorIndexSet;

  // virtual ScalarIndexSet buildScalarIndexSet(const String name,Arcane::IItemFamily *
  // item_family) = 0;
  // virtual void defineIndex(ScalarIndexSet& set , const Arcane::ItemGroup & itemGroup)
  // =
  // 0;
  // virtual ScalarIndexSet buildScalarIndexSet(const String name, const
  // Arcane::ItemGroup
  // & itemGroup) = 0;

  virtual ScalarIndexSet buildScalarIndexSet(const Arccore::String& name,
                                             Arccore::ConstArrayView<Arccore::Integer> localIds,
                                             const IAbstractFamily& family) = 0;

  virtual ScalarIndexSet buildScalarIndexSet(
  const Arccore::String& name, const IAbstractFamily& family) = 0;


  // virtual VectorIndexSet buildVectorIndexSet(const String name, const
  // Arcane::ItemGroup
  // & itemGroup, const Integer n) = 0;

  virtual VectorIndexSet buildVectorIndexSet(const Arccore::String& name,
                                             Arccore::ConstArrayView<Arccore::Integer> localIds,
                                             const IAbstractFamily& family,
                                             Arccore::Integer n) = 0;


  virtual VectorIndexSet buildVectorIndexSet(
  const Arccore::String& name, const IAbstractFamily& family, Arccore::Integer n) = 0;


  // virtual void removeIndex(const ScalarIndexSet & entry, const Arcane::ItemGroup &
  // itemGroup) = 0;
 
  // virtual Integer getIndex(const Entry & entry, const Item & item) const = 0 ;

  // virtual void getIndex(const ScalarIndexSet & entry, const Arcane::ItemVectorView &
  // items, ArrayView<Integer> indexes) const = 0;

  virtual Arccore::UniqueArray<Arccore::Integer> getIndexes(
  const ScalarIndexSet& entry) const = 0;

  virtual Arccore::UniqueArray2<Arccore::Integer> getIndexes(
  const VectorIndexSet& entry) const = 0;

  virtual Alien::IMessagePassingMng* parallelMng() const = 0;

  virtual void setMaxNullIndexOpt(bool flag) = 0;

  virtual Arccore::Integer nullIndex() const = 0;
 
 public:

  virtual void keepAlive(const IAbstractFamily* family) = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Alien
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/