olb::ConcreteCommunicatable< COMMUNICATEE > Class Template Reference

#include <communicatable.h>

Inheritance diagram for olb::ConcreteCommunicatable< COMMUNICATEE >:

Collaboration diagram for olb::ConcreteCommunicatable< COMMUNICATEE >:

Public Member Functions
	ConcreteCommunicatable (COMMUNICATEE &communicatee)
std::size_t	size (ConstSpan< CellID > indices) const override
	Get serialized size for data at locations indices
std::size_t	serialize (ConstSpan< CellID > indices, std::uint8_t *buffer) const override
	Serialize data at locations indices to buffer
std::size_t	deserialize (ConstSpan< CellID > indices, const std::uint8_t *buffer) override
	Deserialize data at locations indices to buffer
std::size_t	size () const
	ADDITIONAL NON OVERWITTEN CALLS: Removing the necessity to provide indices.
std::size_t	serialize (std::uint8_t *buffer) const
	Serialize complete data.
std::size_t	deserialize (const std::uint8_t *buffer)
	Deserialize complete data.
Public Member Functions inherited from olb::Communicatable
virtual	~Communicatable ()

Detailed Description

template<typename COMMUNICATEE>
class olb::ConcreteCommunicatable< COMMUNICATEE >

Definition at line 90 of file communicatable.h.

Constructor & Destructor Documentation

ConcreteCommunicatable()

template<typename COMMUNICATEE >

olb::ConcreteCommunicatable< COMMUNICATEE >::ConcreteCommunicatable ( COMMUNICATEE & communicatee )

inline

Definition at line 95 of file communicatable.h.

                                                    :
    _communicatee{communicatee} { }

Member Function Documentation

deserialize() [1/2]

template<typename COMMUNICATEE >

std::size_t olb::ConcreteCommunicatable< COMMUNICATEE >::deserialize ( const std::uint8_t * buffer )

inline

Deserialize complete data.

Definition at line 182 of file communicatable.h.

  {
    std::size_t noI = std::tuple_size<COMMUNICATEE>::value;
    if (meta::is_aligned<typename COMMUNICATEE::value_type>(buffer)) {
      const auto* source = reinterpret_cast<const typename COMMUNICATEE::value_type*>(buffer);
      for (CellID index=0; index<noI; ++index) {
        _communicatee[index] = *(source++);
      }
    } else {
      const std::uint8_t* source = buffer;
      for (CellID index=0; index<noI; ++index) {
        std::memcpy(reinterpret_cast<void*>(&_communicatee[index]),
                    source,
                    sizeof(typename COMMUNICATEE::value_type));
        source += sizeof(typename COMMUNICATEE::value_type);
      }
    }
    return noI * sizeof(typename COMMUNICATEE::value_type);
  }

deserialize() [2/2]

template<typename COMMUNICATEE >

std::size_t olb::ConcreteCommunicatable< COMMUNICATEE >::deserialize ( ConstSpan< CellID > indices, const std::uint8_t * buffer )

inlineoverridevirtual

Deserialize data at locations indices to buffer

Implements olb::Communicatable.

Definition at line 126 of file communicatable.h.

  {
    if (meta::is_aligned<typename COMMUNICATEE::value_type>(buffer)) {
      const auto* source = reinterpret_cast<const typename COMMUNICATEE::value_type*>(buffer);
      for (CellID index : indices) {
        _communicatee[index] = *(source++);
      }
    } else {
      const std::uint8_t* source = buffer;
      for (CellID index : indices) {
        std::memcpy(reinterpret_cast<void*>(&_communicatee[index]),
                    source,
                    sizeof(typename COMMUNICATEE::value_type));
        source += sizeof(typename COMMUNICATEE::value_type);
      }
    }
    return indices.size() * sizeof(typename COMMUNICATEE::value_type);
  }

References olb::ConstSpan< T >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize() [1/2]

template<typename COMMUNICATEE >

std::size_t olb::ConcreteCommunicatable< COMMUNICATEE >::serialize ( ConstSpan< CellID > indices, std::uint8_t * buffer ) const

inlineoverridevirtual

Serialize data at locations indices to buffer

Implements olb::Communicatable.

Definition at line 105 of file communicatable.h.

  {
    if (meta::is_aligned<typename COMMUNICATEE::value_type>(buffer)) {
      auto* target = reinterpret_cast<typename COMMUNICATEE::value_type*>(buffer);
      for (CellID index : indices) {
        *(target++) = _communicatee[index];
      }
    } else {
      std::uint8_t* target = buffer;
      for (CellID index : indices) {
        std::memcpy(target,
                    reinterpret_cast<const void*>(&_communicatee[index]),
                    sizeof(typename COMMUNICATEE::value_type));
        target += sizeof(typename COMMUNICATEE::value_type);
      }
    }
    return indices.size() * sizeof(typename COMMUNICATEE::value_type);
  }

References olb::ConstSpan< T >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize() [2/2]

template<typename COMMUNICATEE >

std::size_t olb::ConcreteCommunicatable< COMMUNICATEE >::serialize ( std::uint8_t * buffer ) const

inline

Serialize complete data.

Definition at line 161 of file communicatable.h.

  {
    std::size_t noI = std::tuple_size<COMMUNICATEE>::value;
    if (meta::is_aligned<typename COMMUNICATEE::value_type>(buffer)) {
      auto* target = reinterpret_cast<typename COMMUNICATEE::value_type*>(buffer);
      for (CellID index=0; index<noI; ++index) {
        *(target++) = _communicatee[index];
      }
    } else {
      std::uint8_t* target = buffer;
      for (CellID index=0; index<noI; ++index) {
        std::memcpy(target,
                    reinterpret_cast<const void*>(&_communicatee[index]),
                    sizeof(typename COMMUNICATEE::value_type));
        target += sizeof(typename COMMUNICATEE::value_type);
      }
    }
    return noI * sizeof(typename COMMUNICATEE::value_type);
  }

size() [1/2]

template<typename COMMUNICATEE >

std::size_t olb::ConcreteCommunicatable< COMMUNICATEE >::size ( ) const

inline

ADDITIONAL NON OVERWITTEN CALLS: Removing the necessity to provide indices.

• Here, intendet to be used for std::array (for which std::tuple_size works), for other COMMUNICATEE types, a different static size retrieval should be implemented.
• Actually, vector might also work here, however is unfortunately rather passed to ConcreteCommunicatable<std::vector<COLUMN>>
• TODO: Include properly into complete framework, if found usefull. Get serialized size for complete data

Definition at line 155 of file communicatable.h.

  {
    return std::tuple_size<COMMUNICATEE>::value * sizeof(typename COMMUNICATEE::value_type);
  }

Here is the caller graph for this function:

size() [2/2]

template<typename COMMUNICATEE >

std::size_t olb::ConcreteCommunicatable< COMMUNICATEE >::size ( ConstSpan< CellID > indices ) const

inlineoverridevirtual

Get serialized size for data at locations indices

Implements olb::Communicatable.

Definition at line 99 of file communicatable.h.

  {
    return indices.size() * sizeof(typename COMMUNICATEE::value_type);
  }

References olb::ConstSpan< T >::size().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• src/communication/communicatable.h