Subversion Repositories openrisc

// { dg-do run }

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

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

// Contributed by Douglas Gregor 

#include 

template

class function;

template

class invoker_base

{

 public:

  virtual ~invoker_base() { }

  virtual R invoke(Args...) = 0;

  virtual invoker_base* clone() = 0;

};

template

class functor_invoker : public invoker_base

{

 public:

  explicit functor_invoker(const F& f) : f(f) { }

  R invoke(Args... args) { return f(args...); }

  functor_invoker* clone() { return new functor_invoker(f); }

 private:

  F f;

};

template

class function {

 public:

  typedef R result_type;

  function() : invoker (0) { }

  function(const function& other) : invoker(0) {

    if (other.invoker)

      invoker = other.invoker->clone();

  }

  template

  function(const F& f) : invoker(0) {

    invoker = new functor_invoker(f);

  }

  ~function() {

    if (invoker)

      delete invoker;

  }

  function& operator=(const function& other) {

    function(other).swap(*this);

    return *this;

  }

  template

  function& operator=(const F& f) {

    function(f).swap(*this);

    return *this;

  }

  void swap(function& other) {

    invoker_base* tmp = invoker;

    invoker = other.invoker;

    other.invoker = tmp;

  }

  result_type operator()(Args... args) const {

    assert(invoker);

    return invoker->invoke(args...);

  }

 private:

  invoker_base* invoker;

};

struct plus {

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

};

struct multiplies {

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

};

int main()

{

  function f1 = plus();

  assert(f1(3, 5) == 8);

  f1 = multiplies();

  assert(f1(3, 5) == 15);

  return 0;

}