IDataInternal.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* IDataInternal.h                                             (C) 2000-2024 */
/*                                                                           */
/* Partie interne à Arcane de IData.                                         */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_INTERNAL_IDATAINTERNAL_H
#define ARCANE_CORE_INTERNAL_IDATAINTERNAL_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/core/ArcaneTypes.h"
 
#include "arcane/utils/UniqueArray.h"
#include "arcane/utils/IHashAlgorithm.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
class IDataCompressor;
class INumericDataInternal;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class DataCompressionBuffer
{
 public:
 
  UniqueArray<std::byte> m_buffer;
  Int64 m_original_dim1_size = 0;
  Int64 m_original_dim2_size = 0;
  IDataCompressor* m_compressor = nullptr;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class DataHashInfo
{
 public:
 
  explicit DataHashInfo(IHashAlgorithmContext* context)
  : m_context(context)
  {}
 
 public:
 
  IHashAlgorithmContext* context() const { return m_context; }
  Int32 version() const { return m_version; }
  void setVersion(Int32 v) { m_version = v; }
 
 private:
 
  IHashAlgorithmContext* m_context = nullptr;
  Int32 m_version = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT IDataInternal
{
 public:
 
  virtual ~IDataInternal() = default;
 
 public:
 
  virtual bool compressAndClear(DataCompressionBuffer& buf)
  {
    ARCANE_UNUSED(buf);
    return false;
  }
 
  virtual bool decompressAndFill(DataCompressionBuffer& buf)
  {
    ARCANE_UNUSED(buf);
    return false;
  }
 
  virtual INumericDataInternal* numericData() { return nullptr; }
 
  virtual void computeHash(DataHashInfo& hash_info) = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT INumericDataInternal
{
 public:
 
  virtual ~INumericDataInternal() = default;
 
 public:
 
  virtual MutableMemoryView memoryView() = 0;
 
  virtual Int32 extent0() const = 0;
 
  virtual void changeAllocator(const MemoryAllocationOptions& alloc_info) = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class NullDataInternal
: public IDataInternal
{
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class DataType>
class IArrayDataInternalT
: public IDataInternal
{
 public:
 
  virtual void reserve(Integer new_capacity) =0;
 
  virtual Array<DataType>& _internalDeprecatedValue() = 0;
 
  virtual Integer capacity() const =0;
 
  virtual void shrink() const =0;
 
  virtual void resize(Integer new_size) =0;
 
  virtual void dispose() =0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
template <class DataType>
class IArray2DataInternalT
: public IDataInternal
{
 public:
 
  virtual void reserve(Integer new_capacity) = 0;
 
  virtual Array2<DataType>& _internalDeprecatedValue() = 0;
 
  virtual void resizeOnlyDim1(Int32 new_dim1_size) = 0;
 
  virtual void resize(Int32 new_dim1_size, Int32 new_dim2_size) = 0;
 
  virtual void shrink() const = 0;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::impl
{
extern "C++" ARCANE_CORE_EXPORT void
copyContiguousData(INumericDataInternal* destination, ConstMemoryView source, RunQueue& queue);
 
extern "C++" ARCANE_CORE_EXPORT void
copyContiguousData(IData* destination, IData* source, RunQueue& queue);
 
extern "C++" ARCANE_CORE_EXPORT void
fillContiguousDataGeneric(IData* data, const void* fill_address,
                          Int32 datatype_size, RunQueue& queue);
 
template <typename DataType> inline void
fillContiguousData(IData* data, const DataType& value, RunQueue& queue)
{
  constexpr Int32 type_size = static_cast<Int32>(sizeof(DataType));
  fillContiguousDataGeneric(data, &value, type_size, queue);
}
 
} // namespace Arcane::impl
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif