// 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;

template<class T>
struct keyword;

template<class KW, class Default>
struct get_keyword
{
   get_keyword(const Default& x)
      : default_(x)
   {}

   const Default& default_;
};

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

    template <class K, class Default>
    struct apply_value
    {
        typedef const Default& 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; }

    template<class T>
    const nil& operator()(const T& x) const { return *this; }

    template<class K, class Default>
    const Default& operator[](const get_keyword<K, Default>& x) const
    {
       return x.default_;
    }
};

// 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, class Default>
    struct apply_value
      : mpl::apply_if<
            boost::is_same<typename H::key_type, K>
          , mpl::identity<typename H::ref_type>
          , typename T::template apply_value<K, Default>
        >
    {};

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

    template<class H2>
    list<H2, list<H,T> >
    operator,(const list<H2, nil>& x) const
    {
       return list<H2, list<H, T> >(x, *this);
    }

    const list<H, T>& operator,(nil) const
    {
       return *this;
    }

    template<class K, class Default>
    typename apply_value<K, Default>::type 
    operator[](const get_keyword<K, Default>& x) const
    {
       return value(K()).get(x.default_);
    }

    template<class K>
    typename apply_value<K, nil>::type
    operator[](const keyword<K>&) const
    {
       return value(K()).get();
    }
};

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

struct named_base {};

template <class KW, class T>
struct named : named_base
{
    typedef KW key_type;
    typedef T value_type;
    typedef T& ref_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);
    }

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

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

    template<class KW, class T>
    list<named<KW, T>, nil>
    operator()(const named<KW, T>& x) const
    {
       return list<named<KW, T>, nil>(
             x, nil());
    }

    nil operator()(nil) const
    {
       return nil();
    }

    template<class Default>
    get_keyword<Derived, Default>
    operator|(const Default& default_)
    {
       return get_keyword<Derived, Default>(default_);
    }
};

//
// 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;
}

// ------------ 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
//
//
// 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.
//

// Generates boilerplate code
template<class Derived, class R, class K0, class K1 = nil, class K2 = nil, class K3 = nil>
struct named_param_fun
{
   R operator()() const
   {
      return (*this)(nil());
   }

   template<class A0>
   R operator()(const A0& a0) const
   {
      return (*this)(a0, nil());
   }

   template<class A0, class A1>
   R operator()(const A0& a0, const A1& a1) const
   {
      return (*this)(a0, a1, nil());
   }

   template<class A0, class A1, class A2>
   R operator()(const A0& a0, const A1& a1, const A2& a2) const
   {
      return (*this)(a0, a1, a2, nil());
   }

   template<class A0, class A1, class A2, class A3>
   R operator()(const A0& a0, const A1& a1, const A2& a2, const A3& a3) const
   {
      K0 k0;
      K1 k1;
      K2 k2;
      K3 k3;

      return static_cast<const Derived&>(*this).call(
            (k0(a0), k1(a1), k2(a2), k3(a3)));
   }
};

// f() implementation
struct f_impl : named_param_fun<f_impl, int, name_t, value_t, index_t>
{
   template<class Params>
   int call(const Params& p) const
   {
      std::cout << "-------- f --------" << std::endl;
      std::cout << "name = " << p[name | "unnamed"] << std::endl;
      std::cout << "value = " << p[value | 666.222] << std::endl;
      std::cout << "index = " << p[index | 999] << std::endl;
      return 1;
   }
} f;

   
//
// 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[name] << std::endl;
    std::cout << "value = " << p[value | 666.222] << std::endl;
    std::cout << "index = " << p[index | 999] << std::endl;
    return 1;
}

template <class Name>
int g(Name const& name_)
{
    return g(name_, nil(), nil());
}

template <class Name, class Value>
int g(Name const& name_, Value const& value_)
{
    return g(name_, value_, nil());
}

template <class Name, class Value, class Index>
int g(Name const& name_, Value const& value_, Index const& index_)
{
    return g_impl((name(name_), value(value_), index(index_)));
}

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; }