optional_field.hpp

Go to the documentation of this file.

// Copyright (C) 2012 iwg molw5
// For conditions of distribution and use, see copyright notice in COPYING

#pragma once

#include <framework/serializable/base_types.hpp>

namespace framework
{
    namespace serializable
    {
        template <typename Specification>
        class output_flags_frame
        {
            template <typename Output>
            friend bool write_dispatch (
                output_flags_frame <Specification>*,
                output_flags_frame <Specification> const& in, Output& out)
            {
                return dispatch_write <Specification> (in.p_iFlags, out);
            }

            private:
                using type = type_extractor <Specification>;

            public:
                void set_flag (type const flag)
                {
                    p_iFlags |= flag;
                }

                bool write (char const*, std::size_t)
                {
                    return true;
                }

            private:
                type p_iFlags {};
        };

        template <typename Specification, typename Stream>
        class input_flags_frame : std::reference_wrapper <Stream>
        {
            private:
                using type = type_extractor <Specification>;

            public:
                input_flags_frame (Stream& stream, type flags)
                    : std::reference_wrapper <Stream> (stream),
                      p_iFlags(flags)
                {
                }

                bool check_flag (type const flag) const
                {
                    return p_iFlags & flag;
                }

                template <std::size_t N>
                bool read (char* s)
                {
                    return stream_read <N> (this->get(), s);
                }

                bool read (char* s, std::size_t n)
                {
                    return stream_read(this->get(), s, n);
                }

            private:
                type const p_iFlags;
        };

        template <typename Type, typename... Specification>
        struct optional_field : public container_type <
            pack_container <Specification...>,
            pack_container <Specification...>,
            false>
        {
        };

        template <
            typename Type, 
            typename... Specification,
            typename Input,
            typename Output>
        bool read_dispatch (
            optional_field <Type, Specification...>*,
            Input& in, Output& out)
        {
            type_extractor <Type> flags;
            if (!dispatch_read <Type> (in, flags))
                return false;

            input_flags_frame <Type, Input> frame {in, flags};
            return dispatch_read <alias <Specification...>> (frame, out);
        }

        template <
            typename Type, 
            typename... Specification,
            typename Input,
            typename Output>
        bool write_dispatch (
            optional_field <Type, Specification...>*,
            Input const& in, Output& out)
        {
            // Write the object state to the flags stream
            output_flags_frame <Type> frame;
            if (!dispatch_write <alias <Specification...>> (in, frame))
                return false;

            // Write the flags stream to the output stream
            if (!write(frame, out))
                return false;

            // Write the object state to the output stream
            if (!dispatch_write <alias <Specification...>> (in, out))
                return false;

            return true;
        }
    }
}