public:

behavior_impl() = default;

behavior_impl(util::duration tout);

virtual bool invoke(any_tuple&) = 0;

virtual bool invoke(const any_tuple&) = 0;

virtual bool defined_at(const any_tuple&) = 0;

virtual void handle_timeout();

inline const util::duration& timeout() const {

return m_timeout;

}

private:

util::duration m_timeout;

typedef behavior_impl super;

public:

template<typename Expr>

default_behavior_impl(Expr&& expr, const timeout_definition<F>& d)

: super(d.timeout), m_expr(std::forward<Expr>(expr)), m_fun(d.handler) { }

template<typename Expr>

default_behavior_impl(Expr&& expr, util::duration tout, F f)

: super(tout), m_expr(std::forward<Expr>(expr)), m_fun(f) { }

bool invoke(any_tuple& tup) {

return m_expr.invoke(tup);

}

bool invoke(const any_tuple& tup) {

return m_expr.invoke(tup);

}

bool defined_at(const any_tuple& tup) {

return m_expr.can_invoke(tup);

}

void handle_timeout() { m_fun(); }

private:

MatchExpr m_expr;

F m_fun;

public:

typedef intrusive_ptr<behavior_impl> impl_ptr;

partial_function() = default;

partial_function(partial_function&&) = default;

partial_function(const partial_function&) = default;

partial_function& operator=(partial_function&&) = default;

partial_function& operator=(const partial_function&) = default;

partial_function(impl_ptr ptr);

inline bool undefined() const {

return m_impl == nullptr;

}

inline bool defined_at(const any_tuple& value) {

return (m_impl) && m_impl->defined_at(value);

}

inline bool operator()(any_tuple& value) {

return (m_impl) && m_impl->invoke(value);

}

inline bool operator()(const any_tuple& value) {

return (m_impl) && m_impl->invoke(value);

}

inline bool operator()(any_tuple&& value) {

any_tuple cpy{std::move(value)};

return (*this)(cpy);

}

protected:

intrusive_ptr<behavior_impl> m_impl;