IdentifierGroupSerializer.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/io/BufferInputStreamAdapter.h"
#include "catapult/io/PodIoUtils.h"
#include "catapult/io/StringOutputStream.h"
 
namespace catapult { namespace cache {
 
    template<typename TDescriptor>
    class IdentifierGroupSerializer {
    private:
        using KeyType = typename TDescriptor::KeyType;
        using ValueType = typename TDescriptor::ValueType; // this is expected to be IdentifierGroup
 
    public:
        static std::string SerializeValue(const ValueType& value) {
            io::StringOutputStream output(Size(value));
 
            io::Write(output, value.key());
            io::Write64(output, static_cast<uint64_t>(value.size()));
            for (const auto& identifier : value.identifiers())
                Write(output, identifier);
 
            return output.str();
        }
 
        static ValueType DeserializeValue(const RawBuffer& buffer) {
            io::BufferInputStreamAdapter<RawBuffer> input(buffer);
            auto key = io::Read<typename ValueType::GroupingKeyType>(input);
            ValueType value(key);
 
            auto size = io::Read64(input);
            for (auto i = 0u; i < size; ++i) {
                typename ValueType::Identifiers::key_type identifier;
                Read(input, identifier);
                value.add(identifier);
            }
 
            return value;
        }
 
    private:
        template<typename T>
        static void Read(io::InputStream& input, T& value) {
            io::Read(input, value);
        }
 
        template<size_t N, typename TTag>
        static void Read(io::InputStream& input, utils::ByteArray<N, TTag>& value) {
            input.read(value);
        }
 
        template<typename T>
        static void Write(io::OutputStream& input, const T& value) {
            io::Write(input, value);
        }
 
        template<size_t N, typename TTag>
        static void Write(io::OutputStream& input, const utils::ByteArray<N, TTag>& value) {
            input.write(value);
        }
 
    private:
        static size_t Size(const ValueType& value) {
            return sizeof(KeyType) + value.identifiers().size() * sizeof(ValueType);
        }
    };
}}