// Copyright David Abrahams 2003. 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)

#include <cstddef>
#include <iostream>
#include <boost/mpl/apply_if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/implicit_cast.hpp>

namespace test  {
namespace mpl = boost::mpl;

struct named_base {};

template <class KW, class T>
struct named : named_base
{
    typedef KW key_type;
    typedef T value_type;
    
    named(T& x) : value(x) {}
    
    template <class Default>
    T& get( Default const& ) const
    { return value; }
    
    T& get() const
    { return value; }
    
    T& value;
};

template <class Derived>
struct keyword
{
    template <class T>
    named<Derived,T> operator=(T& x) const
    {
        return named<Derived,T>(x);
    }

    template <class T>
    named<Derived,T const> operator=(T const& x) const
    {
        return named<Derived,T const>(x);
    }
};

//
// Add labels to arguments that may have been passed positionally.
// Why the help with function ordering is required is completely
// beyond me.
//
template <class Keyword, class T>
named<Keyword,T const> label_positional_arg(T const& x, ...)
{
    return named<Keyword,T const>(x);
}

template <class Keyword, class T>
named<Keyword,T> label_positional_arg(T& x, char)
{
    return named<Keyword,T>(x);
}

template <class Keyword, class KW2, class T>
named<KW2,T> const& label_positional_arg(named<KW2,T> const& x, int)
{
    return x;
}

// A tuple of labeled argument holders
template <class H, class T>
struct list : H, T
{
    list(H h, T t) : H(h), T(t) {}

    template <class K>
    struct apply
      : mpl::apply_if<
            boost::is_same<typename H::key_type,K>
          , mpl::identity<H>
          , typename T::template apply<K>
        >
    {};

    template <class K>
    typename apply<K>::type const& value(K) const
    {
        return boost::implicit_cast<
            typename apply<K>::type const&
        >(*this);
    }
};

template <class H, class T>
list<H,T> cons(H const& h, T const& t)
{
    return list<H,T>(h,t);
}

struct nil
{
    template <class K>
    struct apply
    {
        typedef nil type;
    };

    template <class D>
    static D const& get(D const& x) { return x; }
    
    template <class D>
    nil const& value(D const& x) const { return *this; }
};

// ------------ end of named param library code -------------


//
// keyword declarations.  PP generatable, of course
//
struct name_t : keyword<name_t>
{
    using keyword<name_t>::operator=;
} name;

struct value_t : keyword<value_t>
{
    using keyword<value_t>::operator=;
} value;

struct index_t : keyword<index_t>
{
    using keyword<index_t>::operator=;
} index;

//
// core function implementation
//

template <class Params>
int f_impl(Params const& p)
{
    std::cout << "-------- f --------" << std::endl;
    std::cout << "name = " << p.value(name).get("unnamed") << std::endl;
    std::cout << "value = " << p.value(value).get(666.222) << std::endl;
    std::cout << "index = " << p.value(index).get(999) << std::endl;
    return 1;
}

//
// f overloads for various #s of args.  This could be avoided somewhat
// by using f((kw1 = v1, kw2 = v2)) and overloading operator, but
// there would be other disadvantages, like an inability to handle two
// initial positional args.  This boilerplate can probably be
// generated with the PP.
//
// Some reduction might be achieved by successively currying single
// arguments and calling the next overload, if the cons lists were
// built backwards.
//
int f()
{
    return f_impl(nil());
}

template <class Name>
int f(Name const& name)
{
    return f_impl(
        cons(
            label_positional_arg<name_t>(name, 0)
          , nil()
        ));
}

template <class Name, class Value>
int f(Name const& name, Value const& value)
{
    return f_impl(
        cons(
            label_positional_arg<name_t>(name, 0)
          , cons(
              label_positional_arg<value_t>(value, 0)
            , nil()
          )));
}

template <class Name, class Value, class Index>
int f(Name const& name, Value const& value, Index const& index)
{
    return f_impl(
        cons(
            label_positional_arg<name_t>(name, 0)
          , cons(
              label_positional_arg<value_t>(value, 0)
            , cons(
                label_positional_arg<index_t>(index, 0)
              , nil()
            ))));
}

//
// Just like f, but no default for name
// 
template <class Params>
int g_impl(Params const& p)
{
    std::cout << "-------- g --------" << std::endl;
    // name has no default
    std::cout << "name = " << p.value(name).get() << std::endl;
    std::cout << "value = " << p.value(value).get(666.222) << std::endl;
    std::cout << "index = " << p.value(index).get(999) << std::endl;
    return 1;
}

template <class Name>
int g(Name const& name)
{
    return g_impl(
        cons(
            label_positional_arg<name_t>(name, 0)
          , nil()
        ));
}

template <class Name, class Value>
int g(Name const& name, Value const& value)
{
    return g_impl(
        cons(
            label_positional_arg<name_t>(name, 0)
          , cons(
              label_positional_arg<value_t>(value, 0)
            , nil()
          )));
}

template <class Name, class Value, class Index>
int g(Name const& name, Value const& value, Index const& index)
{
    return g_impl(
        cons(
            label_positional_arg<name_t>(name, 0)
          , cons(
              label_positional_arg<value_t>(value, 0)
            , cons(
                label_positional_arg<index_t>(index, 0)
              , nil()
            ))));
}


int x1 = f("x", 3.14, 22);
int x2 = f(value = 3.14, name = "x");
int x3 = f(value = 6.5);
int x4 = f();

int x5 = g("x", 3.14, 22);
int x6 = g(value = 3.14, name = "x");

// g has no default for name, so this call fails
//  int x7 = g(value = 6.5);

int x8 = g("q", index = 77);
}

int main() { return 0; }