BasicSerializer.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* BasicSerializer.h                                           (C) 2000-2025 */
/*                                                                           */
/* Simple implementation of 'ISerializer'.                                   */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_SERIALIZE_BASICSERIALIZER_H
#define ARCCORE_SERIALIZE_BASICSERIALIZER_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/serialize/ISerializer.h"
 
#include "arccore/base/Float16.h"
#include "arccore/base/BFloat16.h"
#include "arccore/base/Float128.h"
#include "arccore/base/Int128.h"
#include "arccore/collections/Array.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
class BasicSerializeGatherMessage;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*!
 * \internal
 * \brief Buffer for serializing a data type \a DataType.
 */
template <class DataType>
class BasicSerializerDataT
{
 public:
 
  BasicSerializerDataT()
  : m_reserved_size(0)
  , m_current_position(0)
  {}
 
 public:
 
  void put(Span<const DataType> values)
  {
    Int64 n = values.size();
    Int64 cp = m_current_position;
    Int64 max_size = 1 + m_buffer.size();
    arccoreCheckAt(n + cp, max_size);
 
    DataType* ptr = m_buffer.data() + cp;
    const DataType* vptr = values.data();
    for (Int64 i = 0; i < n; ++i)
      ptr[i] = vptr[i];
    m_current_position += n;
  }
 
  void get(Span<DataType> values)
  {
    Int64 n = values.size();
    Int64 cp = m_current_position;
    Int64 max_size = 1 + m_buffer.size();
    arccoreCheckAt(n + cp, max_size);
 
    const DataType* ptr = m_buffer.data() + cp;
    DataType* vptr = values.data();
    for (Int64 i = 0; i < n; ++i)
      vptr[i] = ptr[i];
    m_current_position += n;
  }
 
 public:
 
  Int64 m_reserved_size;
  Int64 m_current_position;
  Span<DataType> m_buffer;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*!
 * \internal
 * \brief Basic implementation of 'ISerializer'
 */
class ARCCORE_SERIALIZE_EXPORT BasicSerializer
: public ISerializer
{
  friend Arcane::BasicSerializeGatherMessage;
  typedef BasicSerializer ThatClass;
  using ISerializer::putSpan;
  using ISerializer::reserveSpan;
 
 public:
 
  // Temporary class to display buffer sizes.
  class SizesPrinter
  {
   public:
 
    explicit SizesPrinter(const BasicSerializer& sbuf)
    : m_sbuf(sbuf)
    {}
    const BasicSerializer& buf() const { return m_sbuf; }
 
   private:
 
    const BasicSerializer& m_sbuf;
  };
 
 public:
 
  class Impl;
  class Impl2;
 
 public:
 
  BasicSerializer();
  BasicSerializer(const BasicSerializer& sb);
  ~BasicSerializer() override;
 
 private:
 
  void operator=(const BasicSerializer& sb);
 
 public:
 
  using ISerializer::reserve;
 
 public:
 
  void reserveSpan(eDataType dt, Int64 n) override;
  void reserveSpan(eBasicDataType dt, Int64 n) override;
  void reserve(eBasicDataType dt, Int64 n) override;
  void reserve(eDataType dt, Int64 n) override;
  void reserveInteger(Int64 n) override
  {
#ifdef ARCANE_64BIT
    reserve(DT_Int64, n);
#else
    reserve(DT_Int32, n);
#endif
  }
  void reserve(const String& str) override;
 
  void reserveArray(Span<const Real> values) override;
  void reserveArray(Span<const Int16> values) override;
  void reserveArray(Span<const Int32> values) override;
  void reserveArray(Span<const Int64> values) override;
  void reserveArray(Span<const Byte> values) override;
  void reserveArray(Span<const Int8> values) override;
  void reserveArray(Span<const Float16> values) override;
  void reserveArray(Span<const BFloat16> values) override;
  void reserveArray(Span<const Float32> values) override;
  void reserveArray(Span<const Float128> values) override;
  void reserveArray(Span<const Int128> values) override;
 
  void put(Span<const Real> values) override;
  void put(Span<const Int16> values) override;
  void put(Span<const Int32> values) override;
  void put(Span<const Int64> values) override;
  void put(Span<const Byte> values) override;
  void putSpan(Span<const Int8> values) override;
  void putSpan(Span<const Float16> values) override;
  void putSpan(Span<const BFloat16> values) override;
  void putSpan(Span<const Float32> values) override;
  void putSpan(Span<const Float128> values) override;
  void putSpan(Span<const Int128> values) override;
  void put(const String& value) override;
 
  void put(Real value) override
  {
    putReal(value);
  }
  void put(Int64 value) override
  {
    putInt64(value);
  }
  void put(Int32 value) override
  {
    putInt32(value);
  }
  void put(Int16 value) override
  {
    putInt16(value);
  }
  void put(Byte value) override
  {
    putByte(value);
  }
  void put(Int8 value) override
  {
    putInt8(value);
  }
  void put(Float16 value) override
  {
    putFloat16(value);
  }
  void put(BFloat16 value) override
  {
    putBFloat16(value);
  }
  void put(Float32 value) override
  {
    putFloat32(value);
  }
  void put(Float128 value) override
  {
    putFloat128(value);
  }
  void put(Int128 value) override
  {
    putInt128(value);
  }
 
  void putReal(Real value) override
  {
    put(ConstArrayView<Real>(1, &value));
  }
  void putInt64(Int64 value) override
  {
    put(ConstArrayView<Int64>(1, &value));
  }
  void putInt32(Int32 value) override
  {
    put(ConstArrayView<Int32>(1, &value));
  }
  void putInt16(Int16 value) override
  {
    put(ConstArrayView<Int16>(1, &value));
  }
  void putInteger(Integer value) override
  {
#ifdef ARCANE_64BIT
    put(ConstArrayView<Int64>(1, &value));
#else
    put(ConstArrayView<Int32>(1, &value));
#endif
  }
  void putByte(Byte value) override
  {
    put(ConstArrayView<Byte>(1, &value));
  }
  void putInt8(Int8 value) override
  {
    putSpan(ConstArrayView<Int8>(1, &value));
  }
  void putFloat16(Float16 value) override
  {
    putSpan(ConstArrayView<Float16>(1, &value));
  }
  void putBFloat16(BFloat16 value) override
  {
    putSpan(ConstArrayView<BFloat16>(1, &value));
  }
  void putFloat32(Float32 value) override
  {
    putSpan(ConstArrayView<Float32>(1, &value));
  }
  void putFloat128(Float128 value) override
  {
    putSpan(ConstArrayView<Float128>(1, &value));
  }
  void putInt128(Int128 value) override
  {
    putSpan(ConstArrayView<Int128>(1, &value));
  }
 
  void putArray(Span<const Real> values) override;
  void putArray(Span<const Int16> values) override;
  void putArray(Span<const Int32> values) override;
  void putArray(Span<const Int64> values) override;
  void putArray(Span<const Byte> values) override;
  void putArray(Span<const Int8> values) override;
  void putArray(Span<const Float16> values) override;
  void putArray(Span<const BFloat16> values) override;
  void putArray(Span<const Float32> values) override;
  void putArray(Span<const Float128> values) override;
  void putArray(Span<const Int128> values) override;
 
  void get(ArrayView<Real> values) override { ThatClass::getSpan(values); }
  void get(ArrayView<Int64> values) override { ThatClass::getSpan(values); }
  void get(ArrayView<Int32> values) override { ThatClass::getSpan(values); }
  void get(ArrayView<Int16> values) override { ThatClass::getSpan(values); }
  void get(ArrayView<Byte> values) override { ThatClass::getSpan(values); }
 
  void getSpan(Span<Real> values) override;
  void getSpan(Span<Int16> values) override;
  void getSpan(Span<Int32> values) override;
  void getSpan(Span<Int64> values) override;
  void getSpan(Span<Byte> values) override;
  void getSpan(Span<Int8> values) override;
  void getSpan(Span<Float16> values) override;
  void getSpan(Span<BFloat16> values) override;
  void getSpan(Span<Float32> values) override;
  void getSpan(Span<Float128> values) override;
  void getSpan(Span<Int128> values) override;
 
  void getArray(Array<Real>& values) override;
  void getArray(Array<Int16>& values) override;
  void getArray(Array<Int32>& values) override;
  void getArray(Array<Int64>& values) override;
  void getArray(Array<Byte>& values) override;
  void getArray(Array<Int8>& values) override;
  void getArray(Array<Float16>& values) override;
  void getArray(Array<BFloat16>& values) override;
  void getArray(Array<Float32>& values) override;
  void getArray(Array<Float128>& values) override;
  void getArray(Array<Int128>& values) override;
 
  void get(String& values) override;
 
  Real getReal() override
  {
    Real r = 0.;
    get(ArrayView<Real>(1, &r));
    return r;
  }
  Int64 getInt64() override
  {
    Int64 r = 0;
    get(ArrayView<Int64>(1, &r));
    return r;
  }
  Int32 getInt32() override
  {
    Int32 r = 0;
    get(ArrayView<Int32>(1, &r));
    return r;
  }
  Int16 getInt16() override
  {
    Int16 r = 0;
    get(ArrayView<Int16>(1, &r));
    return r;
  }
  Integer getInteger() override
  {
#ifdef ARCANE_64BIT
    return getInt64();
#else
    return getInt32();
#endif
  }
  Byte getByte() override
  {
    Byte r = 0;
    get(ArrayView<Byte>(1, &r));
    return r;
  }
  Int8 getInt8() override
  {
    Int8 r = 0;
    getSpan(ArrayView<Int8>(1, &r));
    return r;
  }
  Float16 getFloat16() override
  {
    Float16 r = {};
    getSpan(ArrayView<Float16>(1, &r));
    return r;
  }
  BFloat16 getBFloat16() override
  {
    BFloat16 r = {};
    getSpan(ArrayView<BFloat16>(1, &r));
    return r;
  }
  Float32 getFloat32() override
  {
    Float32 r = {};
    getSpan(ArrayView<Float32>(1, &r));
    return r;
  }
  Float128 getFloat128() override
  {
    Float128 r = {};
    getSpan(ArrayView<Float128>(1, &r));
    return r;
  }
  Int128 getInt128() override
  {
    Int128 r = {};
    getSpan(ArrayView<Int128>(1, &r));
    return r;
  }
 
  void allocateBuffer() override;
 
  eMode mode() const override;
  void setMode(eMode new_mode) override;
  eReadMode readMode() const override;
  void setReadMode(eReadMode new_read_mode) override;
 
 public:
 
  /*!
   * \brief Indicates whether to serialize the data type to
   * ensure consistency.
   *
   * If active, it requires that calls to reserve() and
   * reserveArray() are consistent with put(). Since this
   * has not been the case historically, this option is not active
   * by default.
   *
   * It is only useful to set this option during writing. In reading,
   * the information is contained in the serializer.
   */
  void setSerializeTypeInfo(bool v);
  bool isSerializeTypeInfo() const;
 
 private:
 
  // Obsolete method in the interface. To be removed as soon as possible
  void allocateBuffer(Int64 nb_real, Int64 nb_int16, Int64 nb_int32,
                      Int64 nb_int64, Int64 nb_byte) override;
 
 public:
 
  ARCCORE_DEPRECATED_2020("internal method")
  Span<Real> realBuffer();
  ARCCORE_DEPRECATED_2020("internal method")
  Span<Int64> int64Buffer();
  ARCCORE_DEPRECATED_2020("internal method")
  Span<Int32> int32Buffer();
  ARCCORE_DEPRECATED_2020("internal method")
  Span<Int16> int16Buffer();
  ARCCORE_DEPRECATED_2020("internal method")
  Span<Byte> byteBuffer();
 
 public:
 
  ConstArrayView<Byte> copyAndGetSizesBuffer();
  Span<Byte> globalBuffer();
  Span<const Byte> globalBuffer() const;
  ARCCORE_DEPRECATED_2020("Do not use. get total size with totalSize()")
  ConstArrayView<Int64> sizesBuffer();
  Int64 totalSize() const;
  void preallocate(Int64 size);
  void releaseBuffer();
  void setFromSizes();
  void printSizes(std::ostream& o) const;
 
  friend inline std::ostream&
  operator<<(std::ostream& o, const BasicSerializer::SizesPrinter& x)
  {
    x.buf().printSizes(o);
    return o;
  }
 
 public:
 
  /*!
   * \brief Initializes the serializer for reading from the data \a buf.
   *
   * The array \a buf must have been obtained via the call to globalBuffer()
   * from a writing serializer.
   */
  void initFromBuffer(Span<const Byte> buf);
  void copy(const ISerializer* from) override;
  void copy(const BasicSerializer& rhs);
  /*!
   * \brief Padding and alignment size.
   *
   * It is guaranteed that every array (buffer) managed by this serializer
   * has a size that is a multiple of paddingSize() in bytes and an
   * alignment on paddingSize().
   */
  static ARCCORE_CONSTEXPR Integer paddingSize() { return 128; }
 
  // TEMPORARY until we use Arcane AllGather. Then to be made private
 protected:
 
  Impl2* m_p2;
 
  Impl* _p() const;
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif