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>