value.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 <tuple>

#include <framework/serializable/base_types.hpp>
#include <framework/serializable/mutator_type.hpp>
#include <framework/serializable/value_type.hpp>
#include <framework/serializable/container_type.hpp>
#include <framework/common/pack_container.hpp>

namespace framework
{
    namespace serializable
    {
        template <
            typename Name,
            typename Specification,
            template <typename> class Implementation>
        struct value_implementation_wrapper
        {
            template <typename Derived>
            struct parameters
            {
                using value_name = Name;

                using value_type = type_extractor <Specification>;

                using value_specification = Specification;

                using derived = Derived;

                using implementation = Implementation <parameters <Derived>>;
            };

            template <typename Derived>
            using type = Implementation <parameters <Derived>>;
        };

        template <typename T>
        struct default_value
        {
            private:
                using value_type = typename T::value_type;

            public:
                value_type const& get () const
                {
                    return p_tValue;
                }

                void set (value_type value)
                {
                    p_tValue = std::move(value);
                }

            protected:
                ~default_value () = default;

                default_value ()
                    : p_tValue()
                {
                }

                default_value (value_type value)
                    : p_tValue(std::move(value))
                {
                }

                default_value (std::tuple <>)
                    : default_value ()
                {
                }

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

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

            protected:
                value_type p_tValue;
        };

        template <
            typename Name,
            typename Specification,
            template <typename> class Implementation = default_value>
        struct value : public value_type <
            Name,
            Specification,
            value_implementation_wrapper <
                Name,
                Specification,
                Implementation
            >::template type>
        {
        };
    }
}