container_type.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>
#include <framework/common/common_macros.hpp>
#include <framework/common/pack_container.hpp>

namespace framework
{
    namespace serializable
    {
        namespace detail
        {
            template <typename T>
            struct recursive_serializable_specification;
        
            template <typename T, typename Enabler = void>
            struct is_container_type_impl;

            template <typename T, typename Enabler = void>
            struct is_container_default_serializable_impl;

            template <typename T>
            struct container_specification_impl;

            template <typename T>
            struct container_children_impl;
        }

        template <
            typename Specification,
            typename Children,
            bool Default = true>
        struct container_type
        {
// GCC bug workaround - www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#580
#if MAX_GNUC_VERSION(4, 8, 0)
            public:
#else
            template <typename T, typename Enabler>
            friend struct detail::is_container_type_impl;
            
            template <typename T, typename Enabler>
            friend struct detail::is_container_default_serializable_impl;

            template <typename T>
            friend struct detail::container_specification_impl;
            
            template <typename T>
            friend struct detail::container_children_impl;
            
            private:
#endif
                using serializable_container_enabler = void;
                using serializable_container_specification = typename std::enable_if <is_pack_container <Specification>::value, Specification>::type;
                using serializable_container_children = typename std::enable_if <is_pack_container <Children>::value, Children>::type;
                enum{ serializable_container_default = Default };

                container_type () = delete;
                ~container_type () = delete;
        };
        
        template <typename T>
        using is_container_type = typename detail::is_container_type_impl <T>::type;

        template <typename T>
        using is_container_default_serializable = typename detail::is_container_default_serializable_impl <T>::type;

        template <typename T>
        using container_specification = typename detail::container_specification_impl <T>::type;

        template <typename T>
        using container_children = typename detail::container_children_impl <T>::type;

        template <
            typename Specification,
            typename Children,
            typename... Args>
        FRAMEWORK_ALWAYS_INLINE
        bool read_dispatch (
            container_type <Specification, Children, true>*,
            Args&&... args)
        {
            return detail::recursive_serializable_specification <Specification>::read(std::forward <Args> (args)...);
        }

        template <
            typename Specification,
            typename Children,
            typename... Args>
        FRAMEWORK_ALWAYS_INLINE
        bool write_dispatch (
            container_type <Specification, Children, true>*,
            Args&&... args)
        {
            return detail::recursive_serializable_specification <Specification>::write(std::forward <Args> (args)...);
        }
    }
}

#include <framework/serializable/container_type.inl>