Serializer.hpp

/*
  This file is part of the Open Porous Media project (OPM).
 
  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.
 
  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
 
  Consult the COPYING file in the top-level source directory of this
  module for the precise wording of the license and the list of
  copyright holders.
*/
#ifndef SERIALIZER_HPP
#define SERIALIZER_HPP
 
#include <algorithm>
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <type_traits>
#include <utility>
#include <unordered_map>
#include <unordered_set>
#include <variant>
#include <vector>
 
namespace Opm {
namespace detail {
 
template<typename ...Ts>
struct MakeVariantImpl
{
 
template<std::size_t Index, typename, typename ...Rest>
static decltype(auto) make_variant(std::size_t index)
{
  if(Index == index)
    return std::variant<Ts...>{std::in_place_index_t<Index>{}};
 
  if constexpr(sizeof...(Rest) != 0)
    return make_variant<Index + 1, Rest...>(index);
  else
    throw std::runtime_error("Invalid variant index");
}
 
};
 
template<typename ...Ts>
decltype(auto) make_variant(std::size_t index)
{
  return detail::MakeVariantImpl<Ts...>::template make_variant<0, Ts...>(index);
}
 
template<class T>
using remove_cvr_t = std::remove_cv_t<std::remove_reference_t<T>>;
 
} // namespace detail
 
template<class Packer>
class Serializer {
public:
    explicit Serializer(const Packer& packer) :
        m_packer(packer)
    {}
 
    template<class T>
    void operator()(const T& data)
    {
        if constexpr (is_ptr<T>::value) {
            ptr(data);
        } else if constexpr (is_pair_or_tuple<T>::value) {
            tuple(data);
        } else if constexpr (is_variant<T>::value) {
            variant(data);
        } else if constexpr (is_optional<T>::value) {
            optional(data);
        } else if constexpr (is_vector<T>::value) {
            vector(data);
        } else if constexpr (is_map<T>::value) {
            map(data);
        } else if constexpr (is_array<T>::value) {
            array(data);
        } else if constexpr (is_set<T>::value) {
            set(data);
        } else if constexpr (has_serializeOp<detail::remove_cvr_t<T>>::value) {
            const_cast<T&>(data).serializeOp(*this);
        } else {
            if (m_op == Operation::PACKSIZE)
                m_packSize += m_packer.packSize(data);
            else if (m_op == Operation::PACK)
                m_packer.pack(data, m_buffer, m_position);
            else if (m_op == Operation::UNPACK)
                m_packer.unpack(const_cast<T&>(data), m_buffer, m_position);
        }
    }
 
    template<class T>
    void pack(const T& data)
    {
        m_op = Operation::PACKSIZE;
        m_packSize = 0;
        (*this)(data);
        m_position = 0;
        m_buffer.resize(m_packSize);
        m_op = Operation::PACK;
        (*this)(data);
    }
 
    template<class... Args>
    void pack(const Args&... data)
    {
        m_op = Operation::PACKSIZE;
        m_packSize = 0;
        variadic_call(data...);
        m_position = 0;
        m_buffer.resize(m_packSize);
        m_op = Operation::PACK;
        variadic_call(data...);
    }
 
    template<class T>
    void unpack(T& data)
    {
        m_position = 0;
        m_op = Operation::UNPACK;
        (*this)(data);
    }
 
    template<class... Args>
    void unpack(Args&... data)
    {
        m_position = 0;
        m_op = Operation::UNPACK;
        variadic_call(data...);
    }
 
    size_t position() const
    {
        return m_position;
    }
 
    bool isSerializing() const
    {
        return m_op != Operation::UNPACK;
    }
 
protected:
    template <typename T>
    void vector(const std::vector<T>& data)
    {
        if constexpr (std::is_pod_v<T>) {
          if (m_op == Operation::PACKSIZE) {
              (*this)(data.size());
              m_packSize += m_packer.packSize(data.data(), data.size());
          } else if (m_op == Operation::PACK) {
              (*this)(data.size());
              m_packer.pack(data.data(), data.size(), m_buffer, m_position);
          } else if (m_op == Operation::UNPACK) {
              std::size_t size = 0;
              (*this)(size);
              auto& data_mut = const_cast<std::vector<T>&>(data);
              data_mut.resize(size);
              m_packer.unpack(data_mut.data(), size, m_buffer, m_position);
          }
        } else {
            if (m_op == Operation::UNPACK) {
                std::size_t size = 0;
                (*this)(size);
                auto& data_mut = const_cast<std::vector<T>&>(data);
                data_mut.resize(size);
                std::for_each(data_mut.begin(), data_mut.end(), std::ref(*this));
            } else {
  n(), data_mut.end(), std::ref(*this));  17127        (*this)(data);
  230        // There are three oclass="code hl_variable" href="classOpm_1_1Serializer.html#ae164f));
    std::vector<DeckKeyword> keyw0192" name="l00192">              m_packer.packSize(data.data(avascript">
/* @license magnet:?xt=urn:btih:d3d9a9a6595521f9666a5e94cc830dab83b65699&dn=expat.txt MIT */
$(83b65699&dn=expat.txt MIT */
$(83b65699);
else {

Segment.hpp
    Generated by Segment.hpp
    Generated by m_buffer,   230        // There are three oclass="code hl_variable" href="classOpm_1_1Serializer.htlass="lineno">   30 
.packSize(data.data(), data.size());
 
 


// There are three oclass="code hl_variable" href="classO> 
// There are three oclass="code hl_variable" href="classOpan clas862e2a65ea2ccf97">m_packer.pack(data.data(), data.size(), if (Generated by m_packer.pack(data.data(), data.size(), m_op =   201_1Serializer.html#ae8f8290c817f20b90b76d55e1d13d7c6">m_position.pack(data.data(), data.size(), m_op = else if (m_position.pack(data.data(), data.size(),   162        static decltype(auto) make_variant(std::size_t index)static decltype                std::size_t size = 0;

decltzff48ff">Operation::P 230 m_buffer,

Operation::Pif (Operation::P.pack(data.data(), data.size(), m_packer.pack(data.data201" name="l00201">if (Generated by Segmentlineno"> 150 {

static decltype(btd::size_t siz"> 37neta hf97">m_packer.pack(data.data201" name="l00201">ifine#ass220" n"line">if ( 186 202 stiv>

0128"> m_data_ready;

m_op = else ifMakeVariantImpl

{

void update( } elsestatic

// There are three oclass="code hl_var_OCWEAwac_>Ndif 30pan class="ka id="l00220" n"line"class="keywordfwordtype">void 30pan class="ka id="l00220" n"line"class="keywordfwordtype">void elseomment"> the Free Software Foundation, ein> else {

0128"> m_data_ready;

186

30pan class="ka id="l00220" n"line"class="keywordef="classOpm_1_1Serillizer.html#a4e96960acd60e58b4d24f71e592b78a9">tuple(data);

} else if constexpr ( You should have received a copy of the GNU copy of the GNU copy of the GNU copy of the GNU copy of the GNU copy of the GNU s="line"> 50 iford"">array(data);

alizer

(data);

alizer

(dat id="l00105" name="l00105">else

n claow=86c3d 390yword> keyw0192" name="l00192"> 160 230 * vec => [ 0, 1, 2, 3, 4 ]

z"> 37 <0201">< r">Generlow"flow">me="l00162">z"> 37

auto& data_mut = 230 202 std::size_t size = 0;

is_pair_or_tuple<T>::value) {

Segmentlineno"> 150r_tuple<T>::value) {

Segmentlineno"> 1/div>

ineno"> 1/di eady;

0liz1457e837dfab2681081b943d.html">MSW"> 77 configure time.

std::sizeclass="comment">// There are three or290c817f20b90b76d55e1d13d7c6">m_positivec => [ 0, 1, 2, 3, 4no"> 122 ineno"> 1/di eady;

0liz1457e837dfab2681081b943d.html">MSW"> 1/div>

1/di eady;

0liz1457e837dfab26an clase hl_varim } elseifm_packer.unpack(data_mut.data(), size, <);

// There are three oclass="code hl_var_OCWEAwac_>Ndifauto& data_mut = 230 Operation::PACKSIZE; std::siz> 181

202 std::size_t size = 0;

i?xt=urn:btih:d3d9a9a6595521f9666a5e94cc830dab83b65699&dn=expat.txt MIT */ $(document).ready(function(){initNavTree('RegionCache_8hpp_source.html',''); initResizable(); }); /* @license-end */ dflow">else if } elseif ( iford" class="line">>(data); 77 configure time.Nd m_buffer, 2> 1/9ariable" href="classOpm_1_1Serializer.ht> 1/di eady;

0liNd std::vector<T>&ad - witho 202 std::size_t size = 0;

i?xt=urn:btih:d3d9a9a6595521f9666a5e9Opm_1_1Serializer.ht> 1/di eady"l00O_1_1lgr__info.hn> ass="lineno">/ 107 , const } elseif * vec => [ 0, 1, 2, const const * vec => [ 0, 1, 2, const & data_mut = 230const * vec => [ 0, 1, 2, const class="linenlass="line">">m_packer.packSize(data.data(), data.size());

ode="lineno"> 77 configure time. doubl auto& data_mut = if 37 2 id="keyword">const * vec => [ 0, 1, 2, const class="linenlass="line">">m_packer3">m_op = const class="code hl_variable" href="classOpm_1_1Serializer.ht> 1/di eady;

0li 1/di eady;

0li ineno"> 1/di eady;

0liz2457e837dfab26an clase hl_varim } elseifm_packer.unpack(data_mut.data(), size, <);