Serializer design document

    class Serializer
    {
    public:
        // interface
        class Serializable {};
        // could be binary or textual
        class InOutStream {};

        template<typename T>
        /* insert SFINAE here */ Serializer & operator << (const T & data)
        {
            ordered.append(data);
        }

        template<typename T>
        /* insert SFINAE here */ Serializer & operator >> (T & data)
        {
            ordered.extract(data);
        }

        template<typename C>
        auto operator << (C & data) -> decltype(std::advance(data.begin() - data.end()), Serializer &)
        {
            ordered.append((std::uint64_t)std::advance(data.begin() - data.end());
            std::for_each(data.begin(), data.end(),
                [this](auto & it)
                {
                    // selects local operator for primitives, global operator for complex
                    (*this) << *it;
                }
            );
        }

        template<typename C>
        auto operator >> (C & data) -> decltype(append(data, *data.begin()), Serializer &)
        {
            std::uint64_t size;
            ordered.extract(size);

            typedef std::iterator_traits<decltype(data.begin())>::value_type Type;

            while (size--> 0)
            {
                Type element;
                (*this) >> element;
                // some templated function
                append(data, std::move(element));
            }
        }

        Serializer & operator [] (const std::string & s)
        {
            return unordered[s];
        }

        std::pair<std::size_t, std::unique_ptr<char[]>> compile();
        void build(std::pair<std::size_t, std::unique_ptr<char[]>>);


    private:
        InOutStream unordered;
        std::map<std::string, Serializer> ordered;
    };


    Serializer & operator << (Serializer & left, const Serializer::Serializable & right)
    {
        return right.save(left, left.getVersion());
    }

    Serializer & operator >> (Serializer & left, Serializer::Serializable & right)
    {
        return right.load(left, left.getVersion());
    }

    class Y : public Serializer::Serializable
    {
        void load(Serializer & s, const Version v) override
        {
            data.clear();
            s >> data;
        }

        void save(Serializer & s, const Version v) override
        {
            s << data;
        }

        std::vector<Y> data;
    };

    class X : public Serializer::Serializable
    {
        void load(Serializer & s, const Version v) override
        {
            // primitives, ordered
            s >> x >> k;
            s >> y1;

            // non-ordered data
            if (v > Version(0, 1, 0))
                s["data"]["something"] >> y2;

        }

        void save(Serializer & s, const Version v) override
        {
            // primitives, ordered data
            s << x << k;
            s << y2;

            // non-ordered data
            if(v > Version(0, 1, 0))
                ss["data"]["something"] << y2;

        }

        std::uint32_t x, k;
        Y y1, y2;
    };

    void test()
    {
        {
            X x;
            Serializer s;
            s << x;

            writeFile(s.compile());
        }

        {
            X x;
            Serializer s;
            s.build(readFile());

            s >> x;
        }
    }