94 lines
1.0 KiB
C++
94 lines
1.0 KiB
C++
#ifndef OPP_FUNCTIONAL_H
|
|
#define OPP_FUNCTIONAL_H
|
|
|
|
namespace opp
|
|
{
|
|
template <class F>
|
|
class function;
|
|
|
|
template <class R, class ... P>
|
|
class function<R(P...)>
|
|
{
|
|
private:
|
|
struct callif
|
|
{
|
|
virtual R call(P...) = 0;
|
|
virtual ~callif() {}
|
|
virtual callif * clone(void) const = 0;
|
|
};
|
|
|
|
template<class CA>
|
|
struct callable : callif
|
|
{
|
|
CA ca;
|
|
|
|
callable(CA ca_) : ca(ca_) {}
|
|
|
|
R call(P... p) {return ca(p...);}
|
|
|
|
callif * clone(void) const
|
|
{
|
|
return new callable(ca);
|
|
}
|
|
};
|
|
|
|
callif * c;
|
|
public:
|
|
template <class F>
|
|
function(F f)
|
|
{
|
|
c = new callable<F>(f);
|
|
}
|
|
|
|
function(const function & f)
|
|
{
|
|
c = f.c->clone();
|
|
}
|
|
|
|
function(function && f)
|
|
{
|
|
c = f.c;
|
|
f.c = nullptr;
|
|
}
|
|
|
|
function(void)
|
|
{
|
|
c = nullptr;
|
|
}
|
|
|
|
function & operator=(const function & f)
|
|
{
|
|
if (c != f.c)
|
|
{
|
|
delete c;
|
|
c = f.c;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
function & operator=(function && f)
|
|
{
|
|
if (c != f.c)
|
|
{
|
|
c = f.c;
|
|
f.c = nullptr;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
~function(void)
|
|
{
|
|
delete c;
|
|
}
|
|
|
|
R operator()(P ... p) const
|
|
{
|
|
return c->call(p...);
|
|
}
|
|
};
|
|
|
|
|
|
}
|
|
|
|
#endif
|