serialization2.h

Go to the documentation of this file.

// -*- mode: c++; tab-width: 4; indent-tabs-mode: t; eval: (progn (c-set-style "stroustrup") (c-set-offset 'innamespace 0)); -*-
// vi:set ts=4 sts=4 sw=4 noet :
// Copyright 2010, The TPIE development team
// 
// This file is part of TPIE.
// 
// TPIE is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the
// Free Software Foundation, either version 3 of the License, or (at your
// option) any later version.
// 
// TPIE 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 Lesser General Public
// License for more details.
// 
// You should have received a copy of the GNU Lesser General Public License
// along with TPIE.  If not, see <http://www.gnu.org/licenses/>
 
#ifndef TPIE_SERIALIZATION2_H
#define TPIE_SERIALIZATION2_H
 
 
#include <tpie/config.h>
#include <tpie/portability.h>
#include <typeinfo>
#include <type_traits>
#include <tpie/is_simple_iterator.h>
#include <tpie/tuple_utils.h>
#include <array>
#include <tpie/array.h>
 
namespace tpie {
 
#ifdef DOXYGEN
 
// The following two declarations are for documentation purposes only.
 
template <typename D>
void serialize(D & dst, const foo & v);
 
template <typename S>
void unserialize(S & src, foo & v);
 
#endif // DOXYGEN
// Library implementations of tpie::serialize and tpie::unserialize.
 
template <typename T>
struct is_trivially_serializable {
    static bool const value
        = std::is_trivially_copyable<T>::value && !std::is_pointer<T>::value;
};
 
template <typename D, typename T>
void serialize(D & dst, const T & v,
               typename std::enable_if<is_trivially_serializable<T>::value>::type * = 0) {
    dst.write((const char *)&v, sizeof(T));
}
 
template <typename S, typename T>
void unserialize(S & src, T & v,
                 typename std::enable_if<is_trivially_serializable<T>::value>::type * = 0) {
    src.read((char *)&v, sizeof(T));
}
 
namespace bits {
 
template <typename D, typename T,
          bool is_simple_itr=tpie::is_simple_iterator<T>::value,
          bool is_ts=is_trivially_serializable<typename std::iterator_traits<T>::value_type>::value>
struct array_encode_magic {
    void operator()(D & dst, T start, T end) {
        using tpie::serialize;
        for (T i=start; i != end; ++i) serialize(dst, *i);
    }
};
 
template <typename D, typename T>
struct array_encode_magic<D, T, true, true> {
    void operator()(D & d, T start, T end) {
        if (start == end) {
            // Do not dereference two iterators pointing to null
            return;
        }
        // We can't derefence end
        auto element_size = sizeof(typename std::iterator_traits<T>::value_type);
        d.write(reinterpret_cast<const char *>(&*start), (end - start) * element_size);
    }
};
 
template <typename D, typename T,
          bool is_simple_itr=tpie::is_simple_iterator<T>::value,
          bool is_ts=is_trivially_serializable<typename std::iterator_traits<T>::value_type>::value>
struct array_decode_magic {
    void operator()(D & dst, T start, T end) {
        using tpie::unserialize;
        for (T i=start; i != end; ++i) unserialize(dst, *i);
    }
};
 
template <typename D, typename T>
struct array_decode_magic<D, T, true, true> {
    void operator()(D & d, T start, T end) {
        if (start == end) {
            // Do not dereference two iterators pointing to null
            return;
        }
        // We can't derefence end
        auto element_size = sizeof(typename std::iterator_traits<T>::value_type);
        d.read(reinterpret_cast<char *>(&*start), (end - start) * element_size);
    }
};
 
struct counter {
    size_t size;
    counter(): size(0) {}
    void write(const void *, size_t s) {size += s;}
};
 
} // namespace bits
 
template <typename D, typename T>
void serialize(D & dst, T start, T end) {
    bits::array_encode_magic<D, T> magic;
    magic(dst, start, end);
}
 
template <typename D, typename T>
void unserialize(D & dst, T start, T end) {
    bits::array_decode_magic<D, T> magic;
    magic(dst, start, end);
}
 
template <typename D, typename T, std::size_t size>
void serialize(D & dst, const T (&x)[size]) {
    using tpie::serialize;
    serialize(dst, x, &x[size]);
}
 
template <typename S, typename T, std::size_t size>
void unserialize(S & src, T (&x)[size]) {
    using tpie::unserialize;
    unserialize(src, x, &x[size]);
}
 
template <typename D, typename T, std::size_t size>
void serialize(D & dst, const std::array<T, size> & v) {
    using tpie::serialize;
    serialize(dst, v.begin(), v.end());
}
 
template <typename S, typename T, std::size_t size>
void unserialize(S & src, std::array<T, size> & v) {
    using tpie::unserialize;
    unserialize(src, v.begin(), v.end());
}
 
template <typename D, typename T, typename alloc_t>
void serialize(D & dst, const std::vector<T, alloc_t> & v) {
    using tpie::serialize;
    serialize(dst, v.size());
    serialize(dst, v.begin(), v.end());
}
 
template <typename S, typename T, typename alloc_t>
void unserialize(S & src, std::vector<T, alloc_t> & v) {
    typename std::vector<T>::size_type s;
    using tpie::unserialize;
    unserialize(src, s);
    v.resize(s);
    unserialize(src, v.begin(), v.end());
}
 
template <typename D, typename T>
void serialize(D & dst, const tpie::array<T> & v) {
    using tpie::serialize;
    serialize(dst, v.size());
    serialize(dst, v.begin(), v.end());
}
 
template <typename S, typename T>
void unserialize(S & src, tpie::array<T> & v) {
    size_type s;
    using tpie::unserialize;
    unserialize(src, s);
    v.resize(s);
    unserialize(src, v.begin(), v.end());
}
 
template <typename D, typename T>
void serialize(D & dst, const std::basic_string<T> & v) {
    using tpie::serialize;
    serialize(dst, v.size());
    serialize(dst, v.c_str(), v.c_str() + v.size());
}
 
template <typename S, typename T>
void unserialize(S & src, std::basic_string<T> & v) {
    typename std::basic_string<T>::size_type s;
    using tpie::unserialize;
    unserialize(src, s);
    v.resize(s);
    unserialize(src, v.c_str(), v.c_str() + v.size());
}
 
template <typename D, typename T, typename U>
void serialize(D & dst, const std::pair<T,U> & v) {
    using tpie::serialize;
    serialize(dst, v.first);
    serialize(dst, v.second);
}
 
template <typename S, typename T, typename U>
void unserialize(S & src, std::pair<T,U> & v) {
    using tpie::unserialize;
    unserialize(src, v.first);
    unserialize(src, v.second);
}
 
template <typename D, typename... Ts>
void serialize(D & dst, const std::tuple<Ts...> & t) {
    tuple_for_each([&](const auto & el) {
        using tpie::serialize;
        serialize(dst, el);
    }, t);
}
 
template <typename S, typename... Ts>
void unserialize(S & src, std::tuple<Ts...> & t) {
    tuple_for_each([&](auto & el) {
        using tpie::unserialize;
        unserialize(src, el);
    }, t);
}
 
template <typename T>
size_t serialized_size(const T & v) {
    using tpie::serialize;
    bits::counter c;
    serialize(c, v);
    return c.size;
}
 
} // namespace tpie
 
#endif // TPIE_SERIALIZATION2_H