ItemLoop.h

Aller à la documentation de ce fichier.

// -*- 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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemLoop.h                                                  (C) 2000-2018 */
/*                                                                           */
/* Classes utilitaires pour gérer les boucles sur les entités.               */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_ITEMLOOP_H
#define ARCANE_ITEMLOOP_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/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];
    // Suppose que les itérations sont indépendantes
    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