action.h

#pragma once
 
#include "group.h"
#include <string>
#include <cgv/type/cond/is_base_of.h>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace base {
 
class CGV_API traverse_policy;

class CGV_API action
{
protected:
    bool default_result_begin;
    bool default_result_end;
public:
    action(bool _default_result_begin, bool _default_result_end);
    void set_default_results(bool _default_result);
    void set_default_result_begin(bool _default_result_begin);
    void set_default_result_end(bool _default_result_end);
    virtual void select(base_ptr p);
    virtual bool implements_action() const;
    virtual traverse_policy* get_policy() const;
    virtual bool begin();
    virtual bool end();
    virtual bool has_begin_only() const;
};
 
template <bool is_derived, class X>
struct extract_policy_struct
{
    static void extract_policy(X*, traverse_policy* &tp) { tp = 0; }
};
 
template <class X>
struct extract_policy_struct<true,X>
{
    static void extract_policy(X* x, traverse_policy* &tp) { tp = static_cast<traverse_policy*>(x); }
};

template <class X>
class base_method_action : public action
{
protected:
    traverse_policy* tp;
    X* x;
public:
    base_method_action(bool _default_result_begin, bool _default_result_end) 
        : action(_default_result_begin, _default_result_end), tp(0), x(0) {}

    void select(base_ptr p) {
        x  = p->get_interface<X>();
        extract_policy_struct<type::cond::is_base_of<traverse_policy, X>::value,X>::extract_policy(x, tp);
    }

    bool implements_action() const {
        return x != 0;
    }

    traverse_policy* get_policy() const {
        return tp;
    }
};
 

template <class X, typename T1>
class method_action : public base_method_action<X>
{
protected:
    T1 v1;
public:
    method_action(T1 _v1, bool _default_result_begin, bool _default_result_end) 
        : base_method_action<X>(_default_result_begin, _default_result_end), v1(_v1) {}

    void set_signature(T1 _v1) { v1 = _v1; }
    bool call_method(void (X::*mp)(T1), bool default_result) { 
        if (this->x && mp) 
            (this->x->*mp)(v1); 
        return default_result; 
    }

    bool call_method(bool (X::*mp)(T1), bool default_result) { 
        if (this->x && mp) 
            return (this->x->*mp)(v1); 
        return default_result; 
    }
};

template <class X, typename R, typename T1>
class single_method_action : public method_action<X,T1>
{
protected:
    R (X::*on_begin)(T1);
public:
    single_method_action(T1 _v1, R (X::*_on_begin)(T1), 
        bool _default_result_begin = false, bool _default_result_end = false) 
        : method_action<X,T1>(_v1, _default_result_begin, _default_result_end), on_begin(_on_begin) {}

    bool begin() { return this->call_method(on_begin, this->default_result_begin); }
    bool has_begin_only() const { return true; }
};

template <class X, typename R1, typename R2, typename T1>
class matched_method_action : public method_action<X,T1>
{
protected:
    R1 (X::*on_begin)(T1);
    R2 (X::*on_end)(T1);
public:
    matched_method_action(T1 _v1, R1 (X::*_on_begin)(T1), R2 (X::*_on_end)(T1), bool _default_result_begin, bool _default_result_end) 
        : method_action<X,T1>(_v1, _default_result_begin, _default_result_end), on_begin(_on_begin), on_end(_on_end) {}

    bool begin() { return this->call_method(on_begin, this->default_result_begin); }
    bool end()   { return this->call_method(on_end, this->default_result_end); }
};

template <typename T1, class X, typename R>
single_method_action<X,R,T1> make_action(T1 _v1, R (X::*_on_begin)(T1), bool _default_result_begin = false, bool _default_result_end = false) {
    return single_method_action<X,R,T1>(_v1, _on_begin, _default_result_begin, _default_result_end);
}

template <typename T1, class X, typename R1, typename R2>
matched_method_action<X,R1,R2,T1> make_action(T1 _v1, R1 (X::*_on_begin)(T1), R2 (X::*_on_end)(T1), bool _default_result_begin = false, bool _default_result_end = false) {
    return matched_method_action<X,R1,R2,T1>(_v1, _on_begin, _on_end, _default_result_begin, _default_result_end);
}
 

template <class X, typename T1, typename T2>
class method_action_2 : public base_method_action<X>
{
protected:
    T1 v1;
    T2 v2;
public:
    method_action_2(T1 _v1, T2 _v2, bool _default_result_begin, bool _default_result_end) 
        : base_method_action<X>(_default_result_begin, _default_result_end), v1(_v1), v2(_v2) {}

    void set_signature(T1 _v1, T2 _v2) { v1 = _v1; v2 = _v2; }
    bool call_method(void (X::*mp)(T1, T2), bool default_result) { 
        if (this->x && mp) 
            (this->x->*mp)(v1,v2); 
        return default_result; 
    }

    bool call_method(bool (X::*mp)(T1, T2), bool default_result) { 
        if (this->x && mp) 
            return (this->x->*mp)(v1, v2); 
        return default_result; 
    }
};

template <class X, typename R, typename T1, typename T2>
class single_method_action_2 : public method_action_2<X,T1,T2>
{
protected:
    R (X::*on_begin)(T1,T2);
public:
    single_method_action_2(T1 _v1, T2 _v2, R (X::*_on_begin)(T1,T2), 
        bool _default_result_begin = false, bool _default_result_end = false) 
        : method_action_2<X,T1,T2>(_v1, _v2, _default_result_begin, _default_result_end), on_begin(_on_begin) {}

    bool begin() { return this->call_method(on_begin, this->default_result_begin); }
    bool has_begin_only() const { return true; }
};

template <typename T1, typename T2, class X, typename R>
single_method_action_2<X,R,T1,T2> make_action_2(T1 _v1, T2 _v2, R (X::*_on_begin)(T1,T2), bool _default_result_begin = false, bool _default_result_end = false) {
    return single_method_action_2<X,R,T1,T2>(_v1, _v2, _on_begin, _default_result_begin, _default_result_end);
}
 
    }
}
 
#include <cgv/config/lib_end.h>