chilon Code

#ifndef CHILON_KEY_VALUE_HPP
#define CHILON_KEY_VALUE_HPP

#include <chilon/print.hpp>

#include <utility>

namespace chilon {

struct key_unique {};
struct key_merge  {};
// TODO: struct key_overwrite {};

template <class K, class V, class A = key_unique>
struct key_value : std::pair<K, V> {
    typedef std::pair<K, V>  base;
    typedef A                append_handler;

    key_value(key_value<K, V, A>&& rhs)      : base(std::move(rhs)) {}
    key_value(key_value<K, V, A> const& rhs) : base(rhs) {}

    template <class T, class U>
    key_value(T&& k, U&& v)
      : base(std::forward<T>(k), std::forward<U>(v)) {}
    key_value() {}
};

template <class A, class K, class V>
auto make_key_value(K&& k, V&& v) CHILON_RETURN(
    key_value<typename std::remove_reference<K>::type,
              typename std::remove_reference<V>::type, A>(std::forward<K>(k), std::forward<V>(v)))

template <class K, class V>
auto make_key_value(K&& k, V&& v) CHILON_RETURN(
    key_value<typename std::remove_reference<K>::type,
              typename std::remove_reference<V>::type>(std::forward<K>(k), std::forward<V>(v)))

template <class O, class U, class V, class A, class... T>
inline void print_args(int const indent, O&      stream,
                       key_value<U, V, A> const& head)
{
    print_args(indent, stream, head.first, ": ", head.second);
}

template <class T, class D = void>
struct get_key : meta::type_<D> {};

template <class K, class V, class A, class D>
struct get_key<key_value<K,V,A>, D> : meta::type_<K> {};

template <class T, class D = void>
struct get_value : meta::type_<D> {};

template <class K, class V, class A, class D>
struct get_value<key_value<K,V,A>, D> : meta::type_<V> {};

template <class T, class D = void>
struct get_appender : meta::type_<D> {};

template <class K, class V, class A, class D>
struct get_appender<key_value<K,V,A>, D> : meta::type_<A> {};

}
#endif