// Copyright CERN and copyright holders of ALICE O2. This software is

// distributed under the terms of the GNU General Public License v3 (GPL

// Version 3), copied verbatim in the file "COPYING".

//

// See http://alice-o2.web.cern.ch/license for full licensing information.

//

// In applying this license CERN does not waive the privileges and immunities

// granted to it by virtue of its status as an Intergovernmental Organization

// or submit itself to any jurisdiction.

#ifndef FLATTERRESTORE_H

#define FLATTERRESTORE_H

/// @file FlattenRestore.h

/// @author Matthias Richter

/// @since 2020-04-05

/// @brief Utilities to copy complex objects to flat buffer and restore

#include <type_traits>

namespace o2::algorithm

{

namespace flatten

{

/// Calculate cumulative value size of a variable number of arguments

/// The function takes parameters by reference and calculates the memory size of

/// all parameters together. The pointer attribute is removed.

///

/// Example:

/// char* array1;

/// int* array2;

/// float* array3;

/// size = value_size(array1, array2, array3);

/// // size is sizeof(char) + sizeof(int) + sizeof(float)

template <typename ValueType, typename... Args>

constexpr size_t value_size(ValueType const& value, Args&&... args)

{

size_t size = sizeof(typename std::remove_pointer<typename std::remove_reference<ValueType>::type>::type);

if constexpr (sizeof...(Args) > 0) {

size += value_size(std::forward<Args>(args)...);

}

return size;

}

/// Copy the content of variable number of arrays with the same extent to a buffer

/// The target pointer is passed be reference and incremented while copying

/// @param wrtptr write pointer

/// @param count extent of the arrays

/// @param args a variable number of pointers to arrays

/// @return copied size in bytes

template <typename TargetType, typename ValueType, typename... Args>

static size_t copy_to(TargetType& wrtptr, size_t count, ValueType* array, Args&&... args)

{

static_assert(std::is_pointer<TargetType>::value == true, "need reference to pointer");

static_assert(sizeof(typename std::remove_pointer<TargetType>::type) == 1, "need char-like pointer");

size_t copySize = 0;

if (array != nullptr) {

copySize = count * value_size(array);

memcpy(wrtptr, array, copySize);

wrtptr += copySize;

} else if (count > 0) {

throw std::runtime_error("invalid nullptr to array of " + std::to_string(count) + " element(s)");

}

if constexpr (sizeof...(Args) > 0) {

copySize += copy_to(wrtptr, count, std::forward<Args>(args)...);

}

return copySize;

}

/// Set pointers to regions in source buffer

/// A variable number of pointer arguments of consecutive arrays in a buffer are set according

/// to the type size and the extent of arrays

/// The read pointer is passed be reference and incremented while copying

/// @param readptr the source buffer

/// @param count extent of the arrays

/// @param args a variable number of references of pointers to arrays

/// @return handled raw size in bytes

template <typename BufferType, typename ValueType, typename... Args>

static size_t set_from(BufferType& readptr, size_t count, ValueType& array, Args&&... args)

{

static_assert(std::is_pointer<typename std::remove_reference<ValueType>::type>::value == true, "need reference to pointer");

array = reinterpret_cast<typename std::remove_reference<ValueType>::type>(readptr);

size_t readSize = count * value_size(array);

readptr += readSize;

if constexpr (sizeof...(Args) > 0) {

readSize += set_from(readptr, count, std::forward<Args>(args)...);

}

return readSize;

}

/// Calculate the total size of a sequence of arrays with the same extent

/// the first argument is a dummy argument to have the same signature as copy_to

/// and set_from

/// @param dummyptr unused

/// @param count extent of the arrays

/// @param args a variable number of references of pointers to arrays

/// @return total size

template <typename BufferType, typename... Args>

static size_t calc_size(BufferType const& dummyptr, size_t count, Args&&... args)

{

return count * value_size(std::forward<Args>(args)...);

}

} // namespace flatten

} // namespace o2::algorithm

#endif