Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456]

NAccelerator
NAcceleratorRuntimeInitialisationInfo
CImpl
NArcane	-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
NAccelerator	Namespace for accelerator usage
NImpl
CItemLocalIdsLoopRanges	Information for the accelerator loop over entities
CConstituentRunCommandBase2	Base class for commands on constituents
CAllEnvCellRunCommandContainer	Container for a command on AllEnvCell
CConstituentCommandContainerBase	Base class of containers for commands on constituents (except for AllEnvCell)
CConstituentRunCommandContainer	Container containing the necessary information for a command on ConstituentItem
CConstituentAndGlobalCellRunCommandContainer	Container containing the necessary information for a command that allows access to both the ConstituentItem and the global entity
CConstituentIndexedSelectionRunCommandContainer	Container containing the necessary information for a command on an indexed selection of ConstituentItem
CGenericConstituentCommandArgs
CGenericConstituentCommand
CIsAlwaysUseSyclNdItem	Template to determine if a type used as a loop in kernels always requires sycl::nb_item as an argument
CHostAtomic
CSyclAtomic
CHostAtomic< eAtomicOperation::Add >
CHostAtomic< eAtomicOperation::Max >
CHostAtomic< eAtomicOperation::Min >
CAtomicImpl
CCommonCudaHipAtomic
CCommonCudaHipAtomicAdd
CCommonCudaHipAtomicMax
CCommonCudaHipAtomicMin
CCommonCudaHipAtomic< int, eAtomicOperation::Add >
CCommonCudaHipAtomic< int, eAtomicOperation::Max >
CCommonCudaHipAtomic< int, eAtomicOperation::Min >
CCommonCudaHipAtomic< Int64, eAtomicOperation::Add >
CCommonCudaHipAtomic< Int64, eAtomicOperation::Max >
CCommonCudaHipAtomic< Int64, eAtomicOperation::Min >
CCommonCudaHipAtomic< double, eAtomicOperation::Add >
CCommonCudaHipAtomic< double, eAtomicOperation::Max >
CCommonCudaHipAtomic< double, eAtomicOperation::Min >
CLambdaStorage	Class to manage the storage of a lambda within an iterator
CGenericDeviceStorage	Manages internal allocation on the device
CDeviceStorageBase	Manages internal allocation on the device
CDeviceStorage	Manages internal allocation on the device for a given type
CIndexIterator	Iterator over an index
CSumOperator	Scan/Reduce operator for sums
CMinOperator	Scan/Reduce Operator for minimum
CMaxOperator	Scan/Reduce Operator for maximum
CGetterLambdaIterator	Iterator over a lambda to retrieve a value via an index
CSetterLambdaIterator	Iterator over a lambda to position a value via an index
CSetter	Allows positioning an element of the output iterator
CGenericFilteringBase	Base class for performing filtering
CGenericFilteringFlag	Class for performing filtering
CGenericFilteringIf	Class for performing filtering
CGenericPartitionerBase	Base class for performing filtering
CGenericPartitionerIf	Class for partitioning a list
CGenericReducerIf	Class for partitioning a list
CReduceOperatorToReducerTypeTraits
CReduceOperatorToReducerTypeTraits< DataType, MaxOperator< DataType > >
CReduceOperatorToReducerTypeTraits< DataType, MinOperator< DataType > >
CReduceOperatorToReducerTypeTraits< DataType, SumOperator< DataType > >
CGenericReducerBase	Base class for performing a reduction
CScannerImpl	Class to perform an exclusive or inclusive scan with a specific operator
CGenericSorterBase	Base class for performing a sort
CGenericSorterMergeSort	Class for sorting a list
CAcceleratorSpecificMemoryCopy
CAcceleratorIndexedCopyTraits
CAcceleratorSpecificMemoryCopyList	Singleton containing the instances of the copy functions on accelerators
CCudaHipKernelRemainingArgsHelper	Class to apply an operation for additional arguments at the beginning and end of a CUDA/HIP kernel
CSyclKernelRemainingArgsHelper	Class to apply an operation for additional arguments at the beginning and end of a Sycl kernel
CPrivatizer
CInvalidKernelClass
CLocalMemoryKernelRemainingArg	Handler for LocalMemory called at the beginning and end of kernel execution
CMultiThreadAlgo	Advanced algorithms in multi-thread mode
CReduceIdentity
CReduceIdentity< double >
CReduceIdentity< Int32 >
CReduceIdentity< Int64 >
CReduceDeviceInfo	Information to perform a reduction on a device
CReduceAtomicSum
CReduceAtomicSum< double >
CReduceAtomicSum< Int64 >
CReduceAtomicSum< Int32 >
CReduceFunctorSum
CReduceFunctorMax
CReduceFunctorMin
CHostDeviceReducerKernelRemainingArg	Class to manage HostDeviceReducer2 arguments at the beginning and end of kernel execution
CHostLaunchLoopRangeBase	Information of a loop using hierarchical parallelism on the host
CHostLaunchLoopRange
CWorkGroupLoopContextBuilder
CWorkGroupSequentialForHelper	Class to execute a portion of the loop sequentially on the host
CExtendedLaunchRunCommand	Class to retain the arguments of a RunCommand
CExtendedLaunchLoop	Class to manage the launch of a hierarchical compute kernel
CArrayBoundRunCommand	Class to store arguments of a RunCommand
CExtendedArrayBoundLoop	Class to manage additional parameters of commands
CThreadGridSynchronizer	Class to manage grid synchronization in multi-thread;
CNullFunc
CDeviceInfoList	Interface for a list of devices
CRuntimeStaticInfo	Static class providing internal functions for Arcane
CIRunnerRuntime	Interface of the runtime associated with an accelerator
CIRunQueueEventImpl	Interface for event implementation
CIRunQueueStream	Interface of an execution stream for a RunQueue
CMemoryTracer	Utility class for tracing memory accesses between the accelerator and the host
CMemoryTracerWrapper	Utility class for tracing allocations/deallocations
CReduceMemoryImpl
CRunCommandImpl	Implementation of a command for accelerator
CRunQueueImplStack
CRunnerImpl
CLock	Lock for the RunQueue pool in multi-thread
CRunQueueImpl	Execution queue for accelerator
CLock	Lock for the RunCommand pool in multi-thread
CRuntimeLoader	Management of accelerator runtime loading
CIReduceMemoryImpl	Interface for memory management for reductions
CGridMemoryInfo	Memory information for reduction on accelerators
CKernelLaunchArgs	Arguments for launching a kernel
CMemoryTracerMng
CInfo
CNativeStream	Opaque type to encapsulate a native 'stream'
CRunCommandLaunchInfo	Temporary object to store the execution information of a command and group tests
CHostRunQueueStream
CHostRunQueueEvent
CCommonRunnerRuntime
CSequentialRunnerRuntime
CThreadRunnerRuntime
CStridedLoopRangesBase	Class to manage the decomposition of a loop into multiple parts
CStridedLoopRanges	Class to manage the decomposition of a loop into multiple parts
Nimpl
CRunCommandItemEnumeratorSubTraitsT	Template to know the entity type associated with T
CRunCommandItemEnumeratorSubTraitsT< ItemLocalIdT< T > >	Specialization for ItemLocalIdT
CRunCommandItemEnumeratorSubTraitsT< IteratorWithIndex< T > >	Specialization for IteratorWithIndex<T>
CRunCommandItemContainer	Container for RunCommandEnumerate
CRunCommandItemEnumeratorTraitsT	Characteristics of an enumerator for a command on entities
CItemRunCommandArgs
NCuda
CConcreteAllocator
CUnderlyingAllocator
CUnifiedMemoryConcreteAllocator
CUnifiedMemoryCudaMemoryAllocator	Allocator for unified memory
CHostPinnedConcreteAllocator
CHostPinnedCudaMemoryAllocator
CDeviceConcreteAllocator
CDeviceCudaMemoryAllocator
COccupancyMap	Map containing the ideal occupancy for a given kernel
CCudaRunQueueStream
CCudaRunQueueEvent
CCudaRunnerRuntime
CCudaMemoryCopier
CCuptiInfo	Singleton class to manage CUPTI
CKernelLaunchArgs	Arguments for launching a kernel
CAcceleratorStatInfoList	Statistics for accelerators
CMemoryTransferInfo	Information on memory transfers between CPU and GPU
CMemoryPageFaultInfo	Information on page faults on CPU or GPU
NHip
CConcreteAllocator
CUnderlyingAllocator
CUnifiedMemoryConcreteAllocator
CUnifiedMemoryHipMemoryAllocator
CHostPinnedConcreteAllocator
CHostPinnedHipMemoryAllocator
CDeviceConcreteAllocator
CDeviceHipMemoryAllocator
CHipRunQueueStream
CHipRunQueueEvent
CHipRunnerRuntime
CHipMemoryCopier
CKernelLaunchArgs	Arguments for launching a kernel
NSycl
CSyclMemoryAllocatorBase	Base class for a specific 'Sycl' allocator
CUnifiedMemorySyclMemoryAllocator
CHostPinnedSyclMemoryAllocator
CDeviceSyclMemoryAllocator
CSyclRunQueueStream
CSyclRunQueueEvent
CSyclRunnerRuntime
CSyclMemoryCopier
CKernelLaunchArgs	Arguments for launching a kernel
CAsyncRunQueuePool	Collection of asynchronous execution queues with priority on accelerator
CAcceleratorRuntimeInitialisationInfoProperties
CMatVariableViewBase	Base class for views on material variables
CMatItemVariableScalarInViewT	Read view on a scalar mesh variable
CMatItemVariableScalarOutViewT	Write view on a scalar mesh variable
CItemRunCommand
CView1DGetterSetter	Class to access a 1D array of a read/write view
CVariableViewBase	Base class for variable views
CView1DSetter	Class to access a 1D array of a read/write view
CItemVariableScalarOutViewBaseT	Write view on a scalar variable of the mesh
CItemVariableScalarOutViewT	Write view on a scalar variable of the mesh
CItemPartialVariableScalarOutViewT	Write view on a partial scalar variable of the mesh
CItemVariableScalarInViewT	Read view on a scalar variable of the mesh
CItemPartialVariableScalarInViewT	Read view on a partial scalar variable of the mesh
CItemPartialVariableArrayInViewT	Read-only view on a partial array variable of the mesh
CItemVariableArrayInViewT	Read-only view on a mesh array variable
CItemVariableArrayOutViewBaseT	Write-only view on a mesh array variable
CItemVariableArrayOutViewT	Write-only view on a mesh array variable
CItemPartialVariableArrayOutViewT	Write-only view on a partial array variable of the mesh
CItemVariableRealNScalarOutViewT	Write-only view on a scalar variable of type 'RealN' of the mesh
CItemPartialVariableRealNScalarOutViewT
CIndexSelecter	Construction of a subset of indices from a criterion
CLocalMemory	Local memory (shared) for a RunCommand
CAcceleratorInitializer	Class to initialize a runtime for the accelerator API
CCooperativeHostWorkItemGrid	Manages a WorkItem grid in a CooperativeWorkGroupLoopRange for the host
CCooperativeWorkGroupLoopContext	Execution context for a command on a set of blocks
CCooperativeWorkGroupLoopRange	Iteration range of a loop using cooperative hierarchical parallelism
CGenericFilterer	Generic filtering algorithm on accelerator
CGenericPartitioner	Generic algorithm for partitioning a list
CGenericReducer	Generic accelerator reduction algorithm
CScanner	Exclusive or inclusive scan algorithms on accelerators
CGenericScanner	Exclusive or inclusive scan algorithms on accelerators
CSetterLambdaIterator	Iterator over a lambda to position a value via an index
CSetter	Allows positioning an element of the output iterator
CGenericSorter	Generic sorting algorithm on accelerator
CInitializer	Internal class to initialize the accelerator runtime
CNumArrayViewSetter
CNumArrayView	Read, write, or read/write view on a 'NumArray'
CNumArrayViewBase	Base class for views on 'NumArray'
CHostDeviceReducerBase	Reduction operator
CHostDeviceReducer	Version 1 of the reduction
CHostDeviceReducer2	Version 2 of the reduction
CSyclReducer	Implementation of the reduction for the SYCL backend
CReducerSum	Class to perform a 'sum' reduction
CReducerMax	Class to perform a 'max' reduction
CReducerMin	Class to perform a 'min' reduction
CReducerSum2	Class to perform a 'sum' reduction
CReducerMax2	Class to perform a 'max' reduction
CReducerMin2	Class to perform a 'min' reduction
CSpanViewSetter
CSpanViewBase	Base class for views on 'NumArray'
CSpanView	Read, write, or read/write view on a 'Span'
CSmallSpanView	Read, write, or read/write view on a 'SmallSpan'
CHostWorkItem	Manages a WorkItem on the host within a WorkGroupLoopRange or CooperativeWorkGroupLoopRange
CDeviceWorkItem
CSyclDeviceWorkItem
CWorkGroupLoopRange	Iteration range of a loop using hierarchical parallelism
CWorkGroupLoopContext	Execution context of a command on a set of blocks
CSyclWorkGroupLoopContext
CSyclCooperativeWorkGroupLoopContext
CWorkGroupLoopContextBase	Base class for WorkGroupLoopContext and CooperativeWorkGroupLoopContext
CSyclWorkGroupLoopContextBase
CHostIndexes
CHostWorkItemIterator
CDeviceIndexesBase
CDeviceWorkItemIterator
CDeviceWorkItemSentinel
CHostWorkItemBlock	Manages a block of WorkItems on the host within a WorkGroupLoopRange or a CooperativeWorkGroupLoopRange
CWorkGroupLoopRangeBase	Iteration range of a loop using hierarchical parallelism
CAcceleratorMng	Module Manager
CAcceleratorRuntimeInitialisationInfo	Information for accelerator initialization
CDeviceId	Identifier of a system component
CDeviceInfo	Information about an accelerator
CDeviceMemoryInfo	Accelerator memory information
CIAcceleratorMng	Accelerator manager interface
CIDeviceInfoList	Interface of a list of devices
CBlockAllocatorWrapper	Common class for managing block allocation
CAcceleratorMemoryAllocatorBase	Base class of a specific allocator for accelerator
CIUnderlyingAllocator
CRegisterRuntimeInfo	Information to initialize the accelerator runtime
CRunnerInternal
CMemoryCopyArgs	Memory copy arguments
CMemoryPrefetchArgs	Memory prefetching arguments
CPointerAttribute	Information about a memory address
CProfileRegion	Region for profiling
CRunCommand	Management of an accelerator command
CRunner	Execution manager for accelerator
CRunQueue	Execution queue for an accelerator
CScopedAsync
CRunQueueBuildInfo	Information to create a RunQueue
CRunQueueEvent	Event for a run queue
CInternalImpl
CRunQueuePool	Collection of RunQueues
CViewBuildInfo	Information to build a view for accelerator data
CNumArray	Multi-dimensional arrays for numerical types accessible on accelerators
Nimpl
Ndetail
Cfloat32_bits
CIterBuilderWithIndex
CIterBuilderNoIndex
CCartesianItemDirectionInfo	Internal structure containing the entity in front and behind in a direction
CCartesianMeshGenerationInfo	Information on Cartesian mesh generation
CMshMeshGenerationInfo	Brief information about a mesh derived from the 'msh' format
CMshPhysicalName	Brief information about a physical name
CMshPhysicalNameList	Brief information about the '$PhysicalNames' block
CMshEntitiesNodes	Info for 0D entities
CMshEntitiesWithNodes	Info for 1D, 2D, and 3D entities
CMshPeriodicOneInfo
CMshPeriodicInfo	Information on periodicity
CItemIndexedListView	Internal view of an array of entities
CItemLocalIdListContainerView	View over the container of a list of ItemLocalId
CMeshItemSharedInfoList	List of ItemSharedInfo associated with a mesh
CMeshMDVariableRefWrapperT
CHasher	Class to calculate the hash of an array
CBasicReaderWriterDatabaseEpilogFormat	Structure to manage the epilogue
CBasicReaderWriterDatabaseHeaderFormat	Structure to manage the header
CBasicReaderWriterDatabaseCommon
CExtentsInfo
CDataInfo
CBasicReader	Simple reader
CIItemGroupFinder	Interface to find the group associated with a variable based on this metadata
CBasicVariableMetaData
CIGenericReader	Generic Reader
CBasicGenericReader	Basic implementation of IGenericReader
CIGenericWriter	Generic Writer
CBasicGenericWriter
CBasicReaderWriterCommon
CKeyValueTextWriter
CImpl
CKeyValueTextReader	Text file writing class for backups/restorations
CImpl
CBasicWriter	Simple read/write
CTextReader2	Class for writing a text file for backups/restorations
CImpl
CTextWriter2	Class for writing a text file for backups/restorations
CImpl
CVariableDataInfo	Variable data information
CVariableDataInfoMap	Associative map of variable data
CTextReader	Class for writing a text file for backups/restorations
CImpl
CTextWriter	Text file writing class for backups/restorations
CImpl
CHashTableMap2Base	Base class for HashTableMap2
CIndex
CHashTableMap2	Implementation of std::unordered_map
Citerator
Cconst_iterator
CStringViewInputStream	Encapsulates an std::istream for a StringView
CExtentValue	Information for a fixed dimension known at compile time
CExtentValue< DynExtent, IndexType_ >	Specialization for a dynamic dimension
CArrayExtentsValue< IndexType_, X0 >	Specialization to hold the dimensions of a 1-dimensional array
CArrayExtentsValue< IndexType_, X0, X1 >	Specialization to hold the dimensions of a 2-dimensional array
CArrayExtentsValue< IndexType_, X0, X1, X2 >	Specialization to hold the dimensions of a 3-dimensional array
CArrayExtentsValue< IndexType_, X0, X1, X2, X3 >	Specialization to hold the dimensions of a 4-dimensional array
CReferenceCounterWrapper	Wrapper around a class managing its own reference counter
CArrayExtentsValue
NMaterials	Always enables tracing in Arcane parts concerning materials
Nmatimpl
CConstituentItemBase	General information about a constituent entity
CItemBase	Base class for mesh entities
NImpl
CConstituentItemIndexedSelectionViewTraits	Characteristics for the container associated with ConstituentItemIndexedSelectionView
CConstituentItemIndexedSelectionViewTraitsBase
CConstituentItemIndexedSelectionViewTraits< ComponentItemVectorView >
CConstituentItemIndexedSelectionViewTraits< MatCellVectorView >
CConstituentItemIndexedSelectionViewTraits< EnvCellVectorView >
CConstituentItemIndexedSelectionViewTraitsSpanBase	Partial specialization for a SmallSpan<T>
CConstituentItemIndexedSelectionViewTraits< SmallSpan< const ConstituentItem > >
CConstituentItemIndexedSelectionViewTraits< SmallSpan< const MatCell > >
CConstituentItemIndexedSelectionViewTraits< SmallSpan< const EnvCell > >
CConstituentAndGlobalCellIteratorValue	Index of an accelerator loop over materials or media
CData	Simple internal structure to avoid using std::tuple for the operator()
CCellToAllEnvCellConverter	Conversion of 'Cell' to 'AllEnvCell'
CNullComponentItemSharedInfoContainer	Container for the null entity
CIConstituentItemVectorImpl	Interface for the implementation of ComponentItemVector
CComponentItemVector	Vector over the entities of a constituent
CComponentItemVectorView	View over a vector of entities of a component
CMatItemVectorView	View over a vector of entities of a material
CEnvItemVectorView	View over a vector of entities of an environment
CComponentPartItemVectorView	View over pure or partial entities of a component
CComponentPurePartItemVectorView	View over the pure part of a component
CComponentImpurePartItemVectorView	View over the impure part of a component
CMatPartItemVectorView	View over pure or partial entities of a material
CMatPurePartItemVectorView	View over the pure part of the entities of a material
CMatImpurePartItemVectorView	View over the impure part of the entities of a material
CEnvPartItemVectorView	View over pure or partial entities of an environment
CEnvPurePartItemVectorView	View over the pure part of the entities of an environment
CEnvImpurePartItemVectorView	View over the impure part of the entities of an environment
CConstituentItem	Represents a component of a multi-material cell
CCellComponentCellEnumerator	Enumerator over the constituents of a cell
CSentinel
CIterator
CIteratorT
CCellComponentCellEnumeratorT	Typed enumerator over the component cells of a cell
CConstituentItemLocalIdListView	View of a ConstituentItemLocalIdList instance
CConstituentItemIndexedSelectionViewBase	Base class for ConstituentItemIndexedSelectionView
CConstituentItemIndexedSelectionView	View over a subset of a ConstituentItem container
CConstituentItemIndexedSelectionEnumerator	Enumerator over the elements of a ConstituentItemIndexedSelectionView
CComponentCellVectorSelectionView	Selection over a ComponentCellVectorView
CEnvCellVectorSelectionView	Selection over an EnvCellVectorView
CMatCellVectorSelectionView	Selection over a MatCellVectorView
CConstituentItemLocalId	Index of a ConstituentItem in a variable
CMatItemLocalId	Index of a MatItem in a variable
CEnvItemLocalId	Index of an EnvItem in a variable
CConstituentItemIndex	Index of a constituent entity in the list of constituent entities
CComponentItemSharedInfoStorageView	Container for constituent data
CConstituentItemSharedInfo	Shared information about 'ComponentItem'
CConstituentItemVectorBuildInfo	Construction options for 'ComponentItemVector' and
CEnvCellVector	Vector over the entities of an environment
CIArrayMeshMaterialVariable	Access interface for CellMaterialVariableArrayRef
CIEnumeratorTracer
CIMeshBlock	Interface of a mesh block
CIMeshComponent	Interface of a component (material or environment) of a mesh
CIUserMeshEnvironment	Interface of a user environment
CIMeshEnvironment	Interface of a mesh environment
CIUserMeshMaterial	Interface of a user material
CIMeshMaterial	Interface of a mesh material
CIMeshMaterialMng	Interface for the material and environment manager of a mesh
CIFactory
CIMeshMaterialVariable	Interface of a material variable on a mesh
CMeshMaterialVariableBuildTraits	Class for managing the creation of the concrete type of the material variable
CIMeshMaterialVariableComputeFunction	Interface of the functor class for recalculating a variable
CIMeshMaterialVariableFactory	Interface of a material variable factory
CIMeshMaterialVariableFactoryMng	Interface of the material variable factory manager
CConstituentItemLocalIdList	List of local indices for 'ComponentItemInternal'
CIMeshComponentInternal	Arcane internal API for 'IMeshComponent'
CIMeshMaterialMngInternal	Internal Arcane API for 'IMeshMaterialMng'
CCopyBetweenDataInfo	Information for copying between two memory regions
CVariableIndexerCommonArgs	Common arguments for all MeshMaterialVariableIndexer methods
CCopyBetweenPartialAndGlobalArgs	Arguments for methods copying between partial and global values
CInitializeWithZeroArgs	Arguments for methods copying between partial and global values
CResizeVariableIndexerArgs	Arguments for methods copying between partial and global values
CIMeshMaterialVariableInternal	Arcane internal API for 'IMeshMaterialVariable'
CIScalarMeshMaterialVariable	Access interface for CellMaterialVariableScalarRef
CEnvAndGlobalCell
CMatAndGlobalCell
CEnumeratorBuilder
CCellMaterialVariableScalarRef	Scalar variable on the cells of a mesh material
CMaterialVariableBuildInfo
CMaterialVariableTypeInfo	Information characterizing the type of a material variable
CMatCell	Represents a material in a multi-material cell
CEnvCell	Arcane cell of an environment
CAllEnvCell	Arcane cell with material and environment information
CMatPartCell
CEnvPartCell
CComponentPartCell
CComponentPartSimdCell
CComponentItemEnumeratorTraitsT
CAllEnvCellVectorView	View over a list of cells with environment information
CComponentCellEnumerator	Enumerator over a part of the cells of a component (material or environment)
CMatCellEnumerator	Enumerator over a part of the cells of a single material
CEnvCellEnumerator	Enumerator over the cells of an environment
CComponentPartCellEnumerator	Enumerator over a sub-part (pure or partial) of a subset of the cells of a component (material or environment)
CMatPartCellEnumerator	Enumerator for pure or impure entities of a material
CEnvPartCellEnumerator	Enumerator over pure or impure entities of an environment
CCellGenericEnumerator	Enumerator over the cells of an environment
CAllEnvCellEnumerator	Enumerator over all environment cells
CComponentEnumerator	Enumerator over components
CMatEnumerator	Enumerator over materials
CEnvEnumerator	Enumerator over environments
CComponentItemEnumeratorTraitsT< ComponentCell >
CComponentItemEnumeratorTraitsT< MatCell >
CComponentItemEnumeratorTraitsT< MatPartCell >
CComponentItemEnumeratorTraitsT< EnvPartCell >
CComponentItemEnumeratorTraitsT< EnvCell >
CComponentItemEnumeratorTraitsT< ComponentPartCell >
CComponentItemEnumeratorTraitsT< ComponentPartSimdCell >
CMatCellVector	Vector over the entities of a material
CMatVarIndex	Represents an index on material and environment variables
CPureMatVarIndex	Index of a pure material item in a variable
CCellEnvironmentVariableScalarRef	Scalar variable on the cells of a mesh environment
CCellEnvironmentVariableArrayRef	Array variable on the cells of a mesh material. For now, this class is only instantiated for cells
CMeshMaterialVariableComputeFunction	Interface for the functor class that recalculates a variable
CMeshMaterialVariableRef	Base class for material variable references
CEnumerator
CCellMaterialVariableArrayRef	Array variable over the cells of a material in the mesh. For now, this class is only instantiated for cells
CAllCellToAllEnvCell	Connectivity table from 'Cell' to its 'AllEnvCell' intended for use on accelerator
CCellToAllEnvCellAccessor	Encapsulation class to access the equivalent connectivity cell -> allenvcell. Intended to be used with the accelerator API via RUNCOMMAND_..
CCellToAllComponentCellEnumerator
CComponentPartSimdCellEnumerator	SIMD enumerator on a sub-part (pure or partial) of a subset of the cells of a component (material or medium)
CLoopFunctorEnvPartSimdCell
CMatVariableViewBase	Base class for variable views
CMatItemVariableScalarInViewT	Read view on a scalar mesh variable
CMatItemVariableScalarOutViewT	Read view on a scalar mesh variable
CEnumeratorTracer
CIMeshMaterialSynchronizeBuffer	Interface for buffers for material variable synchronization
CIMeshMaterialVariableSynchronizer	Interface of the material variable synchronizer
CAcceleratorMeshMaterialSynchronizerImpl	Synchronization strategy for the list of materials/media of entities on the accelerator
CAllCellToAllEnvCellContainer	Connectivity table of 'Cell' to its 'AllEnvCell' intended for use on accelerator
CImpl
CAllEnvData	Information on environment values
CRecomputeConstituentCellInfos
CConstituentConnectivityList	Management of constituent connectivity lists
CConstituentContainer	Container for connectivity data for a constituent type
CView	View onto a list of cell constituents
CNumberOfMaterialComputer	Class for calculating the number of materials in an environment
CContainer
CComponentItemInternalRange	Interval of constituent identifiers in the ComponentItemInternal list
CSentinel
CIterator
CComponentItemInternalData	Management of 'ComponentItemInternal' lists
CStorage	Container for ComponentItemSharedInfo information
CComponentItemListBuilder	Helper class for building a list of ComponentItems for a MeshMaterialVariableIndexer
CComponentItemListBuilderOld	Helper class for building a list of ComponentItems for a MeshMaterialVariableIndexer
CConstituentItemVectorImpl	Implementation of ComponentItemVector
CSetItemHelper	Helper for positioning vector entities
CConstituentListPrinter	Utility functions for displaying constituents
CConstituentModifierWorkInfo	Working structure used during the modification of constituents (via MeshMaterialModifier)
CIMeshMaterialSynchronizerImpl	Strategy for synchronizing the list of materials/media of entities
CIncrementalComponentModifier	Incremental modification of materials
CLegacyMeshMaterialSynchronizerImpl	Strategy for synchronizing the list of materials/media of entities
CMaterialModifierOperation	Operation to add or remove cells from a material
CMeshComponentData	Data of a constituent (material or medium) of a mesh
CMeshComponentPartData	Data of a part (pure or partial) of a constituent
CMeshEnvironment	Mesh environment
CInternalApi
CMeshMaterial	Mesh material
CInternalApi
CMeshMaterialMng	Implementation of a material manager
CRunnerInfo	Information about the execution queue used
CInternalApi
CMeshMaterialModifierImpl
COperationList
CMeshMaterialSynchronizer	Synchronization of the list of materials/media of entities
CMeshMaterialVariableIndexer	Indexer for material variables
CMeshMaterialVariablePrivate	Private section of a material variable
CMeshMaterialVariableSynchronizer	Material variable synchronizer
CLambdaMatItemRangeFunctorT	Functor over an iteration interval instantiated via a lambda function
CItemMaterialVariableScalar	Scalar variable on a mesh material
CMeshMaterialVariableScalar	Scalar variable on a mesh material
CMeshMaterialVariableArray	Array variable on a mesh material
CMeshBlock	Block of a mesh
CMeshBlockBuildInfo	Brief: Information for the creation of a block
CMeshEnvironmentObserver
CMeshEnvironmentBuildInfo	Information for creating an environment
CMatInfo
CMeshMaterialBackup	Saving/restoring material and medium values
CVarData
CMeshMaterialExchangeMng	Management of material exchange between subdomains
CExchangeCellStep
CExchangeCellFactory
CMeshMaterialIndirectModifier	Object allowing indirect modification of materials or media
CMeshMaterialInfo	Info about a material of a mesh
CMeshMaterialMngFactory
CMeshMaterialModifier	Object allowing modification of materials or media
CMultiBufferMeshMaterialSynchronizeBuffer
CBufferInfo
COneBufferMeshMaterialSynchronizeBuffer
CBufferInfo
CMeshMaterialVariable	Base class for material variables
CMaterialVariableScalarTraits	Characteristics for a scalar material variable
CMaterialVariableArrayTraits	Characteristics for an array material variable
CItemMaterialVariableBase	Base class for material variables with the characteristics specified by Traits
CMeshMaterialVariableCommonStaticImpl
CItemMaterialVariableArray	Array variable on a mesh material
CMeshMaterialVariableDependInfo	Information about a variable dependency
CMeshMaterialVariableFactoryMng
CMeshMaterialVariableFactory
CMeshMaterialVariableFactoryRegisterer	Registerer for a material variable factory.
CMeshMaterialVariableSynchronizerList	Synchronizing a list of material variables
CSyncInfo
CImpl
NCartesianMesh
NV2
CCartesianGrid	Encapsulation of a Cartesian grid with cells, nodes, and faces, up to 3 dimensions
CCartesianNumbering	Handling of a Cartesian numbering on a grid of items of up to 3 dimensions Allows conversion from a triplet (i,j,k) to an ID number The IDs range from firstId() to firstId()+nbItem()
NAnyItem
CArray	Array of items of arbitrary types
CArray2	2D array of items of arbitrary types
CFamilyInternal	AnyItem internal family Aggregation of groups to describe variables / partial variables
CFamily	AnyItem family (flyweight pattern) Aggregation of groups to describe variables / partial variables Copy by reference
CIFamilyObserver	AnyItem family observer interface
CILinkFamilyObserver	AnyItem link family observer interface
CGroupBuilder	Tool for building a group
CPartialGroupBuilder	Tool for building a group for a partial variable
CGroup	AnyItem Group Aggregation of Arcane group + information {partial or not} for variables Construction within AnyItem families
CBlockItemEnumerator	Enumerator of an item block
CEnumerator	Enumerator of item blocks
CPairT	Tool to create a pair of items
CLinkFamilyInternal	Internal AnyItem Link Family The stored data are the local IDs of the items and the group offset within the family
CLinkData	Data per link
CLinkIndex	Link index
CEnumerator	Link enumerator
CLink	Link
CLinkAdder	Tool for link addition
CLinkFamily	AnyItem link family (flyweight pattern)
CLinkVariable
CLinkVariableArray
CPrivate
CGroupIndexInfo
CGroupIndexMapping
CUserGroup	User group to specify groups (Arcane) over which one wishes to iterate these groups must be in the family
CVariable	Aggregated variable of arbitrary types (no array variables)
CVariableAdder	Tool for adding a variable to a group
CVariableArray	Aggregated variable array of arbitrary types (no variable arrays) WARNING Arcane variables must be resized beforehand!!!
CVariableAdder	Tool for adding a variable to a group
NInternal	Internal types of Arcane
CIServiceFactory2T	Factory for a service implementing the InterfaceType interface
CServiceAllInterfaceRegisterer	Class allowing the creation and registration of factories for a service
CIServiceFactory2	Internal
CAbstractServiceFactory	Internal
CISingletonServiceFactory	Internal
CDotNetServiceInstance	Base class for a service instance in C#
CServiceInstanceT	Service instance
CServiceFactoryInfo	Information about the manufacturing of a service or a module
CIServiceInterfaceFactory	Interface for a factory function (functor) that creates a service instance corresponding to the InterfaceType interface
CServiceFactory2TV2	Service factory
CServiceInterfaceFactory	Factory for the ServiceType service for the InterfaceType interface
CIServiceInstanceAdder
CSingletonServiceFactoryBase	Base class for factories for singleton services
CServiceInstance	Singleton service instances
CSingletonServiceFactory	Factory for the singleton service of type ServiceType implementing the Interfaces interfaces
CHelper	Utility class allowing the creation of an IServiceInstance for each interface in Interfaces
CServiceInterfaceRegisterer	Class allowing the registration of a factory for a service implementing the InterfaceType interface
CServiceFinderBase2T	Utility class to find one or more services implementing the InterfaceType interface
CServiceInfoPrivate
CServiceInfo	Information about a service
CExternalRef	Management of references to an external object
CHandle
Nmesh	AMR
CAbstractItemFamilyTopologyModifier	Modification of the topology of a family's entities
CAsyncParticleExchanger
CBasicParticleExchanger	Basic particle exchanger (uses blocking reduction)
CCartesianFaceUniqueIdBuilder	Construction of uniqueId() for faces in a cartesian mesh
CCellFamily	Cell Family
CTopologyModifier
CCellFamilyPolicyMng	Cell family policy manager
CCellFamilySerializer	Serialization/Deserialization of cell families
CItemSwapperUtils	Utility class for swapping entities between two entities
CCommonFaceFinder	Finds the common face between two cells
CFaces2DMerger	Merges two faces in 2D (in fact, two edges)
CFaces2DToMergeFinder	In dimension 2, finds common faces between two cells (The faces are actually edges)
CFacesToMergeFinder	This function-class searches for faces to merge when merging two cells
CFaceToQuadrilateralMerger	This function-class aims to merge two faces, where the second is necessarily a quadrangle
CCellToQuadrilateralMerger
CCellToHexahedronMerger	This function-class aims to merge two cells where the second one is necessarily a hexahedron
CCellMerger	Helper class for merging two cells
CCommonItemGroupFilterer	Utility class for common groups across all parts of a mesh
CCustomConnectivity
CLegacyConnectivityTraitsT
CLegacyConnectivityTraitsT< NodeFamily >
CLegacyConnectivityTraitsT< FaceFamily >
CLegacyConnectivityTraitsT< EdgeFamily >
CLegacyConnectivityTraitsT< CellFamily >
CLegacyConnectivity
CFaceToCellConnectivity	Mutualization for Face-Cell connectivities (Legacy or New)
CFaceToCellIncrementalItemConnectivity	Overriding the IncrementalItemConnectivity type to manage Face -> BackCell and FrontCell connectivities
CCustomConnectivity< FaceFamily, CellFamily >
CDoFUids
CDoFFamily
CDoFFamilyCompactPolicy
CDoFFamilyPolicyMng	Manager of policies for a DoF family
CDynamicMeshFactoryBase
CDynamicMeshFactory
CDynamicAMRMeshFactory
CDynamicMesh	Implementation of a mesh
CInitialAllocator
CDynamicMeshCartesianBuilder	Information for mesh exchange between sub-domains
CDynamicMeshCartesian2DBuilder
CDynamicMeshCartesian3DBuilder
CDynamicMeshChecker
CDynamicMeshIncrementalBuilder	Construction of a mesh incrementally
CNodeInFacePtr
CNodeInFace
CItemLocalIdAndUniqueId
CDynamicMeshKindInfos	Mesh information for a given entity kind
CDynamicMeshMergerHelper
CDynamicMeshMerger	Information for mesh exchange between subdomains
CEdgeFamily	Edge family
CTopologyModifier
CEdgeFamilyPolicyMng	Edge family policy manager
CT_CellEdgeInfo	Helper class for parallel determination of edge unique IDs
CItemInfoMultiList
CMyInfo
CParallel3EdgeUniqueIdBuilder
CEdgeUniqueIdBuilder	Construction of ghost layers
CEmptyMesh
CEmptyMeshModifier
CExtraGhostCellsBuilder	Construction of additional ghost cells
CIExtraGhostItemsAdder
CExtraGhostItemsManager
CExtraGhostParticlesBuilder	Construction of extra ghost cells
CFaceFamily	Face family
CTopologyModifier
CFaceFamilyPolicyMng	Policy manager for a face family
CTiedInterfaceSerializeStepFactory
CT_CellFaceInfo	Helper class for parallel determination of face unique_ids
CFaceUniqueIdBuilder	Construction of ghost layers
CFaceUniqueIdBuilder2	Construction of the uniqueId() for faces
CNarrowCellFaceInfo	Stores info about a face of a cell
CWideCellFaceInfo	Stores info about a face of a cell
CBoundaryFaceInfo	Info for managing boundary faces of sub-domains
CAnyFaceInfo	Info for managing faces of sub-domains
CResendCellInfo
CBoundaryFaceBitonicSortTraits	Functor for sorting BoundaryFaceInfo via bitonic sort
CAnyFaceBitonicSortTraits	Functor for sorting AnyFaceInfo using bitonic sort
CUniqueIdSorter
CFullCellInfo	Info to create/serialize a cell knowing the uniqueId() and owner() of all these sub-entities (cells, edges, and faces)
CNodeCellList
CGhostLayerBuilder	Construction of ghost layers
CNodeUidToSubDomain
CGhostLayerBuilder2	Construction of ghost layers
CBoundaryNodeInfo	Structure containing boundary node information
CHashFunction
CBoundaryNodeBitonicSortTraits	Functor for sorting BoundaryNodeInfo via bitonic sort
CBoundaryNodeToSendInfo
CGhostLayerMng
CGraphBuilder
CGraphConnectivityObserverT
CGraphObserverT
CGraphIncrementalConnectivity
CGraphDoFs
CIncrementalItemConnectivityContainer
CAbstractIncrementalItemConnectivity	Abstract class for managing connectivities
CIncrementalItemConnectivityBase	Base class for incremental item->item[] connectivities
CInternalApi
CIncrementalItemConnectivity	Incremental item->item[] connectivity
COneItemIncrementalItemConnectivity	Incremental item->item connectivity
CIndexedIncrementalItemConnectivity
CIndexedIncrementalItemConnectivityMng	Interface for the manager of incremental connectivities indexed on entities
CIndexedItemConnectivityAccessor
CIndirectItemFamilySerializer	Indirect serialization/deserialization of entity families
CDynamicMeshInternal
CItemConnectivityInfo	Information on connectivity by entity type
CItemConnectivitySelector	Selection between historical and on-demand connectivities
CItemConnectivitySelectorT	Selection between historical and on-demand connectivities
CItemData
CItemDataList
CCompareUniqueIdWithSuppression
CItemFamily	Entity Family
CAdjacencyInfo
CInternalApi
CVariables
CItemFamilyCompactPolicy	Base class for entity compaction policies
CStandardItemFamilyCompactPolicy	Compaction policy for Node, Edge, Face, or Cell entity families
CItemFamilyNetwork
CItemFamilyPolicyMng	Manager for the policies of a family of entities
CItemFamilySerializer	Serialization/Deserialization of item families
CItemFamilyVariableSerializer	Manages the serialization/deserialization of variables within a family
CItemGroupDynamicMeshObserver
CItemGroupsSerializer2	Serializes the entities of the groups
CItemGroupsSynchronize	Information to synchronize groups between sub-domains
CNodeInternalConnectivityIndex	Specialization of CompactItemItemInternalIndexT to access nodes
CEdgeInternalConnectivityIndex	Specialization of CompactItemItemInternalConnectivityIndexT to access edges
CFaceInternalConnectivityIndex	Specialization of CompactItemItemInternalConnectivityIndexT to access faces
CCellInternalConnectivityIndex	Specialization of CompactItemItemInternalConnectivityIndexT to access cells
CHParentInternalConnectivityIndex	Specialization of CompactItemItemInternalConnectivityIndexT to access HParents
CHChildInternalConnectivityIndex	Specialization of CompactItemItemInternalConnectivityIndexT to access HParents
CItemInternalMap	Associative array of ItemInternal
CLookupData
CItemRefinement
CFaceSetCompare
CItemsExchangeInfo2	Information for exchanging entities of a given family and their characteristics
CItemSharedInfoWithType	Temporary class to hold an ItemSharedInfo and an entity type
CItemSharedInfoList	Mesh info for a given entity type
CItemNumElements
CVariables
CItemsOwnerBuilderImpl	Implementation of the owner calculation algorithm
CItemOwnerInfo	Information about a shared entity
CItemOwnerInfoSortTraits
CItemsOwnerBuilder	Generic class for calculating entity owners
CItemTools	Utilities helping to find items based on others
CMapCoordToUid	Structure for searching for a node based on its coordinates The hashing key is the geometric position of the node
CBox
CNodeMapCoordToUid
CFaceMapCoordToUid
CMeshCompacter	Management of mesh family compaction
CMeshCompactMng	Manager for compacting families of a mesh
CMeshEventsImpl	Implementation of mesh events
CMeshExchange	Exchange of mesh entities between subdomains
CIncrementalUnorderedMultiArray
CDynamicMultiArray
CMeshExchangeMng	Interface for the mesh exchange manager between subdomains
CMeshExchanger	Information for a mesh exchange between sub-domains
CMeshInfos	Class containing mesh information
CMeshNodeMerger	Merging nodes of a mesh
CMeshPartitionConstraintMng	Mesh partitioning constraint manager
CHelper	Helper for constraint management
CMeshRefinement	Implementation of unstructured mesh refinement adaptation algorithms
CMeshUniqueIdMng	Mesh uniqueId() numbering manager
CMeshVariables	Variables containing the information of connectivities common to 1D, 2D, and 3D meshes
CNewItemOwnerBuilder
CNewWithLegacyConnectivity	Class holding a new connectivity but also filling the legacy one Both custom and legacy connectivities of ItemConnectivitySelector are built
CNewWithLegacyConnectivityType
CNodeFamily	Node family
CTopologyModifier
CItemCompare2
CItemCompare3
CNodeFamilyPolicyMng	Node family policy manager
CNonBlockingParticleExchanger	Particle Exchanger
COneMeshItemAdder
CCellInfoProxy
CFaceInfoMng	AMR
CNodeInfo
CFaceInfo	Info on an active Face
CFaceInfo2	Info on an active Face
CParallelAMRConsistency
CParticleFamily	Particle family
CParticleFamilyCompactPolicy	Compaction policy for particles
CParticleFamilyPolicyMng	Manager for the policies of a particle family
CParticleFamilySerializer	Serialization/Deserialization of link families
CPolyhedralMeshImpl
CPolyhedralMesh
CSubMeshTools
CTiedInterfaceBuilderInfos
CTiedInterfaceFaceInfoMng
CTiedInterfaceNodeInfo
CTiedInterfaceFace	Master or slave face of an interface
CTiedInterfaceMasterFace
CNodeInfo
CTiedInterfaceSortedNodeInfo
CTiedInterfaceStructurationInfo
CTiedInterfaceBuilder	Construction of semi-conformal interface information
CTiedInterfacePartitionConstraint
CITiedInterfaceRebuilder
CTiedInterface	Information on mesh semi-conformities
CPartitionConstraintBase
CTiedInterfaceExchanger	Exchanger between sub-domains of linked interfaces
COneSubDomainInfo
CDeserializedInfo
CFaceInfo
CTiedInterfaceMng	Implementation of the tied interface manager
CExternalPartitionConstraint
CFaceReorienter	This function/class reorients faces
NAxlOptionsBuilder
COneOptionImpl
CDocumentXmlWriter	XML writer for a data set
CDocumentJSONWriter	JSON writer for a data set
COptionList	Data set option list
COneOption	Base class for a dynamic option
CSimple	Data set 'Simple' option
CEnumeration	Data set 'Enumeration' option
CExtended	Data set 'Extended' option
CComplex	Data set 'Complex' option
CServiceInstance	Data set 'ServiceInstance' option
CDocument	Data set 'ServiceInstance' option
NParallel	Concurrency implementation
CIParallelSort	Interface of a parallel sorting algorithm
CBitonicSortDefaultTraits	Provides the necessary operations for sorting via the BitonicSort class
CBitonicSort	Parallel bitonic sort algorithm
CGhostItemsVariableParallelOperation	Parallel operations on ghost entities
CIStat	Statistics on parallelism
CStat	Statistics on parallelism
CCumulativeStat
CSerializedStats	Serialization info
CVariableParallelOperationBase	Interface for a class of parallel operations on variables
CIRequestCreator	Interface for a request creator
CIRequestList	Message request list
CISubRequest	Sub-request of a request
CMessageId	MessageId
C_Message
CMessageRank	Rank of a message
CMessageSourceInfo	Information about the source of a message
CMessageTag	Message tag
CPointToPointMessageInfo	Information for sending/receiving a point-to-point message
CRequest	Message request
C_Request
CCommunicator	Communicator for message exchange
C_Communicator
NMessagePassing	Declarations of types and methods used by message exchange mechanisms
NMpi
CIMpiProfiling	Abstraction interface for MPI operations. Primarily used to employ a decorator for MPI functions in order to profile them without being too verbose and intrusive in the MPIAdapter
CMpiInfo	Informative structure linked to the enumerations for MPI operations. Provides the name associated with the enum as well as a description of the operation
CMpiAdapter	Adapter for MPI
CRequestSet
CRequestInfo
CSubRequestInfo
CMpiContigMachineShMemWinBaseInternal
CMpiControlDispatcher
CMpiLock	Lock for MPI calls
CSection
CMpiMachineShMemWinBaseInternal
CMpiMachineShMemWinBaseInternalCreator
CMpiMultiMachineShMemWinBaseInternal	Class based on MpiMachineShMemWinBaseInternal but capable of managing multiple segments per process
CMpiRequest	MPI specialization of a 'Request'
CMpiRequestList	MPI request list
CMpiSerializeDispatcher
CSerializeSubRequest
CSendSerializerSubRequest	Send sub-request
CReceiveSerializerSubRequest
CMpiTypeDispatcher
CNoMpiProfiling	Implementation of the MPI operations interface. Corresponds to a simple call to MPI functions of the same name
CStdMpiReduceOperator	Reduction operators for standard types
CIMpiReduceOperator	Reduction operators for complex types (Real2, Real3, Real2x2 and Real3x3)
CBuiltInMpiReduceOperator	Internal MPI reduction operator (MPI_MAX, MPI_MIN, MPI_SUM)
CMpiDatatype	Encapsulation of an MPI_Datatype
CMpiMessagePassingMng	MPI implementation of the message exchange manager
CBuildInfo
CSerializeByteConverter	Wrapper for sending a byte array from a serializer
CStandaloneMpiMessagePassingMng	Standalone version of MpiMessagePassingMng
CImpl
Nimpl
CShareMemoryDispatcherContainer
Ninternal
CBasicSerializeMessage	Serializing message using a BasicSerializer
CSerializeMessageList	Serialization message list
CProbeInfo
CRequestListBase	Base class of a request list
CFullRankInfo	Correspondence information between the different ranks of a communicator
CSourceDestinationFullRankInfo	Encapsulates source/destination information
CRankTagBuilder	Class to calculate a tag containing sender and receiver information from a user tag
CHybridMessageQueue	Interface for a message queue with threads
C_ThreadIntegralType
CHybridParallelDispatch	Message interface for type Type
CAllToAllVariableInfo
CReduceInfo
CMinMaxSumInfo
CMpiThreadDispatcherContainerTraits
CMpiThreadAllDispatcher
CCreateSubParallelMngInfo	Information needed to create a sub-parallelMng()
CHybridSerializeMessageList
CHybridSerializeMessageRequest
CHybridParallelMngBuildInfo	Info for constructing a HybridParallelMng
CHybridParallelMng	Thread-based parallelism manager
CImpl
CRequestList	Implementation of IRequestList for HybridParallelMng
CHybridParallelMngContainer	Container of information for the hybrid mode message manager
CHybridParallelMngContainerFactory
CHybridParallelSuperMng	Supervisor of parallelism using MPI and Threads
CMpiSharedMemoryParallelSuperMng	Shared memory supervisor with MPI initialization
CHybridContigMachineShMemWinBaseInternal
CHybridMachineShMemWinBaseInternal
CHybridMachineShMemWinBaseInternalCreator
CSharedMemoryBasicAsyncQueue	Basic implementation of a multi-threaded queue
CIAsyncQueue	Asynchronous queue allowing the exchange of information between threads
CSharedMemoryContigMachineShMemWinBaseInternal
CSharedMemoryMachineShMemWinBaseInternal
CSharedMemoryMachineShMemWinBaseInternalCreator
CSendBufferInfo	Send buffer information
CReceiveBufferInfo	Receive buffer information
CISharedMemoryMessageQueue	Interface of a message queue with threads
CRequestAsyncQueue
CSharedMemoryMessageQueue	Message queue between ranks shared by a SharedMemoryParallelMng
CSubQueue	File for messages from a rank in shared memory
CSharedMemoryMessageRequest	Message within SharedMemoryMessageQueue
CSortFunctor
CSharedMemoryParallelDispatch	Message interface for type Type
CResizableArrayRef
CReduceInfo
CMinMaxSumInfo
CThreadDispatcherContainerTraits
CSharedMemoryAllDispatcher
CCreateSubParallelMngInfo	Information required to create a sub-parallelMng()
CSharedMemoryParallelDispatchBase	Base class common to SharedMemoryParallelDispatch
CIResizableArray
CAllToAllVariableInfo
CSharedMemoryParallelMngBuildInfo	Info to construct a SharedMemoryParallelMng
CSharedMemoryParallelMng	Thread-based parallelism manager
CRequestList	Implementation of IRequestList for SharedMemoryParallelMng
CImpl
CSharedMemoryParallelMngContainer	Container for shared memory message manager information
CSharedMemoryParallelMngContainerFactory
CSharedMemoryParallelSuperMng	Parallelism supervisor using threads
CCommunicator	Communicator for message exchange
C_Communicator
CDispatchers	Interface of the dispatcher container
CContainerTraits
CGatherMessageInfoBase	Brief information for a 'gather' message
CGatherMessageInfo	Brief information for a 'gather' message for data type DataType
CIControlDispatcher	Manage control streams for parallel messages
CIDispatchers	Interface of the dispatcher container
CIMessagePassingMng	Interface of the message passing manager
CIContigMachineShMemWinBaseInternal	Class allowing the creation of a memory window for a node of computation
CIMachineShMemWinBaseInternal	Class allowing the creation of memory windows for a computing node
CSubRequestCompletionInfo	Completion information for a sub-request
CIProfiler	Interface of a profiler for message exchanges
CIRequestList	Message request list
CISerializeDispatcher	Interface for serialization messages
CISerializeMessage	Interface for a serialization message between IMessagePassingMng
CISerializeMessageList	Interface for a serialization message list
COneStat	Statistic on a message
CStatCollection	List of statistics
CIStat	Statistics on parallelism
CITypeDispatcher	Parallel message handling for the type Type
CMessageId	MessageId
C_Message
CMessagePassingMng	Message passing manager
CMessageRank	Rank of a message
CMessageSourceInfo	Information about the source of a message
CMessageTag	Message tag
CPointToPointMessageInfo	Information for sending/receiving a point-to-point message
CPointToPointSerializerMng	Point-to-point communications using 'ISerializer'
CImpl
CISubRequest	Sub-request of a request
CIRequestCreator	Interface for a request creator
CRequest	Message request
C_Request
CStatData	Statistical data set for profiling
CStat	Statistics manager for parallelism
CBasicSerializeMessage	Serializing message using a BasicSerializer
Ndom
CDOMException
CDOMWriter
CDOMImplementation
CNode
CDocument
CDocumentFragment
CNodeList
CCharacterData
CAttr
CElement
CText
CComment
CCDATASection
CDocumentType
CNotation
CEntity
CEntityReference
CProcessingInstruction
CNamedNodeMap
CDOMImplementationSource
CUserDataHandler
CDOMError
CDOMErrorHandler
CDOMLocator
CXPathException
CXPathEvaluator
CXPathExpression
CXPathNSResolver
CXPathResult
CXPathSetIterator
CXPathSetSnapshot
CXPathNamespace
C_wxmlText
C_wxmlComment
C_wxmlDocType
C_wxmlDocumentFragment
C_wxmlCDATA
C_wxmlNodeList
C_wxmlEntityReference
C_wxmlCharacterData
C_wxmlProcessingInstruction
C_wxmlNamedNodeMapPtr
CLibXml2_DOMImplementation
CLibXml2_ErrorHandler	Handling of XML reader errors
CLibXml2_Parser	Class encapsulating the XML document parser
CLibXml2_SchemaValidator	Class encapsulating XML Schema validation of an XML document
CILibXml2_Reader
CLibXml2_MemoryReader
CLibXml2_FileReader
CXmlDocumentHolderLibXml2
Ndomutils
CNameIterator
NGeometricUtilities	Utility functions on geometry
CQuadMapping	Class allowing mapping Cartesian coordinates to barycentric coordinates
CProjectionInfo	Information about the projection of a point onto a segment or a triangle
Nproperties
CConfigurationPropertyReader
CJSONPropertyReader
CParameterListPropertyVisitor
CPropertySetting
CSetterArg
CGetterArg
CPropertySettingTraits
CPropertySettingTraits< String >
CPropertySettingTraits< StringList >
CPropertySettingTraits< bool >
CPropertySettingTraits< Int32 >
CPropertySettingTraits< Int64 >
CIPropertySetting	Property parameter interface
CPropertySettingBase	Base class of a property typed by a class
CPropertySettingBuilder
CIPropertyVisitor	Property visitor interface
CPropertyVisitor	Base class of a typed visitor on a property
CGenericPropertyVisitorWrapper
CPropertySettingsBuildInfo
CIPropertySettingsInfo
CPropertySettingsInfo
CPropertySettingsRegisterer	Property settings registrar
CPropertyDeclaration
Ngeometric
CBarycentricGeomShapeComputerByType
CBarycentricGeomShapeComputer	Calculates GeomShapes using barycenters
CCellConnectivity	Information on the connectivity of a cell
CNullConnectivity	Connectivity information for geometric elements of type IT_NullType
CVertexConnectivity	Connectivity information for geometric elements of type GeomType::Vertex
CLine2Connectivity	Connectivity information for geometric elements of type GeomType::Line2
CTriangle3Connectivity	Connectivity information for geometric elements of type GeomType::Triangle3
CQuad4Connectivity	Connectivity information for geometric elements of type GeomType::Quad4
CPentagon5Connectivity	Connectivity information for geometric elements of type GeomType::Pentagon5
CHexagon6Connectivity	Connectivity information for geometric elements of type GeomType::Hexagon6
CTetraedron4Connectivity	Connectivity information for geometric elements of type GeomType::Tetraedron4
CPyramid5Connectivity	Connectivity information for geometric elements of type GeomType::Pyramid5
CPentaedron6Connectivity	Connectivity information for geometric elements of type GeomType::Pentaedron6
CHexaedron8Connectivity	Connectivity information for geometric elements of type GeomType::Hexaedron8
CHeptaedron10Connectivity	Connectivity information for geometric elements of type GeomType::Heptaedron10
COctaedron12Connectivity	Connectivity information for geometric elements of type GeomType::Octaedron12
CGeomElementBase	Base class for geometric elements
CTriangle3Element	Geometric elements of type GeomType::Triangle3
CQuad4Element	Geometric elements of type GeomType::Quad4
CPentagon5Element	Geometric elements of type GeomType::Pentagon5
CHexagon6Element	Geometric elements of type GeomType::Hexagon6
CTetraedron4Element	Geometric elements of type GeomType::Tetraedron4
CPyramid5Element	Geometric elements of type GeomType::Pyramid5
CPentaedron6Element	Geometric elements of type GeomType::Pentaedron6
CHexaedron8Element	Geometric elements of type GeomType::Hexaedron8
CHeptaedron10Element	Geometric elements of type GeomType::Heptaedron10
COctaedron12Element	Geometric elements of type GeomType::Octaedron12
CGeomElementConstViewBase	Base class for constant views on geometric elements
CGeomElementViewBase	Base class for modifiable views on geometric elements
CTriangle3ElementConstView	Constant view on geometric elements of type GeomType::Triangle3
CTriangle3ElementView	Modifiable view on geometric elements of type GeomType::Triangle3
CQuad4ElementConstView	Constant view on geometric elements of type GeomType::Quad4
CQuad4ElementView	Modifiable view on geometric elements of type GeomType::Quad4
CPentagon5ElementConstView	Constant view on geometric elements of type GeomType::Pentagon5
CPentagon5ElementView	Modifiable view on geometric elements of type GeomType::Pentagon5
CHexagon6ElementConstView	Constant view on geometric elements of type GeomType::Hexagon6
CHexagon6ElementView	Modifiable view on geometric elements of type GeomType::Hexagon6
CTetraedron4ElementConstView	Constant view on geometric elements of type GeomType::Tetraedron4
CTetraedron4ElementView	Modifiable view on geometric elements of type GeomType::Tetraedron4
CPyramid5ElementConstView	Constant view on geometric elements of type GeomType::Pyramid5
CPyramid5ElementView	Modifiable view on geometric elements of type GeomType::Pyramid5
CPentaedron6ElementConstView	Constant view on geometric elements of type GeomType::Pentaedron6
CPentaedron6ElementView	Modifiable view on geometric elements of type GeomType::Pentaedron6
CHexaedron8ElementConstView	Constant view on geometric elements of type GeomType::Hexaedron8
CHexaedron8ElementView	Modifiable view on geometric elements of type GeomType::Hexaedron8
CHeptaedron10ElementConstView	Constant view on geometric elements of type GeomType::Heptaedron10
CHeptaedron10ElementView	Modifiable view on geometric elements of type GeomType::Heptaedron10
COctaedron12ElementConstView	Constant view on geometric elements of type GeomType::Octaedron12
COctaedron12ElementView	Modifiable view on geometric elements of type GeomType::Octaedron12
CFaceConnectic	Local connectivity structure
CEdgeConnectic	Local cell connectivity structures
CNodeConnectic	Local cell connectivity structures
CSVCFaceConnectic	Local cell and svc connectivity structures
CLocalCellNodeReal	Table of 12 real-type elements. Used for weighting the nodes of the cells (the largest having 12 nodes)
CGeomShape	Geometric shape
CGeomShapeMng	Class managing the GeomShapes of a mesh
CGeomShapeMutableView	Mutable view on a GeomShape
CGeomShapeOperation	Template class to apply specific operations to a geometric shape view
CGeomShapeConnectivity
CGeomShapeStdBuilder
CGeomShapeView	Constant view on a geometric shape GeomShape
CGeomShape2DView	View on 2D geometric shape
CGeomShape3DView	View on 3D geometric shape
CTriangle3ShapeView	Specific view on geometric shapes of type GeomType::Triangle3
CQuad4ShapeView	Specific view on geometric shapes of type GeomType::Quad4
CPentagon5ShapeView	Specific view on geometric shapes of type GeomType::Pentagon5
CHexagon6ShapeView	Specific view on geometric shapes of type GeomType::Hexagon6
CTetraedron4ShapeView	Specific view on geometric shapes of type GeomType::Tetraedron4
CPyramid5ShapeView	Specific view on geometric shapes of type GeomType::Pyramid5
CPentaedron6ShapeView	Specific view on geometric shapes of type GeomType::Pentaedron6
CHexaedron8ShapeView	Specific view on geometric shapes of type GeomType::Hexaedron8
CHeptaedron10ShapeView	Specific view on geometric shapes of type GeomType::Heptaedron10
COctaedron12ShapeView	Specific view on geometric shapes of type GeomType::Octaedron12
CGeomType	Enumeration specifying the type of polygon or polyhedron associated with a geometric element or shape
NLoop	Namespace containing various classes managing loops over entities
CItemLoopFunctor	Template class to encapsulate a loop over entities
NMatVec
CAMGLevel
CAMG
CPointInfo
CMatrixImpl	Matrix with CSR storage
CMatrix	Matrix with CSR storage
CIPreconditioner	Interface for a preconditioner
CConjugateGradientSolver
CDiagonalPreconditioner	Diagonal preconditioner
CMatrixOperation
CMatrixOperation2
CAMGPreconditioner
CAMGSolver
CDirectSolver	Direct solver using Gaussian pivot
CVectorImpl
CVector	Linear algebra vector
Nrandom
Nutils
Cmake_unsigned
Cmake_unsigned< Int32 >
Cmake_unsigned< UInt32 >
CConstMod
Cinteger_traits_base
Cinteger_traits
Cinteger_traits< int >
Cinteger_traits< unsigned int >
Cinteger_traits< long >
Cinteger_traits< unsigned long >
Cdo_add
Cdo_add< true >
Cdo_add< false >
Cconst_mod
Cconst_mod< unsigned int, 0 >
Cconst_mod< unsigned long, 0 >
Cdo_compare
Cdo_compare< false, false >
Cdo_compare< true, true >
Cdo_compare< true, false >
Cdo_compare< false, true >
CInversiveCongruential
CLinearCongruential	Compile-time configurable linear congruential generator
CMersenneTwister	MersenneTwister class pattern
CNormalDistribution
CTKiss
CTMrg32k3a
CUniform01	Generates a random number in the interval [0,1[
CUniformInt
CUniformOnSphere
CUniformSmallInt
NNumerics
CIParallelCorefinement	Parallel corefinement interface
CParallelCorefinementService
CInternal
CBox
CCheckCloseFaces	Test distance between faces
CNodeComparator
CAddEdges
CGeometryKernelSurfaceImpl
CNodeMapping
CGeometryKernelSurfaceToolsService
CISurface	Purely virtual interface for surface representation
CISurfaceUtils
CFaceFaceContact
CEuclidian3Geometry
CIComputeLine
CComputeLine2
CIComputeSurface
CComputeTriangle3
CComputeQuad4
CComputePentagon5
CComputeHexagon6
CIComputeVolume
CComputeTetraedron4
CComputeHeptaedron10
CComputeOctaedron12
CComputeGenericVolume
CEuclidian3GeometryService
CIGeometry	Geometric calculation interface
CIGeometryProperty	Geometric properties
CEnumerator
CIGeometryMng	Geometric calculation manager
CGeometryServiceBase
CGenericGSInternalUpdater
CItemGroupGeometryProperty	Internal class implementation for TemisGeometryService and Euclidian3GeometryService
CStorageInfo
CContainerAccessorT	Generic (empty) model for accessing StorageInfo by storage type
CContainerAccessorT< Real >
CContainerAccessorT< Real3 >
NHdf5Utils	Utility functions for Hdf5
CHdf5Mutex
CHInit	Class serving as an initializer for HDF
CHid	Encapsulates a hid_t
CHProperty	Encapsulates a hid_t for a property (H5P*)
CHFile	Encapsulates a hid_t for a file
CHGroupSearch	Helper class for searching a group
CHGroup	Encapsulates a hid_t for a group
CHSpace	Encapsulates a hid_t for a dataspace
CHDataset	Encapsulates a hid_t for a dataset
CHAttribute	Encapsulates a hid_t for an attribute
CHType	Encapsulates a hid_t for a type
CStandardTypes	Definition of standard Arcane types for hdf5
CStandardArray	Encapsulates a simple dataset from an HDF5 file that represents an array
CStandardArrayT	Encapsulates a simple dataset from an HDF5 file that represents an array
CValueWithUid
CStandardScalarT	Encapsulates a simple dataset from an HDF5 file that represents a scalar (possibly String)
NMeshSubdivider
CPattern	Class Pattern which allows manipulation of a refinement pattern (pattern in English)
NVtkPolyhedralTools
CReadStatus
CPrintInfoLevel
NConvert	Functions to convert one type to another
NImpl
CStringViewInputStream	Encapsulates an std::istream for a StringView
CConvertPolicy	Information on the behavior of conversion methods
CStringViewToDoubleConverter	Class for converting a 'StringView' to 'double'
CStringViewToIntegral	Class for converting a 'StringView' to an integral type
CType	Template class for converting a type
CScalarType
CType< Int64 >	Specialization for scalar types
CType< Int32 >
CType< Real >
NSHA1Algorithm
CSHA1
Csha1_ctx	Algorithm context
NSHA3Algorithm
CSHA3
Csha3_ctx	Algorithm context
Ninternal
CTraceAccessor2	API UNDER DEVELOPMENT. DO NOT USE
CTracePrinter
NAlina
Nbackend
Ndetail
Cuse_builtin_matrix_ops< adapter::block_matrix_adapter< Matrix, BlockType > >
Cuse_builtin_matrix_ops< Alina::adapter::complex_adapter< Matrix > >
Cuse_builtin_matrix_ops< Alina::adapter::matrix_builder< RowBuilder > >
Cuse_builtin_matrix_ops< std::tuple< N, PRng, CRng, VRng > >
Cuse_builtin_matrix_ops< adapter::reordered_matrix< Matrix > >
Cuse_builtin_matrix_ops< CSRMatrix< V, C, P > >
Ccuda_deleter
Cuse_builtin_matrix_ops
Cvalue_type< std::tuple< N, PRng, CRng, VRng > >
Crows_impl< std::tuple< N, PRng, CRng, VRng > >
Ccols_impl< std::tuple< N, PRng, CRng, VRng > >
Cnonzeros_impl< std::tuple< N, PRng, CRng, VRng > >
Crow_iterator< std::tuple< N, PRng, CRng, VRng > >
Ctype
Crow_begin_impl< std::tuple< N, PRng, CRng, VRng > >
Crow_nonzeros_impl< std::tuple< N, PRng, CRng, VRng > >
Cptr_data_impl< std::tuple< N, PRng, CRng, VRng > >
Ccol_data_impl< std::tuple< N, PRng, CRng, VRng > >
Cval_data_impl< std::tuple< N, PRng, CRng, VRng > >
Cis_builtin_vector< adapter::reordered_vector< Vector > >
Cbackends_compatible	Metafunction that checks if two backends are compatible
Cvalue_type	Metafunction that returns value type of a matrix or a vector type
Ccol_type	Metafunction that returns column type of a matrix
Cptr_type	Metafunction that returns pointer type of a matrix
Crows_impl	Implementation for function returning the number of rows in a matrix
Ccols_impl	Implementation for function returning the number of columns in a matrix
Cbytes_impl	Implementation for function returning number of bytes allocated for a matrix/vector
Cptr_data_impl
Ccol_data_impl
Cval_data_impl
Cnonzeros_impl	Implementation for function returning the number of nonzeros in a matrix
Crow_nonzeros_impl	Implementation for function returning the number of nonzeros in a matrix row
Crow_iterator	Metafunction returning the row iterator type for a matrix type
Crow_begin_impl	Implementation for function returning row iterator for a matrix
Cspmv_impl	Implementation for matrix-vector product
Cresidual_impl	Implementation for residual error compuatation
Cclear_impl	Implementation for zeroing out a vector
Ccopy_impl	Implementation for vector copy
Cinner_product_impl	Implementation for inner product
Caxpby_impl	Implementation for linear combination of two vectors
Caxpbypcz_impl	Implementation for linear combination of three vectors
Cvmul_impl	Implementation for element-wise vector product
Creinterpret_as_rhs_impl	Reinterpret the vector to be compatible with the matrix value type
Crelaxation_is_supported	Is the relaxation supported by the backend?
Ccoarsening_is_supported	Is the coarsening supported by the backend?
CBlockCSRBackend	BlockCSRBackend backend definition
Cprovides_row_iterator
Cparams	Backend parameters
Crows_impl< BlockCSRMatrix< V, C, P > >
Ccols_impl< BlockCSRMatrix< V, C, P > >
Cnonzeros_impl< BlockCSRMatrix< V, C, P > >
Cspmv_impl< Alpha, BlockCSRMatrix< V, C, P >, Vec1, Beta, Vec2 >
Cresidual_impl< BlockCSRMatrix< V, C, P >, Vec1, Vec2, Vec3 >
Cis_builtin_vector
Cis_builtin_vector< std::vector< V > >
Cis_builtin_vector< SmallSpan< V > >
Cis_builtin_vector< Span< V > >
Cis_builtin_vector< numa_vector< V > >
Cbackends_compatible< BuiltinBackend< T1 >, BuiltinBackend< T2 > >
Crows_impl< CSRMatrix< V, C, P > >
Ccols_impl< CSRMatrix< V, C, P > >
Cbytes_impl< Vec, typename std::enable_if< is_builtin_vector< Vec >::value >::type >
Cptr_data_impl< CSRMatrix< V, C, P > >
Ccol_data_impl< CSRMatrix< V, C, P > >
Cval_data_impl< CSRMatrix< V, C, P > >
Cnonzeros_impl< CSRMatrix< V, C, P > >
Crow_nonzeros_impl< CSRMatrix< V, C, P > >
Cclear_impl< Vec, typename std::enable_if< is_builtin_vector< Vec >::value >::type >
Cinner_product_impl< Vec1, Vec2, typename std::enable_if< is_builtin_vector< Vec1 >::value &&is_builtin_vector< Vec2 >::value >::type >
Caxpby_impl< A, Vec1, B, Vec2, typename std::enable_if< is_builtin_vector< Vec1 >::value &&is_builtin_vector< Vec2 >::value >::type >
Caxpbypcz_impl< A, Vec1, B, Vec2, C, Vec3, typename std::enable_if< is_builtin_vector< Vec1 >::value &&is_builtin_vector< Vec2 >::value &&is_builtin_vector< Vec3 >::value >::type >
Cvmul_impl< Alpha, Vec1, Vec2, Beta, Vec3, typename std::enable_if< is_builtin_vector< Vec1 >::value &&is_builtin_vector< Vec2 >::value &&is_builtin_vector< Vec3 >::value &&math::static_rows< typename value_type< Vec1 >::type >::value==math::static_rows< typename value_type< Vec2 >::type >::value &&math::static_rows< typename value_type< Vec1 >::type >::value==math::static_rows< typename value_type< Vec3 >::type >::value >::type >
Cvmul_impl< Alpha, Vec1, Vec2, Beta, Vec3, typename std::enable_if< is_builtin_vector< Vec1 >::value &&is_builtin_vector< Vec2 >::value &&is_builtin_vector< Vec3 >::value &&(math::static_rows< typename value_type< Vec1 >::type >::value !=math::static_rows< typename value_type< Vec2 >::type >::value||math::static_rows< typename value_type< Vec1 >::type >::value !=math::static_rows< typename value_type< Vec3 >::type >::value)>::type >
Ccopy_impl< Vec1, Vec2, typename std::enable_if< is_builtin_vector< Vec1 >::value &&is_builtin_vector< Vec2 >::value >::type >
Creinterpret_as_rhs_impl< MatrixValue, Vector, IsConst, typename std::enable_if< is_builtin_vector< Vector >::value >::type >
Ccoarsening_is_supported< Backend, RugeStubenCoarsening, typename std::enable_if<!std::is_arithmetic< typename backend::value_type< Backend >::type >::value >::type >
Ccuda_matrix	CUSPARSE matrix in CSR format
Ccuda	CUDA backend
Cprovides_row_iterator
Cparams	Backend parameters
Cgather
Cscatter
Cbytes_impl< thrust::device_vector< V > >
Cspmv_impl< Alpha, cuda_matrix< V >, thrust::device_vector< V >, Beta, thrust::device_vector< V > >
Cresidual_impl< cuda_matrix< V >, thrust::device_vector< V >, thrust::device_vector< V >, thrust::device_vector< V > >
Cclear_impl< thrust::device_vector< V > >
Ccopy_impl< V, thrust::device_vector< T > >
Ccopy_impl< thrust::device_vector< T >, V >
Ccopy_impl< thrust::device_vector< T1 >, thrust::device_vector< T2 > >
Cinner_product_impl< thrust::device_vector< V >, thrust::device_vector< V > >
Caxpby_impl< A, thrust::device_vector< V >, B, thrust::device_vector< V > >
Cfunctor
Caxpbypcz_impl< A, thrust::device_vector< V >, B, thrust::device_vector< V >, C, thrust::device_vector< V > >
Cfunctor
Cvmul_impl< A, thrust::device_vector< V >, thrust::device_vector< V >, B, thrust::device_vector< V > >
Cfunctor
Ccuda_event
Ccuda_clock
Crows_impl< DistributedMatrix< Backend > >
Cspmv_impl< Alpha, DistributedMatrix< Backend >, Vec1, Beta, Vec2 >
Cresidual_impl< DistributedMatrix< Backend >, Vec1, Vec2, Vec3 >
Cspmv_impl< Alpha, DistributedSchurPressureCorrection< US, PS >, Vec1, Beta, Vec2 >
Cresidual_impl< DistributedSchurPressureCorrection< US, PS >, Vec1, Vec2, Vec3 >
Cspmv_impl< Alpha, sdd_projected_matrix< SDD, Matrix >, Vec1, Beta, Vec2 >
Cresidual_impl< sdd_projected_matrix< SDD, Matrix >, Vec1, Vec2, Vec3 >
Cis_eigen_sparse_matrix
Cis_eigen_type
Cis_eigen_sparse_matrix< Eigen::Map< Eigen::SparseMatrix< Scalar, Flags, Storage > > >
Cis_eigen_sparse_matrix< Eigen::SparseMatrix< Scalar, Flags, Storage > >
Cis_eigen_type< T, typename std::enable_if< std::is_arithmetic< typename T::RealScalar >::value &&std::is_base_of< Eigen::EigenBase< T >, T >::value >::type >
Cvalue_type< T, typename std::enable_if< is_eigen_type< T >::value >::type >
Cnonzeros_impl< T, typename std::enable_if< is_eigen_sparse_matrix< T >::value >::type >
Crow_iterator< T, typename std::enable_if< is_eigen_sparse_matrix< T >::value >::type >
Crow_begin_impl< T, typename std::enable_if< is_eigen_sparse_matrix< T >::value >::type >
CEigenBackend	Eigen backend
Cprovides_row_iterator
Chold_host
Cspmv_impl< Alpha, M, V1, Beta, V2, typename std::enable_if< is_eigen_sparse_matrix< M >::value &&is_eigen_type< V1 >::value &&is_eigen_type< V2 >::value >::type >
Cresidual_impl< M, V1, V2, V3, typename std::enable_if< is_eigen_sparse_matrix< M >::value &&is_eigen_type< V1 >::value &&is_eigen_type< V2 >::value &&is_eigen_type< V3 >::value >::type >
Cclear_impl< V, typename std::enable_if< is_eigen_type< V >::value >::type >
Cinner_product_impl< V1, V2, typename std::enable_if< is_eigen_type< V1 >::value &&is_eigen_type< V2 >::value >::type >
Caxpby_impl< A, V1, B, V2, typename std::enable_if< is_eigen_type< V1 >::value &&is_eigen_type< V2 >::value >::type >
Caxpbypcz_impl< A, V1, B, V2, C, V3, typename std::enable_if< is_eigen_type< V1 >::value &&is_eigen_type< V2 >::value &&is_eigen_type< V3 >::value >::type >
Cvmul_impl< Alpha, V1, V2, Beta, V3, typename std::enable_if< is_eigen_type< V1 >::value &&is_eigen_type< V2 >::value &&is_eigen_type< V3 >::value >::type >
Ccopy_impl< V1, V2, typename std::enable_if< is_eigen_type< V1 >::value &&is_eigen_type< V2 >::value >::type >
CHybridBuiltinBackend	Hybrid backend uses scalar matrices to build the hierarchy, but stores the computed matrices in the block format
Cprovides_row_iterator
Cbackends_compatible< HybridBuiltinBackend< B1, C, P >, HybridBuiltinBackend< B2, C, P > >
Cbackends_compatible< BuiltinBackend< T1, C, P >, HybridBuiltinBackend< B2, C, P > >
Cbackends_compatible< HybridBuiltinBackend< B1, C, P >, BuiltinBackend< T2, C, P > >
Cspmv_impl< Alpha, Matrix, Vector1, Beta, Vector2, std::enable_if_t< detail::use_builtin_matrix_ops< Matrix >::value &&math::static_rows< typename value_type< Matrix >::type >::value==math::static_rows< typename value_type< Vector1 >::type >::value &&math::static_rows< typename value_type< Matrix >::type >::value==math::static_rows< typename value_type< Vector2 >::type >::value > >
Cresidual_impl< Matrix, Vector1, Vector2, Vector3, std::enable_if_t< detail::use_builtin_matrix_ops< Matrix >::value &&math::static_rows< typename value_type< Matrix >::type >::value==math::static_rows< typename value_type< Vector1 >::type >::value &&math::static_rows< typename value_type< Matrix >::type >::value==math::static_rows< typename value_type< Vector2 >::type >::value &&math::static_rows< typename value_type< Matrix >::type >::value==math::static_rows< typename value_type< Vector3 >::type >::value > >
Cspmv_impl< Alpha, Matrix, Vector1, Beta, Vector2, std::enable_if_t< detail::use_builtin_matrix_ops< Matrix >::value &&(math::static_rows< typename value_type< Matrix >::type >::value !=math::static_rows< typename value_type< Vector1 >::type >::value||math::static_rows< typename value_type< Matrix >::type >::value !=math::static_rows< typename value_type< Vector2 >::type >::value)> >
Cresidual_impl< Matrix, Vector1, Vector2, Vector3, std::enable_if_t< detail::use_builtin_matrix_ops< Matrix >::value &&(math::static_rows< typename value_type< Matrix >::type >::value !=math::static_rows< typename value_type< Vector1 >::type >::value||math::static_rows< typename value_type< Matrix >::type >::value !=math::static_rows< typename value_type< Vector2 >::type >::value||math::static_rows< typename value_type< Matrix >::type >::value !=math::static_rows< typename value_type< Vector3 >::type >::value)> >
Crelaxation_is_supported< Backend, GaussSeidelRelaxation, typename std::enable_if< !Backend::provides_row_iterator::value >::type >
Cvalue_type< sparse_matrix >
Crows_impl< sparse_matrix >
Ccols_impl< sparse_matrix >
Cnonzeros_impl< sparse_matrix >
Crow_iterator< sparse_matrix >
Citerator
Crow_begin_impl< sparse_matrix >
Cspmv_impl< Alpha, preconditioner::SchurPressureCorrectionPreconditioner< US, PS >, Vec1, Beta, Vec2 >
Cresidual_impl< preconditioner::SchurPressureCorrectionPreconditioner< US, PS >, Vec1, Vec2, Vec3 >
Cis_builtin_vector< std::vector< StaticMatrix< T, N, M > > >	Enable static matrix as a value-type
Cis_builtin_vector< std::vector< std::complex< T > > >	Enable std::complex as a value-type
Cis_builtin_vector< std::vector< Eigen::Matrix< T, N, M > > >	Enable Eigen matrix as a value-type
Crelaxation_is_supported< Backend, SPAI1Relaxation, typename std::enable_if<(Alina::math::static_rows< typename Backend::value_type >::value > 1)>::type >
Nadapter
Cblock_matrix_adapter
Crow_iterator
Ccomplex_adapter
Crow_iterator
Cmatrix_builder	Generates matrix rows as needed with help of user-provided functor
Crow_iterator
Creordered_matrix
Crow_iterator
Creordered_vector
Creorder
Cscaled_matrix
Crow_iterator
Cscaled_problem
Ndetail
Ccommon_scalar_backend
CPropertyWrapper
Cempty_params	Class to handle empty parameter list
Cnon_copyable
Ccommon_scalar_backend< B, B, typename std::enable_if< math::static_rows< typename B::value_type >::value==1 >::type >
Ccommon_scalar_backend< BuiltinBackend< V1 >, BuiltinBackend< V2 >, typename std::enable_if< math::static_rows< V1 >::value !=1||math::static_rows< V2 >::value !=1 >::type >
Cskip_negative
CQRFactorization
CQRFactorization< value_type, typename std::enable_if< math::is_static_matrix< value_type >::value >::type >
Cdefault_inner_product	Default inner product getter for iterative solvers
Nerror
Cempty_level
Npreconditioner
CCPRDynamicRowSumPreconditioner	CPR preconditioner with Dynamic Row Sum modification
Cparams
CCPRPreconditioner	Two stage preconditioner of the Constrained Pressure Residual type
Cparams
CDummyPreconditioner	Dummy preconditioner using identity matrix
CSchurPressureCorrectionPreconditioner	Schur-complement pressure correction preconditioner
Cparams
Nsolver
Ccuda_skyline_lu
CSkylineLUSolver	Direct solver that uses Skyline LU factorization
NImpl
CILUSolver	Solver for sparse triangular systems obtained as a result of an incomplete LU factorization
Cparams
CILUSolver< BuiltinBackend< value_type, col_type, ptr_type > >	Solver for sparse triangular systems obtained as a result of an incomplete LU factorization
Cparams
Csptr_solve
Ctask
CILUSolver< backend::HybridBuiltinBackend< Block, Col, Ptr > >
NIO
Cmm_reader	Matrix market reader
Nrelaxation
Cilu0
Cilu0< backend::cuda< real > >	Implementation of ILU0 smoother for CUDA backend
Cparams
Nmath
Cscalar_of< StaticMatrix< T, N, M > >	Scalar type of a non-scalar type
Creplace_scalar< StaticMatrix< T, N, M >, S >	Replace scalar type in the static matrix
Crhs_of< StaticMatrix< T, N, N > >	RHS type corresponding to a non-scalar type
Celement_of< StaticMatrix< T, N, M > >	Element type of a non-scalar type
Cis_static_matrix< StaticMatrix< T, N, M > >	Whether the value type is a statically sized matrix
Cstatic_rows< StaticMatrix< T, N, M > >	Number of rows for statically sized matrix types
Cstatic_cols< StaticMatrix< T, N, M > >	Number of columns for statically sized matrix types
Cadjoint_impl< StaticMatrix< T, N, M > >	Specialization of conjugate transpose for static matrices
Cinner_product_impl< StaticMatrix< T, N, 1 > >	Inner-product result of two static vectors
Cinner_product_impl< StaticMatrix< T, N, M > >	Inner-product result of two static matrices
Cnorm_impl< StaticMatrix< T, N, M > >	Implementation of Frobenius norm for static matrices
Czero_impl< StaticMatrix< T, N, M > >	Specialization of zero element for static matrices
Cis_zero_impl< StaticMatrix< T, N, M > >	Specialization of zero element for static matrices
Cidentity_impl< StaticMatrix< T, N, N > >	Specialization of identity for static matrices
Cconstant_impl< StaticMatrix< T, N, M > >	Specialization of constant for static matrices
Cinverse_impl< StaticMatrix< T, N, N > >	Specialization of inversion for static matrices
Cscalar_of< std::complex< T > >	Specialization that extracts the scalar type of a complex type
Creplace_scalar< std::complex< T >, S >	Replace scalar type in the complex type
Cadjoint_impl< std::complex< T > >	Specialization of conjugate transpose for scalar complex arguments
Cinner_product_impl< std::complex< T > >	Default implementation for inner product
Cconstant_impl< std::complex< T > >	Specialization of constant element for complex type
Cscalar_of< Eigen::Matrix< T, N, M > >	Scalar type of a non-scalar type
Creplace_scalar< Eigen::Matrix< T, N, M >, S >	Replace scalar type in the static matrix
Crhs_of< Eigen::Matrix< T, N, N > >	RHS type corresponding to a non-scalar type
Celement_of< Eigen::Matrix< T, N, M > >	Element type of a non-scalar type
Cis_static_matrix< Eigen::Matrix< T, N, M > >	Whether the value type is a statically sized matrix
Cstatic_rows< Eigen::Matrix< T, N, M > >	Number of rows for statically sized matrix types
Cstatic_cols< Eigen::Matrix< T, N, M > >	Number of columns for statically sized matrix types
Cadjoint_impl< Eigen::Matrix< T, N, M > >	Specialization of conjugate transpose for eigen matrices
Cinner_product_impl< Eigen::Matrix< T, N, 1 > >	Inner-product result of two Eigen vectors
Cinner_product_impl< Eigen::Matrix< T, N, M > >	Inner-product result of two Eigen matrices
Cnorm_impl< Eigen::Matrix< T, N, M > >	Specialization of element norm for eigen matrices
Czero_impl< Eigen::Matrix< T, N, M > >	Specialization of zero element for eigen matrices
Cis_zero_impl< Eigen::Matrix< T, N, M > >	Specialization of zero element for eigen matrices
Cidentity_impl< Eigen::Matrix< T, N, N > >	Specialization of identity for eigen matrices
Cconstant_impl< Eigen::Matrix< T, N, M > >	Specialization of constant for eigen matrices
Cinverse_impl< Eigen::Matrix< T, N, N > >	Specialization of inversion for eigen matrices
Cscalar_of	Scalar type of a non-scalar type
Crhs_of	RHS type corresponding to a non-scalar type
Celement_of	Element type of a non-scalar type
Creplace_scalar	Replace scalar type in the static matrix
Cis_static_matrix	Whether the value type is a statically sized matrix
Cstatic_rows	Number of rows for statically sized matrix types
Cstatic_cols	Number of columns for statically sized matrix types
Cadjoint_impl	Default implementation for conjugate transpose
Cinner_product_impl	Default implementation for inner product
Cnorm_impl	Default implementation for element norm
Czero_impl	Default implementation for the zero element
Cis_zero_impl	Default implementation for zero check
Cidentity_impl	Default implementation for the identity element
Cconstant_impl	Default implementation for the constant element
Cinverse_impl	Default implementation of inversion operation
CCSRMatrixView	Sparse matrix stored in CSR (Compressed Sparse Row) format
CCSRMatrix	Sparse matrix stored in CSR (Compressed Sparse Row) format
Crow_iterator
CBlockCSRMatrix	Sparse matrix in Block CSR format
CCSRRow	Represents a row of a CSR Matrix
CCSRRowColumnIndex	Index in the RowColumn list of a CSR Matrix
CCSRRowColumnIterator	Represents an iterator over the columns of a CSRRow
CCSRRowRangeIterator	Iterator over rows of a CSR Matrix
CSentinel	Sentinel to detect end of iteration
CCSRRowRange	Represents a range of rows of a CSR Matrix
CSolverResult	Result of a solution
CPropertyTree
Cmulti_array
Ccircular_buffer
Cis_complex
Cis_complex< std::complex< T > >
CAMG	Algebraic multigrid method
Cparams	Parameters of the method
CAMGLevel
CBiCGStabLSolverParams	Parameters for BiCGStab(L) solver
CBiCGStabLSolver	BiCGStab(L) method
CBiCGStabSolverParams	Parameters for BiConjugate Gradient Stabilized solver
CBiCGStabSolver	BiConjugate Gradient Stabilized (BiCGSTAB) method
CBuiltinBackend
Cprovides_row_iterator
Cgather
Cscatter
Cnullspace_params
Cplain_aggregates	Plain aggregation
Cparams	Aggregation parameters
Cpointwise_aggregates	Pointwise aggregation
Cparams	Aggregation parameters
CAggregationCoarsening	Non-smoothed aggregation
Cparams	Coarsening parameters
CAsScalarCoarsening	Apply a scalar coarsening on a block matrix
Ctype
CRugeStubenCoarsening	Classic Ruge-Stuben coarsening with direct interpolation
Cparams	Coarsening parameters
CSmoothedAggregationCoarserning	Smoothed aggregation coarsening
Cparams	Coarsening parameters
CSmoothedAggregationEnergyMinCoarsening	Smoothed aggregation with energy minimization
Cparams	Coarsening parameters
CCoarseningRuntime
CConjugateGradientSolverParams	Parameters for Conjugate Gradient solver
CConjugateGradientSolver	Conjugate Gradients solver
CCSRArray	Array for internal CSRMatrix fields
CSpanChooser
CSpanChooser< T, 4 >
CSpanChooser< T, 8 >
CCuthillMcKeeReorderer	(Reverse) Cuthill-McKee matrix reorder algorithm
CDeflatedSolver	Iterative preconditioned solver with deflation
Cparams	Combined parameters of the bundled preconditioner and the iterative solver
CDistributedAMG
Cparams
CDistributedAMGLevel
CDistributedPMISAggregation	Distributed PMIS aggregation
Cparams
CDistributedAggregationCoarsening	Distributed non-smoothed aggregation coarsening scheme
Cparams
CDistributedSmoothedAggregationCoarsening	Distributed smoothed aggregation coarsening scheme
Cparams
CDistributedCoarseningRuntime
CDistributedCPRPreconditioner	Distributed CPR preconditioner
Cparams
CDistributedDirectSolverBase	Base class for distributed direct solver
CDistributedDirectSolverRuntime	Runtime wrapper for distributed direct solvers
CDistributedEigenSparseLUDirectSolver	Distributed wrapper for Eigen::SparseLU solver
CDistributedInnerProduct	Inner product for distributed vectors
CCommunicationPattern	Call to handle communication pattern
CDistributedMatrix	Distributed Matrix using message passing
CDistributedPreconditionedSolver	Iterative solver wrapper for distributed linear systems
Cparams
CDistributedPreconditioner	Distributed Preconditioner
CDistributedBlockPreconditioner	Distributed block preconditioner
CDistributedChebyshevRelaxation
CDistributedDampedJacobiRelaxation
CDistributedGaussSeidelRelaxation
CDistributedILU0Relaxation
CDistributedILUKRelaxation
CDistributedILUPRelaxation
CDistributedILUTRelaxation
CDistributedSPAI0Relaxation
CDistributedSPAI1Relaxation
CAsDistributedPreconditioner	Use a relaxation as a distributed preconditioner
CDistributedRelaxationRuntime	Distributed memory sparse approximate inverse relaxation scheme
CDistributedSchurPressureCorrection	Distributed Schur complement pressure correction preconditioner
Cparams
CDistributedSkylineLUDirectSolver	Provides distributed direct solver interface for Skyline LU solver
CDistributedConjugateGradientSolver
CDistributedBiCGStabSolver
CDistributedBiCGStabLSolver
CDistributedFlexibleGMRESSolver
CDistributedGMRESSolver
CDistributedIDRSSolver
CDistributedLooseGMRESSolver
CDistributedPreconditionerOnlySolver
CRichardsonSolve
CDistributedSolverRuntime
Cconstant_deflation	Pointwise constant deflation vectors
Csdd_projected_matrix
CDistributedSubDomainDeflation	Distributed solver based on subdomain deflation
Cparams
CEigenSolver	Wrapper around eigen direct solvers
CExecutionContext
CFlexibleGMRESSolverParams	Parameters for FlexibleGMRES solver
CFlexibleGMRESSolver	Flexible GMRES method. \rst Flexible version of the GMRES method [Saad03]_. \endrst
CGMRESSolverParams	Parameters for GMRES solver
CGMRESSolver	Generalized Minimal Residual (GMRES) method
CIDRSSolverParams	Parameters for IDR(s) solver
CIDRSSolver	IDR(s) method (Induced Dimension Reduction)
CLooseGMRESSolverParams	Parameters for Loose GMRES solver
CLooseGMRESSolver	Loose GMRES. \rst The LGMRES algorithm [BaJM05]_ is designed to avoid some problems in the convergence in restarted GMRES, and often converges in fewer iterations. \endrst
Cmake_block_solver
CMatrixPartitionerRuntime	Runtime-configurable wrapper around matrix partitioner
Cmpi_datatype_impl	Converts C type to MPI datatype
Cmpi_datatype_impl< float >
Cmpi_datatype_impl< double >
Cmpi_datatype_impl< long double >
Cmpi_datatype_impl< int >
Cmpi_datatype_impl< unsigned >
Cmpi_datatype_impl< long long >
Cmpi_datatype_impl< unsigned long long >
Cmpi_datatype_impl< T, typename std::enable_if< std::is_same< T, ptrdiff_t >::value &&!std::is_same< ptrdiff_t, long long >::value &&!std::is_same< ptrdiff_t, int >::value >::type >
Cmpi_datatype_impl< T, typename std::enable_if< std::is_same< T, size_t >::value &&!std::is_same< size_t, unsigned long long >::value &&!std::is_same< ptrdiff_t, unsigned int >::value >::type >
Cmpi_datatype_impl< char >
Cmpi_init	Convenience wrapper around MPI_Init/MPI_Finalize
Cmpi_init_thread	Convenience wrapper around MPI_Init_threads/MPI_Finalize
Cmpi_communicator	Convenience wrapper around MPI_Comm
Cnuma_vector	NUMA-aware vector container
CParmetisMatrixPartitioner
Cparams
CPreconditionedSolver	Convenience class that bundles together a preconditioner and an iterative solver
Cparams	Combined parameters of the bundled preconditioner and the iterative solver
CPreconditionerOnlySolver	Solver which only apply preconditioner once
CPreconditionerRuntime	Runtime-configurable preconditioners
CProfiler	Profiler class
Cscoped_ticker
Cprofile_unit
CRelaxationAsBlock	Converts input matrix to block format before constructing an AMG smoother
Ctype
CRelaxationAsPreconditioner	Allows to use an AMG smoother as standalone preconditioner
CChebyshevRelaxation	Chebyshev polynomial smoother
Cparams	Relaxation parameters
CDampedJacobiRelaxation	Damped Jacobi relaxation
Cparams	Relaxation parameters
CGaussSeidelRelaxation	Gauss-Seidel relaxation
Cparams	Relaxation parameters
Cparallel_sweep
Ctask
CILU0Relaxation
Cparams	Relaxation parameters
CILUKRelaxation	ILU(k) smoother
Cparams	Relaxation parameters
Cnonzero
Csparse_vector
Ccomp_indices
CILUPRelaxation	ILU(k) smoother
Cparams	Relaxation parameters
CILUTRelaxation
Cparams	Relaxation parameters
Csparse_vector
Cnonzero
Ccomp_indices
Chigher_than
CL_first
Cby_abs_val
Cby_col
CSPAI0Relaxation	Sparse approximate interface smoother
CSPAI1Relaxation	Sparse approximate interface smoother
CRelaxationBase	Base class for solvers
CRelaxationRuntime	Runtime configurable relaxation
CRichardsonSolverParams	Parameters for Richardson solver
CRichardsonSolver	Richardson iteration
CSampleMainContext
CScopedStreamModifier	Save ostream flags in constructor, restore in destructor
CSimpleMatrixPartitioner	Simple matrix partitioner merging consecutive domains together
Cparams
CSolverBase	Base class for solvers
CSolverRuntime	Runtime-configurable wrappers around iterative solvers
CStaticMatrix
Cis_static_matrix
Cis_static_matrix< StaticMatrix< T, N, M > >
NImpl
CCoreArray	Internal array for Arccore
CBasicTranscoder
CForLoopProfilingStat	Execution statistics of a loop
CForLoopStatInfoListImpl
CForLoopCumulativeStat	Cumulative statistics on the number of executed loops
CAcceleratorStatInfoList	Statistics for accelerators
CMemoryTransferInfo	Information on memory transfers between CPU and GPU
CMemoryPageFaultInfo	Information on page faults on CPU or GPU
CScopedStatLoop	Class allowing retrieval of the time spent between the constructor call and the destructor call
CForLoopStatInfoList	Loop execution statistics
CViewTypeT
CViewTypeT< const T >
CSpanTypeFromSize	To have the type (SmallSpan or Span) depending on the size (Int32 or Int64)
CSpanTypeFromSize< T, Int32 >
CSpanTypeFromSize< T, Int64 >
CDynamicExtentStorage	Class to store the size of a SpanImpl
CExtentStorageBase
CExtentStorage	Specialization for the compile-time known number of elements
CExtentStorage< Int32, DynExtent >	Specialization for the dynamic number of elements
CExtentStorage< Int64, DynExtent >	Specialization for the dynamic number of elements
CStridedLoopRanges
CHostKernelRemainingArgsHelper	Class to apply methods of additional arguments at the beginning and end of the kernel
CHostSpecificMemoryCopy	Implementation of copies and filling on host
CIMemoryPoolAllocator	Interface for an allocator for a MemoryPool
CMemoryPool	Class to manage a list of allocated zones
CImpl
CAllocatedMap	Associative array of allocated pointers and associated size
CFreedMap	Associative array of free memory locations by size
CIndexedMemoryCopyArgs	Arguments for copying specific indices between two memory regions
CIndexedMultiMemoryCopyArgs	Arguments for copying specific indices to/from multiple memory regions
CISpecificMemoryCopy	Interface of a specialized memory copier for a given data size
CISpecificMemoryCopyList	Interface of a list of specialized ISpecificMemoryCopy instances
CSpecificMemoryCopyList	List of specialized ISpecificMemoryCopy instances
CSpecificMemoryCopyBase
CSpecificMemoryCopyRef	Reference to a copier
CGlobalMemoryCopyList	Singleton class containing the instance to use for copies
CNumArrayBaseCommon	Common implementation for NumArray
CNumArrayContainer	Container for the NumArray class
CStackMemoryAllocator	Allocator with pre-allocated buffer
CHostIndexedCopyTraits
CHostSpecificMemoryCopyList	Specific copier when no accelerator runtime is initialized
NDependencyInjection
Nimpl
CFactoryInfoImpl
CIConcreteFactory
NInjector
CImpl
CInstanceInfo
CCoreArray	Internal array for Arccore
Ndetail
CView2TypeT
CView2TypeT< const T >
NConcurrency
CStdThreadImplementation	Implementation of ITreadImplementation using the standard C++ library
CLegacyStdThreadBarrier	Implementation of a barrier
CStdThreadBarrier	Implementation of a barrier using std::barrier
CNullFunc
NTrace	Namespace containing types related to traces
CWidth	Formatting the stream by length
CPrecision	Formatting real numbers with a given precision
CColor	Sets a color for the message
CSetter	Sets a message class
CIteratorWithIndexBase
CIteratorWithIndex	Base class for an iterator that preserves the iteration index
CAlephIndexing	Indexing Manager
CIAlephTopology
CIAlephVector
CIAlephMatrix
CIAlephFactory
CIAlephFactoryImpl	Interface of an implementation factory for Aleph
CAlephKernelResults
CAlephKernelSolverInitializeArguments	Information to initialize the linear solver used
CAlephKernelArguments
CAlephKernel
CAlephMatrix	Matrix of a linear system
CAlephOrdering	Reordering manager
CAlephParams	Parameters of a linear system
CAlephTopology	Information about the parallel environment
CTypesSolver
CAlephVector	Vector of a linear system
CCudaAlephFactoryImpl
CCuda
CCNCCoeff
CCNCCoeffIndexCompare
CCNCSparseRowColumn
CCNC_Matrix
CCNC_MatrixPatternCRS
CCNC_MatrixCRS
CCNC_Vector
CAlephVectorCnc
CAlephMatrixCnc
CAlephVectorHypre
CAlephMatrixHypre
CHypreAlephFactoryImpl
CAlephFactory
CFactoryImpl
CAlephKappaService
CAlephTopologyPETSc
CAlephVectorPETSc
CAlephMatrixPETSc
CPETScAlephFactoryImpl
CAlephTopologySloop
CAlephVectorSloop
CAlephMatrixSloop
CSloopAlephFactoryImpl
CAlephVectorTrilinos
CAlephMatrixTrilinos
CTrilinosAlephFactoryImpl
CAMRPatchPosition	Class allowing the definition of a patch position in the Cartesian mesh
CAMRZonePosition	Class allowing the definition of a mesh zone
CCartesianConnectivity	Connectivity information of a Cartesian mesh
CIndex	List of the 8 entities around another entity
CPermutation	Permutation in Index for each direction
CCartesianConnectivityLocalId	Class for accessing Cartesian connectivities
CCartesianMeshImpl	Specific information for a Cartesian mesh
CInternalApi
CCartesianMeshAMRMng	Class allowing access to the specific AMR methods of the Cartesian mesh
CCartesianMeshCoarsening	Coarsens a Cartesian mesh by 2
CCartesianMeshCoarsening2	Coarsens a Cartesian mesh by 2
CCartesianMeshNumberingMng	Numbering manager interface for Cartesian mesh
CCartesianMeshPatchListView	View of a list of patches
CSentinel	Sentinel for iteration over a list of patches
CIterator	Iterator for a list of patches
CCartesianMeshRenumberingInfo	Information for renumbering
CCartesianPatch	AMR Patch of a Cartesian mesh
CDirCell	Cell before and after a cell along a direction
CDirCellLocalId	Cell before and after a cell along a direction
CDirCellNode	Cell with directional node information
CDirCellNodeLocalId	Cell with directional node information
CDirCellFace	Cell with directional face information
CDirCellFaceLocalId	Cell with directional face information
CCellDirectionMng	Info about the cells in a specific X, Y, or Z direction of a structured mesh
CImpl
CDirFace	Info on the cell before and after a face along a direction
CDirFaceLocalId	Info on the cell before and after a face along a direction
CFaceDirectionMng	Info on the faces of a specific direction X, Y, or Z of a structured mesh
CImpl
CICartesianMesh	Interface of a Cartesian mesh
CICartesianMeshPatch	Interface of an AMR patch of a Cartesian mesh
CAMRPatchPositionLevelGroup	Class allowing storage of patches by level
CAMRPatchPositionSignature	Class for managing patch signatures
CAMRPatchPositionSignatureCut	Class allowing a patch to be cut into several smaller patches
CCartesianMeshAMRPatchMng
CCartesianMeshNumberingMngInternal
CCartesianMeshPatch	Information by direction for each type of mesh entity
CImpl
CCartesianMeshUniqueIdRenumbering	Renumbering of uniqueId() for Cartesian meshes
CNewUniqueIdList
CCartesianPatchGroup
CICartesianMeshAMRPatchMng
CICartesianMeshInternal	Internal part of ICartesianMesh
CICartesianMeshNumberingMngInternal	Interface for Cartesian mesh numbering manager
CICartesianMeshPatchInternal
CDirNode	Node before and after a node following a direction
CDirNodeCellIndex
CDirNodeLocalId	Node before and after a node following a direction
CNodeDirectionMng	Info about nodes in a specific direction X, Y, or Z of a structured mesh
CItemDirectionInfo
CImpl
CSimpleHTMLMeshAMRPatchExporter
CImpl
CCartesianMeshUniqueIdRenumberingV2	Renumbering of uniqueId() for Cartesian meshes
CAbstractCaseDocumentVisitor	Abstract visitor for a scalar data point
CAbstractScalarDataVisitor	Abstract visitor for a scalar data item
CAbstractArrayDataVisitor	Abstract visitor for an array data item
CAbstractArray2DataVisitor	Abstract visitor for a 2D array data item
CAbstractMultiArray2DataVisitor	Abstract visitor for a variable-sized 2D array data item
CAbstractDataVisitor	Abstract visitor for a data item
CAbstractItemOperationByBasicType	Abstract operator on entities sorted by type
CAbstractModule	Class representing a module
CAbstractService	Base class of a service
CActionWrapperService	Wrapper around an action
CApplicationBuildInfo	Information for constructing an instance of IApplication
CImpl
CBadIDException	Exception for an invalid identifier
CBadItemIdException	Exception for an invalid entity ID
CInternalErrorException	Exception when an internal error occurs
CBadVariableKindTypeException	Exception for an invalid variable kind/type
CBadPartialVariableItemGroupNameException	Exception for an invalid partial variable item group name
CUnknownItemTypeException	Exception when a mesh entity is not of a known type
CBadReferenceException	Exception when trying to dereference a null pointer
CReaderWriterException	Exception in a reader or writer
CAssertionException	Exception in an assertion
CSimplePropertyT	Basic implementation of a property
CIScalarDataT	Interface of a scalar data item of type T
CIArrayDataT	Interface of a 1D array data item of type T
CIArray2DataT	Interface of a bi-dimensional array data item of type T
CIMultiArray2DataT	Interface of a multi-sized 2D array data item of type T
CVariableScalarT	Scalar variable
CVariableArrayT	Implementation of a variable on a 1D array
CArray2VariableT	Variable on a 2D array
CVariableRefScalarT	Reference to a scalar variable
CVariableRefArrayT	Array variable
CVariableRefArray2T	Two-dimensional array variable
CMultiArray2VariableRefT
CItemVariableScalarRefT	Scalar variable on a mesh entity type
CMeshVariableScalarRefT	Scalar variable on a mesh entity type
CMeshVariableArrayRefT	Array variable on a mesh entity type
CItemPartialVariableScalarRefT	Partial scalar variable on a mesh entity type
CMeshPartialVariableScalarRefT	Scalar variable on a mesh entity type
CSharedMeshVariableScalarRefT
CSharedItemVariableScalarRefT
CMeshMDVariableRefBaseT	Base class managing a multi-dimensional variable on a mesh entity
CMeshMDVariableRefT	Class managing a multi-dimensional variable on a mesh entity
CIArrayDataInternalT	Interface for an array data of type T
CIArray2DataInternalT	Interface for a two-dimensional array data of type T
CArray2VariableDiff
CAssertion	Base class for assertions in unit tests
CBasicModule	Basic module
CBasicService	Base class of a service linked to a subdomain
CBasicTimeLoopService	Base class for a service operating during the time loop
CBasicUnitTest	Basic unit test service
CBlockIndex	Block containing a list of indices with an offset
CBlockIndexList	Class managing an array in the form of a block list
CBlockIndexListBuilder	Class allowing the construction of a BlockIndexList
CCartesianGridDimension	Information about the dimensions of a Cartesian grid
CNodeUniqueIdComputer2D	Class for calculating the uniqueId() of a node in 2D based on its position in the grid
CCellUniqueIdComputer2D	Class for calculating the uniqueId() of a cell in 2D based on its position in the grid
CFaceUniqueIdComputer2D	Class for calculating the uniqueId() of a face in 2D based on its position in the grid
CNodeUniqueIdComputer3D	Class for calculating the uniqueId() of a node in 3D based on its position in the grid
CCellUniqueIdComputer3D	Class for calculating the uniqueId() of a cell in 3D based on its position in the grid
CFaceUniqueIdComputer3D	Class for calculating the uniqueId() of a face in 2D based on its position in the grid
CCartesianMeshAllocateBuildInfo	Information for allocating entities of an unstructured mesh
CImpl
CCaseDatasetSource	Source of a case dataset
CImpl
CCaseFunctionBuildInfo	Information to build an instance of CaseFunction
CCaseFunction	Dataset function
CCaseFunction2	Implementation of CaseFunction allowing direct return of the value associated with a parameter without passing through a reference
CCaseNodeNames	XML node names of an Arcane dataset
CImpl
CCaseOptionBasePrivate	Implementation of the base class for a data set option
CCaseOptionBase	Base class for a data set option
CCaseOptionBuildInfo	Information for building a dataset option
CCaseOptionComplexValue	Base class for a complex option value
CCaseOptionName	Name of a data set option. This class allows storing the name of an option in multiple languages
CCaseOptionEnumValue	Name and value of a data set enumeration
CCaseOptionEnumValues	Set of values for an enumeration
CCaseOptionEnum	Enumerated data set option
CCaseOptionEnumT	Enumerated data set option
CCaseOptionMultiEnum	Multi-enumeration data set option
CCaseOptionMultiEnumT	Multi-enumeration data set option
CCaseOptionError	Error in the dataset
CCaseOptionException	Exception related to the dataset
CCaseOptionExtended	Option for the extended type dataset
CCaseOptionExtendedT	Option for the extended type dataset
CCaseOptionMultiExtended	Option for the extended list of types dataset
CCaseOptionMultiExtendedT	Option for the extended list of types dataset
CXmlElementContentChecker	Checks the validity of content between elements
CCaseOptionList	List of configuration options for a service or module
CInternalApi
CCaseOptionListMulti	Data set option list containing multiple identical children
CCaseOptionsPrivate
CCaseOptions	Base class for a data set options list
CXmlContent
CCaseOptionServiceT
CCaseOptionServiceContainer	Implementation of the container for a service of type InterfaceType
CCaseOptionService	Base class for options using services
CCaseOptionMultiService	Base class for a service option that can appear multiple times
CCaseOptionMultiServiceT	Data set option of the service list type
CICaseOptionServiceContainer	Interface of a service instance container
CCaseOptionServiceImpl	Base class for implementing options using services
CCaseOptionMultiServiceImpl	Base class for a service option that can appear multiple times
CCaseOptionTraitsT
CCaseOptionTraitsT< Array< Type > >	Specialization for 'Array' options
CCaseOptionSimple	Base class for simple options (single value)
CCaseOptionSimpleT	Simple data set option (real, integer, boolean, ...)
CCaseOptionMultiSimple
CCaseOptionMultiSimpleT	Data set option of simple type list (real, integer, boolean, ...)
CCaseOptionsMain
CCaseOptionsMulti	Base class for an array of complex data set options
CCaseTable	Data set function
CICFParamSetter
CCFParamSetterT
CCaseTableParams	Parameter of a function
CImpl
CCheckpointInfo	Information about a checkpoint
CCheckpointReadInfo	Checkpoint reading information
CCheckpointService	Protection/recovery service
CCodeServicePrivate
CCodeService	Abstract class for a code service
CCommonVariables	Common variables of a case
CIConfigurationSection	Interface for a configuration section
CIConfiguration	Interface for a configuration
CIConfigurationMng	Configuration manager
CConnectivity
CPrinter	Class for writing a connectivity marker
CConnectivityItemVectorCatalyst	Temporary type automatically cast to ConnectivityItemVector
CConnectivityItemVector	Manages the retrieval of connectivity information
CContigMachineShMemWin	Class allowing the creation of a shared memory window between the subdomains of the same node. The segments of this window will be contiguous in memory
CContigMachineShMemWinBase	Class allowing the creation of a shared memory window between the subdomains of the same node. The segments of this window will be contiguous in memory
CArrayVariant	Polymorphic base type for arrays (dimension 1)
CBadVariantTypeException	Exception for an invalid variant type
CDataAllocationInfo	Information on data allocation
CDataStorageBuildInfo	Information to construct an instance of 'IData'
CDataStorageTypeInfo	Type information for a data container
CDataTracerT	DataTracer for a data of type DataType
CDataTypeNames	List of names for eDataType
CDataTypeTraitsT
CBuiltInProxy	Proxy of a language type
CDataTypeTraitsT< bool >	Specialization of DataTypeTraitsT for the type bool
CDataTypeTraitsT< Byte >	Specialization of DataTypeTraitsT for the type Byte
CDataTypeTraitsT< Real >	Specialization of DataTypeTraitsT for the type Real
CDataTypeTraitsT< Float128 >	Specialization of DataTypeTraitsT for the type Float128
CDataTypeTraitsT< Float32 >	Specialization of DataTypeTraitsT for the type Float32
CDataTypeTraitsT< BFloat16 >	Specialization of DataTypeTraitsT for the type BFloat16
CDataTypeTraitsT< Float16 >	Specialization of DataTypeTraitsT for the type Float16
CDataTypeTraitsT< Int8 >	Specialization of DataTypeTraitsT for the type Integer
CDataTypeTraitsT< Int16 >	Specialization of DataTypeTraitsT for the type Integer
CDataTypeTraitsT< Int32 >	Specialization of DataTypeTraitsT for the type Int32
CDataTypeTraitsT< Int64 >	Specialization of DataTypeTraitsT for the type Int64
CDataTypeTraitsT< Int128 >	Specialization of DataTypeTraitsT for the type Int128
CDataTypeTraitsT< String >	Specialization of DataTypeTraitsT for the type String
CDataTypeTraitsT< Real2 >	Specialization of DataTypeTraitsT for the type Real2
CDataTypeTraitsT< Real3 >	Specialization of DataTypeTraitsT for the type Real3
CDataTypeTraitsT< Real2x2 >	Specialization of DataTypeTraitsT for the type Real2x2
CDataTypeTraitsT< Real3x3 >	Specialization of DataTypeTraitsT for the type Real3x3
CDataTypeTraitsT< NumVector< Real, Size > >	Specialization of DataTypeTraitsT for the type NumVector<Real,Size>
CDataTypeTraitsT< NumMatrix< Real, RowSize, ColumnSize > >	Specialization of DataTypeTraitsT for the type NumMatrix<Real,RowSize,ColumnSize>
CIDataOperation	Interface of an operation on a data
CIDataTracerT	Interface of a tracer
CRealArray2Variant	Variant that can contain the types ConstArray2View, Real2x2, and Real3x3
CRealArrayVariant	Variant that can contain the types ConstArrayView, Real2, and Real3
CScalarVariant	Polymorphic base type for scalars (dimension 0)
CSmallVariant	Class managing a polymorphic type
CVariantGetterT
CVariantBase	Base class for polymorphic types
CIDataTypeDataDispatcherT	Template class for dispatching data (IData) according to their type (DataType)
CIDataTypeDataDispatcherT< String >	Specialization of IDataDispatcherT for the 'String' class
CAbstractDataTypeDispatchingDataVisitor	IDataVisitor dispatching operations according to the data type
CDataTypeDispatchingDataVisitor	IDataVisitor dispatching operations according to the data type
CDirectory	Class managing a directory
CXmlDocumentHolderLibXml2
CLIBXML2_RefCount
CLIBXML2_DOMImplementation
CLIBXML2_Node
CLIBXML2_NodeList
CLIBXML2_NodeListDFSSearch
CLIBXML2_EmptyNamedNodeMap
CLIBXML2_CharacterData
CLIBXML2_Attr
CLIBXML2_Element
CLocalName
CQualifiedName
CLIBXML2_NamedNodeMap
CLIBXML2_NamedNodeMapDT
CLIBXML2_TextBase
CLIBXML2_Text
CLIBXML2_Comment
CLIBXML2_CDATASection
CLIBXML2_DocumentType
CLIBXML2_Notation
CLIBXML2_Entity
CLIBXML2_EntityReference
CLIBXML2_ProcessingInstruction
CLIBXML2_DocumentFragment
CLIBXML2_Document
CLIBXML2_DOMWriter
CLIBXML2_DOMNamespaceContext
CLIBXML2_PartialLoad
CDotNetRuntimeInitialisationInfo	Information for the initialization of the '.Net' runtime
CImpl
CEntryPointBuildInfo	Information to build an entry point
CEntryPoint	Module entry point
CEnumeratorTraceInfo	Information for an enumerator's traces
CEnumeratorTraceWrapper	Wrapper around an enumerator for traces
CArrayOperator	Generic binary operator for expressions
CArrayOperatorT
CArrayExpressionImpl
CBadExpressionException	Exception when an expression is not valid
CBadOperandException	Exception for operands in expression operations
CBadOperationException	Exception on an expression operation
CBinaryExpressionImpl	Implementation of a binary expression
CBinaryOperator	Generic binary operator for expressions
CDefaultBinaryOperator
CExpression	Reference to an expression
CExpressionImpl	Base class for the expression implementation
CExpressionResult	Polymorphic base type of an expression
CIExpressionImpl	Interface for the different implementations of an expression
CLitteralExpressionImpl	Implementation of a literal expression containing a scalar
CLitteralOperator	Generic cast operator for literals
CLitteralOperatorT
COperatorMng	Stores all possible operator types on expressions
CUnaryExpressionImpl	Implementation of a unary expression
CUnaryOperator	Generic unary operator for expressions
CDefaultUnaryOperator
CWhereExpressionImpl	Implementation of a binary expression
CWhereOperator	Generic operator for conditional expressions
CWhereOperatorT
CExternalPartitionConstraint
CFaceReorienter	This function/class reorients faces
CGlobalTimeHistoryAdder	Class allowing the addition of one or more values to a value history
CGroupIndexTableView
CGroupIndexTable	Base class of a hash table between group items and their positions in the table
CIApplication	Application interface
CIArcaneMain	Interface of the code management class
CIAsyncParticleExchanger	Interface of an asynchronous particle exchanger
CIBackwardMng	Interface managing backward strategies
CIBase	Interface of the base class for main arcane objects
CICartesianMeshGenerationInfo	Brief: Cartesian mesh generation information
CICaseDocumentFragment	Interface of a part of a dataset
CICaseDocument	Interface of a class managing an XML document of the dataset
CICaseDocumentVisitor	Visitor interface for a dataset option
CICaseFunction	Interface of a dataset function
CICaseFunctionProvider	Interface of a service providing user functions for the JDD
CICaseFunctionDotNetProvider	Interface of a service providing user functions for the JDD
CICaseMeshMasterService	Interface of the service managing the meshes of the dataset
CCaseMeshReaderReadInfo	Necessary information for reading a mesh file
CICaseMeshReader	Interface for the mesh reading service from the dataset
CICaseMeshService	Interface of the service managing dataset meshes
CICaseMng	Case manager interface
CICaseOptionList	Interface for a data set options list
CICaseOptions	Interface for a list of data set options
CICaseOptionsMulti	Interface for a list of options that appears multiple times
CICheckpointMng	Interface of the checkpoint information manager
CICheckpointReader	Interface for the protection/recovery reading service
CICheckpointReader2	Interface for the protection/recovery reading service (V2)
CICheckpointWriter	Interface of the checkpoint/recovery write service
CICodeService	Interface of a case loader
CICriteriaLoadBalanceMng	Class interface allowing criteria to be added to adjust the load balance
CIData	Interface of a data item
CIScalarData	Interface of a scalar data item
CIArrayData	Interface of a 1D array data item
CIArray2Data	Interface of a 2D array data item
CIMultiArray2Data	Interface of a multi 2D array data item
CIDataFactory	Interface of a data factory
CIDataFactoryMng	Interface of the data factory manager
CIDataReader	Interface for reading variable data
CDataReaderInfo	Data reading information
CVariableDataReadInfo	Data reading information for a variable
CIDataReader2	Interface for reading data of a variable (Version 2)
CIDataReaderWriter	Interface for reading/writing variable data
CIDataStorageFactory	Interface of a data container factory
CIDataVisitor	Interface of the visitor pattern for a data item
CIScalarDataVisitor	Interface of the visitor pattern for a scalar data item
CIArrayDataVisitor	Interface of the visitor pattern for an array data item
CIArray2DataVisitor	Interface of the visitor pattern for a 2D array data item
CIMultiArray2DataVisitor	Interface of the visitor pattern for a variable-sized 2D array data item
CIDataWriter	Interface for writing variable data
CIDeflateService	Interface of a service allowing compression/decompression of data
CIDirectExecution	Interface of a direct execution service
CIDirectory	Interface of a class managing a directory
CIDirectSubDomainExecuteFunctor	Interface of a functor to execute code directly after the creation of a subdomain without going through the time loop
CIDoFFamily	Interface of a DoF family
CIEntryPoint	Interface of a module entry point
CIEntryPointMng	Interface for the entry point manager
CIExternalPlugin	Interface for external service loading
CIExtraGhostCellsBuilder	Interface of a builder for "extraordinary" ghost cells
CIExtraGhostItemsBuilder	Interface for an "extraordinary" ghost item builder
CIExtraGhostParticlesBuilder	Interface of a builder for "extraordinary" ghost cells
CIFactoryServiceT	Factory interface for a class implementing InterfaceType
CIGetVariablesValuesParallelOperation	Operations to access variable values from another subdomain
CIGhostLayerMng
CIGraphConnectivity	Graph connectivity tooling
CIGraphConnectivityObserver
CIGraphObserver
CIGraph2	Mesh graph interface
CIGraphModifier2	Interface for a mesh graph
CIGridMeshPartitioner	Interface of a mesh partitioner on a grid
CIIncrementalItemSourceConnectivity	Interface for the source of an incremental connectivity
CIIncrementalItemTargetConnectivity	Interface for the target of an incremental connectivity
CIIncrementalItemConnectivity	Interface for managing an incremental connectivity
CIIndexedIncrementalItemConnectivity	Interface to manage incremental connectivity
CIIndexedIncrementalItemConnectivityMng	Interface of the manager for indexed incremental item connectivities
CIInitialPartitioner	Interface of an initial partitioner
CIIOMng	Interface of the input/output manager
CIItemConnectivity	Interface to manage connectivity
CIItemConnectivityAccessor	Interface to manage access to a connectivity
CIItemConnectivityInfo	Interface for connectivity information by entity type
CIItemConnectivityMng
CIItemConnectivitySynchronizer
CIItemEnumeratorTracer	Interface for an enumerator tracer on entities
CIItemFamily	Interface of an entity family
CIItemFamilyCompactPolicy	Entity compaction policy
CIItemFamilyExchanger	Exchange of entities and their characteristics for a given family
CIItemFamilyModifier	Interface for modifying a family
CIItemFamilyNetwork
CIItemFamilyPolicyMng	Interface for entity family policies
CIItemFamilySerializer	Manages the serialization/deserialization of entities in a family
CIItemFamilySerializeStep	Interface for a step in the serialization of entity families
CNotifyActionArgs
CIItemFamilySerializeStepFactory	Factory for creating a step in the serialization of entity families
CIItemFamilyTopologyModifier	Interface for modifying the topology of entities within a family
CIItemInternalSortFunction	Interface of an entity sorting function
CIItemOperationByBasicType	Interface of an operator on entities sorted by type
CILoadBalanceMng	Interface for registering variables for load balancing
CIMainFactory	Factory for Arcane classes
CIMesh
CIMeshArea	Interface of a mesh area
CIMeshBase
CIMeshBuilder	Interface of a mesh creation/reading service
CIMeshChecker	Interface for mesh verification methods
CIMeshCompacter	Management of mesh family compaction
CIMeshCompactMng	Interface for managing the compaction of mesh families
CIMeshExchangeMng	Interface for managing mesh exchanges between subdomains
CIMeshExchanger	Management of a mesh exchange between subdomains
CIMeshFactory	Interface of the service managing mesh reading
CIMeshFactoryMng	Interface of the mesh factory manager
CIUnstructuredMeshInitialAllocator	Allocator for unstructured meshes
CICartesianMeshInitialAllocator	Allocator for Cartesian meshes
CIPolyhedralMeshInitialAllocator	Allocator for polyhedral meshes
CIMeshInitialAllocator	Interface for allocating mesh entities
CIMeshMng	Mesh manager interface
CMeshModifierAddCellsArgs	Arguments for IMeshModifier::addCells()
CMeshModifierAddFacesArgs	Arguments for IMeshModifier::addFaces()
CIMeshModifier	Mesh modification interface
CIMeshPartitionConstraint	Interface of a mesh partitioning constraint
CIMeshPartitionConstraintMng	Interface of a mesh partitioning constraint manager
CIMeshPartitioner	Interface of a mesh partitioner
CIMeshPartitionerBase	Interface of a mesh partitioner
CIMeshReader	Interface of the service managing the reading of a mesh
CIMeshStats	Interface of a class providing mesh information
CIMeshSubdivider	IMeshSubdivider
CIMeshUniqueIdMng
CIMeshUtilities	Interface of a class providing utility functions on meshes
CIMeshWriter	Interface of a mesh writing service
CIModule	Interface of a module
CIModuleFactoryInfo	Information about a module factory
CIModuleFactory2	Module factory interface (V2)
CModuleFactoryReference	Reference counter for a module factory
CIModuleMaster	Interface of the main module
CIModuleMng	Module manager interface
CIndexedItemConnectivityViewBase	Base class for a view on unstructured connectivity
CIndexedItemConnectivityViewBase2	Base class for a view on unstructured connectivity
CIndexedItemConnectivityGenericViewT	Specialized view on unstructured connectivity between two entities
CIndexedItemConnectivityViewT< ItemType, Node >	View on ItemType->Node connectivity
CIndexedItemConnectivityViewT< ItemType, Edge >	View on ItemType->Edge connectivity
CIndexedItemConnectivityViewT< ItemType, Face >	View of ItemType->Face connectivity
CIndexedItemConnectivityViewT< ItemType, Cell >	View of ItemType->Cell connectivity
CIndexedItemConnectivityViewT< ItemType, DoF >	View of ItemType->DoF connectivity
CIndexedParticleCellConnectivityView	View of Particle->Cell connectivity
CMutableIndexedParticleCellConnectivityView	Editable view of Particle->Cell connectivity
CCartesianMeshAllocateBuildInfoInternal	Internal part of CartesianMeshAllocateBuildInfo
CDotNetRuntimeInitialisationInfoProperties
CGatherGroup	Class allowing the grouping of data from certain sub-domains onto other sub-domains
CGatherGroupInfo	Class allowing the calculation and storage of grouping information
CICaseMngInternal	Internal part of ICaseMng
CICaseOptionListInternal	Internal API of the data set options list interface
CDataCompressionBuffer	Class to manage data compression/decompression
CDataHashInfo	Information for calculating data hash
CIDataInternal	Internal part of IData
CINumericDataInternal	Interface for an 'IData' of a numeric type
CNullDataInternal
CIGatherGroup	Interface class allowing the grouping of data from certain subdomains onto other subdomains
CIGatherGroupInfo	Interface class allowing the calculation and storage of grouping information
CItemConnectivityMemoryInfo	Memory usage information for connectivities
CIIncrementalItemConnectivityInternal	Internal Arcane API for IIncrementalItemConnectivity
CIItemFamilyInternal	Internal part of IItemFamily
CIItemFamilySerializerMngInternal	Manages the serialization/deserialization of entities in a family
CILoadBalanceMngInternal	Internal API of ILoadBalanceMng to Arcane
CIMeshInternal	Internal part of IMesh
CIMeshModifierInternal	Internal part of IMeshModifier
CIParallelMngInternal	Internal part of IParallelMng
CIParallelMngUtilsFactory	Interface of a factory for the utility functions of IParallelMng
CIPolyhedralMeshModifier	Internal part of IMesh
CItemGroupImplInternal	Internal API of ItemGroupImpl in Arcane
CItemGroupSubPartsByType	Management of sub-parts of a group based on the type of its elements
CItemGroupInternal	Implementation of the ItemGroupImpl class
CCheckNeedUpdateMutex	Mutex to protect calls to ItemGroupImpl::_checkNeedUpdate()
CScopedLock
CTimeHistoryAddValueArgInternal	Class extending the arguments when adding a value to a value history
CITimeHistoryMngInternal	Interface for the internal part of a value history manager
CVariableResizeArgs	Arguments for resizing a variable
CIVariableInternal	Internal part of Ivariable
CIVariableMngInternal	Interface of the variable manager
CIVariableSynchronizerMngInternal	Internal Arcane API for IVariableSynchronizerMng
CMachineShMemWinMemoryAllocator
CMachineShMemWinVariableBase	Class allowing access to the shared memory part between sub-domains of the same node of a variable
CMachineShMemWinVariable2DBase	Class allowing access to the shared memory part between sub-domains of the same node of a 2D array variable
CMachineShMemWinVariableMDBase	Class allowing access to the shared memory part between sub-domains of the same node of a 2D array variable
CParallelMngInternal	Internal part of IParallelMng
CSerializeMessage	Message using a SerializeBuffer
CStringVariableReplace
CUnstructuredMeshAllocateBuildInfoInternal	Internal part of UnstructuredMeshAllocateBuildInfo
CVariableUtilsInternal
CIParallelDispatchT	Parallel message handling for the type Type
CIParallelExchanger	Information exchange between processors
CIParallelMng	Interface of the parallelism manager for a subdomain
CIParallelMngContainer	Interface for an 'IParallelMng' container
CIParallelMngContainerFactory	Interface for an 'IParallelMng' container factory
CIParallelNonBlockingCollective	Interface for non-blocking collective parallel operations
CIParallelNonBlockingCollectiveDispatchT	Interface for non-blocking collectives for the type Type
CIParallelReplication	Brief information on parallel subdomain replication
CIParallelSuperMng	Abstract class of the parallelism supervisor
CIParallelTopology	Information on the computing core allocation topology
CIParticleExchanger	Interface of a particle exchanger
CIParticleFamily	Interface of a particle family
CIPhysicalUnit	Physical unit
CIPhysicalUnitConverter	Interface of a unit converter
CIPhysicalUnitSystem	Interface of a unit system
CIPhysicalUnitSystemService	Interface of a service managing a unit system
CIPostProcessorWriter	Interface for a writer for post-processing information
CIPrimaryMesh
CProperty	Definition of types for properties
CIPropertyValue	Interface of a property value
CIPropertyType	Interface of a property type
CIPropertyTypeInstance	Interface of a property type instance
CIPropertyMng	Interface of the property manager
CRNGSeedHelper	Class allowing easy manipulation of a seed
CIRandomNumberGenerator	Interface for a random number generator
CIRayFaceIntersector	Generic interface for calculating the intersection of a ray with a face
CIRayMeshIntersection	Calculation of the intersection between a set of segments and the surface of a mesh
CIRessourceMng	Interface of a resource manager
CISerializedData	Interface of a serialized data
CIService	Interface of a service
CIServiceInstance	Interface of a service instance
CISingletonServiceInstance	Interface of a singleton service instance
CIServiceInstanceT	Typed interface managing a service instance
CIServiceAndModuleFactoryMng	Interface of a service and module factory manager
CIServiceFactoryInfo	Information about a service factory
CIServiceInfo	Interface for service or module information
CIServiceLoader	Service loading interface
CIServiceMng	Service manager interface
CISession	Interface for a case execution session
CISharedReference	Interface of a reference counter
CISimpleTableComparator	Class interface representing a table comparator. To be used with a service implementing ISimpleTableOutput
CISimpleTableInternalComparator	Class interface representing a SimpleTableInternal comparator (aka STI)
CISimpleTableInternalMng	Class interface representing a manager for SimpleTableInternal (aka STI)
CISimpleTableOutput	Interface representing a simple table output
CSimpleTableReaderWriterUtils	Class containing two static methods useful for implementations
CISimpleTableReaderWriter	Class interface allowing reading a file and writing a file with or from a SimpleTableInternal
CISimpleTableWriterHelper	Class interface for writing a file using ISimpleTableReaderWriter. Provides methods for managing parallel writing and name symbols
CIStandardFunction	Interface managing a standard function
CISubDomain	Interface of the subdomain manager
CItem	Base class for a mesh element
CIndex	Index of an Item in a variable
CNode	Node of a mesh
CIndex	Index of a Node in a variable
CItemWithNodes	Mesh element based on nodes (Edge,Face,Cell)
CEdge	Edge of a cell
CIndex	Index of an Edge in a variable
CFace	Face of a cell
CIndex	Index of a Face in a variable
CCell	Cell of a mesh
CIndex	Index of a Cell in a variable
CParticle	Particle
CDoF	Degree of freedom class
CItemAllocationInfo
CConnectedFamilyInfo
CFamilyInfo
CItemArrayEnumerator	Enumerator over an array of mesh entities
CItemArrayEnumeratorT	Enumerator over an array of mesh entities of type ItemType
CItemCompare
CCompareItemIdsByLevel
CItemCompatibility	Methods for conversions between different entity management classes of entities
CItemConnectedEnumerator	Enumerator over a list of entities connected to another
CItemConnectedEnumeratorT	Enumerator over a typed list of connected entities of type ItemType
CItemConnectedEnumeratorBase	Base class for enumerators over a list of connected entities
CItemConnectedEnumeratorBaseT	Typed base class for enumerators over a list of connected entities
CItemConnectedListViewConstIterator	Iterator for the ItemConnectedListView class
CItemConnectedListViewConstIteratorT
CItemConnectedListView	View of a list of entities connected to another entity
CItemConnectedListViewT	View of a list of entities connected to another
CItemConnectivityContainerView	Views of containers holding connectivity. This class allows the containers used to be opaque outside of Arcane to facilitate their eventual change
CItemEnumeratorPOD
CItemEnumerator	Enumerator over a list of entities
CItemEnumeratorT	Enumerator over a typed list of entities of type ItemType
CItemEnumeratorIndex	Represents an index of an enumeration over an entity
CItemEnumeratorIndexT	Represents an index of an enumeration over an entity ItemType
CItemEnumeratorBase	Base class for enumerators over a list of entities
CItemEnumeratorBaseT	Base class for enumerators over a list of entities
CItemFamilyCompactInfos	Information to manage the compaction of entities of a family
CItemFamilyItemListChangedEventArgs	Event arguments for entity addition or deletion
CItemFamilySerializeArgs	Arguments for the serialization callbacks of entity families
CItemFlags	Flags for entity characteristics
CAbstractItemRangeFunctor	Base class for functors on a list of entities
CItemRangeFunctorT	Functor for iterating over a list of entities
CLambdaItemRangeFunctorT	Functor on an iteration interval instantiated via a lambda function
CItemGroupComputeFunctor	Functor for calculating elements of a group
CItemGenericInfoListView	View of the generic information of an entity family
CItemGroup	Mesh entity group
CItemGroupT	Reference to a group of a given kind
COwnItemGroupComputeFunctor
CGhostItemGroupComputeFunctor
CInterfaceItemGroupComputeFunctor
CItemItemGroupComputeFunctor
CInnerFaceItemGroupComputeFunctor
COuterFaceItemGroupComputeFunctor
CActiveCellGroupComputeFunctor
COwnActiveCellGroupComputeFunctor
CLevelCellGroupComputeFunctor
COwnLevelCellGroupComputeFunctor
CActiveFaceItemGroupComputeFunctor
COwnActiveFaceItemGroupComputeFunctor
CInnerActiveFaceItemGroupComputeFunctor
COuterActiveFaceItemGroupComputeFunctor
CItemGroupImplNull	Null group class
CItemGroupImplItemGroupComputeFunctor
CItemCheckSuppressedFunctor
CItemGroupImpl	Brief: Implementation of a mesh entity group
CItemSorter
CIItemGroupObserver
CFuncTraits
CItemGroupObserverWithInfoT
CItemGroupObserverWithoutInfoT
CItemGroupRangeIterator	Iterator over the elements of a group
CItemGroupRangeIteratorT	Iteration range over a group of mesh entities
CItemIndexArrayView	View over an index array (localIds()) of entities
CItemInfoListView	View of a list to obtain information about entities
CItemInfoListViewT	Base class for specialized views of entity information
CNodeInfoListView	View of node information
CEdgeInfoListView	View of edge information
CFaceInfoListView	View of face information
CCellInfoListView	View of cell information
CParticleInfoListView	View of particle information
CDoFInfoListView	View of DoF information
CItemBaseBuildInfo	Class for building an instance of ItemBase
CItemInternalConnectivityList	Connectivity information, for an entity family, allowing transition between old and new connectivity implementations
CInt32View	Specific view to manage null entities
CContainer	Container of views for the connectivity information of a family
CKindInfo
CItemBase	Base class for mesh entities
CMutableItemBase	Methods allowing modification of ItemBase
CItemInternal	Internal structure of a mesh entity
CItemInternalCompatibility	Methods for conversions between different entity management classes
CItemInternalEnumerator	Enumerator over a list of entities
CItemInternalSortFunction	Interface for an entity sorting function
CItemInternalVectorViewConstIterator	Iterator for an ItemInternalVectorView
CItemInternalVectorView	Internal view on an array of entities
CItemLocalId	Index of an Item in a variable
CItemLocalIdT	Index of an ItemType entity in a variable
CItemLocalIdToItemConverter	Class to convert an ItemLocalId to an entity (Item)
CItemLocalIdToItemConverterT	Class to convert an ItemLocalId to an entity (Item)
CNodeLocalIdToNodeConverter	Class to convert a NodeLocalId to an edge
CEdgeLocalIdToEdgeConverter	Class to convert an EdgeLocalId to an edge
CFaceLocalIdToFaceConverter	Class to convert a FaceLocalId to a face
CCellLocalIdToCellConverter	Class to convert a CellLocalId to a cell
CParticleLocalIdToParticleConverter	Class to convert a ParticleLocalId to a particle
CDoFLocalIdToDoFConverter	Class to convert a DoFLocalId to a degree of freedom
CItemLocalIdListViewConstIterator	Base class for iterators for ItemLocalIdViewT
CItemLocalIdListViewConstIteratorT	Iterator for ItemLocalIdViewT
CItemLocalIdListView	View over a list of ItemLocalId
CItemLocalIdListViewT	Typed view over a list of connectivity entities
CItemPairEnumerator	Enumerator over an array of arrays of mesh entities
CItemPairEnumeratorSubT	Enumerator over an array of arrays of mesh entities of type ItemType and SubItemType
CItemPairEnumeratorT	Enumerator over an array of arrays of mesh entities of type ItemType and SubItemType
CItemPairGroup	Table of entity lists
CCustomFunctorWrapper	Wrapper for an ItemPairGroup::CustomFunctor
CItemPairGroupT	Reference to a group of a given kind
CItemPairGroupBuilder	Construction of the entity lists for the ItemPairGroup
CItemPairGroupImplNull	Null group class
CItemPairGroupImplPrivate
CItemPairGroupImpl	Implementation of an array of lists of entities
CItemPrinter	Utility class for printing information about an entity
CInternal
CFullItemPrinter
CNeighborItemPrinter
CRefinementPatternT
CItemRefinementPatternT
CItemRefinementPatternT< IT_Quad4 >
CItemRefinementPatternT< IT_Hexaedron8 >
CHexRefinementPattern27Hex
CItemRefinementPatternT< IT_Tetraedron4 >
CTetraRefinementPattern8T
CTetraRefinementPattern32T
CItemRefinementPatternT< IT_Pentaedron6 >
CPrismRefinementPattern8Pr
CPrismRefinementPattern27Pr
CItemRefinementPatternT< IT_Pyramid5 >
CPyramidRefinementPattern4Py8T
CPyramidRefinementPattern6Py4T
CPyramidRefinementPattern4Py
CPyramidRefinementPattern19Py12T
CItemRefinementPatternT< IT_HemiHexa5 >
CHemiHex5RefinementPattern3HHex5_2Pr_1HHex7
CHemiHex5RefinementPattern7HHex5_4Pr_3HHex6_2HHex7_1Hex
CItemRefinementPatternT< IT_HemiHexa6 >
CHemiHex6RefinementPattern4HHex5_4HHex7
CHemiHex6RefinementPattern6HHex6_12HHex5_6HHex7_1Hex
CItemRefinementPatternT< IT_HemiHexa7 >
CHemiHex7RefinementPattern4HHex7_4Pr_2HHex5_1Hex
CHemiHex7RefinementPattern8HHex7_14Pr_9HHex5_7Hex
CItemRefinementPatternT< IT_AntiWedgeLeft6 >
CAntiWedgeLeft6RefinementPattern4AWL6_4Pr
CAntiWedgeLeft6RefinementPattern9AWL6_18Pr
CItemRefinementPatternT< IT_AntiWedgeRight6 >
CAntiWedgeRight6RefinementPattern4AWR6_4Pr
CAntiWedgeRight6RefinementPattern9AWR6_18Pr
CItemRefinementPatternT< IT_DiTetra5 >
CDiTetra5RefinementPattern3DT_4Py_2T
CDiTetra5RefinementPattern7DT_2T
CDiTetra5RefinementPattern64T
CDiTetra5RefinementPattern32DT
CItemSharedInfo	Internal shared structure of a mesh entity
CItemTypeId	Type of an entity (Item)
CItemTypeInfo	Info on a mesh entity type
CLocalFace	Local information about a cell face
CLocalEdge	Local information about a cell edge
CItemTypeInfoBuilder	Construction of the information for a mesh entity type
CMultiBufferT	Buffer for multiple allocation
CItemTypeMng	Mesh entity type manager
CItemVectorT	Typed entity vector
CItemVectorViewConstIteratorT
CIndexedItemConnectivityViewT
CSimdItemEnumeratorT	Enumerator over a list of entities
CSimdItemT	Manages a vector of ItemType entities
CItemVectorViewT	View on a typed array of entities
CInternalConnectivityInfo	Static class for obtaining information about the connectivity configuration
CItemTraitsT	Characteristics of mesh elements
CItemTraitsT< Node >	Characteristics of mesh entities of type Node
CItemTraitsT< Edge >	Characteristics of mesh entities of type Edge
CItemTraitsT< Face >	Characteristics of mesh entities of type Face
CItemTraitsT< Cell >	Characteristics of mesh entities of type Cell
CItemTraitsT< Particle >	Characteristics of mesh entities of type Particle
CItemTraitsT< DoF >	Characteristics of mesh entities of type DoF
CItemLocalIdTraitsT	Characteristics associated with 'localId()'
CItemLocalIdTraitsT< Item >	Specialization for 'Item' which does not have 'ItemTraitsT'
CItemUniqueId	Unique identifier of an entity
CHashTraitsT< ItemUniqueId >	Specialization for Int64
CItemVector	Entity vector
CConstArrayViewPOD_T
CItemIndexArrayViewPOD
CItemVectorViewPOD
CItemVectorViewConstIterator	Iterator for the ItemVectorView class
CItemVectorView	View on a vector of entities
CITiedInterface	Interface of a class managing semi-conforming mesh
CITimeHistoryAdder	Class interface allowing the addition of one or more values to a value history
CITimeHistoryCurveWriter	Interface of a curve writer
CTimeHistoryCurveInfo	Information for writing a curve
CTimeHistoryCurveWriterInfo	Information about writing curves
CITimeHistoryCurveWriter2	Interface for a curve writer
CTimeHistoryAddValueArg
CITimeHistoryMng	Class managing a history of values
CITimeHistoryTransformer	Interface of an object transforming history curves
CCommonInfo	Common info for each curve
CITimeLoop	Interface of a time loop
CITimeLoopMng	Interface for the time loop manager
CITimeLoopService	Interface of a service operating during the time loop
CITimerMng	Interface of a timer manager
CITimeStats	Interface managing execution time statistics
CITransferValuesParallelOperation	Sends values across different processors
CIUnitTest	Interface of a unit test service
CIXmlUnitTest	Interface of a unit test service providing a test report in the form of an XML node
CIVariable	Interface of a variable
CIVariableComputeFunction	Interface of the functor class for recalculating a variable
CIVariableFactory	Interface for a variable factory
CIVariableFilter	Functor of a filter applicable to variables
CIVariableMng	Variable manager interface
CIVariableParallelOperation	Interface of a class for parallel operations on variables
CIVariableReader	Brief reading of variables during calculation
CIVariableSynchronizer	Interface of a variable synchronization service
CIVariableSynchronizerMng	Interface of the variable synchronization manager
CIVariableUtilities	Interface providing utility functions on variables
CIVariableWriter	Writing variables for initialization and during calculation
CIVerifierService	Interface of the data verification service between two executions
CIXmlDocumentHolder	Manager of a DOM document
CMachineShMemWin	Class allowing the creation of a shared memory window between sub-domains of the same node
CMachineShMemWinBase	Class allowing the creation of a shared memory window between the subdomains of the same node
CMachineShMemWinVariableCommon	Class allowing access to the shared elements of the variable in shared memory
CMachineShMemWinVariableArrayT	Class allowing access to the shared elements of the variable in shared memory
CMachineShMemWinMeshVariableScalarT	Class allowing access to the shared elements of the variable in shared memory
CMachineShMemWinVariableArray2T	Class allowing access to the shared elements of the variable in shared memory
CMachineShMemWinMeshVariableArrayT	Class allowing access to the shared elements of the variable in shared memory
CMachineShMemWinMDVariableT	Class allowing access to shared elements of the variable in shared memory
CMachineShMemWinMeshMDVariableT	Class allowing access to shared elements of the variable in shared memory
CMachineShMemWinMeshVectorMDVariableT	Class allowing access to shared elements of the variable in shared memory
CMachineShMemWinMeshMatrixMDVariableT	Class allowing access to shared elements of the variable in shared memory
CMeshAccessor	Access to mesh information
CMeshArea	Mesh area
CMeshAreaAccessor	Access to information about a mesh area
CMeshBuildInfo	Parameters necessary for building a mesh
CMeshCriteriaLoadBalanceMng	Class allowing criteria to be added to adjust the load balance
CMeshEventArgs	Arguments for mesh events
CMeshHandle	Handle on a mesh
CMeshHandleRef
CMeshHandleOrMesh	Compatibility class to hold a MeshHandle or an IMesh*
CMeshItemInternalList	Indirection tables for mesh entities
CMeshKind	Characteristics of a mesh
CMeshVectorMDVariableRefT	Class managing a multi-dimensional 'NumVector' type variable on a mesh entity
CMeshMatrixMDVariableRefT	Class managing a multi-dimensional 'NumMatrix' type variable on a mesh entity
CItemPartialVariableArrayRefT	Scalar partial variable on a mesh entity type
CMeshPartialVariableArrayRefT	Scalar partial variable on a mesh entity type
CMeshPartInfo	Information about a partitioned mesh
CMeshReaderMng	Mesh reader manager
CImpl
CMeshStats
CMeshTimeHistoryAdder	Class allowing the addition of one or more values to a value history
CMeshToMeshTransposer	Item transposer between sub-meshes
C_CompareNodes
C_CompareItemWithNodes
CIItemFiller
CEdgeFiller
CCellFiller
CFaceFiller
CNodeFiller
CMeshUtilsCheckConnectivity
CItemInternalXml
CItemVariableArrayRefT	Array variable on a mesh entity type
CMeshVariableInfoT	Generic information about the types of a mesh variable
CMeshVariableInfoT< Node, Real, 0 >
CMeshVariableInfoT< Node, Real, 1 >
CMeshVariableInfoT< Node, Real2, 0 >
CMeshVariableInfoT< Node, Real2, 1 >
CMeshVariableInfoT< Node, Real2x2, 0 >
CMeshVariableInfoT< Node, Real2x2, 1 >
CMeshVariableInfoT< Node, Real3, 0 >
CMeshVariableInfoT< Node, Real3, 1 >
CMeshVariableInfoT< Node, Real3x3, 0 >
CMeshVariableInfoT< Node, Real3x3, 1 >
CMeshVariableInfoT< Node, Int32, 0 >
CMeshVariableInfoT< Node, Int32, 1 >
CMeshVariableInfoT< Node, Int64, 0 >
CMeshVariableInfoT< Node, Int64, 1 >
CMeshVariableInfoT< Edge, Real, 0 >
CMeshVariableInfoT< Edge, Real, 1 >
CMeshVariableInfoT< Edge, Real3, 0 >
CMeshVariableInfoT< Edge, Real3, 1 >
CMeshVariableInfoT< Edge, Real2, 0 >
CMeshVariableInfoT< Edge, Real2, 1 >
CMeshVariableInfoT< Edge, Real2x2, 0 >
CMeshVariableInfoT< Edge, Real2x2, 1 >
CMeshVariableInfoT< Edge, Real3x3, 0 >
CMeshVariableInfoT< Edge, Real3x3, 1 >
CMeshVariableInfoT< Edge, Int32, 0 >
CMeshVariableInfoT< Edge, Int32, 1 >
CMeshVariableInfoT< Edge, Int64, 0 >
CMeshVariableInfoT< Edge, Int64, 1 >
CMeshVariableInfoT< Face, Real, 0 >
CMeshVariableInfoT< Face, Real, 1 >
CMeshVariableInfoT< Face, Real2, 0 >
CMeshVariableInfoT< Face, Real2, 1 >
CMeshVariableInfoT< Face, Real3, 0 >
CMeshVariableInfoT< Face, Real3, 1 >
CMeshVariableInfoT< Face, Real2x2, 0 >
CMeshVariableInfoT< Face, Real2x2, 1 >
CMeshVariableInfoT< Face, Real3x3, 0 >
CMeshVariableInfoT< Face, Real3x3, 1 >
CMeshVariableInfoT< Face, Int32, 0 >
CMeshVariableInfoT< Face, Int32, 1 >
CMeshVariableInfoT< Face, Int64, 0 >
CMeshVariableInfoT< Face, Int64, 1 >
CMeshVariableInfoT< Cell, Real, 0 >
CMeshVariableInfoT< Cell, Real, 1 >
CMeshVariableInfoT< Cell, Real3, 0 >
CMeshVariableInfoT< Cell, Real3, 1 >
CMeshVariableInfoT< Cell, Real2, 0 >
CMeshVariableInfoT< Cell, Real2, 1 >
CMeshVariableInfoT< Cell, Real2x2, 0 >
CMeshVariableInfoT< Cell, Real2x2, 1 >
CMeshVariableInfoT< Cell, Real3x3, 0 >
CMeshVariableInfoT< Cell, Real3x3, 1 >
CMeshVariableInfoT< Cell, Int32, 0 >
CMeshVariableInfoT< Cell, Int32, 1 >
CMeshVariableInfoT< Cell, Int64, 0 >
CMeshVariableInfoT< Cell, Int64, 1 >
CMeshVariableInfoT< DoF, Real, 0 >
CMeshVariableInfoT< DoF, Real, 1 >
CMeshVariableInfoT< DoF, Real2, 0 >
CMeshVariableInfoT< DoF, Real2, 1 >
CMeshVariableInfoT< DoF, Real2x2, 0 >
CMeshVariableInfoT< DoF, Real2x2, 1 >
CMeshVariableInfoT< DoF, Real3, 0 >
CMeshVariableInfoT< DoF, Real3, 1 >
CMeshVariableInfoT< DoF, Real3x3, 0 >
CMeshVariableInfoT< DoF, Real3x3, 1 >
CMeshVariableInfoT< DoF, Int32, 0 >
CMeshVariableInfoT< DoF, Int32, 1 >
CMeshVariableInfoT< DoF, Int64, 0 >
CMeshVariableInfoT< DoF, Int64, 1 >
CMeshVariableRef	Base class for a variable on mesh entities
CItemNumericOperation
CItemNumericOperation< Real >
CModuleBuildInfo	Information for building a module
CModuleFactory	Module factory
CModuleFactory2	Class implementing IModuleFactory2
CModuleFactory2T	Template class for module factory
CModuleMaster	Main module
CModuleProperty	Module creation properties
CNodesOfItemReorderer	Utility class to reorder the nodes of an entity
CNullXmlDocumentHolder
CObservablePool	List of observables
CObserverPool	List of observers
COutputChecker	Manages outputs based on physical time, CPU time, or a number of iterations
CReduceSumOfRealHelper	Class managing a reduction of a sum of values
CIMultiReduce	Management of multiple reductions
CMultiReduce
CParallelExchangerOptions	Options for IParallelMng::processExchange()
CParallelMngDispatcherBuildInfo
CParallelMngDispatcher	Redirects the message management of sub-domains according to the argument type
CDefaultControlDispatcher	Implementation of Arccore::MessagePassing::IControlDispatcher
CSerializeDispatcher
CParallelMngContainerBase
CParallelMngUtilsAccessor	'friend' class of IParallelMng allowing access to IParallelMng::_internalUtilsFactory() const;
CParallelNonBlockingCollectiveDispatcher	Redirects the message management of sub-domains according to the argument type
CParallelSuperMngDispatcher	Redirects the message management of sub-domains based on the argument type
CPostProcessorWriterBasePrivate
CPostProcessorWriterCommonBase	Base class for a writer for post-processing information
CPostProcessorWriterBase	Base class for a writer service for post-processing information
CPreciseOutputChecker
CPrivateVariableArrayT	Class for factoring scalar variables on mesh entities
CPrivateVariableScalarT	Class for factoring scalar variables on mesh entities
CPropertyVariant
CScalarPropertyType
CArrayPropertyType
CPropertiesImpl
CPropertiesImplBase
CProperties	List of properties
CRawCopy
CRawCopy< Byte >
CRawCopy< Int16 >
CRawCopy< Int8 >
CRawCopy< Int32 >
CRawCopy< Int64 >
CRawCopy< String >
CRawCopy< Real >
CRawCopy< BFloat16 >
CRawCopy< Float16 >
CRawCopy< Float32 >
CRawCopy< Real2 >
CRawCopy< Real3 >
CRawCopy< Real2x2 >
CRawCopy< Real3x3 >
CRessourceMng	Resource manager
CSequentialSection	Section of code to be executed sequentially
CSerializeBuffer	Implementation of a buffer for serialization
CSerializedData	Interface for serialized data
CServiceBuilder	Utility class for instantiating a service of a given interface
CServiceBuilderWithOptionsBase
CServiceBuilderWithOptions	Utility class for instantiating a service of a given interface with options
CServiceBuildInfoBase	Information for creating a service
CServiceBuildInfo	Structure containing the information to create a service
CServiceFinder2T	Utility class to find one or more services implementing the InterfaceType interface
CServiceInstanceRef	Reference to a service instance
CServiceProperty	Service creation properties
CServiceRegisterer	Service and module registrar
CSharedReference	Implementation of a reference counter using std::atomic
CSimdItemBase	Class managing a SIMD vector of entities
CSimdItemDirectBase
CSimdItemIndexT	Vector index with indirection for an entity type. TODO: store the indices in a vector register to be able to perform the gather quickly. For this, create the equivalent of AVXSimdReal for Int32
CSimdItemDirectIndexT	Vector index without indirection for an entity type
CSimdItem	Manages a vector of Item entities
CSimdItemDirectT	Manages a vector of ItemType entities
CSimdSetter	Object allowing positioning of values in a SIMD vector
CSimdDirectSetter	Object allowing positioning of values in a SIMD vector
CSimdItemEnumeratorBase	Base class for enumerators over vectorial entities (SimdItem)
CSimdItemEnumeratorContainerTraits
CSimplePropertyTraitsT
CSimplePropertyTraitsT< String >
CSimpleReadOnlyPropertyT	Basic implementation of a read-only property
CSimpleSVGMeshExporter	Exporting an SVG mesh
CImpl
CSimpleTableInternal	Structure representing a simple table
CStandardCaseFunction	Class managing a standard dataset function
CSubDomainBuildInfo	Parameters necessary for building a subdomain
CSynchronizerMatrixPrinter	Parallel operations on ghost entities
CTemporaryVariableBuildInfo	Parameters required to build a temporary variable
CNodesOfItemReordererTester
CTiedFace	Semi-conforming mesh face
CTiedNode	Semi-conformal mesh node
CTimeLoopPrivate	Time loop
CTimeLoop	Time loop
CTimeLoopEntryPointInfo	Info about a time loop entry point
CTimeLoopSingletonServiceInfo	Info of a time loop singleton service
CTimer	Management of a timer
CSentry	Sentinel for the timer. The sentinel associated with a timer allows it to be triggered upon its construction and stopped upon its destruction. This ensures that the timer will be properly stopped in case of an exception, for example
CAction	Positions the name of the currently executing action
CPhase	Positions the phase of the currently executing action
CSimplePrinter	Displays the time elapsed between the call to the constructor and the destructor
CUnitTestServiceAdapter	Adapts a service that declares tests to the IUnitTest interface
CTestFuncInfo
CUnstructuredMeshAllocateBuildInfo	Information for allocating entities of an unstructured mesh
CImpl
CUnstructuredMeshConnectivityView	View of the standard connectivities of an unstructured mesh
CVariablePrivate
CItemGroupPartialVariableObserver	Observer events on the underlying ItemGroup
CVariable	Instance of a variable
CArrayVariableDiff
CVariableBuildInfo	Parameters necessary for building a variable
CNullTag	Tag for a null VariableBuildInfo
CNullVariableBuildInfo	Constructor for a null variable
CVariableCollectionEnumerator
CVariableCollection	Variable collection
CImpl
CVariableComparerArgs	Arguments for VariableComparer methods
CVariableComparerResults	Results of a comparison operation
CVariableComparer	Class to perform comparisons between variables
CVariableComputeFunction	Interface of the variable recalculation functor class
CVariableDataTypeTraitsT	Template class for information about a variable type
CVariableDataTypeTraitsT< Byte >	Specialization of VariableDataTypeTraitsT for the byte type
CVariableDataTypeTraitsT< Real >	Specialization of VariableDataTypeTraitsT for the Real type
CVariableDataTypeTraitsT< Float128 >	Specialization of VariableDataTypeTraitsT for the Float128 type
CVariableDataTypeTraitsT< Int8 >	Specialization of VariableDataTypeTraitsT for the Int8 type
CVariableDataTypeTraitsT< Int16 >	Specialization of VariableDataTypeTraitsT for the Int16 type
CVariableDataTypeTraitsT< Int32 >	Specialization of VariableDataTypeTraitsT for the type Int32
CVariableDataTypeTraitsT< Int64 >	Specialization of VariableDataTypeTraitsT for the type Int64
CVariableDataTypeTraitsT< Int128 >	Specialization of VariableDataTypeTraitsT for the type Int128
CVariableDataTypeTraitsT< String >	Specialization of VariableDataTypeTraitsT for the type String
CVariableDataTypeTraitsT< BFloat16 >	Specialization of VariableDataTypeTraitsT for the type BFloat16
CVariableDataTypeTraitsT< Float16 >	Specialization of VariableDataTypeTraitsT for the type Float16
CVariableDataTypeTraitsT< Float32 >	Specialization of VariableDataTypeTraitsT for the type Float32
CVariableDataTypeTraitsT< Real2 >	Specialization of VariableDataTypeTraitsT for the type Real2
CVariableDataTypeTraitsT< Real3 >	Specialization of VariableDataTypeTraitsT for the type Real3
CVariableDataTypeTraitsT< Real2x2 >	Specialization of VariableDataTypeTraitsT for the type Real3x3
CVariableDataTypeTraitsT< Real3x3 >	Specialization of VariableDataTypeTraitsT for the type Real3x3
CVariableDependInfo	Information about a variable dependency
CVariableDiff	Base class for value comparisons between two variables
CDiffInfo
CDiffPrinter
CVariableFactory	Registerer of a variable factory
CVariableFactoryRegisterer	Variable factory registrar
CVariableInfo	Information characterizing a variable
CVariableMetaData	Metadata on a variable
CVariableRef	Reference to a variable
CUpdateNotifyFunctorList	Internal class to manage functors called when the variable is updated
CVariableRefArrayLockT	Lock on an array variable
CScalarVariableDiff
CVariableStatusChangedEventArgs	Arguments of the event notifying a change in the state of a variable
CVariableSynchronizerEventArgs	Arguments for the event notifying a variable synchronization
CVariableTypeInfo	Information characterizing the type of a variable
CVariableViewBase	Base class for views on variables
CView1DGetterSetter	Class to access a 1D array of a read/write view
CView1DSetter	Class to access a 1D array of a read/write view
CItemVariableScalarOutViewT	Write view on a scalar mesh variable
CItemVariableScalarInViewT	Read view on a scalar mesh variable
CItemVariableArrayInViewT	Read view on an array mesh variable
CItemVariableArrayOutViewT	Write view on an array mesh variable
CItemVariableRealNScalarOutViewT	Write view on a mesh scalar variable of type 'RealN'
CVarRefEnumerator
CVerifierService	Base class for the data verification service between two runs
CDiffInfo
CXmlException	XML file related exceptions
CXmlNodeSameName
CXmlNode	Node of a DOM tree
CXmlElement	Element of a DOM tree
CXmlNodeConstIterator
CXmlNodeIterator
CXmlNodeNameIterator	Iterator over the children of a node from with name ref_name
CXmlNodeList	List of nodes of a DOM tree
CXmlPropertyValue	Interface of a property value
CCoreClrLibInfo
CArcaneCodeService
CItemStaticInfo
CArcaneHdf5Registerer
CHdf5MpiReaderWriter	Parallel reading/writing in HDF5 format
CVarOffset
CArcaneHdf5CheckpointService2	Protection/reprise au format ArcaneHdf5
CHdf5ReaderWriter	Reading/Writing in HDF5 format
CHdf5ItemVariableInfo
CHdf5ScalarVariableInfo
CHdf5VariableInfoBase	Base class for reading or writing a variable
CICorrespondanceFunctor	Functor to establish the correspondence between a entity of the current mesh and that of the saved mesh
CHdf5VariableReaderHelperBase
CTimePathPair
CHdf5VariableReaderHelper	Reading variables in HDF5 format
CTimeVariableInfoBase
CHdf5VariableReaderHelper2	Reading variables in HDF5 format
CTimeVariableInfoBase
CCorrespondanceInfo	Correspondence information between saved uids and those of the current mesh for the group group
CHdf5VariableReader	Reading variables in HDF5 format
CManualHdf5VariableReader	Reading variables in HDF5 format
COldManualHdf5VariableReader	Reading variables in HDF5 format via an XML descriptor
CHdf5VariableWriterHelper
CHdf5VariableWriter	Writing variables in HDF5 format
CManualHdf5DataWriter
CManualHdf5VariableWriter	Writing variables in HDF5 format
CMEDMeshReader	MED format mesh reader
CMEDToArcaneItemInfo	Information for mapping MED types to Arcane types for entities
CMEDFamilyInfo	Information about a MED entity family
CMEDGroupInfo	List of groups and the entities belonging to them
CAutoCloseMED
CMEDMeshReaderService	Service for reading a mesh in MED format
CMEDCaseMeshReader	Service for reading a mesh in MED format from the dataset
CBuilder
CVtkHdfDataWriter
CVtkHdfPostProcessor	Post-processing in Ensight Hdf format
CVtkHdfV2DataWriter
CDatasetGroupAndName	Class to store a pair (hdf_group, dataset_name)
CDatasetInfo	Class to store offset information
CWritePartInfo	Offset information for the part to write associated with a rank
CItemGroupCollectiveInfo	Collective information for an ItemGroup;
CDataInfo	Stores info about the data to be saved and the associated offset
CVtkHdfV2PostProcessor	Post-processing in VtkHdf V2 format
Chyoda_shared_data
CHyoda
CHyodaEnvs
CHyodaIceT
CHyodaMatrix
CHyodaMats
CHyodaMix
CHyodaPapi
CHyodaTcp
CIHyodaPlugin
CApplication	Supervisor
CPatternBuilder	Class which allows building patterns
CArcaneBasicMeshSubdividerService	Arcane Service for meshing the dataset
CArcaneCaseMeshMasterService
CArcaneCaseMeshService	Arcane Service for meshing the dataset
CEigenValueAndVectorComputer	Class to calculate the eigenvalues and eigenvectors of a matrix
CPowerResult	Result of applying the power method
CBinaryTree	Class to create a binary tree
CTreeNode	Information about a tree node
CArcaneGeometricMeshPartitionerService	Mesh geometric partitioning service
CArcaneMainStaticInfo
CArcaneBatchMainFactory
CArcaneMainExecFunctor
CArcaneMainAutoDetectRuntimeHelper	Class to manage calls to runtime auto-detection mechanisms (MPI, Accelerators)
CArcaneMainExecutionOverrideFunctor
CIApplicationBuildInfoVisitor
CArcaneMain	Execution management class
CImpl
CArcaneMainBatchProperties	Properties associated with ArcaneMain
CArcaneMainBatch	Batch execution of a code
CSessionExec	Execution information for a session
CSubInfo	Info per subdomain that must be destroyed at the end of execution
CExecFunctor
CArcaneSession	Session
CArcaneSimpleExecutorMainFactory
CArcaneSimpleExecutor	Class for directly executing code without going through the time loop
CImpl
CCaseDocumentFragment
CCaseDocument	Class managing an XML document of the dataset
CCaseDocumentLangTranslatorVisitor
CCaseDocumentLangTranslator	Class managing the translation of a dataset into another language
CCaseMng	Case manager
COptionsReader
CErrorInfo
CCaseOptionsFilterUsed
CCheckpointMng	Protection Manager
CConfigurationMng
CConfigurationSection
CConfiguration
CConfigValue
CConfigurationReader	Configuration file readers
CDataFactory	Interface of a data factory
CDataFactoryMng	Data factory manager
CSumDataOperator
CMinusDataOperator
CMaxDataOperator
CMinDataOperator
CDataOperationT
CAbstractDataStorageFactory	Data container factory
CDataStorageFactory	Data container factory
CDataSynchronizeDispatcherBase
CDataSynchronizeDispatcher	Manages synchronization for a data item
CDataSynchronizeMultiDispatcher	Synchronization of a list of variables
CDataSynchronizeMultiDispatcherV2	Synchronization of a list of variables
CSimpleDataSynchronizeImplementation	Basic serialization implementation
CFactory
CDataSynchronizeResult	Information about the result of a synchronization
CVariableSyncInfo	Information about the list of shared/ghost entities for a given rank for a synchronization
CDataSynchronizeBufferInfoList	Information for sending (share) or receiving (ghost) messages
CDataSynchronizeInfo	Information necessary to synchronize entities across a group
CRestoreVariableFilter
CDefaultBackwardMng
CEntryPointMng	Entry Point Manager
CExecutionStatsDumper	Writing execution statistics
CLicenseErrorException	License exception
CFlexLMMng	FlexLM manager
CFlexLMTools	Wrapper to access FlexLMMng for a given set of features
CGetVariablesValuesParallelOperation	Operations to access variable values from another subdomain
CHelper
CIDataSynchronizeBuffer	Generic buffer for data synchronization
CIDataSynchronizeImplementation	Interface for a generic dispatcher
CIDataSynchronizeImplementationFactory	Interface for a generic dispatcher factory
CAbstractDataSynchronizeImplementation
CArcaneMainExecInfo	Execution information
CArray2DataT	Two-dimensional array data of type DataType
CImpl
CArrayDataT	Array data of type T
CImpl
CDataSynchronizeBufferBase	Base class for the IDataSynchronizeBuffer implementation
CBufferInfo	Buffer for one synchronization element (send, receive, or comparison)
CSingleDataSynchronizeBuffer	IDataSynchronizeBuffer implementation for a single data item
CMultiDataSynchronizeBuffer	IDataSynchronizeBuffer implementation for multiple data items
CIBufferCopier	Interface for copying elements between two regions with indexing
CDirectBufferCopier
CTableBufferCopier
CDataSynchronizeDispatcherBuildInfo	Info to build a DataSynchronizeDispatcher
CIDataSynchronizeDispatcher	Interface to manage the synchronization of a data item
CIDataSynchronizeMultiDispatcher	Interface for synchronizing a list of variables
CLegacyMeshBuilder	Mesh construction via the "historical" method
CMeshBuildInfo
CProxyItemVariableNull	"Null" implementation of the IProxyItemVariable interface. Allows having a unit reference variable
CProxyItemVariable	Implementation of the IProxyItemVariable interface
CIProxyItemVariable	Interface proxy to access variables defining weights
CStoreIProxyItemVariable	Class for accessing the proxy without dereferencing in the code
CPartitionerMemoryInfo	Class for managing partitioning criteria
CMemInfo	Cache system for accessing memory related to a cell
CCriteriaMng
CLoadBalanceMngInternal
CMeshFactoryMng
CMeshMng
CParallelMngUtilsFactoryBase	Base class of a factory for IParallelMng utility functions
CThreadBindingMng
CTimeHistoryValue	Base class for a value history
CTimeHistoryValueT	Value history of type T
CTimeHistoryMngInternal
CVariableMng	Variable manager
CVariableNameInfo
CVNIComparer
CInternalApi
CVariableIOWriterMng	Writing management for variables
CCheckpointSaveFilter
CVariableIOReaderMng	Reading management for variables
CVariableDataTypeInfo
CIDataReaderWrapper	Interface to use IDataReader or IDataReader2
COldDataReaderWrapper	Wrapper for IDataReader
CDataReaderWrapper	Wrapper for IDataReader2
CVariableSynchronizer	Interface of a variable synchronization service
CSyncMessage	Synchronization management
CScopedBuffer
CVariableSynchronizerComputeList	Calculation of the list of entities to synchronize
CRankInfo
CGhostRankInfo
CShareRankInfo
CVariableSynchronizerMng	Variable synchronizer manager
CInternalApi
CBufferList	Manages a pool of buffers associated with an allocator
CInternalInfosDumper	Internal information dumping for Arcane
CIOMng	Input/Output Manager
CItemEnumeratorTracer	Interface for an enumerator tracer on entities
CLoadBalanceMng	Standard implementation of a variable registration interface for load balancing
CMainFactory	Creation of Arcane classes
CMemoryDataReaderWriter	Reading/writing data in memory
CMeshPartitionerTester	Mesh repartitioning test class
CModuleMng	Module manager
CNullPhysicalUnit
CNullPhysicalUnitConverter
CNullPhysicalUnitSystem
CNullPhysicalUnitSystemService
CNullVariableSynchronizer	Synchronization of variables in sequential mode
CINumArrayDataT	Interface of an 'IData' whose container is based on a 'NumArray'
CNumArrayDataT	Implementation of an 'IData' whose container is based on a 'NumArray'
CInternal
CParallelExchanger	Information exchange between processors
CParallelReplication	Brief information on parallel subdomain replication
CParallelTopology	Information on the topology for allocating computing cores
CPrintCaseDocumentVisitor	Visitor to display the values of the dataset
CIndent
CPropertyMng	Property Manager
CScalarDataT	Scalar data of type T
CInternal
CSequentialRequestList
CSequentialParallelDispatchT	Message interface for type Type
CSequentialContigMachineShMemWinBaseInternal
CSequentialMachineShMemWinBaseInternal
CSequentialParallelMngUtilsFactory
CSequentialParallelMng	Sequential mode parallelism manager
CImpl
CSequentialParallelMngBuilder
CSequentialParallelMngContainerFactory
CSequentialParallelMngBuildInfo	Information to construct a SequentialParallelMng
CSequentialParallelSuperMng	Sequential parallelism supervisor
CServiceAndModuleFactoryMng	Manager of service and module factories
CImpl
CServiceLoader	Service loader in the architecture
CServiceMng	Service manager
CSession	Session
CImpl	Session
CSimpleGridMeshPartitioner	Grid mesh partitioner
CGhostCellsBuilder	Information about extra ghost cells
CGridInfo
CStringArrayData	Array data of a unicode character string (specialization)
CImpl
CStringScalarData	Scalar data of a unicode string
CInternal
CMeshBuilderMaster
CSubDomain	Implementation of a subdomain manager
CPropertyMngCheckpoint	Class to manage the reading/writing of properties in checkpoints/rollbacks
CGnuplotTimeHistoryCurveWriter2	GNUPLOT format writer
CTimeHistoryMng2	Manager of a history of values
CTimeLoopMng	Time loop manager
CModuleState
CTimeLoopReader	Time loop loading functor
CTimerMng	Timer manager
CTimeStats	Statistics on execution times
CTimeValue
CPhaseValue
CMetricCollector
CAction	Action
CAllActionsInfo	Information to save/reconstruct an action tree
CActionSeries	Action series
CTraceMngPolicy	Management of trace behavior
CTransferValuesParallelOperation	Operations to transfer values to other subdomains
CVariableMetaDataList
CVariableReaderMng	Management of variable reading
CVarReadInfo
CVariableSizeSorter	Variable sorter based on used memory size
CVariableSynchronizerStats	Synchronization statistics
CStatInfo
CVariableUtilities	Utility functions for variables
CVtuMeshReaderBase	Reader for mesh files in VTK format
CvtkExtReader
CVtuMeshReader
CVtuCaseMeshReader
CBuilder
CVtuMeshWriter	Writing mesh files in VTU format (from VTK)
CXmfMeshReader	Mesh file reader in msh format
CXmfMeshWriter	Writing mesh files in xmf format
CDirectExecutionContextImpl
CDirectCodeFunctor
CArcaneLauncherDirectExecuteFunctor
CArcaneLauncher	Execution management class
CDirectExecutionContext	Direct execution context
CDirectSubDomainExecutionContext	Direct execution context with subdomain creation
CImpl
CGeneralHelp
CIDirectExecutionContext	Implementation of the execution management class
CIDirectExecutionFunctor
CIDirectSubDomainExecutionFunctor
CDirectExecutionWrapper
CStandaloneAcceleratorMng	Standalone implementation of 'IAcceleratorMng.h'
CImpl
CStandaloneSubDomain	Standalone implementation of a sub-domain
CImpl
CLimaGroupReader
CLimaVolume
CLimaMalippMeshBase	Mesh file reader via the LIMA library for '.mli' or 'mli2' files
CLimaMalippReaderT	Mesh file reader via the LIMA library
CLimaMalippReaderWrapper
CNodeGroupReader
CEdgeGroupReader
CFaceGroupReader
CCellGroupReader
CLimaMalipp2DReaderWrapper
CLimaMalipp3DReaderWrapper
CLimaMalippReader	Mesh file reader via the LIMA library
CLimaUtils
CLimaMeshBase	Mesh file reader via the LIMA library
CLimaWrapper	Mesh file reader via the LIMA library
CLimaMeshReaderWrapper
CLima2DReaderWrapper
CLima3DReaderWrapper
CLimaMeshReader	Mesh file reader via the LIMA library
CLimaMeshReaderService	Mesh file reader via the LIMA library
CLimaCaseMeshReader
CBuilder
CLimaMeshWriter
CLimaTest
CLimaCutInfosReader	Construction of a 3D mesh
CIndexedSpace	Indexed set/space to define matrix and vector support
CEmptyIndexedSpace
CMatrix	Matrix class, to be used by user
CMatrixExpr	Class to inherite to perform matrix computations
CMatrixLinComb	Matrix Helper class to handle add and scalar multiply
CVectorAXPY	Matrix Helper class to handle add and scalar multiply
CVector	Vector class, to be used by user
CVectorExpr	Class to inherite to perform matrix computations
CVectorLinComb	Vector Helper class to handle add and scalar multiply
CBasicItemPairGroupComputeFunctor	Utility functions on a mesh
CAdjacencyType
CAdjacencyComputeFunctor
CDoFManager
CDualUniqueIdMng
Ctraits_item_code
Ctraits_item_code< Node, Int64 >
Ctraits_item_code< Face, Int64 >
Ctraits_item_code< Cell, Int64 >
Ctraits_item_code< Edge, Int64 >
Ctraits_item_code< Particle, Int64 >
CGhostLayerFromConnectivityComputer	Tool for calculating the ghost layer of a family based on connectivity
CIItemConnectivityGhostPolicy
CAbstractConnectivity	Abstract connectivity management class
CItemConnectivity	Item->item connectivity, exactly 1 item connected per item (0 not allowed)
CItemConnectivityT
CItemArrayConnectivity
CItemArrayConnectivityT
CItemMultiArrayConnectivity
CItemMultiArrayConnectivityT
CFamilyState
CConnectivityStateData
CConnectivityState
CItemConnectivityMng
CItemConnectivitySynchronizer
CItemScalarProperty
CItemArrayProperty
CItemMultiArrayProperty
CPolyhedralMeshFactory
CUnstructuredMeshUtilities	Utility functions for a mesh
CMpiAutoInit	Singleton class to automatically call MPI_Init and MPI_Finalize if necessary. MPI_Finalize is only called if we performed the init ourselves
CAutoDetecterMPI
CIVariableSynchronizerMpiCommunicator	Interface of a specific MPI communicator for synchronizations
CMpiBatchMainFactory
CMpiBlockVariableSynchronizerDispatcher	Block implementation for MPI synchronization
CFactory
CMpiDatatypeList	Manages the MPI_Datatypes associated with Arcane types
CMpiDirectSendrecvVariableSynchronizerDispatcher	Implementation of synchronization via MPI_Sendrecv
CFactory
CMpiErrorHandler	Message interface for the Type
CMpiLegacyVariableSynchronizerDispatcher	Optimized implementation for MPI synchronization
CFactory
CMpiNeighborVariableSynchronizerDispatcher
CFactory
CMpiParallelDispatchT	Message interface for type Type
CMinMaxSumInfo
CVariableSynchronizerMpiCommunicator	Specific communicator created via MPI_Dist_graph_create_adjacent
CMpiVariableSynchronizer	Specific MPI synchronizer
CMpiParallelMngUtilsFactory
CMpiParallelMngBuildInfo	Info to construct an MpiParallelMng
CMpiParallelMng	Parallelism manager using MPI
CImpl
CRequestList	Specialization of MpiRequestList for MpiParallelMng
CMpiParallelNonBlockingCollective	Parallelism manager using MPI
CMpiParallelNonBlockingCollectiveDispatchT	MPI implementation of non-blocking collectives for the type Type
CMpiParallelSuperMng	MPI-based parallelism supervisor
CMpiSequentialParallelSuperMng	MPI mode supervisor with a single allocated process to behave as if it were sequential but with an existing MPI communicator because we are compiled with MPI
CMpiTimeInterval
CMpiTimerMng	Timer manager using the MPI library
CMpiVariableSynchronizeDispatcher	Optimized implementation for MPI synchronization
CFactory
CNCCLVariableSynchronizeDispatcher	NCCL implementation of synchronization
CFactory
CArcaneGlibThreadImplementation	Implementation of threads using Glib
CGlibThreadImplementationService
CSharedMemoryThreadMng
CTBBMutexImpl
CTBBBarrier
CTBBThreadImplementation	Implementation of threads using TBB (Intel Threads Building Blocks)
CStartFunc
CTBBThreadImplementationService
CArcaneBasicVerifierService
CGroupFinder
CArcaneBasicVerifierService2
CArcaneBasicVerifierServiceV3
CArcaneInitialPartitioner
CTrueOwnerInfo
CArcaneCasePartitioner	External mesh partitioning service
CArcaneVerifierModule	Verification module
CArcaneCheckpointModule	Module managing protections (checkpoint/restart mechanism)
CArcaneCurveWriter	Writing curves in the specific Arcane format
CImpl
CArcaneDirectExecution	Direct execution service
CArcaneLoadBalanceModule	Load balancing module
CArcaneMeshConverter	Mesh format conversion service
CArcanePostProcessingModule	Output module for post-processing
CArcaneStdRegisterer
CBackwardCppStackTraceService
CArcaneBasicCheckpointService	Basic protection/recovery (version 1)
CMetaData
CArcaneBasic2CheckpointService	Basic protection/recovery (version 2)
CArcaneBasic2CheckpointReaderService	Protection reading (version 2)
CRayTriangle3DIntersection	Calculates the intersection of a ray with a set of triangles in 3D
CBasicRayFaceIntersector
CBasicRayMeshIntersection	Basic service for calculating intersection between segments and mesh
CFoundInfo
CBzip2DeflateService	Compression service using the 'Bzip2' library
CBzip2DataCompressor	Compression service using the 'Bzip2' library
CCartesian2DMeshGenerator	Service for 2D Cartesian mesh generation
CCartesian3DMeshGenerator	Service for 3D Cartesian mesh generation
CCartesianMeshGeneratorBuildInfo
CCartesianMeshGenerator
CDbgHelpSymContainer
CDbgHelpStackTraceService	Function call tracing service using 'DbgHelp'
CDbgHelpSymbolizerService	Function call tracing service using libunwind
CDumpW	Wrapper transforming calls to the IDataWriter interface into IDumpW
CDataVisitor
CDumpWEnsight7	Writes in Ensight7 format
CEnsightPart	Correspondence between Ensight element type and Arcane
CGroupPartInfo	Information to share a group into elements of the same subtype
CWriteBase	Functor for writing a variable
CWriteDouble	Functor for writing a variable of type Real
CWriteArrayDouble	Functor for writing a variable of type Real
CWriteReal3	Functor to write a variable of type Real2
CWriteArrayReal3	Functor to write a variable of type Real3
CDumpWEnsight7OutFile	Abstraction of an output file for ensight
CEnsight7PostProcessorService	Post-processing in Ensight7 format
CEnsight7PostProcessorServiceV2	Post-processing in Ensight7 format
CDumpWUCD	Writing in UCD format
CUCDPostProcessorService	Post-processing in UCD format
CFileHashDatabase	Hash database implemented as a file system
CDirFileInfo	Name of the directory and file containing the hash
CGraphDistributor	Redistribute graph data to another "communicator"
CGenericHashAlgorithmService
CSimpleSequentialMeshBuilder	Helper class to generate a sequential mesh based on connectivity and node coordinates
CReal3Compare
CHoneyComb2DMeshGeneratorService	Service for generating a Cartesian mesh in 2D
CHoneyComb3DMeshGeneratorService	Service for generating a Cartesian mesh in 3D
CHoneyComb2DMeshGenerator
CCellLineInfo
CHoneyComb3DMeshGenerator
CCellLineInfo	Info about a line of hexagons
CHWLocProcessorAffinityService
CNodeInfo
CIMeshGenerator	Interface of a mesh generator
CHashDatabaseReadArgs
CHashDatabaseWriteArgs
CHashDatabaseWriteResult
CIHashDatabase
CIosFile	File Read/Write Routines
CIMshMeshReader
CIRedisContext
CMetisGraph
CMetisGraphView
CMetisGraphDigest	Calculates a global checksum of Metis inputs/outputs
CMetisGraphGather
CMetisWrapper	Wrapper around Parmetis calls
COtf2LibWrapper	Wrapper class for OTF2 library functions
CEntryPointId
CEntryPointIdCompare
CInternalIds
COtf2MessagePassingProfilingService	Profiling service for "message passing" in JSON format
COtf2MpiProfiling	Implementation of the MPI operations interface. Decorates each MPI call with functions from the library Otf2 for profiling
CParallelDataReader	Parallel reading
CImpl	Parallel reading
CParallelDataWriter	Parallel writer for outputting data by increasing uniqueId()
CImpl
CParallelDataWriterList	List of 'ParallelDataWriter'
CSodStandardGroupsBuilder	Class for creating standard groups for a Sod shock tube
CJsonMessagePassingProfilingService	JSON message passing profiling service
CKdiDataWriter
CKdiPostProcessor	Post-processing using Kdi
CDebugSourceInfo
CDWHandler
CLibUnwindStackTraceService	Function call trace service using libunwind
CProcInfo	Information about a memory address
CLLVMSymbolizerService
CLinuxPerfPerformanceCounterService
CLZ4DeflateService	Compression service using the 'LZ4' library
CLZ4DataCompressor	Compression service using the 'LZ4' library
CMasterModule	Master Module
CMeshGeneratorService	Mesh generation service
CMeshPartitionerBase	Base class for a load balancing service
CMetisMeshPartitioner	Mesh partitioner using the PARMetis library
CMshMeshReader	Mesh file reader in msh format
CMeshV4ElementsBlock	Information about a block for $Elements for version 4
CMeshPhysicalName	Information about a physical name
CMeshPhysicalNameList	Information about the '$PhysicalNames' block
CMeshV4EntitiesNodes	Info for 0D entities
CMeshV4EntitiesWithNodes	Info for 1D, 2D, and 3D entities
CMeshInfo
CMshMeshReaderService
CMshCaseMeshReader
CBuilder
CMshMeshWriter	Writing mesh files in msh format
CArcaneToMshTypeInfo	Information mapping between MSH type and Arcane type
CItemFamilyWriteInfo
CPhysicalTagInfo
CEntityInfo
CItemGroupWriteInfo
CMshMeshWriterService	Writing the mesh files in msh format
CMshParallelMeshReader	Mesh file reader in msh format
CMshToArcaneTypeInfo	Mapping information between MSH type and Arcane type
CMshElementBlock	Info of a block for $Elements for version 4
CMshNodeBlock	Info of a block for $Nodes
CMshItemKindInfo	Information to create entities of a certain kind
CMshMeshAllocateInfo	Information to create Arcane entities
CPapiTimerMng
CPapiPerformanceCounterService
CPapiPerformanceService	Profiling service using the PAPI library
CPartitionConverter	Conversion of an array of floats to an array of integers/longs. \abstract This class manages the scaling in the following way: [0,W_max] --> [1,EW_max] with Sum(EW) < "max"
CPDESRandomNumberGeneratorService
CMonoFuncAddrGetter
CProfFuncInfo
CProfStackInfo
CProfAddrInfo
CProfFuncComparer
CStaticAlloc	Static allocator for profiling
Crebind
CProfInfos
CSortedProfStackInfo
CFuncAddrInfo
CIStackInfoProvider	Interface to retrieve call stack information
CIFuncInfoProvider
CNullFuncInfoProvider
CProfPerformanceService	Profiling service using 'setitimer'
CPTScotchMeshPartitioner	Mesh partitioner using the PtScotch library
CRedisHashDatabase
CSimpleCsvComparatorService
CSimpleCsvOutputService
CSimpleCsvReaderWriter
CSimpleMeshGenerator	Simple generator for each type of mesh entity
CSimpleTableInternalComparator
CSimpleTableInternalMng
CSimpleTableWriterHelper
CSod3DMeshGenerator	3D shock tube generation service
CSodMeshGenerator	Mesh generator for a shock tube
CImpl
CSplitSDMeshPartitioner	Mesh partitioner inspired by the SplitSD library, developed initially at ONERA for Dassault Aviation
CTypesArcaneCheckpoint
CTypesArcanePostProcessing	Types for the post-processing module
CTypesMetisMeshPartitioner
CUdunitsPhysicalUnit
CUdunitsPhysicalUnitConverter
CUdunitsPhysicalUnitSystem
CUdunitsUnitSystemService	Service for managing physical unit system using 'udunits2'
CUnitTestModule	Master module
CVoronoiMeshIOService	Reader for IFP internal Voronoi mesh files
CVoronoiFile
CVtkMeshIOService	Mesh file reader for legacy VTK format
CVtkMesh
CVtkStructuredGrid
CVtkFile
CVtkLegacyMeshWriter
CVtkMeshReader
CVtkLegacyCaseMeshReader
CBuilder
CVtkPolyhedralMeshIOService
CVtkReader
CVariableInfo
CVtkPolyhedralCaseMeshReader
CBuilder
CToArcaneType
CToArcaneType< float >
CToArcaneType< long long >
CZoltanInfo	Information for partitioning with Zoltan
CZoltanMeshPartitioner	Mesh partitioner using the Zoltan library
CZstdDataCompressor	Compression service using the 'zstd' library
CTotalviewAdapter
CAMRCallBackMng
CAMRComputeFunction	Interface for the CellVariable transport functor class
CAMRTransportFunctorT	Functor associated with a method of a class T
CApplicationInfoPrivate
CApplicationInfo	Application information
CArithmeticException	Exception when an arithmetic error occurs
CArrayFullAccessorT
CDefaultConverter
CArrayConverter	Conversion of an array from one type to another type
CArrayConverter< InputType, InputType, DefaultConverter< InputType, InputType > >	Conversion of an array from one type to another type
CConstArrayConverter	Conversion of an array from one type to another type
CConstArrayConverter< InputType, InputType, DefaultConverter< InputType, InputType > >	Conversion of an array from one type to another type
CArrayShape	Array shape
CAtomicInt32	Atomic 'Int32' type
CDeleteOnDestroyBehaviour
CAutoDestroyUserData	UserData that self-destructs once detached
CAutoRefT	Encapsulation of a pointer with a reference counter
CBadAlignmentException	Exception when an address is not correctly aligned
CCriticalSection	Critical section in multi-thread
CBuiltInDataTypeContainer	Container containing an instance of a class per data type
CArcaneDataTypeContainer	Container containing an instance of a class per data type Arcane
CDeleter	Utility class for destroying objects allocated by new
CDirectedAcyclicGraphT
CSortedElementSet
CReverseOrderSet
CDirectedGraphT
CDualUniqueArrayBase	Base class for DualUniqueArray
CDualUniqueArray	Represents an array having a view on both CPU and accelerator
CIModifierImpl
CModifier
CHostModifier
CNumArrayModifierImpl
CUniqueArrayModifierImpl
CFileContent	Description and content of a file
CFloatingPointExceptionSentry	Class allowing temporary activation/deactivation of exceptions of the processor
CFunctorWithAddressT	FunctorWithAddress associated with a method of a class T
CGoBackwardException	Exception to request a backward step in the time loop
CGraphBaseT
CIterableEnsembleT
CIntegerHashFunctionT	Functor for a hash function
CIntegerHashFunctionT< Int32 >	Hashing function for a 32-bit integer
CIntegerHashFunctionT< Int64 >	Hashing function for a 64-bit integer
CIntegerHashFunctionT< StringView >	Hashing function for a string
CHashTraitsT
CHashTraitsT< Int32 >	Specialization for Int32
CHashTraitsT< Int64 >	Specialization for Int64
CIntegerHashSuite	Class allowing for iterative hash calculation
CHashTableException
CHashTableBase	Base class for a simple hash table for entities
CHashTableBaseT	Base class for a hash table for associative arrays
CHashData
CHashTableMapEnumeratorT	Enumerator for a HashTableMap
CHashTableMapT	Hash table for associative arrays
CData
CHPReal	Class implementing a High-Precision real number
CIAMRTransportFunctor	Interface of a functor with argument
CIDataCompressor	Interface of a service for compressing/decompressing data
CIFunctorWithAddress	Interface of a functor
CHashAlgorithmValue	Hash algorithm return value
CIHashAlgorithmContext	Context for calculating a hash incrementally
CIHashAlgorithm	Interface of a hashing algorithm
CIBinaryMathFunctor	Interface of a binary mathematical function
CMemoryInfoChunk	Information about an allocated chunk
CIMemoryInfo	Interface for a memory usage information collector
CIMessagePassingProfilingService	Interface of a profiling service dedicated to "message passing"
CApplicationInfoProperties	Information about an application
CMemoryBuffer	Management of a memory buffer
CParallelLoopOptionsProperties	Class to set the values of ParallelLoopOptions via properties
CParameterCaseOption	Class representing the set of parameters that can modify the dataset options
CParameterListWithCaseOption	Parameter list with information to override dataset options
CImpl
CNameValuePair
CParameterOptionAddrPart	Class representing a part of a data set option address. Note that in XML, the index starts at 1 and not at 0
CParameterOptionAddr	Class representing a data set option address. This address must be in the form: "tag/tag[index]/tag" Address parts without an index will have the default index (=1)
CParameterOptionElement	Class representing an XML element (an Arcane option). This element has an address and a value
CParameterOptionElementsCollection	Class representing a collection of XML elements (a set of Arcane options)
CInvalidArgumentException	Exception when a fatal error has occurred
CIOException	Exception when an input/output error is detected
CIOnlineDebuggerService	Interface of a hybrid debugger service
CIPerformanceCounterService	Interface of a service for accessing performance counters
CIProcessorAffinityService	Interface of a CPU core affinity management service
CIProfilingService	Interface of a profiling service
CProfilingSentry	Class allowing automatic start and stop of a service
CProfilingSentryWithInitialize	Class allowing automatic start and stop of a service
CISO88591Transcoder	ISO-8859-1 Transcoder from/to UTF-16
CIThreadMng	Interface of a thread manager
CITraceMngPolicy	Interface for the configuration manager of a trace manager
CITranscoder	Interface of a converter to/from the UTF-16 format
CIUserData	Interface for user data attached to another object
CIUserDataList	Interface of a list that manages user data
CFloatInfo	Information about the floating-point type
CFloatInfo< float >	Specialization of the FloatInfo class for the float type
CFloatInfo< double >	Specialization of the FloatInfo class for the double type
CFloatInfo< long double >	Specialization of the FloatInfo class for the type long double
CLinearOffsetMap	List of linear offsets
CMD5HashAlgorithm	Calculates the MD5 hashing function of an array
CMDIndexBase	Base class for managing indices of an N-dimensional array
CMDIndex< 0, IndexType_ >
CMDIndex< 1, IndexType_ >
CMDIndex< 2, IndexType_ >
CMDIndex< 3, IndexType_ >
CMDIndex< 4, IndexType_ >
CIMemoryAccessTrace
CMemoryAccessInfo
CMemoryInfo	Memory usage information collector
CMemoryInfoSorter
CTracePrinter
CHexaPrint
CMultiArray2	Base class for multi-sized 2D arrays
CSharedMultiArray2	Multi-sized 2D array with reference semantics
CUniqueMultiArray2	Multi-sized 2D array with value semantics
CMultiArray2View	Modifiable view on a MultiArray2
CConstMultiArray2View	Constant view on a MultiArray2
CJaggedSmallSpan	View on a MultiArray2
CNameComparer	Utility class for comparing an instance's name
CNullThreadMng	Thread manager in single-threaded mode
CTypeEqualT	Comparison operations for a numeric type T
CFloatEqualT	Defines the == operator for floats
CTypeEqualT< float >	Specialization of TypeEqualT for the float type
CTypeEqualT< double >	Specialization of TypeEqualT for the double type
CTypeEqualT< long double >	Specialization of TypeEqualT for the long double type
CNumericTraitsT< Real2 >
CNumericTraitsT< const Real2 >
CNumericTraitsT< Real3 >
CNumericTraitsT< const Real3 >
CNumericTraitsT< Real2x2 >
CNumericTraitsT< const Real2x2 >
CNumericTraitsT< Real3x3 >
CNumericTraitsT< const Real3x3 >
CNumMatrix	Small fixed-size matrix containing RowSize rows and ColumnSize columns
CNumVector	Small fixed-size vector of N numerical data points
COStringStreamPrivate
COStringStream	Output stream linked to a String
CParallelFatalErrorException	Exception when a 'parallel' fatal error is generated
CPtrT	Encapsulation of a pointer
CReal2POD
CReal2	Class managing a 2-dimensional real vector
CReal2Proxy	Class managing a 2-dimensional real vector
CReal2x2POD	POD structure for a Real2x2
CReal2x2	Class managing a 2x2 matrix of reals
CReal2x2Proxy	Proxy of type 'Real2x2'
CReal3POD
CReal3	Class managing a 3-dimensional real vector
CReal3Proxy	Proxy for a Real3
CReal3x3POD	POD structure for a Real3x3
CReal3x3	Class managing a 3x3 real matrix
CReal3x3Proxy	Proxy for a 'Real3x3'
CScopedPtrT	Encapsulation of an automatically destructing pointer
CSHA1HashAlgorithm	Implementation of the SHA-1 algorithm
CSHA3HashAlgorithm	Base class for SHA-3 algorithms
CSHA3_256HashAlgorithm	Hash for the SHA-3 256 algorithm
CSHA3_224HashAlgorithm	Hash for the SHA-3 224 algorithm
CSHA3_384HashAlgorithm	Hash for the SHA-3 384 algorithm
CSHA3_512HashAlgorithm	Hash for the SHA-3 512 algorithm
CRefCounter
CSharedPtrT
CSignalException	Exception when a signal occurs
CSimdReal3	Represents a vectorized Real3
CSimdReal2	Represents a vectorized Real2
CSimdReal3x3	Represents a vectorized Real3x3
CSimdReal2x2	Represents a vectorized Real2x2
CSimdTypeTraits	Characteristics of vector types
CSimdTypeTraits< Real >
CSimdTypeTraits< Real2 >
CSimdTypeTraits< Real2x2 >
CSimdTypeTraits< Real3 >
CSimdTypeTraits< Real3x3 >
CSimdEnumeratorBase	Base class for vector enumerators with indirection
CAVXSimdX8Int32	Vectorization of Int32 integers using AVX
CAVXSimdX4Real	Vectorization of real numbers using AVX
CAVXSimdX8Real	Vectorization of real numbers using AVX with blocks of 8 reals
CAVXSimdInfo
CAVX512SimdReal	Vectorization of reals using AVX512 vectorization
CAVX512SimdInfo
CEMULSimdX2Int32	Integer vectorization using emulation
CEMULSimdX4Int32	Integer vectorization using emulation
CEMULSimdReal	Real vectorization using emulation
CEMULSimdInfo
CSSESimdX4Int32	Vectorization of integers using SSE
CSSESimdX2Real	Vectorization of reals using SSE
CSSESimdX4Real	Vectorization of reals using SSE
CSSESimdX8Real	Vector of 8 doubles with SSE implementation
CSSESimdInfo
CStringDictionary	Unicode string dictionary
CImpl	Implementation of the unicode string dictionary
CTestLoggerImpl
CTestLogger	Utility class for logging test information
CInnerTimer_DAY
CTraceTimerT
CUserDataList	Manages a list of user data
CImpl
CVector2	Class managing a 2-dimensional vector of type T
CVector3	Class managing a 3-dimensional vector of type T
CTaskFunctor	Functor without arguments for a task
CTaskFunctorWithContext	Functor for a task taking a TaskContext as an argument
CValueChecker	Checking the validity of certain values
CVersionInfo	Information about a version
CCaseOptionsHdf5MpiReaderWriter	Options
CArcaneHdf5MpiReaderWriterObject	Generation de la classe de base du Service
CCaseOptionsHdf5ReaderWriter	Options
CArcaneHdf5ReaderWriterObject	Generation de la classe de base du Service
CCaseOptionsHdf5VariableReader	Options
CCaseOptionReadValue
CCaseOptionRead
CArcaneHdf5VariableReaderObject	Generation de la classe de base du Service
CCaseOptionsHdf5VariableWriter	Options
CCaseOptionWriteValue
CCaseOptionWrite
CArcaneHdf5VariableWriterObject	Generation de la classe de base du Service
CCaseOptionsVtkHdfPostProcessor	Options
CArcaneVtkHdfPostProcessorObject	Generation de la classe de base du Service
CCaseOptionsVtkHdfV2PostProcessor	Options
CArcaneVtkHdfV2PostProcessorObject	Generation de la classe de base du Service
CCaseOptionsArcaneBasicMeshSubdividerService	Options
CArcaneArcaneBasicMeshSubdividerServiceObject	Generation de la classe de base du Service
CCaseOptionsArcaneCaseMeshMasterService	Options
CArcaneArcaneCaseMeshMasterServiceObject	Generation de la classe de base du Service
CCaseOptionsArcaneGeometricMeshPartitionerService	Options
CArcaneArcaneGeometricMeshPartitionerServiceObject	Generation de la classe de base du Service
CCaseOptionsMeshPartitionerTesterService	Options
CArcaneMeshPartitionerTesterServiceObject	Generation de la classe de base du Service
CCaseOptionsBasicParticleExchanger	Options
CArcaneBasicParticleExchangerObject	Generation de la classe de base du Service
CCaseOptionsArcaneBasicCheckpoint	Options
CArcaneArcaneBasicCheckpointObject	Generation de la classe de base du Service
CCaseOptionsArcaneCasePartitioner	Options
CArcaneArcaneCasePartitionerObject	Generation de la classe de base du Service
CCaseOptionsArcaneCeaVerifier	Options
CCaseOptionTraceValue
CCaseOptionTrace
CArcaneArcaneCeaVerifierObject	Generation de la classe de base du Module
CCaseOptionsArcaneDirectExecution	Options
CArcaneArcaneDirectExecutionObject	Generation de la classe de base du Service
CCaseOptionsArcaneLoadBalance	Options
CArcaneArcaneLoadBalanceObject	Generation de la classe de base du Module
CCaseOptionsArcaneMeshConverter	Options
CArcaneArcaneMeshConverterObject	Generation de la classe de base du Service
CCaseOptionsCartesian2DMeshGenerator	Options
CCaseOptionPartInfoXValue
CCaseOptionPartInfoX
CCaseOptionPartInfoYValue
CCaseOptionPartInfoY
CArcaneCartesian2DMeshGeneratorObject	Generation de la classe de base du Service
CCaseOptionsCartesian3DMeshGenerator	Options
CCaseOptionPartInfoXValue
CCaseOptionPartInfoX
CCaseOptionPartInfoYValue
CCaseOptionPartInfoY
CCaseOptionPartInfoZValue
CCaseOptionPartInfoZ
CArcaneCartesian3DMeshGeneratorObject	Generation de la classe de base du Service
CCaseOptionsEnsight7PostProcessor	Options
CArcaneEnsight7PostProcessorObject	Generation de la classe de base du Service
CCaseOptionsHoneyComb2DMeshGenerator	Options
CArcaneHoneyComb2DMeshGeneratorObject	Generation de la classe de base du Service
CCaseOptionsHoneyComb3DMeshGenerator	Options
CArcaneHoneyComb3DMeshGeneratorObject	Generation de la classe de base du Service
CCaseOptionsKdiPostProcessor	Options
CArcaneKdiPostProcessorObject	Generation de la classe de base du Service
CCaseOptionsMaster	Options
CArcaneMasterObject	Generation de la classe de base du Module
CCaseOptionsMetisMeshPartitioner	Options
CArcaneMetisMeshPartitionerObject	Generation de la classe de base du Service
CCaseOptionsPTScotchMeshPartitioner	Options
CArcanePTScotchMeshPartitionerObject	Generation de la classe de base du Service
CCaseOptionsSod3DMeshGenerator	Options
CArcaneSod3DMeshGeneratorObject	Generation de la classe de base du Service
CCaseOptionsSplitSDMeshPartitioner	Options
CArcaneSplitSDMeshPartitionerObject	Generation de la classe de base du Service
CCaseOptionsUnitTest	Options
CArcaneUnitTestObject	Generation de la classe de base du Module
CCaseOptionsVtkPolyhedralMeshIO	Options
CArcaneVtkPolyhedralMeshIOObject	Generation de la classe de base du Service
CCaseOptionsZoltanMeshPartitioner	Options
CArcaneZoltanMeshPartitionerObject	Generation de la classe de base du Service
CAPReal	Emulation of real number in arbitrary precision
CTrueType	Structure equivalent to the boolean value true
CFalseType	Structure equivalent to the boolean value true
CArgumentException	Exception when an argument is invalid
CArray2View	Mutable view for a 2D array
CConstArray2View	View for a constant 2D array
CArray3View	View for a 3D array
CConstArray3View	View for a constant 3D array
CArray4View	View for a 4D array
CConstArray4View	Constant view for a 4D array
CArrayBoundsBase
CArrayBounds
CArrayStridesBase< 0 >	Specialization of ArrayStrideBase for 0-dimensional arrays (scalars)
CArrayStridesBase	Class to maintain the stride in each dimension
CArrayExtentsBase< ExtentsV<> >	Specialization of ArrayExtentsBase for 0-dimensional arrays (scalars)
CArrayExtentsBase	Class to maintain the number of elements in each dimension
CArrayExtents< ExtentsV< SizeType_, X0 > >	Extent for 1-dimensional arrays
CArrayExtents< ExtentsV< SizeType_, X0, X1 > >	Extent for 2-dimensional arrays
CArrayExtents< ExtentsV< SizeType_, X0, X1, X2 > >	Extent for 3-dimensional arrays
CArrayExtents< ExtentsV< SizeType_, X0, X1, X2, X3 > >	Extent for 4-dimensional arrays
CArrayExtentsWithOffset< ExtentsV< SizeType_, X0 >, LayoutType >	Extent and Offset for 1-dimensional arrays
CArrayExtentsWithOffset< ExtentsV< SizeType_, X0, X1 >, LayoutType >	Extent and Offset for 2-dimensional arrays
CArrayExtentsWithOffset< ExtentsV< SizeType_, X0, X1, X2 >, LayoutType >	Extent and Offset for 3-dimensional arrays
CArrayExtentsWithOffset< ExtentsV< SizeType_, X0, X1, X2, X3 >, LayoutType >	Extent and Offset for 4-dimensional arrays
CArrayIterator	Iterator over Arccore array classes
CArrayLayout2
CArrayLayout3
CRightLayoutN
CLeftLayoutN
CRightLayout
CLeftLayout
CRightLayoutN< 2 >
CRightLayoutN< 3 >
CLeftLayoutN< 2 >
CLeftLayoutN< 3 >
CDefaultLayout	The default layout is always RightLayout
CArrayRange	Interval over Arccore array classes
CConstArrayView	Constant view of an array of type T
CConstIterT	Constant iterator interval
CIterT	Iterator intervalThis class manages an iterator pair allowing modification of the elements of the container
CArrayView	Modifiable view of an array of type T
CArraySizeChecker
CArraySizeChecker< Int32 >	Specialization to test conversion to Int32
CArraySizeChecker< Int64 >	Specialization to test conversion to Int64
CAutoRef2	Encapsulation of a pointer with a reference counter
CBadCastException	Exception when a conversion from one type to another is invalid
CSpanImpl	View of an array of elements of type T
CSpan	View of an array of elements of type T
CSmallSpan	View of an array of elements of type T
CSpan2Impl	View for a 2D array
CSpan2	View for a 2D array whose size is an 'Int64'
CSmallSpan2	View for a 2D array whose size is an 'Int32'
CIMDRangeFunctor	Interface of a functor on a multi-dimensional iteration interval of dimension RankValue
CRangeFunctorT	Functor over an iteration interval
CLambdaRangeFunctorT	Functor over an iteration interval instantiated via a lambda function
CLambdaRangeFunctorTVa	Functor over an iteration interval instantiated via a lambda function
CForLoopRange	Iteration range for a loop
CSimpleForLoopRanges	Simple iteration range
CComplexForLoopRanges	Complex iteration range
CCheckedPointer	Encapsulation of a pointer
CReferenceCounterAccessor	Accessor for reference counter management methods
CReferenceCounter	Encapsulation of a pointer with a reference counter
CIFunctorWithArgumentT	Interface of a functor with an argument but without a return value
CIFunctorWithArgAndReturn2	Interface of a functor with 2 arguments and a return value
CFunctorT	Functor associated with a method of a class T
CFunctorWithArgumentT	Functor associated with a method of a class T
CStdFunctorWithArgumentT	Generic Functor using the std::function class
CRefTraits	Characteristics for managing reference counters
CRef	Reference to an instance
CMDDimType
CExtentsV
CMDSpan	Base class for multi-dimensional views
CNumArray	Multi-dimensional arrays for numerical types accessible on accelerators
CArrayExtentsWithOffset
CMDIndex
CArrayExtents
CArrayExtentsValueDynamic
CFixedArray	Fixed-size 1D array
CBFloat16	'Brain Float16' type
CConcurrencyBase	Basic information for multi-threading management
CException	Base class for an exception
CExtentsV< IndexType_ >	Specialization for 0-dimensional array extents
CExtentsV< IndexType_, X0 >	Specialization for 1-dimensional array extents
CExtentsV< IndexType_, X0, X1 >	Specialization for 2-dimensional array extents
CExtentsV< IndexType_, X0, X1, X2 >	Specialization for 3-dimensional array extents
CExtentsV< IndexType_, X0, X1, X2, X3 >	Specialization for 4-dimensional array extents
CFatalErrorException	Exception when a fatal error has occurred
CFloat128	128-bit floating-point type
CFloat16	Half-precision floating-point type
CForLoopRunInfo	Loop execution information
CForLoopTraceInfo	Trace information for a 'for' loop
CGenericRegistererBase
CGenericRegisterer	Template class to manage a global list for registering factories
CInfo
CGlibDynamicLibrary
CGlibDynamicLibraryLoader	Interface for a dynamic library loader
CIFunctor	Interface of a functor
CIndexOutOfRangeException	Exception when a value is not within a given range
CInt128	128-bit integer type
CIDynamicLibrary	Interface of a dynamic library
CIDynamicLibraryLoader	Interface of a dynamic library loader
CStringImpl	Implementation of the String class
CIObservable	Interface of an observable
CIObserver	Observer interface
CIRangeFunctor	Interface of a functor on an iteration interval
CIStackTraceService	Interface of a function call tracing service
CISymbolizerService	Interface of a source code symbol retrieval service
CIteratorBase	Iteration interval.This class manages an iteration interval with a beginning and an end. It allows for the simple construction of an iterator pair to iterate over the entire container
CMDDimType< 0 >
CMDDimType< 1 >
CMDDimType< 2 >
CMDDimType< 3 >
CMDDimType< 4 >
CConstMemoryView	Constant view on a contiguous memory region containing fixed-size elements
CMutableMemoryView	Mutable view on a contiguous memory region containing fixed-size elements
CConstMultiMemoryView	List of constant views on contiguous memory regions
CMutableMultiMemoryView	List of mutable views on contiguous memory regions
CNotImplementedException	Exception when a function is not implemented
CNotSupportedException	Exception when an operation is not supported
CNumericTraitsT	Information for numeric types
CObservable	Base class of an observable
CAutoDetachObservable	Observable that automatically calls IObservable::detachAllObservers() in the destructor
CAbstractObserver	Base class of an observer
CObserverT	Observer for a type T
CParallelLoopOptions	Execution options for a parallel loop in multi-threading
CAllStatInfoList
CThreadLocalStatInfo
CForLoopOneExecStat	Class to manage the profiling of a single loop execution
CProfilingRegistry	Profiling manager
CLambdaMDRangeFunctor	Functor over an iteration interval instantiated via a lambda function
CRefTraitsTagId< InstanceType, REF_TAG_SHARED_PTR >	Specialization to indicate that 'shared_ptr' implementation is used
CRefTraitsTagId< InstanceType, REF_TAG_REFERENCE_COUNTER >	Specialization to indicate that 'ReferenceCounter' implementation is used
CRefImpl	Implementation of the reference to an instance
CDeleter
CBasicDeleter
CRefBase	Base class for reference management
CBasicDeleterBase
CDeleterBase
CReferenceCounterTag	Structure used to tag interfaces/classes that use an internal reference counter
CRefTraitsTagId
CReferenceCounterImpl	Thread-safe implementation of a reference counter
CStackFrame	Stores the addresses corresponding to a call stack. This class is internal and should not be used outside of Arccore
CFixedStackFrameArray	Stores a fixed maximum size list of StackFrame
CStackTrace	Information about function call stacks
CStringFormatter
CStringUtilsImpl
CString	Unicode character string
CStringFormatterArgToString
CStringFormatterArg	Class used to format a character string
CStringBuilder	Unicode character string constructor
CStringException
CStringView	View of a UTF-8 character string
CTimeoutException	Exception when a timeout occurs
CTraceInfo	Trace information
CArray2	Class representing a classic 2D array
CSharedArray2	Shared 2D data vector with reference semantics
CUniqueArray2	2D data vector with value semantics (STL style)
CAbstractArrayBase	Internal base class for arrays
CAbstractArray	Abstract base class for a vector
CAlignedMemoryAllocator	Memory allocator with specific memory alignment
CAllocatedMemoryInfo	Information about an allocated memory region
CArccoreApplicationBuildInfo	Information for initializing an application
CBadAllocException
CArray	Base class for 1D data vectors
CSharedArray	1D vector of data with reference semantics
CUniqueArray	1D data vector with value semantics (STL style)
CArrayDebugInfo	Debug information for array classes
CArrayMetaData	Array Metadata
CArrayImplBase	This type is no longer used
CArrayImplT	This class is no longer used
CArraySimdPadder
CObjectImpl	Base class for an object with a reference counter
CEnumeratorImplBase	Enumerator interface
CEnumeratorBase	Generic enumerator
CEnumeratorT	Typed enumerator
CCollectionEventArgs	Arguments of an event sent by a collection
CCollectionImplBase	Base class for collection implementation
CCollectionImplT	Base class for implementation of a typed collection
CCollectionBase	Base class for a collection
CCollection	Base class for a strongly typed collection
CCommandLineArguments	Command Line Arguments
CImpl
CNameValuePair	Command line parameters
CListEnumeratorT	Typed enumerator for an array
CList	Implementation of a collection of elements in vector form
CEventObservable	Base class for an event handler
CEventObserver	Event observer
CEventObservableView	Class managing observers associated with an event
CDataViewSetter	Class for accessing an element of a write view
CDataViewGetter	Class for accessing an element of a read view
CDataViewGetterSetter	Class for accessing an element of a read/write view
CDefaultMemoryAllocator	Memory allocator via malloc/realloc/free
CPrintableMemoryAllocator	Memory allocator via malloc/realloc/free with listing output
CEventObservableBase	Base class for an event handler
CImpl
CEventObserverBase	Base class for an event observer
CEventObserverPool	Stores references to observers
CIMemoryAllocator	Interface for a memory allocator
CIMemoryPool	Interface of a memory pool
CIMemoryResourceMng	Memory resource management for CPUs and accelerators
CArccoreApplicationBuildInfoImpl
CPropertyImpl
CFieldProperty
CInt32Value
CPropertyKeyValues
CNameValuePair
CIMemoryCopier	Interface for memory copies with accelerator support
CIMemoryResourceMngInternal	Internal part of Arcane's 'IMemoryResourceMng'
CMemoryResourceMng	Memory resource management for CPUs and accelerators
CProcessExecArgs
CProcess	Class allowing the execution of an external process
CJSONWrapperUtils
CJSONValue	Represents a JSON value
CImpl
CJSONKeyValue	Represents a (key,value) pair of JSON
CImpl
CJSONKeyValueList	List of (key,value) pairs of a JSON document
CJSONValueList	List of values of a JSON document
CJSONDocument	Management of a JSON document
CImpl
CJSONWriter	JSON format writer
CObject
CArray
CImpl
CListImplBase	Array with virtual allocator
CListImplT
CListEnumeratorImplT
CListEnumeratorBase	Generic enumerator for an array
CListConstEnumeratorBase	Generic constant enumerator for an array
CListConstEnumeratorT
CMemoryAllocationArgs	Class containing information to specialize allocations
CMemoryAllocationOptions	Options to configure allocations
CDefaultHostMemoryCopier
CParameterList	Parameter list
CImpl
CNameValuePair
CSmallArray	1D data array with pre-allocated stack buffer
CBadIndexException
CStringVector	Vector of 'String'
CImpl
CNullThreadImplementationFactory
CSerialTask
CNullTaskImplementation
CGlibMutex	Encapsulates a GMutex from glib
CLock
CImpl	Glib mutex
CGlibPrivate	Encapsulates a GPrivate from glib
CImpl	Glib private
CGlibCond	Encapsulates a GCond from glib
CImpl
CGlibThreadBarrier
CGlibThreadImplementation	Implementation of ITreadImplementation with 'Glib'
CConcurrencyApplicationBuildInfo
CConcurrencyApplication
CTaskFactoryInternal	Internal Arcane API for 'TaskFactory'
CITaskImplementation	Implementation of a task factory
CIThreadBarrier	Interface of a barrier between threads
CIThreadImplementation	Interface of a service implementing thread support
CIThreadImplementationService	Interface of a thread management service
CMutex	Mutex
CScopedLock
CManualLock
CGlobalMutex	Global Mutex
CScopedLock
CNullThreadBarrier	Implementation of a single-threaded barrier
CNullThreadImplementation	Implementation of threads in single-threaded mode
CParallelFor1DLoopInfo	Characteristics of a multi-thread 1D loop
CSpinLock	SpinLock
CScopedLock
CManualLock
CStdThreadImplementationService	Implementation of threads using C++20 STL classes
CLegacyStdThreadImplementationService	Implementation of threads using LegacyStdBarrier for barriers
CTaskContext	Execution context of a task
CITaskFunctor	Interface for a task functor
CITask	Interface for a concurrent task
CTaskFactory	Factory for tasks
COneTBBTaskFunctor
COneTBBTask
CTBBTaskImplementation
CMDParallelForExecute
CTaskInfoLockGuard	Class for positioning TaskThreadInfo::taskIndex()
CImpl
CTaskObserver
CParallelForExecute
CTBBParallelFor	Executor for a 1D loop
CTBBMDParallelFor	Executor for a multi-dimensional loop
CTBBDeterministicParallelFor	Deterministic implementation of ParallelFor
CThreadPrivateStorage	Container for thread-private values
CThreadPrivateBase	Base class allowing an instance of an object to be stored per thread
CICreateFunctor
CThreadPrivate	Class allowing an instance of a type per thread
CBasicSerializeGatherMessage
CBasicSerializerNewImpl	Implementation of a contiguous in-memory serialization buffer
CSizeInfo	Information about the allocated size with and without padding
CBasicSerializerDataT	Buffer for serializing a data type DataType
CBasicSerializer	Basic implementation of 'ISerializer'
CSizesPrinter
CImpl
CImpl2
CISerializer	Serializer interface
CITimeMetricCollector	Interface managing statistics on execution
CTimeMetricActionBuildInfo
CTimeMetricAction
CTimeMetricId
CTimeMetricSentry	Sentinel for collecting temporal information
CStandardPhaseTimeMetrics	Standards for temporal phases
CTraceMessageListenerArgs	Arguments for ITraceMessageListener::visitMessage()
CITraceMessageListener	Interface for a visitor for trace messages
CITraceStream	Stream for a trace
CITraceMng	Trace manager interface
CStandaloneTraceMessage	Management of a standalone message
CTraceAccessor	Trace access class
CTraceClassConfig	Configuration associated with a trace class
CTraceMessage	Message handling
CTraceMessageDbg
CTraceTimer
CFileTraceStream	Trace file or stream
CTraceMngStreamList	Manages a list of streams per thread
CTraceMngStreamListStorage	Container for managing TraceMngStreamList instances
CTraceMng	Implementation of the trace manager
CTraceClass	Information about a message class
CAcceleratorRuntimeInitialisationInfo	Information for accelerator initialization
CIAcceleratorMng	Accelerator manager interface
CServiceAllInterfaceRegisterer	Class allowing the creation and registration of factories for a service
CServiceInfo	Information about a service
CIMpiReduceOperator	Reduction operators for complex types (Real2, Real3, Real2x2 and Real3x3)
CMpiAdapter	Adapter for MPI
CRequestSet
CRequestInfo
CSubRequestInfo
CMpiDatatype	Encapsulation of an MPI_Datatype
CMpiLock	Lock for MPI calls
CSection
CMpiSerializeDispatcher
CSerializeSubRequest
CSendSerializerSubRequest	Send sub-request
CReceiveSerializerSubRequest
CStdMpiReduceOperator	Reduction operators for standard types
CRunner	Execution manager for accelerator
CRunQueue	Execution queue for an accelerator
CScopedAsync
CExternalReferenceCounterAccessor
CArrayTraits	Characteristics for an array
CGlobalMemoryCopyList	Singleton class containing the instance to use for copies
CISpecificMemoryCopyList	Interface of a list of specialized ISpecificMemoryCopy instances
NArcaneTest
CAlephIndexTest
CAlephSolver
CAlephMultiTest
CSolverBuildInfo
CAlephTestModule	Test module for Aleph
CAlephTestScheme
CAlephTestSchemeFaces
CCaseOptionsAlephIndexTest	Options
CCaseOptionBoundaryConditionValue
CCaseOptionBoundaryCondition
CArcaneAlephIndexTestObject	Generation de la classe de base du Module
CCaseOptionsAlephMultiTest	Options
CArcaneAlephMultiTestObject	Generation de la classe de base du Module
CCaseOptionsAlephTestModule	Options
CCaseOptionBoundaryConditionValue
CCaseOptionBoundaryCondition
CArcaneAlephTestModuleObject	Generation de la classe de base du Module
NArccore	Namespace of Arccore
NInternal
CExternalRef	Management of references to an external object
CHandle
NValueFiller
Nimpl
CBuildInfo
CFillTraitsT
CFillTraitsBaseT
CIntegerFillTraitsT
CFloatFillTraitsT
CFillTraitsT< char >
CFillTraitsT< signed char >
CFillTraitsT< unsigned char >
CFillTraitsT< short >
CFillTraitsT< unsigned short >
CFillTraitsT< int >
CFillTraitsT< unsigned int >
CFillTraitsT< long >
CFillTraitsT< unsigned long >
CFillTraitsT< long long >
CFillTraitsT< unsigned long long >
CFillTraitsT< Int128 >
CFillTraitsT< float >
CFillTraitsT< double >
CFillTraitsT< long double >
CFillTraitsT< BFloat16 >
CFillTraitsT< Float16 >
CFillTraitsT< Float128 >
NMessagePassing	Namespace containing the types and declarations that manage the message-passing parallelism mechanism
Ninternal
CBasicSerializeMessage	Serializing message using a BasicSerializer
CSerializeMessageList	Serialization message list
CProbeInfo
CRequestListBase	Base class of a request list
NMpi
CMpiInfo	Informative structure linked to the enumerations for MPI operations. Provides the name associated with the enum as well as a description of the operation
CBasicSerializeMessage	Serializing message using a BasicSerializer
CIMpiProfiling	Abstraction interface for MPI operations. Primarily used to employ a decorator for MPI functions in order to profile them without being too verbose and intrusive in the MPIAdapter
CIMpiReduceOperator	Reduction operators for complex types (Real2, Real3, Real2x2 and Real3x3)
CMpiAdapter	Adapter for MPI
CRequestSet
CRequestInfo
CSubRequestInfo
CMpiDatatype	Encapsulation of an MPI_Datatype
CMpiLock	Lock for MPI calls
CSection
CMpiMessagePassingMng	MPI implementation of the message exchange manager
CBuildInfo
CMpiRequest	MPI specialization of a 'Request'
CMpiSerializeDispatcher
CSerializeSubRequest
CSendSerializerSubRequest	Send sub-request
CReceiveSerializerSubRequest
CMpiTypeDispatcher
CNoMpiProfiling	Implementation of the MPI operations interface. Corresponds to a simple call to MPI functions of the same name
CStandaloneMpiMessagePassingMng	Standalone version of MpiMessagePassingMng
CImpl
CStdMpiReduceOperator	Reduction operators for standard types
CMessageId	MessageId
C_Message
CIRequestCreator	Interface for a request creator
CIRequestList	Message request list
CISubRequest	Sub-request of a request
CMessagePassingMng	Message passing manager
CMessageRank	Rank of a message
CMessageSourceInfo	Information about the source of a message
CMessageTag	Message tag
CPointToPointMessageInfo	Information for sending/receiving a point-to-point message
CRequest	Message request
C_Request
CSubRequestCompletionInfo	Completion information for a sub-request
CCommunicator	Communicator for message exchange
C_Communicator
CDispatchers	Interface of the dispatcher container
CContainerTraits
CIDispatchers	Interface of the dispatcher container
CIProfiler	Interface of a profiler for message exchanges
CISerializeDispatcher	Interface for serialization messages
CIStat	Statistics on parallelism
CStat	Statistics manager for parallelism
CGatherMessageInfo	Brief information for a 'gather' message for data type DataType
CGatherMessageInfoBase	Brief information for a 'gather' message
CIControlDispatcher	Manage control streams for parallel messages
CIMessagePassingMng	Interface of the message passing manager
CISerializeMessage	Interface for a serialization message between IMessagePassingMng
CISerializeMessageList	Interface for a serialization message list
COneStat	Statistic on a message
CPointToPointSerializerMng	Point-to-point communications using 'ISerializer'
CImpl
CStatData	Statistical data set for profiling
CBuiltInDataTypeContainer	Container containing an instance of a class per data type
CExternalReferenceCounterAccessor
CArrayTraits	Characteristics for an array
CArrayTraits< T * >	Default implementation indicating that a type is not POD
CArrayTraits< const T * >	Default implementation indicating that a type is not POD
CArrayTraits< char >
CArrayTraits< signed char >
CArrayTraits< unsigned char >
CArrayTraits< short >
CArrayTraits< int >
CArrayTraits< long >
CArrayTraits< unsigned short >
CArrayTraits< unsigned int >
CArrayTraits< unsigned long >
CArrayTraits< float >
CArrayTraits< double >
CArrayTraits< long double >
CArrayTraits< std::byte >
CArrayTraits< Float16 >
CArrayTraits< BFloat16 >
CITraceMng	Trace manager interface
CString	Unicode character string
CStringBuilder	Unicode character string constructor
CStringFormatterArg	Class used to format a character string
CStringView	View of a UTF-8 character string
CAPReal	Emulation of real number in arbitrary precision
CFalseType	Structure equivalent to the boolean value true
CTrueType	Structure equivalent to the boolean value true
CArray2View	Mutable view for a 2D array
CArray3View	View for a 3D array
CArray4View	View for a 4D array
CArrayIterator	Iterator over Arccore array classes
CArrayView	Modifiable view of an array of type T
CConstArray2View	View for a constant 2D array
CConstArray3View	View for a constant 3D array
CConstArray4View	Constant view for a 4D array
CConstArrayView	Constant view of an array of type T
CConstIterT	Constant iterator interval
CIterT	Iterator intervalThis class manages an iterator pair allowing modification of the elements of the container
CSmallSpan	View of an array of elements of type T
CSmallSpan2	View for a 2D array whose size is an 'Int32'
CSpan	View of an array of elements of type T
CSpan2	View for a 2D array whose size is an 'Int64'
CSpan2Impl	View for a 2D array
CSpanImpl	View of an array of elements of type T
CStringImpl	Implementation of the String class
CStringVector	Vector of 'String'
CImpl
CArgumentException	Exception when an argument is invalid
CCheckedPointer	Encapsulation of a pointer
CException	Base class for an exception
CFatalErrorException	Exception when a fatal error has occurred
CFixedStackFrameArray	Stores a fixed maximum size list of StackFrame
CIndexOutOfRangeException	Exception when a value is not within a given range
CIStackTraceService	Interface of a function call tracing service
CNotImplementedException	Exception when a function is not implemented
CNotSupportedException	Exception when an operation is not supported
CRef	Reference to an instance
CReferenceCounter	Encapsulation of a pointer with a reference counter
CReferenceCounterImpl	Thread-safe implementation of a reference counter
CRefTraits	Characteristics for managing reference counters
CStackFrame	Stores the addresses corresponding to a call stack. This class is internal and should not be used outside of Arccore
CStackTrace	Information about function call stacks
CTimeoutException	Exception when a timeout occurs
CTraceInfo	Trace information
CFunctorT	Functor associated with a method of a class T
CFunctorWithArgumentT	Functor associated with a method of a class T
CIFunctor	Interface of a functor
CIFunctorWithArgAndReturn2	Interface of a functor with 2 arguments and a return value
CIFunctorWithArgumentT	Interface of a functor with an argument but without a return value
CStdFunctorWithArgumentT	Generic Functor using the std::function class
CArrayRange	Interval over Arccore array classes
CReferenceCounterTag	Structure used to tag interfaces/classes that use an internal reference counter
CAbstractArray	Abstract base class for a vector
CAlignedMemoryAllocator	Memory allocator with specific memory alignment
CAllocatedMemoryInfo	Information about an allocated memory region
CArray	Base class for 1D data vectors
CArray2	Class representing a classic 2D array
CArrayMetaData	Array Metadata
CDefaultMemoryAllocator	Memory allocator via malloc/realloc/free
CIMemoryAllocator	Interface for a memory allocator
CMemoryAllocationArgs	Class containing information to specialize allocations
CMemoryAllocationOptions	Options to configure allocations
CPrintableMemoryAllocator	Memory allocator via malloc/realloc/free with listing output
CSharedArray	1D vector of data with reference semantics
CSharedArray2	Shared 2D data vector with reference semantics
CUniqueArray	1D data vector with value semantics (STL style)
CUniqueArray2	2D data vector with value semantics (STL style)
CISerializer	Serializer interface
CITimeMetricCollector	Interface managing statistics on execution
CBasicSerializer	Basic implementation of 'ISerializer'
CSizesPrinter
CImpl
CImpl2
NDI_Test
CIA
CIB
CIA2
CIB2
CIC
CID
CIE
CINone
CAImpl
CBImpl
CB2Impl
CEImpl
CCDImpl
CA2Impl
Ninternal
CIsRefCounted
CIsRefCounted< T, typename internal::EnableIfCond< T::kRefCounted >::Type >
CIsGenericValueImpl
CIsGenericValueImpl< T, typename Void< typename T::EncodingType >::Type, typename Void< typename T::AllocatorType >::Type >
CIsGenericValue
CTypeHelper
CTypeHelper< ValueType, bool >
CTypeHelper< ValueType, int >
CTypeHelper< ValueType, unsigned >
CTypeHelper< ValueType, int64_t >
CTypeHelper< ValueType, uint64_t >
CTypeHelper< ValueType, double >
CTypeHelper< ValueType, float >
CTypeHelper< ValueType, const typename ValueType::Ch * >
CTypeHelper< ValueType, typename ValueType::Array >
CTypeHelper< ValueType, typename ValueType::ConstArray >
CTypeHelper< ValueType, typename ValueType::Object >
CTypeHelper< ValueType, typename ValueType::ConstObject >
CBigInteger
CDiyFp
CDouble
CDecodedStream
CGenericRegexSearch
CGenericRegex	Regular expression engine with subset of ECMAscript grammar
CRange
CState
CFrag
CStack	A type-unsafe stack for storing different types of data
CStreamLocalCopy
CStreamLocalCopy< Stream, 1 >	Do copy optimization
CStreamLocalCopy< Stream, 0 >	Keep reference
CSchema
CSchemaArray
CProperty
CPatternProperty
CISchemaValidator
CISchemaStateFactory
CIValidationErrorHandler
CHasher
CNumber
CU
CSchemaValidationContext
CTokenHelper
CTokenHelper< Stack, char >
Nmba
Ndetail
Cpower
Cpower< N, 0 >
Cgrid_iterator	N-dimensional grid iterator (nested loop with variable depth)
Ccontrol_lattice
Cinitial_approximation
Ccontrol_lattice_dense
Ccontrol_lattice_sparse
Clinear_approximation
CMBA
NStrongOptions
Cseq
Cgen_seq
Cgen_seq< 0, Is... >
COptionTools
CInternal
CInternal< T, N, CurN, Head, Tail... >
CInternal< T, N, CurN, T, Tail... >
CInternal< T, N, CurN >
CInternal2
CInternal2< T, Nmin, Nmax, CurN, Head, Tail... >
CInternal2< T, Nmin, Nmax, CurN, T, Tail... >
CInternal2< T, Nmin, Nmax, CurN >
CInternal3
CInternal3< T, CurN, Head, Tail... >
CInternal3< T, CurN, T, Tail... >
CInternal3< T, CurN >
CInternal4
CInternal4< std::tuple< AllowedTypes... >, Head, Tail... >
CInternal4< std::tuple< AllowedTypes... > >
CInternal44
CInternal44< Arg, Head, Tail... >
CInternal44< Arg, Head >
CInternal44< Arg >
COptionValue
COptionProxy
NTest1
CITestClassWithDeleter
CTestClassWithDeleter
NTestArccore
CIntSubClass
CIntSubClassNoPod
CIntPtrSubClass
NTestCopyNumArray
CB
NTestCuda
CIA
CA
C__MY_ItemEnumerator
CAlinaConvergenceInfo
CAlinaDistributedSolver
CAlinaLib
CAlinaParameters
CAlinaPreconditioner
CAlinaSequentialSolver
CAllocator	Concept for allocating, resizing and freeing memory block
CAllocatorTest
CArcaneAlephTestSchemeFacesObject	Generation de la classe de base du Service
CArcaneArcaneCaseMeshServiceObject	Generation de la classe de base du Service
CArcaneArcaneCheckpointObject	Generation de la classe de base du Module
CArcaneArcanePostProcessingObject	Generation de la classe de base du Module
CArcaneEuclidian3GeometryObject	Generation de la classe de base du Service
CArcaneLegacyMap
CArcaneMonoThreadAttachCallback
CArcanePDESRandomNumberGeneratorObject	Generation de la classe de base du Service
CArcaneSimpleCsvComparatorObject	Generation de la classe de base du Service
CArcaneSimpleCsvOutputObject	Generation de la classe de base du Service
CASCII	ASCII encoding
CAutoUTF	Dynamically select encoding according to stream's runtime-specified UTF encoding type
CAutoUTFInputStream	Input stream wrapper with dynamically bound encoding and automatic encoding detection
CAutoUTFOutputStream	Output stream wrapper with dynamically bound encoding and automatic encoding detection
CBaseReaderHandler	Default implementation of Handler
CBaseTestClass
CBasicIStreamWrapper	Wrapper of std::basic_istream into RapidJSON's Stream concept
CBasicOStreamWrapper	Wrapper of std::basic_ostream into RapidJSON's Stream concept
Cbilinear_deflation
CCaseOptionsAlephTestSchemeFaces	Options
CCaseOptionsArcaneCaseMeshService	Options
CCaseOptionInitVariableValue
CCaseOptionInitVariable
CCaseOptionInit
CCaseOptionsArcaneCheckpoint	Options
CCaseOptionsArcanePostProcessing	Options
CCaseOptionOutput
CCaseOptionExperimentalPythonPlugin
CCaseOptionsEuclidian3Geometry	Options
CCaseOptionsPDESRandomNumberGenerator	Options
CCaseOptionsSimpleCsvComparator	Options
CCaseOptionsSimpleCsvOutput	Options
CCrtAllocator	C-runtime library allocator
CCursorStreamWrapper	Cursor stream wrapper for counting line and column number if error exists
Cdeflation_vectors
CDerivedTestClass
CEncodedInputStream	Input byte stream wrapper with a statically bound encoding
CEncodedInputStream< UTF8<>, MemoryStream >	Specialized for UTF8 MemoryStream
CEncodedOutputStream	Output byte stream wrapper with statically bound encoding
CEncoding	Concept for encoding of Unicode characters
CFileReadStream	File byte stream for input using fread()
CFileWriteStream	Wrapper of C file stream for output using fwrite()
CFooBase
CFooDerived
CGenericArray	Helper class for accessing Value of array type
CGenericDocument	A document for parsing JSON text as DOM
CClearStackOnExit
CGenericInsituStringStream	A read-write string stream
CGenericMember	Name-value pair in a JSON object value
CGenericMemberIterator	(Constant) member iterator for a JSON object value
CGenericMemoryBuffer	Represents an in-memory output byte stream
CGenericObject	Helper class for accessing Value of object type
CGenericPointer	Represents a JSON Pointer. Use Pointer for UTF8 encoding and default allocator
CToken	A token is the basic units of internal representation
CPercentEncodeStream	A helper stream to encode character (UTF-8 code unit) into percent-encoded sequence
CGenericReader	SAX-style JSON parser. Use Reader for UTF8 encoding and default allocator
CClearStackOnExit
CStackStream
CNumberStream
CNumberStream< InputStream, StackCharacter, false, false >
CNumberStream< InputStream, StackCharacter, true, false >
CNumberStream< InputStream, StackCharacter, true, true >
CGenericSchemaDocument	JSON schema document
CSchemaEntry
CGenericSchemaValidator	JSON Schema Validator
CGenericStreamWrapper	A Stream Wrapper
CGenericStringBuffer	Represents an in-memory output stream
CGenericStringRef	Reference to a constant string (not taking a copy)
CGenericStringStream	Read-only string stream
CGenericUri
CGenericValue	Represents a JSON value. Use Value for UTF8 encoding and default allocator
CFlag
CString
CShortString
CNumber
CI
CU
CObjectData
CArrayData
CData
CHandler	Concept for receiving events from GenericReader upon parsing. The functions return true if no error occurs. If they return false, the event publisher should terminate the process
Charmonic_deflation
CHeptaedron10Connectivity	Connectivity information for geometric elements of type GeomType::Heptaedron10
CHeptaedron10Element	Geometric elements of type GeomType::Heptaedron10
CHeptaedron10ElementConstView	Constant view on geometric elements of type GeomType::Heptaedron10
CHeptaedron10ElementView	Modifiable view on geometric elements of type GeomType::Heptaedron10
CHeptaedron10ShapeView	Specific view on geometric shapes of type GeomType::Heptaedron10
CHexaedron8Connectivity	Connectivity information for geometric elements of type GeomType::Hexaedron8
CHexaedron8Element	Geometric elements of type GeomType::Hexaedron8
CHexaedron8ElementConstView	Constant view on geometric elements of type GeomType::Hexaedron8
CHexaedron8ElementView	Modifiable view on geometric elements of type GeomType::Hexaedron8
CHexaedron8ShapeView	Specific view on geometric shapes of type GeomType::Hexaedron8
CHexagon6Connectivity	Connectivity information for geometric elements of type GeomType::Hexagon6
CHexagon6Element	Geometric elements of type GeomType::Hexagon6
CHexagon6ElementConstView	Constant view on geometric elements of type GeomType::Hexagon6
CHexagon6ElementView	Modifiable view on geometric elements of type GeomType::Hexagon6
CHexagon6ShapeView	Specific view on geometric shapes of type GeomType::Hexagon6
Chyoda_taxi_data
CIGenericRemoteSchemaDocumentProvider
Cimaxdiv_t
CInstanceBuilder
CInstanceRegisterer
CIntegerArrayTester
CISerializeValue
CItemGroupBuilder
CKDIBase
CKDIChunk
CLambaDeviceFunc
CLine2Connectivity	Connectivity information for geometric elements of type GeomType::Line2
Clinear_deflation
Cmake_random
Cmake_random< Alina::StaticMatrix< T, N, M > >
Cmake_random< std::complex< T > >
Cmba_deflation
Cmd5_ctx
CMemoryPoolAllocator	Default memory allocator used by the parser and DOM
CChunkHeader	Chunk header for perpending to each chunk
CSharedData
CMemoryStream	Represents an in-memory input byte stream
CMemoryTester
CMyArrayTest
CMyClass
CMyMemoryPoolAllocator
CMyThread
CNoCopyData
COctaedron12Connectivity	Connectivity information for geometric elements of type GeomType::Octaedron12
COctaedron12Element	Geometric elements of type GeomType::Octaedron12
COctaedron12ElementConstView	Constant view on geometric elements of type GeomType::Octaedron12
COctaedron12ElementView	Modifiable view on geometric elements of type GeomType::Octaedron12
COctaedron12ShapeView	Specific view on geometric shapes of type GeomType::Octaedron12
CParseResult	Result of parsing (wraps ParseErrorCode)
Cpartitioned_deflation
CPentaedron6Connectivity	Connectivity information for geometric elements of type GeomType::Pentaedron6
CPentaedron6Element	Geometric elements of type GeomType::Pentaedron6
CPentaedron6ElementConstView	Constant view on geometric elements of type GeomType::Pentaedron6
CPentaedron6ElementView	Modifiable view on geometric elements of type GeomType::Pentaedron6
CPentaedron6ShapeView	Specific view on geometric shapes of type GeomType::Pentaedron6
CPentagon5Connectivity	Connectivity information for geometric elements of type GeomType::Pentagon5
CPentagon5Element	Geometric elements of type GeomType::Pentagon5
CPentagon5ElementConstView	Constant view on geometric elements of type GeomType::Pentagon5
CPentagon5ElementView	Modifiable view on geometric elements of type GeomType::Pentagon5
CPentagon5ShapeView	Specific view on geometric shapes of type GeomType::Pentagon5
Cpoisson_2d
CPrettyWriter	Writer with indentation and spacing
CPrivatizer
CPyramid5Connectivity	Connectivity information for geometric elements of type GeomType::Pyramid5
CPyramid5Element	Geometric elements of type GeomType::Pyramid5
CPyramid5ElementConstView	Constant view on geometric elements of type GeomType::Pyramid5
CPyramid5ElementView	Modifiable view on geometric elements of type GeomType::Pyramid5
CPyramid5ShapeView	Specific view on geometric shapes of type GeomType::Pyramid5
CQHyoda
CQHyodaGdb
CQHyodaGL
CQHyodaGLCell
CQHyodaIceT
CQHyodaJob
CQHyodaMachine
CQHyodaPapi
CQHyodaSsh
CQHyodaTcp
CQHyodaTool
CQHyodaToolCell
CQHyodaToolMatrix
CQHyodaToolMesh
CQHyodaX11
CQHyodaX11Emacs
CQHyodaX11Embed
CQHyodaX11Mathematica
CQHyodaX11Xterm
CQHyodaX11XtermLog
CQuad4Connectivity	Connectivity information for geometric elements of type GeomType::Quad4
CQuad4Element	Geometric elements of type GeomType::Quad4
CQuad4ElementConstView	Constant view on geometric elements of type GeomType::Quad4
CQuad4ElementView	Modifiable view on geometric elements of type GeomType::Quad4
CQuad4ShapeView	Specific view on geometric shapes of type GeomType::Quad4
CReal_Int32
Crenumbering
CSampleClass1
CSchemaValidatingReader	A helper class for parsing with validation
CSerializeValue
CSerializeValueList
CSimple1
CSimple2
Csparse_matrix
CSpecification
CStdAllocator
Crebind
CStdAllocator< void, BaseAllocator >
Crebind
CStream	Concept for reading and writing characters
CStreamTraits	Provides additional information for stream
CStreamTraits< GenericInsituStringStream< Encoding > >
CStreamTraits< GenericStringStream< Encoding > >
CStringSerializeValue
CStrucInfoProc
CStrucListeDomMail
CStrucListeVoisMail
CStrucMaillage
CStructureBlocEtendu
CStructureInterface
Ctag_ref_value
CTesterMemoryAllocatorV3	Allocator for testing arguments
CTestInfo
CTestInstance
CTestMutexLock1
CTestSharedArray2
CTestSpinLock1
CTetraedron4Connectivity	Connectivity information for geometric elements of type GeomType::Tetraedron4
CTetraedron4Element	Geometric elements of type GeomType::Tetraedron4
CTetraedron4ElementConstView	Constant view on geometric elements of type GeomType::Tetraedron4
CTetraedron4ElementView	Modifiable view on geometric elements of type GeomType::Tetraedron4
CTetraedron4ShapeView	Specific view on geometric shapes of type GeomType::Tetraedron4
CTranscoder	Encoding conversion
CTranscoder< Encoding, Encoding >	Specialization of Transcoder with same source and target encoding
CTriangle3Connectivity	Connectivity information for geometric elements of type GeomType::Triangle3
CTriangle3Element	Geometric elements of type GeomType::Triangle3
CTriangle3ElementConstView	Constant view on geometric elements of type GeomType::Triangle3
CTriangle3ElementView	Modifiable view on geometric elements of type GeomType::Triangle3
CTriangle3ShapeView	Specific view on geometric shapes of type GeomType::Triangle3
CUTF16	UTF-16 encoding
CUTF16BE	UTF-16 big endian encoding
CUTF16LE	UTF-16 little endian encoding
CUTF32	UTF-32 encoding
CUTF32BE	UTF-32 big endian encoding
CUTF32LE	UTF-32 little endian enocoding
CUTF8	UTF-8 encoding
CVertexConnectivity	Connectivity information for geometric elements of type GeomType::Vertex
CWriter	JSON writer
CLevel	Information for each nested level
CXYZ