IDataInternal.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 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-2025 */
/*                                                                           */
/* Internal part of IData in Arcane.                                         */
/*---------------------------------------------------------------------------*/
#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;

  virtual IMemoryAllocator* memoryAllocator() const = 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