Serialization.H

Go to the documentation of this file.

/* Copyright 2021 Luca Fedeli
 *
 * This file is part of WarpX.
 *
 * License: BSD-3-Clause-LBNL
 */
 
#ifndef ABLASTR_MSG_LOGGER_SERIALIZATION_H_
#define ABLASTR_MSG_LOGGER_SERIALIZATION_H_
 
#include <algorithm>
#include <array>
#include <cstring>
#include <iterator>
#include <string>
#include <type_traits>
#include <vector>
 
namespace ablastr::utils::serialization
{
    template <typename T,
        std::enable_if_t<std::is_trivially_copyable_v<T> || std::is_same_v<T, std::string>, bool> = true>
    void put_in(const T &val, std::vector<char> &vec)
    {
        if constexpr (std::is_same<T, std::string>())
        {
            const char *c_str = val.c_str();
            const auto length = static_cast<int>(val.size());
 
            put_in(length, vec);
            std::copy(c_str, c_str + length, std::back_inserter(vec));
        }
        else
        {
            const auto *ptr_val = reinterpret_cast<const char *>(&val);
            std::copy(ptr_val, ptr_val + sizeof(T), std::back_inserter(vec));
        }
    }

    template <typename T>
    void put_in_vec(const std::vector<T> &val, std::vector<char> &vec)
    {
        put_in(static_cast<int>(val.size()), vec);
        for (const auto &el : val) {
            put_in(el, vec);
        }
    }

    template <typename T,
        std::enable_if_t<std::is_trivially_copyable_v<T> || std::is_same_v<T, std::string>, bool> = true>
    T get_out(std::vector<char>::const_iterator &it)
    {
        if constexpr (std::is_same<T, std::string>())
        {
            const auto length = get_out<int>(it);
            auto str = std::string{it, it + length};
            it += length;
 
            return str;
        }
        else
        {
            auto temp = std::array<char, sizeof(T)>{};
            std::copy(it, it + sizeof(T), temp.begin());
            it += sizeof(T);
            T res;
            std::memcpy(&res, temp.data(), sizeof(T));
 
            return res;
        }
    }

    template <typename T>
    std::vector<T> get_out_vec(std::vector<char>::const_iterator &it)
    {
        const auto length = get_out<int>(it);
 
        std::vector<T> res(length);
        for (int i = 0; i < length; ++i) {
            res[i] = get_out<T>(it);
        }
 
        return res;
    }
}
 
#endif //ABLASTR_MSG_LOGGER_SERIALIZATION_H_