IData.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* IData.h                                                     (C) 2000-2023 */
/*                                                                           */
/* Interface d'une donnée.                                                   */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_IDATA_H
#define ARCANE_IDATA_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/ArcaneTypes.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT IData
{
  ARCCORE_DECLARE_REFERENCE_COUNTED_INCLASS_METHODS();
 
 public:
 
  virtual ~IData() = default;
 
 public:
 
  virtual eDataType dataType() const = 0;
 
  virtual Integer dimension() const = 0;
 
  virtual Integer multiTag() const = 0;
 
  ARCCORE_DEPRECATED_2020("Use cloneRef() instead")
  virtual IData* clone() = 0;
 
  ARCCORE_DEPRECATED_2020("Use cloneEmptyRef() instead")
  virtual IData* cloneEmpty() = 0;
 
  virtual Ref<IData> cloneRef() = 0;
 
  virtual Ref<IData> cloneEmptyRef() = 0;
 
  virtual DataStorageTypeInfo storageTypeInfo() const = 0;
 
  virtual void serialize(ISerializer* sbuf, IDataOperation* operation) = 0;
 
  virtual void resize(Integer new_size) = 0;
 
  virtual void serialize(ISerializer* sbuf, Int32ConstArrayView ids, IDataOperation* operation) = 0;
 
  virtual void fillDefault() = 0;
 
  virtual void setName(const String& name) = 0;
 
  virtual Ref<ISerializedData> createSerializedDataRef(bool use_basic_type) const = 0;
 
  virtual void assignSerializedData(const ISerializedData* sdata) = 0;
 
  virtual void allocateBufferForSerializedData(ISerializedData* sdata) = 0;
 
  virtual void copy(const IData* data) = 0;
 
  virtual void swapValues(IData* data) = 0;
 
  virtual void computeHash(IHashAlgorithm* algo, ByteArray& output) const = 0;
 
  virtual ArrayShape shape() const = 0;
 
  virtual void setShape(const ArrayShape& new_shape) = 0;
 
 public:
 
  virtual void setAllocationInfo(const DataAllocationInfo& v) = 0;
 
  virtual DataAllocationInfo allocationInfo() const = 0;
 
 public:
 
  virtual void visit(IDataVisitor* visitor) = 0;
 
  virtual void visitScalar(IScalarDataVisitor* visitor) = 0;
 
  virtual void visitArray(IArrayDataVisitor* visitor) = 0;
 
  virtual void visitArray2(IArray2DataVisitor* visitor) = 0;
 
  virtual void visitMultiArray2(IMultiArray2DataVisitor* visitor);
 
  virtual IDataInternal* _commonInternal() = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class IScalarData
: public IData
{
 public:
  virtual void visit(IDataVisitor* visitor) = 0;
  virtual void visit(IScalarDataVisitor* visitor) = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class DataType>
class IScalarDataT
: public IScalarData
{
 public:
  typedef IScalarDataT<DataType> ThatClass;
 
 public:
  virtual DataType& value() = 0;
 
  virtual const DataType& value() const = 0;
 
  ARCCORE_DEPRECATED_2020("Use cloneTrueRef() instead")
  virtual ThatClass* cloneTrue() = 0;
 
  ARCCORE_DEPRECATED_2020("Use cloneTrueEmpty() instead")
  virtual ThatClass* cloneTrueEmpty() = 0;
 
  virtual Ref<ThatClass> cloneTrueRef() = 0;
 
  virtual Ref<ThatClass> cloneTrueEmptyRef() = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class IArrayData
: public IData
{
 public:
  virtual void visit(IDataVisitor* visitor) = 0;
  virtual void visit(IArrayDataVisitor* visitor) = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class DataType>
class IArrayDataT
: public IArrayData
{
 public:
 
  typedef IArrayDataT<DataType> ThatClass;
 
 public:
 
  ARCCORE_DEPRECATED_2021("Use view() instead.")
  virtual Array<DataType>& value() = 0;
 
  ARCCORE_DEPRECATED_2021("Use view() instead.")
  virtual const Array<DataType>& value() const = 0;
 
 public:
 
  virtual ConstArrayView<DataType> view() const = 0;
 
  virtual ArrayView<DataType> view() = 0;
 
  ARCCORE_DEPRECATED_2020("Use cloneTrueRef() instead")
  virtual ThatClass* cloneTrue() = 0;
 
  ARCCORE_DEPRECATED_2020("Use cloneTrueEmptyRef() instead")
  virtual ThatClass* cloneTrueEmpty() = 0;
 
  virtual Ref<ThatClass> cloneTrueRef() = 0;
 
  virtual Ref<ThatClass> cloneTrueEmptyRef() = 0;
 
  virtual IArrayDataInternalT<DataType>* _internal() = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class IArray2Data
: public IData
{
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class IMultiArray2Data
: public IData
{
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class DataType>
class IArray2DataT
: public IArray2Data
{
 public:
 
  typedef IArray2DataT<DataType> ThatClass;
 
  ARCCORE_DEPRECATED_2021("Use view() instead.")
  virtual Array2<DataType>& value() = 0;
 
  ARCCORE_DEPRECATED_2021("Use view() instead.")
  virtual const Array2<DataType>& value() const = 0;
 
 public:
 
  virtual ConstArray2View<DataType> view() const = 0;
 
  virtual Array2View<DataType> view() = 0;
 
  ARCCORE_DEPRECATED_2020("Use cloneTrueRef() instead")
  virtual ThatClass* cloneTrue() = 0;
 
  ARCCORE_DEPRECATED_2020("Use cloneTrueEmptyRef() instead")
  virtual ThatClass* cloneTrueEmpty() = 0;
 
  virtual Ref<ThatClass> cloneTrueRef() = 0;
 
  virtual Ref<ThatClass> cloneTrueEmptyRef() = 0;
 
  virtual IArray2DataInternalT<DataType>* _internal() = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class DataType>
class IMultiArray2DataT
: public IMultiArray2Data
{
 public:
  typedef IMultiArray2DataT<DataType> ThatClass;
 
 
  virtual MultiArray2<DataType>& value() = 0;
 
  virtual const MultiArray2<DataType>& value() const = 0;
 
  virtual ThatClass* cloneTrue() = 0;
 
  virtual ThatClass* cloneTrueEmpty() = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif