Subversion Repositories openrisc

// { dg-options "-std=gnu++0x" }

// { dg-do "run" }

// A basic implementation of TR1's bind using variadic teplates

// Contributed by Douglas Gregor 

#include 

// Trivial reference_wrapper

template

struct reference_wrapper

{

  reference_wrapper(T& x) : ptr(&x) { }

  operator T&() const { return *ptr; }

  T& get() const { return *ptr; }

  T* ptr;

};

template reference_wrapper ref(T& x) { return x; }

template reference_wrapper cref(const T& x) { return x; }

// Simple type-traits we'll need

template

struct add_reference

{

  typedef T& type;

};

template

struct add_reference

{

  typedef T& type;

};

template

struct is_same

{

  static const bool value = false;

};

template

struct is_same

{

  static const bool value = true;

};

// For creating the constructor parameters of tuple<>

template

struct add_const_reference

{

  typedef const T& type;

};

template

struct add_const_reference

{

  typedef T& type;

};

// 6.1.3 Class template tuple: Needed for bind() implementation

template

class tuple;

template<> class tuple<> { };

template

class tuple

  : private tuple

{

  typedef tuple inherited;

 public:

  tuple() { }

  // implicit copy-constructor is okay

  tuple(typename add_const_reference::type v,

        typename add_const_reference::type... vtail)

    : m_head(v), inherited(vtail...) { }

  template

  tuple(const tuple& other)

    : m_head(other.head()), inherited(other.tail()) { }

  template

  tuple& operator=(const tuple& other)

  {

    m_head = other.head();

    tail() = other.tail();

    return *this;

  }

  typename add_reference::type       head()       { return m_head; }

  typename add_reference::type head() const { return m_head; }

  inherited&                               tail()       { return *this; }

  const inherited&                         tail() const { return *this; }

 protected:

  Head m_head;

};

template

struct make_tuple_result

{

  typedef T type;

};

template

struct make_tuple_result >

{

  typedef T& type;

};

// 6.1.3.2 Tuple creation functions

struct ignore_t {

  template ignore_t& operator=(const T&) { return *this; }

} ignore;

template

tuple::type...>

make_tuple(const Values&... values)

{

  return tuple::type...>(values...);

}

template

tuple tie(Values&... values)

{

  return tuple(values...);

}

// 6.1.3.3 Tuple helper classes

template

struct tuple_size;

template<>

struct tuple_size >

{

  static const __SIZE_TYPE__ value = 0;

};

template

struct tuple_size >

{

  static const __SIZE_TYPE__ value = 1 + tuple_size >::value;

};

template

struct tuple_element;

template

struct tuple_element >

{

  typedef typename tuple_element >::type type;

};

template

struct tuple_element<0, tuple >

{

  typedef Head type;

};

// 6.1.3.4 Element access

template

class get_impl;

template

class get_impl >

{

  typedef typename tuple_element >::type Element;

  typedef typename add_reference::type RJ;

  typedef typename add_const_reference::type PJ;

  typedef get_impl > Next;

 public:

  static RJ get(tuple& t)

  { return Next::get(t.tail()); }

  static PJ get(const tuple& t)

  { return Next::get(t.tail()); }

};

template

class get_impl<0, tuple >

{

  typedef typename add_reference::type RJ;

  typedef typename add_const_reference::type PJ;

 public:

  static RJ get(tuple& t)       { return t.head(); }

  static PJ get(const tuple& t) { return t.head(); }

};

template

typename add_reference<

           typename tuple_element >::type

         >::type

get(tuple& t)

{

  return get_impl >::get(t);

}

template

typename add_const_reference<

           typename tuple_element >::type

         >::type

get(const tuple& t)

{

  return get_impl >::get(t);

}

// 6.1.3.5 Relational operators

inline bool operator==(const tuple<>&, const tuple<>&) { return true; }

template

bool operator==(const tuple& t, const tuple& u)

{

  return t.head() == u.head() && t.tail() == u.tail();

}

template

bool operator!=(const tuple& t, const tuple& u)

{

  return !(t == u);

}

inline bool operator<(const tuple<>&, const tuple<>&) { return false; }

template

bool operator<(const tuple& t, const tuple& u)

{

  return (t.head() < u.head() ||

          (!(t.head() < u.head()) && t.tail() < u.tail()));

}

template

bool operator>(const tuple& t, const tuple& u)

{

  return u < t;

}

template

bool operator<=(const tuple& t, const tuple& u)

{

  return !(u < t);

}

template

bool operator>=(const tuple& t, const tuple& u)

{

  return !(t < u);

}

// enable_if, the breakfast of champions

template

struct enable_if {

  typedef Type type;

};

template

struct enable_if { };

// 3.6 Function object binders

// 3.6.1 Class template is_bind_expression

template

struct is_bind_expression {

  static const bool value = false;

};

// 3.6.2 Class template is_placeholder

template

struct is_placeholder {

  static const int value = 0;

};

// 3.6.3 Function template bind

template struct placeholder {} ;

template struct int_c { };

// A tuple of integer values

template struct int_tuple {};

// make_indexes_impl is a helper for make_indexes

template

struct make_indexes_impl;

template

struct make_indexes_impl, T, Types...>

{

  typedef typename make_indexes_impl

                                     int_tuple,

                                     Types...>::type type;

};

template

struct make_indexes_impl > {

  typedef int_tuple type;

};

// make_indexes takes a variable-length number of N types and

// generates an int_tuple that contains <0, 1, 2, ..., N-1>. These can

// be used as indexes for tuple's get or tuple_element operation.

template

struct make_indexes : make_indexes_impl<0, int_tuple<>, Types...> { };

// Get the Ith tuple element, but only if I is in bounds.

template

struct safe_tuple_element{ };

template

struct safe_tuple_element,

         typename enable_if<(I >= 0 &&

                             I < tuple_size >::value)

                            >::type>

{

  typedef typename tuple_element >::type type;

};

// mu maps a bound argument to an actual argument, given a tuple of

// the arguments passed to the function object returned by bind().

// Return the stored reference from reference_wrapper

template

inline T& mu(reference_wrapper& bound_arg, const tuple&)

{

  return bound_arg.get();

}

// Unwrap a tuple into separate arguments and forward to the function

// object f.

template

inline typename F::result_type

unwrap_and_forward(F& f, int_tuple, const tuple& args)

{

  return f(get(args)...);

}

// Evaluate the inner bind expression

template

inline typename enable_if::value,

                          typename Bound::result_type>::type

mu(Bound& bound_arg, const tuple& args)

{

  typedef typename make_indexes::type Indexes;

  return unwrap_and_forward(bound_arg, Indexes(), args);

}

// Retrieve the Ith argument from args

template

inline typename safe_tuple_element::value - 1,

                                   tuple >::type

mu(Bound& bound_arg, const tuple& args)

{

  return get::value-1>(args);

}

// Return the stored value.

template

struct is_reference_wrapper {

  static const bool value = false;

};

template

struct is_reference_wrapper > {

  static const bool value = true;

};

template

inline typename enable_if<(!is_bind_expression::value

                           && !is_placeholder::value

                           && !is_reference_wrapper::value),

                          Bound&>::type

mu(Bound& bound_arg, const tuple&)

{

  return bound_arg;

}

//

template

typename F::result_type

apply_functor(F& f, tuple& bound_args, int_tuple,

              const tuple& args)

{

  return f(mu(get(bound_args), args)...);

}

template

class bound_functor

{

  typedef typename make_indexes::type indexes;

 public:

  typedef typename F::result_type result_type;

  explicit bound_functor(const F& f, const BoundArgs&... bound_args)

    : f(f), bound_args(bound_args...) { }

  template

  typename F::result_type operator()(Args&... args) {

    return apply_functor(f, bound_args, indexes(), tie(args...));

  }

 private:

  F f;

  tuple bound_args;

};

template

struct is_bind_expression > {

  static const bool value = true;

};

template

inline bound_functor

bind(const F& f, const BoundArgs&... bound_args)

{

  return bound_functor(f, bound_args...);

}

// 3.6.4 Placeholders

template

struct is_placeholder > {

  static const int value = I;

};

placeholder<1> _1;

placeholder<2> _2;

placeholder<3> _3;

placeholder<4> _4;

placeholder<5> _5;

placeholder<6> _6;

placeholder<7> _7;

placeholder<8> _8;

placeholder<9> _9;

// Test code

template

struct plus {

  typedef T result_type;

  T operator()(T x, T y) { return x + y; }

};

template

struct multiplies {

  typedef T result_type;

  T operator()(T x, T y) { return x * y; }

};

template

struct negate {

  typedef T result_type;

  T operator()(T x) { return -x; }

};

int main()

{

  int seventeen = 17;

  int forty_two = 42;

  assert(bind(plus(), _1, _2)(seventeen, forty_two) == 59);

  assert(bind(plus(), _1, _1)(seventeen, forty_two) == 34);

  assert(bind(plus(), _2, _1)(seventeen, forty_two) == 59);

  assert(bind(plus(), 5, _1)(seventeen, forty_two) == 22);

  assert(bind(plus(), ref(seventeen), _2)(seventeen, forty_two) == 59);

  assert(bind(plus(), bind(multiplies(), 3, _1), _2)(seventeen, forty_two)

         == 93);

  return 0;

}