AnyItemGroup.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* AnyItemGroup.h                                              (C) 2000-2025 */
/*                                                                           */
/* Aggregated group of arbitrary types.                                      */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_ANYITEM_ANYITEMGROUP_H
#define ARCANE_CORE_ANYITEM_ANYITEMGROUP_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include <map>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/ItemGroup.h"
#include "arcane/core/ItemInfoListView.h"
#include "arcane/core/anyitem/AnyItemGlobal.h"
#include "arcane/core/anyitem/AnyItemPrivate.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::AnyItem
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*
 * NB: It must be known very early whether we are iterating over a variable
 * or a partial variable
 *
 */

class GroupBuilder
{
 public:
 
  GroupBuilder(ItemGroup g)
  : m_group(g)
  , m_is_partial(false)
  {}
  ItemGroup group() const { return m_group; }
  bool isPartial() const { return m_is_partial; }
 
 protected:
 
  ItemGroup m_group;
  bool m_is_partial;
};

class PartialGroupBuilder
: public GroupBuilder
{
 public:
 
  PartialGroupBuilder(ItemGroup g)
  : GroupBuilder(g)
  {
    this->m_is_partial = true;
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class Group
{
  static ItemInternal* _toInternal(const Item& v)
  {
    return ItemCompatibility::_itemInternal(v);
  }
 
 public:

  class BlockItemEnumerator
  {
   private:
 
    typedef ItemInternal* ItemInternalPtr;
 
   public:
 
    BlockItemEnumerator(const Private::GroupIndexInfo& info)
    : m_info(info)
    , m_items(m_info.group->itemInfoListView())
    , m_local_ids(m_info.group->itemsLocalId().data())
    , m_index(0)
    , m_count(m_info.group->size())
    , m_is_partial(info.is_partial)
    {}
 
    BlockItemEnumerator(const BlockItemEnumerator& e)
    : m_info(e.m_info)
    , m_items(e.m_items)
    , m_local_ids(e.m_local_ids)
    , m_index(e.m_index)
    , m_count(e.m_count)
    , m_is_partial(e.m_is_partial)
    {}

    Item operator*() const { return m_items[m_local_ids[m_index]]; }
    // TODO: return an 'Item*' similar to ItemEnumerator.
    ItemInternal* operator->() const { return Group::_toInternal(m_items[m_local_ids[m_index]]); }
    inline void operator++() { ++m_index; }
    inline bool hasNext() { return m_index < m_count; }
    inline Integer count() const { return m_count; }

    inline Integer varIndex() const { return (m_is_partial) ? m_index : m_local_ids[m_index]; }

    inline Integer localId() const { return m_info.local_id_offset + m_index; }

    inline Integer groupIndex() const { return m_info.group_index; }

    inline ItemGroup group() const { return ItemGroup(m_info.group); }
 
   private:
 
    const Private::GroupIndexInfo& m_info;
 
    ItemInfoListView m_items;
    const Int32* ARCANE_RESTRICT m_local_ids;
    Integer m_index;
    Integer m_count;
    bool m_is_partial;
  };

  class Enumerator
  {
   public:
 
    Enumerator(const Private::GroupIndexMapping& groups)
    : m_current(std::begin(groups))
    , m_end(std::end(groups))
    {}
    Enumerator(const Enumerator& e)
    : m_current(e.m_current)
    , m_end(e.m_end)
    {}
    inline bool hasNext() const { return m_current != m_end; }
    inline void operator++() { m_current++; }
    inline BlockItemEnumerator enumerator()
    {
      return BlockItemEnumerator(*m_current);
    }
    inline Integer groupIndex() const { return m_current->group_index; }
    ItemGroup group() const { return ItemGroup(m_current->group); }
 
   private:
 
    Private::GroupIndexMapping::const_iterator m_current;
    Private::GroupIndexMapping::const_iterator m_end;
  };
 
 public:

  Group(const Private::GroupIndexMapping& groups)
  : m_groups(groups)
  {}

  inline Enumerator enumerator() const
  {
    return Enumerator(m_groups);
  }

  inline Integer size() const
  {
    return m_groups.size();
  }
 
  //private:
 public:

  const Private::GroupIndexMapping& m_groups;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::AnyItem
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif