datapack.h

Go to the documentation of this file.

#ifndef FPMAS_IO_DATAPACK_H
#define FPMAS_IO_DATAPACK_H
 
#include <string>
#include <set>
#include <list>
#include <deque>
 
#include "fpmas/api/communication/communication.h"
#include "../api/utils/ptr_wrapper.h"
 
namespace fpmas { namespace io { namespace datapack {
    using fpmas::api::communication::DataPack;
    using api::utils::PtrWrapper;
 
    template<typename T, typename Enable = void>
        struct Serializer {
        };
 
    template<template<typename, typename Enable = void> class S>
        class BasicObjectPack {
            friend Serializer<std::string>;
            friend Serializer<BasicObjectPack<S>>;
 
            private:
            DataPack _data {0, 1};
            std::size_t write_offset = 0;
            mutable std::size_t read_offset = 0;
 
            public:
            BasicObjectPack() = default;
 
            template<typename T>
                BasicObjectPack(const T& item) {
                    std::size_t count = S<T>::size(*this, item); 
                    this->allocate(count);
                    S<T>::to_datapack(*this, item);
                    write_offset+=count;
                }
 
            template<typename T>
                BasicObjectPack<S>& operator=(const T& item) {
                    this->allocate(S<T>::size(*this, item));
                    S<T>::to_datapack(*this, item);
                    return *this;
                }
 
            template<typename T>
                std::size_t size() const {
                    return S<T>::size(*this);
                }
 
            template<typename T>
                std::size_t size(const T& item) const {
                    return S<T>::size(*this, item);
                }
 
            const DataPack& data() const {
                return _data;
            }
 
            std::size_t readOffset() const {
                return read_offset;
            }
 
            void seekRead(std::size_t offset = 0) const {
                read_offset = offset;
            }
 
            std::size_t writeOffset() const {
                return write_offset;
            }
 
            void seekWrite(std::size_t offset = 0) {
                write_offset = offset;
            }
 
            template<typename T>
                void put(const T& item) {
                    S<T>::to_datapack(*this, item);
                }
 
            template<typename T>
                T get() const {
                    T item = S<T>::from_datapack(*this);
                    return item;
                }
 
            void allocate(std::size_t size) {
                _data = {size, 1};
            }
 
            void expand(std::size_t size) {
                _data.resize(_data.size + size);
            }
 
            template<typename T>
                void write(const T& item) {
                    std::size_t count = sizeof(T);
                    std::memcpy(&_data.buffer[write_offset], &item, count);
                    write_offset+=count;
                }
 
            void write(const void* input_data, std::size_t count) {
                    std::memcpy(&_data.buffer[write_offset], input_data, count);
                    write_offset+=count;
            }
 
            template<typename T>
                void read(T& item) const {
                    std::size_t count = sizeof(T);
                    std::memcpy(&item, &_data.buffer[read_offset], count);
                    read_offset+=count;
                }
 
            void read(void* output_data, std::size_t count) const {
                std::memcpy(output_data, &_data.buffer[read_offset], count);
                read_offset+=count;
            }
 
            template<typename T>
                T check() const {
                    T item;
                    check(item);
                    return item;
                }
 
            template<typename T>
                void check(T& item) const {
                    std::size_t pos = readOffset();
                    read(item);
                    seekRead(pos);
                }
 
            DataPack dump() {
                write_offset = 0;
                read_offset = 0;
                return std::move(_data);
            }
 
            static BasicObjectPack<S> parse(DataPack&& data_pack) {
                BasicObjectPack<S> pack;
                pack._data = std::move(data_pack);
                return pack;
            }
 
            static BasicObjectPack<S> parse(const DataPack& data_pack) {
                BasicObjectPack<S> pack;
                pack._data = data_pack;
                return pack;
            }
 
            BasicObjectPack<S> extract(std::size_t size) const {
                BasicObjectPack<S> pack;
                pack.allocate(size);
                std::memcpy(
                        pack._data.buffer,
                        &this->_data.buffer[this->read_offset],
                        size
                        );
                this->read_offset+=size;
                return pack;
            }
        };
 
    template<template<typename, typename> class S>
        struct Serializer<BasicObjectPack<S>> {
 
            template<typename PackType>
                static std::size_t size(
                        const PackType&, const BasicObjectPack<S>&) {
                    return sizeof(std::size_t);
                }
 
            template<typename PackType>
                static void to_datapack(
                        PackType& parent, const BasicObjectPack<S>& child) {
                    parent.write(child._data.size);
                    parent.expand(child._data.size);
                    parent.write(child._data.buffer, child._data.size);
                }
 
            template<typename PackType>
                static BasicObjectPack<S> from_datapack(const PackType& parent) {
                    std::size_t size;
                    parent.read(size);
 
                    BasicObjectPack<S> child;
                    child.allocate(size);
                    parent.read(child._data.buffer, size);
                    return child;
                }
        };
 
    template<typename T>
        struct Serializer<T, typename std::enable_if<std::is_fundamental<T>::value>::type> {
            template<typename PackType>
                static std::size_t size(const PackType&) {
                    return sizeof(T);
                }
 
            template<typename PackType>
                static std::size_t size(const PackType&, const T&) {
                    return sizeof(T);
                }
 
 
            template<typename PackType>
                static void to_datapack(PackType& pack, const T& item) {
                    pack.write(item);
                }
 
            template<typename PackType>
                static T from_datapack(const PackType& pack) {
                    T item;
                    pack.read(item);
                    return item;
                }
        };
 
    template<>
        struct Serializer<std::string> {
            template<typename PackType>
                static std::size_t size(const PackType&, const std::string& str) {
                    return sizeof(std::size_t) + str.size();
                }
 
            template<typename PackType>
                static void to_datapack(PackType& pack, const std::string& str) {
                    pack.write(str.size());
                    pack.write(str.data(), str.size());
                }
 
            template<typename PackType>
                static std::string from_datapack(const PackType& pack) {
                    std::size_t size;
                    pack.read(size);
 
                    std::string str(&pack.data().buffer[pack.readOffset()], size);
                    pack.seekRead(pack.readOffset() + size);
                    return str;
                }
        };
 
    template<typename T>
        struct Serializer<std::vector<T>> {
            template<typename PackType>
                static std::size_t size(const PackType& p, const std::vector<T>& vec) {
                    std::size_t n = p.template size<std::size_t>();
                    for(const T& item : vec)
                        n += p.template size(item);
                    return n;
                }
 
            template<typename PackType>
                static void to_datapack(PackType& pack, const std::vector<T>& vec) {
                    pack.template put(vec.size());
                    for(const T& item : vec)
                        pack.template put(item);
                }
 
            template<typename PackType>
                static std::vector<T> from_datapack(const PackType& pack) {
                    std::size_t size = pack.template get<std::size_t>();
                    std::vector<T> data;
                    data.reserve(size);
                    for(std::size_t i = 0; i < size; i++)
                        data.emplace_back(pack.template get<T>());
                    return data;
                }
        };
 
 
    template<typename T>
        struct Serializer<std::set<T>> {
            template<typename PackType>
            static std::size_t size(const PackType& p, const std::set<T>& set) {
                std::size_t n = p.template size<std::size_t>();
                for(const T& item : set)
                    n += p.template size(item);
                return n;
            }
 
            template<typename PackType>
                static void to_datapack(PackType& pack, const std::set<T>& set) {
                    pack.template put(set.size());
                    // Items are written in order
                    for(const T& item : set)
                        pack.template put(item);
                }
 
            template<typename PackType>
                static std::set<T> from_datapack(const PackType& pack) {
                    std::size_t size = pack.template get<std::size_t>();
                    std::set<T> set;
                    auto current_hint = set.end();
                    for(std::size_t i = 0; i < size; i++) {
                        // Constant time insertion before end, since data is
                        // already sorted.
                        set.emplace_hint(current_hint, pack.template get<T>());
                        // Updates hint
                        current_hint = set.end();
                    }
                    return set;
                }
        };
 
    template<typename T>
        struct Serializer<std::list<T>> {
 
            template<typename PackType>
                static std::size_t size(const PackType& p, const std::list<T>& list) {
                    std::size_t n = p.template size<std::size_t>();
                    for(const T& item : list)
                        n += p.template size(item);
                    return n;
                }
 
            template<typename PackType>
                static void to_datapack(PackType& pack, const std::list<T>& list) {
                    pack.template put(list.size());
                    // Items are written in order
                    for(const T& item : list)
                        pack. template put(item);
                }
 
            template<typename PackType>
                static std::list<T> from_datapack(const PackType& pack) {
                    std::size_t size = pack.template get<std::size_t>();
                    std::list<T> data;
                    for(std::size_t i = 0; i < size; i++) {
                        data.emplace_back(pack.template get<T>());
                    }
                    return data;
                }
        };
 
    template<typename T>
        struct Serializer<std::deque<T>> {
            template<typename PackType>
                static std::size_t size(const PackType& p, const std::deque<T>& deque) {
                    std::size_t n = p.template size<std::size_t>();
                    for(auto item : deque)
                        n += p.template size(item);
                    return n;
                }
 
            template<typename PackType>
                static void to_datapack(PackType& pack, const std::deque<T>& deque) {
                    pack.template put(deque.size());
                    // Items are written in order
                    for(const T& item : deque)
                        pack.template put(item);
                }
 
            template<typename PackType>
                static std::deque<T> from_datapack(const PackType& pack) {
                    std::size_t size = pack.template get<std::size_t>();
                    std::deque<T> deque;
                    for(std::size_t i = 0; i < size; i++) {
                        deque.emplace_back(pack.template get<T>());
                    }
                    return deque;
                }
        };
 
    template<typename T1, typename T2>
        struct Serializer<std::pair<T1, T2>> {
            template<typename PackType>
                static std::size_t size(const PackType& p, const std::pair<T1, T2>& pair) {
                    return p.template size(pair.first)
                        + p.template size(pair.second);
                }
 
            template<typename PackType>
                static void to_datapack(
                        PackType& pack, const std::pair<T1, T2>& pair) {
                    pack.template put(pair.first);
                    pack.template put(pair.second);
                }
 
            template<typename PackType>
                static std::pair<T1, T2> from_datapack(const PackType& pack) {
                    // Call order guaranteed, DO NOT CALL gets FROM THE CONSTRUCTOR
                    T1 first = pack.template get<T1>();
                    T2 second = pack.template get<T2>();
                    return {std::move(first), std::move(second)};
                }
        };
 
    template<typename K, typename T, typename Comp, typename Alloc>
        struct Serializer<std::map<K, T, Comp, Alloc>> {
            template<typename PackType>
                static std::size_t size(
                        const PackType& p,
                        const std::map<K, T, Comp, Alloc>& map) {
                    std::size_t n = p.template size<std::size_t>();
                    for(const auto& item : map)
                        n += p.template size(item);
                    return n;
                }
 
            template<typename PackType>
                static void to_datapack(
                        PackType& pack,
                        const std::map<K, T, Comp, Alloc>& map) {
                    pack.template put(map.size());
                    // Items are written in order
                    for(const auto& item : map)
                        pack.template put(item);
                }
 
            template<typename PackType>
                static std::map<K, T, Comp, Alloc> from_datapack(
                        const PackType& pack) {
                    std::size_t size = pack.template get<std::size_t>();
                    std::map<K, T> map;
                    for(std::size_t i = 0; i < size; i++)
                        map.emplace_hint(
                                map.end(), pack.template get<std::pair<K, T>>());
                    return map;
                }
        };
 
    template<typename K, typename T, typename Hash, typename KeyEq, typename Alloc>
        struct Serializer<std::unordered_map<K, T, Hash, KeyEq, Alloc>> {
            template<typename PackType>
                static std::size_t size(
                        const PackType& p,
                        const std::unordered_map<K, T, Hash, KeyEq, Alloc>& map) {
                    std::size_t n = p.template size<std::size_t>();
                    for(const auto& item : map)
                        n += p.template size(item);
                    return n;
                }
 
            template<typename PackType>
                static void to_datapack(
                        PackType& pack,
                        const std::unordered_map<K, T, Hash, KeyEq, Alloc>& map) {
                    pack.template put(map.size());
                    // Items are written in order
                    for(const auto& item : map)
                        pack.template put(item);
                }
 
            template<typename PackType>
                static std::unordered_map<K, T, Hash, KeyEq, Alloc> from_datapack(
                        const PackType& pack) {
                    std::size_t size = pack.template get<std::size_t>();
                    std::unordered_map<K, T> map;
                    map.reserve(size);
                    for(std::size_t i = 0; i < size; i++)
                        map.emplace(pack.template get<std::pair<K, T>>());
                    return map;
                }
        };
 
    template<typename T, std::size_t N>
        struct Serializer<std::array<T, N>> {
            template<typename PackType>
                static std::size_t size(const PackType& p, const std::array<T, N>& array) {
                    std::size_t n = 0;
                    for(const T& item : array)
                        n += p.template size(item);
                    return n;
                }
 
            template<typename PackType>
                static void to_datapack(PackType& pack, const std::array<T, N>& array) {
                    for(const T& item : array)
                        pack.template put(item);
                }
 
            template<typename PackType>
                static std::array<T, N> from_datapack(const PackType& pack) {
                    std::array<T, N> array;
                    for(std::size_t i = 0; i < N; i++)
                        array[i] = pack.template get<T>();
                    return array;
                }
        };
 
    template<>
        struct Serializer<DistributedId> {
            template<typename PackType>
                static std::size_t size(const PackType& p) {
                    return
                        p.template size<int>()
                        + p.template size<FPMAS_ID_TYPE>();
                }
 
            template<typename PackType>
                static std::size_t size(const PackType& p, const DistributedId&) {
                    return size(p);
                }
            template<typename PackType>
                static void to_datapack(PackType& pack, const DistributedId& id) {
                    pack.template put(id.rank());
                    pack.template put(id.id());
                }
            template<typename PackType>
                static DistributedId from_datapack(const PackType& pack) {
                    // Call order guaranteed, DO NOT CALL gets FROM THE CONSTRUCTOR
                    int p = pack.template get<int>();
                    FPMAS_ID_TYPE id = pack.template get<FPMAS_ID_TYPE>();
                    return {p, id};
                }
        };
 
    typedef BasicObjectPack<Serializer> ObjectPack;
 
    template<typename T, typename> struct LightSerializer;
 
    typedef BasicObjectPack<LightSerializer> LightObjectPack;
 
    template<typename T, typename Enable = void>
        struct LightSerializer {
            static std::size_t size(const LightObjectPack& p) {
                return Serializer<T>::size(p);
            }
 
            static std::size_t size(const LightObjectPack& p, const T& item) {
                return Serializer<T>::size(p, item);
            }
 
            static void to_datapack(LightObjectPack& pack, const T& item) {
                Serializer<T>::to_datapack(pack, item);
            }
 
            static T from_datapack(const LightObjectPack& pack) {
                return Serializer<T>::from_datapack(pack);
            }
        };
 
    template<template<typename, typename> class S>
        std::ostream& operator<<(std::ostream& o, const BasicObjectPack<S>& pack) {
            o.setf(std::ios_base::hex, std::ios_base::basefield);
            o.setf(std::ios_base::showbase);
            for(std::size_t i = 0; i < pack.data().size; i++)
                o << (unsigned short) pack.data().buffer[i] << " ";
            o.unsetf(std::ios_base::showbase);
            o.unsetf(std::ios_base::hex);
            return o;
        }
}}}
#endif