inline_object.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/serializable.hpp>
#include <framework/serializable/utility/comparable.hpp>
#include <framework/serializable/common_macros.hpp>

namespace framework
{
    namespace serializable
    {
        template <typename... Types>
        class inline_object : 
            public serializable <inline_object <Types...>, Types...>,
            public comparable <inline_object <Types...>>
        {
            private:
                DEFINE_BASE_TEMPLATE(inline_object <Types...>);

            public:
                inline_object () = default;
                inline_object (inline_object const&) = default;
                inline_object (inline_object&&) = default;
                inline_object& operator= (inline_object const&) = default;
                inline_object& operator= (inline_object&&) = default;

                template <typename... Args>
                inline_object (Args&&... args)
                    : serializable <inline_object <Types...>, Types...> (std::forward <Args> (args)...)
                {
                }

                inline_object (std::tuple <>)
                    : inline_object ()
                {
                }
                
                template <typename... Args>
                inline_object (std::tuple <Args...>&& args)
                    : inline_object (
                        std::forward <std::tuple <Args...>> (args), 
                        static_cast <make_indices <sizeof... (Args)>*> (nullptr))
                {
                }

            private:
                template <typename... Args, typename... Indices>
                inline_object (std::tuple <Args...> args, pack_container <Indices...>*)
                    : serializable <inline_object <Types...>, Types...> (std::forward <Args> (std::get <Indices::value> (args))...)
                {
                }

           public:
                template <typename Name, typename... Args>
                auto get (Args&&... args) const ->
                decltype(std::declval <base <Name>> ().get(std::forward <Args> (args)...))
                {
                    return base <Name>::get(std::forward <Args> (args)...);
                }

                template <typename Name, typename... Args>
                auto set (Args&&... args) ->
                decltype(std::declval <base <Name>> ().set(std::forward <Args> (args)...))
                {
                    return base <Name>::set(std::forward <Args> (args)...);
                }

                template <typename Name, typename... Args>
                auto check (Args&&... args) const ->
                decltype(std::declval <base <Name>> ().check(std::forward <Args> (args)...))
                {
                    return base <Name>::check(std::forward <Args> (args)...);
                }

                template <typename Name, typename... Args>
                auto clear (Args&&... args) ->
                decltype(std::declval <base <Name>> ().clear(std::forward <Args> (args)...))
                {
                    return base <Name>::clear(std::forward <Args> (args)...);
                }
        };
    }
}