map.hpp

// Copyright (C) 2013, Ennio Barbaro.
//
// Use, modification, and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://sbabbi.github.io/tinympl for documentation.
//
// You are welcome to contact the author at:
//  enniobarbaro@gmail.com
//

#ifndef TINYMPL_MAP_HPP
#define TINYMPL_MAP_HPP

#include <tinympl/equal_to.hpp>
#include <tinympl/variadic/all_of.hpp>
#include <tinympl/variadic/is_unique.hpp>
#include <tinympl/variadic/find.hpp>
#include <tinympl/variadic/at.hpp>
#include <tinympl/variadic/left_fold.hpp>
#include <tinympl/variadic/remove_if.hpp>
#include <tinympl/unordered_equal.hpp>
#include <tinympl/sequence.hpp>
#include <type_traits>
#include <utility>

namespace tinympl {

template<class T> struct is_pair : std::false_type {};

template<class FirstType,class SecondType>
struct is_pair<std::pair<FirstType,SecondType> > : std::true_type
{
    typedef FirstType first_type;
    typedef SecondType second_type;
};

template<class ... Args> struct map
{
    static_assert( variadic::all_of< is_pair, Args...>::type::value, "All the arguments of a map must be key/value pairs");
    static_assert( variadic::is_unique<typename Args::first_type ...>::type::value,"Duplicate keys in the map");

    template<class T>
    struct at
    {
        enum {index = variadic::find<T, typename Args::first_type ... >::type::value };

        static_assert(index < sizeof...(Args),"Key T not present in the map");

        typedef typename variadic::at<index,Args...>::type::second_type type;
    };

    enum
    {
        size = sizeof ... (Args) 
    };

    enum
    {
        empty = (size == 0) 
    };

    template<class Key>
    using count = std::integral_constant<
            std::size_t,
            (variadic::find<Key, typename Args::first_type ... >::type::value == size ? 0 : 1)>;

    template<class Key,class Value>
    struct insert : std::conditional<
            count<Key>::type::value == 0,
            map<Args..., std::pair<Key,Value> >,
            map<Args...> > {};

    template<class ... KeyValuePairs>
    struct insert_many
    {
        static_assert( variadic::all_of< is_pair, KeyValuePairs...>::type::value, "All the arguments of insert_many must be key/value pairs");
        template<class Map,class T> using insert_one_t = typename Map::template insert<typename T::first_type, typename T::second_type>;

        typedef typename variadic::left_fold<insert_one_t,map,KeyValuePairs...>::type type;
    };

    template<class Key>
    class erase
    {
        template<class T> using key_comparer = std::is_same<typename T::first_type,Key>;

    public:
        typedef typename variadic::remove_if< key_comparer, tinympl::map, Args...>::type type;
    };
};

template<class ... As,class ... Bs>
struct equal_to< map<As...>, map<Bs...> > : unordered_equal< sequence<As...>, sequence<Bs...> > {};

}

#endif // TINYMPL_MAP_HPP