UtilsTypes.h

Aller à la documentation de ce fichier.

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* UtilsTypes.h                                                (C) 2000-2025 */
/*                                                                           */
/* Définition des types généraux des classes utilitaires de Arcane.          */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_UTILSTYPES_H
#define ARCANE_UTILS_UTILSTYPES_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/ArcaneGlobal.h"
#include "arccore/base/BaseTypes.h"
#include "arccore/base/RefDeclarations.h"
#include "arccore/collections/CollectionsGlobal.h"
#include "arccore/concurrency/ConcurrencyGlobal.h"
#include "arccore/trace/TraceGlobal.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
template<typename T> class MultiArray2View;
template<typename T> class ConstMultiArray2View;
template<typename T> class MultiArray2;
template<typename DataType> class UniqueMultiArray2;
template<typename DataType> class SharedMultiArray2;
 
template<typename T> class EnumeratorT;
template<typename T> class ListEnumeratorT;
 
template<typename T> class Collection;
template<typename T> class List;
 
class EventObservableBase;
class EventObserverBase;
template<typename... Args> class EventObservable;
template<typename... Args> class EventObserver;
template <typename... Args> class EventObservableView;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class Real2;
class Real3;
class Real2x2;
class Real3x3;
template <typename T> class Vector2;
template <typename T> class Vector3;
using Int64x3 = Vector3<Int64>;
using Int32x3 = Vector3<Int32>;
using Int64x2 = Vector2<Int64>;
using Int32x2 = Vector2<Int32>;
template<typename T,int Size> class NumVector;
template<typename T,int RowSize,int ColumnSize = RowSize> class NumMatrix;
using RealN2 = NumVector<Real,2>;
using RealN3 = NumVector<Real,3>;
using RealN2x2 = NumMatrix<Real,2>;
using RealN3x3 = NumMatrix<Real,3>;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class HPReal;
class JSONWriter;
class JSONValue;
class JSONDocument;
class JSONValueList;
class CommandLineArguments;
class ApplicationInfo;
class VersionInfo;
 
class IObservable;
class IObserver;
class Observable;
class Observer;
 
class ArrayShape;
class ConstMemoryView;
using MemoryView ARCANE_DEPRECATED_REASON("Use 'ConstMemoryView' instead") = ConstMemoryView;
class MutableMemoryView;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class IPerformanceCounterService;
class ForLoopTraceInfo;
class ForLoopOneExecStat;
namespace impl
{
class ForLoopStatInfoList;
class ForLoopStatInfoListImpl;
class ForLoopCumulativeStat;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Dans ConcurrencyUtils.h
 
class ParallelLoopOptions;
class ParallelFor1DLoopInfo;
class TaskContext;
class ITaskFunctor;
template<typename InstanceType>
class TaskFunctor;
template<typename InstanceType>
class TaskFunctorWithContext;
class ITask;
class ITaskImplementation;
class TaskFactory;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Ces classes ne sont pas accessibles dans 'utils' mais il est possible
// d'utiliser des pointeurs sur ces instances.
// La définition est dans 'arcane_accelerator_core'
namespace Accelerator
{
class Runner;
class RunQueue;
}
using Accelerator::Runner;
using Accelerator::RunQueue;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class DefaultLayout;
template<int RankValue> class RightLayoutN;
template<int RankValue> class LeftLayoutN;
template<int RankValue> class MDDimType;
class IMemoryResourceMng;
using IMemoryRessourceMng = IMemoryResourceMng;
template <typename IndexType_ = Int32, Int32... RankSize> class ExtentsV;
template<class DataType,typename Extents,typename LayoutPolicy = DefaultLayout >
class MDSpan;
template<typename DataType,typename Extents,typename LayoutPolicy = DefaultLayout >
using MDSpanBase ARCANE_DEPRECATED_REASON("Use 'MDSpan' type instead") = MDSpan<DataType,Extents,LayoutPolicy>;
template<class DataType,typename Extents,typename LayoutType = DefaultLayout >
class NumArray;
template<typename DataType,typename Extents,typename LayoutPolicy = DefaultLayout >
using NumArrayBase ARCANE_DEPRECATED_REASON("Use 'NumArray' type instead") = NumArray<DataType,Extents,LayoutPolicy>;
template<typename ExtentType> class ArrayBounds;
template<int RankValue, typename IndexType_ = Int32> class MDIndexBase;
template<int RankValue, typename IndexType_ = Int32> class MDIndex;
template<int RankValue, typename IndexType_ = Int32> using ArrayIndexBase = MDIndexBase<RankValue,IndexType_>;
template<int RankValue, typename IndexType_ = Int32> using ArrayIndex = MDIndex<RankValue,IndexType_>;
template<int RankValue> using ArrayBoundsIndexBase ARCANE_DEPRECATED_REASON("Use 'MDIndexBase' type instead") = ArrayIndexBase<RankValue>;
template<int RankValue> using ArrayBoundsIndex ARCANE_DEPRECATED_REASON("Use 'MDIndex' type instead") = ArrayIndex<RankValue>;
template<typename Extents> class ArrayExtentsBase;
template<typename Extents> class ArrayExtents;
template<int RankValue> class ArrayStridesBase;
template<typename Extents,typename LayoutPolicy> class ArrayExtentsWithOffset;
class ForLoopRange;
template<int RankValue, typename IndexType_ = Int32> class SimpleForLoopRanges;
template<int RankValue, typename IndexType_ = Int32> class ComplexForLoopRanges;
template<int RankValue> class IMDRangeFunctor;
template<int RankValue> class ArrayExtentsValueDynamic;
namespace impl
{
template<typename IndexType_, Int32... RankSize> class ArrayExtentsValue;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
// Pour compatibilité avec l'existant (à supprimer après la version 3.8)
using LoopRange = ForLoopRange;
template<int RankValue> using SimpleLoopRanges = SimpleForLoopRanges<RankValue>;
template<int RankValue> using ComplexLoopRanges = ComplexForLoopRanges<RankValue>;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
// Les types de ce namespace sont dans la composante 'arcane_accelerator_core'
// et ne sont pas directement accessibles dans 'arcane_utils'.
// Ils peuvent cependant être utilisés en paramètre de certaines méthodes.
 
namespace Accelerator
{
class RunQueue;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef Array<Pointer> PointerArray;
typedef Array<Byte> ByteArray;
typedef Array<UChar> UCharArray;
typedef Array<Int64> Int64Array;
typedef Array<Int32> Int32Array;
typedef Array<Int16> Int16Array;
typedef Array<Int8> Int8Array;
typedef Array<Integer> IntegerArray;
typedef Array<Real> RealArray;
typedef Array<BFloat16> BFloat16Array;
typedef Array<Float16> Float16Array;
typedef Array<Float32> Float32Array;
typedef Array<bool> BoolArray;
typedef Array<String> StringArray;
typedef Array<Real2> Real2Array;
typedef Array<Real3> Real3Array;
typedef Array<Real2x2> Real2x2Array;
typedef Array<Real3x3> Real3x3Array;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef Array2<Pointer> PointerArray2;
typedef Array2<Byte> ByteArray2;
typedef Array2<UChar> UCharArray2;
typedef Array2<Int64> Int64Array2;
typedef Array2<Int32> Int32Array2;
typedef Array2<Int16> Int16Array2;
typedef Array2<Int8> Int8Array2;
typedef Array2<Integer> IntegerArray2;
typedef Array2<Real> RealArray2;
typedef Array2<BFloat16> BFloat16Array2;
typedef Array2<Float16> Float16Array2;
typedef Array2<Float32> Float32Array2;
typedef Array2<bool> BoolArray2;
typedef Array2<String> StringArray2;
typedef Array2<Real2> Real2Array2;
typedef Array2<Real3> Real3Array2;
typedef Array2<Real2x2> Real2x2Array2;
typedef Array2<Real3x3> Real3x3Array2;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef SharedArray2<Pointer> PointerSharedArray2;
typedef SharedArray2<Byte> ByteSharedArray2;
typedef SharedArray2<UChar> UCharSharedArray2;
typedef SharedArray2<Int64> Int64SharedArray2;
typedef SharedArray2<Int32> Int32SharedArray2;
typedef SharedArray2<Int16> Int16SharedArray2;
typedef SharedArray2<Int8> Int8SharedArray2;
typedef SharedArray2<Integer> IntegerSharedArray2;
typedef SharedArray2<Real> RealSharedArray2;
typedef SharedArray2<BFloat16> BFloat16SharedArray2;
typedef SharedArray2<Float16> Float16SharedArray2;
typedef SharedArray2<Float32> Float32SharedArray2;
typedef SharedArray2<bool> BoolSharedArray2;
typedef SharedArray2<String> StringSharedArray2;
typedef SharedArray2<Real2> Real2SharedArray2;
typedef SharedArray2<Real3> Real3SharedArray2;
typedef SharedArray2<Real2x2> Real2x2SharedArray2;
typedef SharedArray2<Real3x3> Real3x3SharedArray2;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef UniqueArray2<Pointer> PointerUniqueArray2;
typedef UniqueArray2<Byte> ByteUniqueArray2;
typedef UniqueArray2<UChar> UCharUniqueArray2;
typedef UniqueArray2<Int64> Int64UniqueArray2;
typedef UniqueArray2<Int32> Int32UniqueArray2;
typedef UniqueArray2<Integer> IntegerUniqueArray2;
typedef UniqueArray2<Real> RealUniqueArray2;
typedef UniqueArray2<bool> BoolUniqueArray2;
typedef UniqueArray2<String> StringUniqueArray2;
typedef UniqueArray2<Real2> Real2UniqueArray2;
typedef UniqueArray2<Real3> Real3UniqueArray2;
typedef UniqueArray2<Real2x2> Real2x2UniqueArray2;
typedef UniqueArray2<Real3x3> Real3x3UniqueArray2;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef Array2View<Pointer> PointerArray2View;
typedef Array2View<Byte> ByteArray2View;
typedef Array2View<UChar> UCharArray2View;
typedef Array2View<Int64> Int64Array2View;
typedef Array2View<Int32> Int32Array2View;
typedef Array2View<Int16> Int16Array2View;
typedef Array2View<Integer> IntegerArray2View;
typedef Array2View<Real> RealArray2View;
typedef Array2View<bool> BoolArray2View;
typedef Array2View<String> StringArray2View;
typedef Array2View<Real2> Real2Array2View;
typedef Array2View<Real3> Real3Array2View;
typedef Array2View<Real2x2> Real2x2Array2View;
typedef Array2View<Real3x3> Real3x3Array2View;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef ConstArray2View<Pointer> PointerConstArray2View;
typedef ConstArray2View<Byte> ByteConstArray2View;
typedef ConstArray2View<UChar> UCharConstArray2View;
typedef ConstArray2View<Int64> Int64ConstArray2View;
typedef ConstArray2View<Int32> Int32ConstArray2View;
typedef ConstArray2View<Int16> Int16ConstArray2View;
typedef ConstArray2View<Integer> IntegerConstArray2View;
typedef ConstArray2View<Real> RealConstArray2View;
typedef ConstArray2View<bool> BoolConstArray2View;
typedef ConstArray2View<String> StringConstArray2View;
typedef ConstArray2View<Real2> Real2ConstArray2View;
typedef ConstArray2View<Real3> Real3ConstArray2View;
typedef ConstArray2View<Real2x2> Real2x2ConstArray2View;
typedef ConstArray2View<Real3x3> Real3x3ConstArray2View;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef UniqueArray<Pointer> PointerUniqueArray;
typedef UniqueArray<Byte> ByteUniqueArray;
typedef UniqueArray<UChar> UCharUniqueArray;
typedef UniqueArray<Int64> Int64UniqueArray;
typedef UniqueArray<Int32> Int32UniqueArray;
typedef UniqueArray<Int16> Int16UniqueArray;
typedef UniqueArray<Int8> Int8UniqueArray;
typedef UniqueArray<Integer> IntegerUniqueArray;
typedef UniqueArray<Real> RealUniqueArray;
typedef UniqueArray<BFloat16> BFloat16UniqueArray;
typedef UniqueArray<Float16> Float16UniqueArray;
typedef UniqueArray<Float32> Float32UniqueArray;
typedef UniqueArray<bool> BoolUniqueArray;
typedef UniqueArray<String> StringUniqueArray;
typedef UniqueArray<Real2> Real2UniqueArray;
typedef UniqueArray<Real3> Real3UniqueArray;
typedef UniqueArray<Real2x2> Real2x2UniqueArray;
typedef UniqueArray<Real3x3> Real3x3UniqueArray;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef SharedArray<Pointer> PointerSharedArray;
typedef SharedArray<Byte> ByteSharedArray;
typedef SharedArray<UChar> UCharSharedArray;
typedef SharedArray<Int64> Int64SharedArray;
typedef SharedArray<Int32> Int32SharedArray;
typedef SharedArray<Int16> Int16SharedArray;
typedef SharedArray<Int8> Int8SharedArray;
typedef SharedArray<Integer> IntegerSharedArray;
typedef SharedArray<Real> RealSharedArray;
typedef SharedArray<BFloat16> BFloat16SharedArray;
typedef SharedArray<Float16> Float16SharedArray;
typedef SharedArray<Float32> Float32SharedArray;
typedef SharedArray<bool> BoolSharedArray;
typedef SharedArray<String> StringSharedArray;
typedef SharedArray<Real2> Real2SharedArray;
typedef SharedArray<Real3> Real3SharedArray;
typedef SharedArray<Real2x2> Real2x2SharedArray;
typedef SharedArray<Real3x3> Real3x3SharedArray;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef MultiArray2<Pointer> PointerMultiArray2;
typedef MultiArray2<Byte> ByteMultiArray2;
typedef MultiArray2<UChar> UCharMultiArray2;
typedef MultiArray2<Int64> Int64MultiArray2;
typedef MultiArray2<Int32> Int32MultiArray2;
typedef MultiArray2<Int16> Int16MultiArray2;
typedef MultiArray2<Integer> IntegerMultiArray2;
typedef MultiArray2<Real> RealMultiArray2;
typedef MultiArray2<bool> BoolMultiArray2;
typedef MultiArray2<String> StringMultiArray2;
typedef MultiArray2<Real2> Real2MultiArray2;
typedef MultiArray2<Real3> Real3MultiArray2;
typedef MultiArray2<Real2x2> Real2x2MultiArray2;
typedef MultiArray2<Real3x3> Real3x3MultiArray2;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
        
typedef ArrayView<Pointer> PointerArrayView;
typedef ArrayView<Byte> ByteArrayView;
typedef ArrayView<UChar> UCharArrayView;
typedef ArrayView<Int64> Int64ArrayView;
typedef ArrayView<Int32> Int32ArrayView;
typedef ArrayView<Int16> Int16ArrayView;
typedef ArrayView<Integer> IntegerArrayView;
typedef ArrayView<Real> RealArrayView;
typedef ArrayView<bool> BoolArrayView;
typedef ArrayView<String> StringArrayView;
typedef ArrayView<Real2> Real2ArrayView;
typedef ArrayView<Real3> Real3ArrayView;
typedef ArrayView<Real2x2> Real2x2ArrayView;
typedef ArrayView<Real3x3> Real3x3ArrayView;

typedef ConstArrayView<Pointer> PointerConstArrayView;
typedef ConstArrayView<Byte> ByteConstArrayView;
typedef ConstArrayView<UChar> UCharConstArrayView;
typedef ConstArrayView<Int64> Int64ConstArrayView;
typedef ConstArrayView<Int32> Int32ConstArrayView;
typedef ConstArrayView<Int16> Int16ConstArrayView;
typedef ConstArrayView<Integer> IntegerConstArrayView;
typedef ConstArrayView<Real> RealConstArrayView;
typedef ConstArrayView<bool> BoolConstArrayView;
typedef ConstArrayView<String> StringConstArrayView;
typedef ConstArrayView<Real2> Real2ConstArrayView;
typedef ConstArrayView<Real3> Real3ConstArrayView;
typedef ConstArrayView<Real2x2> Real2x2ConstArrayView;
typedef ConstArrayView<Real3x3> Real3x3ConstArrayView;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef Collection<String> StringCollection;

typedef List<String> StringList;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
typedef Span<Pointer> PointerSpan;
typedef Span<std::byte> ByteSpan;
typedef Span<UChar> UCharSpan;
typedef Span<Int64> Int64Span;
typedef Span<Int32> Int32Span;
typedef Span<Int16> Int16Span;
typedef Span<Integer> IntegerSpan;
typedef Span<Real> RealSpan;
typedef Span<bool> BoolSpan;
typedef Span<Integer> IntegerSpan;
typedef Span<Real2> Real2Span;
typedef Span<Real3> Real3Span;
typedef Span<Real2x2> Real2x2Span;
typedef Span<Real3x3> Real3x3Span;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

typedef Span<const Pointer> PointerConstSpan;
typedef Span<const std::byte> ByteConstSpan;
typedef Span<const UChar> UCharConstSpan;
typedef Span<const Int64> Int64ConstSpan;
typedef Span<const Int32> Int32ConstSpan;
typedef Span<const Int16> Int16ConstSpan;
typedef Span<const Integer> IntegerConstSpan;
typedef Span<const Real> RealConstSpan;
typedef Span<const bool> BoolConstSpan;
typedef Span<const Integer> IntegerConstSpan;
typedef Span<const Real2> Real2ConstSpan;
typedef Span<const Real3> Real3ConstSpan;
typedef Span<const Real2x2> Real2x2ConstSpan;
typedef Span<const Real3x3> Real3x3ConstSpan;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

using PointerSmallSpan = SmallSpan<Pointer>;
using ByteSmallSpan = SmallSpan<std::byte>;
using UCharSmallSpan = SmallSpan<UChar>;
using Int64SmallSpan = SmallSpan<Int64>;
using Int32SmallSpan = SmallSpan<Int32>;
using Int16SmallSpan = SmallSpan<Int16>;
using IntegerSmallSpan = SmallSpan<Integer>;
using RealSmallSpan = SmallSpan<Real>;
using BoolSmallSpan = SmallSpan<bool>;
using IntegerSmallSpan = SmallSpan<Integer>;
using Real2SmallSpan = SmallSpan<Real2>;
using Real3SmallSpan = SmallSpan<Real3>;
using Real2x2SmallSpan = SmallSpan<Real2x2>;
using Real3x3SmallSpan = SmallSpan<Real3x3>;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

using PointerConstSmallSpan = SmallSpan<const Pointer>;
using ByteConstSmallSpan = SmallSpan<const std::byte>;
using UCharConstSmallSpan = SmallSpan<const UChar>;
using Int64ConstSmallSpan = SmallSpan<const Int64>;
using Int32ConstSmallSpan = SmallSpan<const Int32>;
using Int16ConstSmallSpan = SmallSpan<const Int16>;
using IntegerConstSmallSpan = SmallSpan<const Integer>;
using RealConstSmallSpan = SmallSpan<const Real>;
using BoolConstSmallSpan = SmallSpan<const bool>;
using IntegerConstSmallSpan = SmallSpan<const Integer>;
using Real2ConstSmallSpan = SmallSpan<const Real2>;
using Real3ConstSmallSpan = SmallSpan<const Real3>;
using Real2x2ConstSmallSpan = SmallSpan<const Real2x2>;
using Real3x3ConstSmallSpan = SmallSpan<const Real3x3>;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif