ItemLoop.h

Go to the documentation of this file.

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemLoop.h                                                  (C) 2000-2025 */
/*                                                                           */
/* Utility classes for managing loops over entities.                         */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_ITEMLOOP_H
#define ARCANE_CORE_ITEMLOOP_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/ItemEnumerator.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{

namespace Loop
{

  template <typename IterType, typename Lambda> inline void
  _InternalSimpleItemLoop(ItemVectorView view, const Lambda& lambda)
  {
    if (view.size() == 0)
      return;
    bool is_contigous = view.indexes().isContigous();
    //is_contigous = false;
    if (is_contigous) {
      Int32 x0 = view.localIds()[0];
      // Assuming iterations are independent
      ARCANE_PRAGMA_IVDEP
      for (Int32 i = 0, n = view.size(); i < n; ++i)
        lambda(IterType(x0 + i));
    }
    else {
      ENUMERATE_ITEM (iitem, view) {
        lambda(IterType(iitem.localId()));
      }
    }
  }

  template <typename ItemType>
  class ItemLoopFunctor
  {
   public:
 
    typedef typename ItemType::Index IterType;
    typedef ItemVectorViewT<ItemType> VectorViewType;
    typedef ItemGroupT<ItemType> ItemGroupType;
    typedef ItemLoopFunctor<ItemType> ThatClass;
 
   private:
 
    ItemLoopFunctor(ItemVectorView items)
    : m_items(items)
    {}
 
   public:
 
    static ThatClass create(const ItemGroupType& items)
    {
      return ThatClass(items.view());
    }
    static ThatClass create(VectorViewType items)
    {
      return ThatClass(items);
    }
 
   public:
 
    template <typename Lambda>
    void operator<<(Lambda&& lambda)
    {
      _InternalSimpleItemLoop<IterType>(m_items, lambda);
    }
 
   private:
 
    ItemVectorView m_items;
  };
 
  typedef ItemLoopFunctor<Cell> ItemLoopFunctorCell;
  typedef ItemLoopFunctor<Node> ItemLoopFunctorNode;
 
} // End of namespace Loop
 
} // End of namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

#define ENUMERATE_ITEM_LAMBDA(item_type, iter, container) \
  Arcane::Loop::ItemLoopFunctor##item_type ::create((container)) << [=](Arcane::Loop::ItemLoopFunctor##item_type ::IterType iter)
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif