00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019 #ifndef CLIPSENVIRONMENT_H
00020 #define CLIPSENVIRONMENT_H
00021
00022 #include <string>
00023 #include <map>
00024 #include <stdexcept>
00025 #include <map>
00026 #include <queue>
00027
00028 #include <cstdio>
00029
00030 #include <sigc++/sigc++.h>
00031 #include <glibmm.h>
00032
00033 #include <clipsmm/enum.h>
00034 #include <clipsmm/object.h>
00035
00036 #include <clipsmm/activation.h>
00037 #include <clipsmm/defaultfacts.h>
00038 #include <clipsmm/fact.h>
00039 #include <clipsmm/function.h>
00040 #include <clipsmm/global.h>
00041 #include <clipsmm/module.h>
00042 #include <clipsmm/rule.h>
00043 #include <clipsmm/template.h>
00044
00045 #include <clipsmm/utility.h>
00046 #include <clipsmm/any.h>
00047
00048 extern "C" {
00049 int EnvDefineFunction2WithContext( void *, char *, int, int ( * ) ( void * ), char *, char *, void * );
00050 }
00051
00052 namespace CLIPS {
00053
00057 class Environment: public Object {
00058 public:
00059 typedef CLIPSPointer<Environment> pointer;
00060
00061 Environment();
00062
00063 ~Environment();
00064
00069 bool batch_evaluate( const std::string& filename );
00070
00075 bool binary_load( const std::string& filename );
00076
00081 bool binary_save( const std::string& filename );
00082
00087 bool build( const std::string& construct );
00088
00092 void clear( );
00093
00099 Values evaluate( const std::string& expression );
00100
00106 Values function( const std::string& function_name, const std::string& arguments=std::string() );
00107
00119 int load( const std::string& filename );
00120
00124 void reset();
00125
00130 bool save( const std::string& filename );
00131
00138 bool auto_float_dividend_enabled();
00139
00147 bool use_auto_float_dividend( bool use = true );
00148
00155 bool dynamic_constraint_checking_enabled();
00156
00164 bool use_dynamic_constraint_checking( bool use = true );
00165
00172 bool sequence_operator_recognition_enabled();
00173
00181 bool use_sequence_operator_recognition( bool use = true );
00182
00189 bool static_constraint_checking_enabled();
00190
00197 bool use_static_constraint_checking( bool use = true );
00198
00206 bool fact_duplication_enabled();
00207
00214 bool use_fact_duplication( bool use = true );
00215
00216 bool incremental_reset_enabled();
00217
00218 bool use_incremental_reset( bool use = true );
00219
00220 bool global_reset_enable();
00221
00222 bool use_global_reset( bool use=true );
00223
00228 bool is_dribble_active( );
00229
00234 bool dribble_off( );
00235
00240 bool dribble_on( const std::string& dribble_file );
00241
00249 int is_watched( const std::string& item );
00250
00251 bool watch( const std::string& item );
00252
00253 bool unwatch( const std::string& item );
00254
00255 void set_as_current();
00256
00257 Fact::pointer assert_fact( const std::string& factstring );
00258 Fact::pointer assert_fact_f( const char *format, ... );
00259
00260 void clear_focus_stack();
00261
00264 DefaultFacts::pointer get_default_facts( const std::string& default_facts_name );
00265
00267 std::vector<std::string> get_default_facts_names();
00268
00270 std::vector<std::string> get_default_facts_names( const Module& module );
00271
00273 std::vector<std::string> get_default_facts_names( Module::pointer module );
00274
00275 DefaultFacts::pointer get_default_facts_list_head();
00276
00277 Template::pointer get_template( const std::string& template_name );
00278
00280 std::vector<std::string> get_template_names();
00281
00283 std::vector<std::string> get_template_names( const Module& module );
00284
00286 std::vector<std::string> get_template_names( Module::pointer module );
00287
00288 Template::pointer get_template_list_head();
00289
00290 Rule::pointer get_rule( const std::string& rule_name );
00291
00293 std::vector<std::string> get_rule_names();
00294
00296 std::vector<std::string> get_rule_names( const Module& module );
00297
00299 std::vector<std::string> get_rule_names( Module::pointer module );
00300
00301 Rule::pointer get_rule_list_head();
00302
00303 void remove_rules();
00304
00305 Module::pointer get_module( const std::string& module_name );
00306
00307 Module::pointer get_current_module();
00308
00309 std::vector<std::string> get_module_names();
00310
00311 Module::pointer get_module_list_head();
00312
00318 void refresh_agenda();
00319
00325 void refresh_agenda( const Module& module );
00326
00332 void refresh_agenda( Module::pointer module );
00333
00339 void reorder_agenda();
00340
00346 void reorder_agenda( const Module& module );
00347
00353 void reorder_agenda( Module::pointer module );
00354
00364 long int run( long int runlimit = -1 );
00365
00384 void run_threaded( long int runlimit = -1, int priority = 0 );
00385
00387 void join_run_thread();
00388
00390 sigc::signal<void, long int> signal_run();
00391
00393 SalienceEvaluation get_salience_evaluation();
00394
00399 SalienceEvaluation set_salience_evaluation( SalienceEvaluation se );
00400
00402 ConflictResolution get_conflict_resolution_strategy();
00403
00408 ConflictResolution set_conflict_resolution_strategy( ConflictResolution cr );
00409
00418 bool check_agenda_changed();
00419
00420 Module::pointer get_focused_module();
00421
00422 std::vector<std::string> get_focus_stack();
00423
00424 Activation::pointer get_activation_list_head();
00425
00426 Global::pointer get_global( const std::string& global_name );
00427
00428 Global::pointer get_global_list_head();
00429
00431 std::vector<std::string> get_globals_names();
00432
00434 std::vector<std::string> get_globals_names( const Module& module );
00435
00437 std::vector<std::string> get_globals_names( Module::pointer module );
00438
00439 bool check_globals_changed();
00440
00441 Function::pointer get_function( const std::string& function_name );
00442
00443 Function::pointer get_function_list_head();
00444
00446 std::vector<std::string> get_function_names();
00447
00449 std::vector<std::string> get_function_names( const Module& module );
00450
00452 std::vector<std::string> get_function_names( Module::pointer module );
00453
00454 sigc::signal<void> signal_clear();
00455 sigc::signal<void> signal_periodic();
00456 sigc::signal<void> signal_reset();
00457 sigc::signal<void> signal_rule_firing();
00458 sigc::signal<void> signal_agenda_changed();
00459 sigc::signal<void> signal_globals_changed();
00460
00461 template < typename T_return >
00462 bool add_function( std::string name, const sigc::slot0<T_return>& slot);
00463
00464 template < typename T_return, typename T_arg1 >
00465 bool add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot);
00466
00467 template < typename T_return, typename T_arg1, typename T_arg2 >
00468 bool add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot);
00469
00470 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00471 bool add_function( std::string name, const sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>& slot);
00472
00473 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00474 bool add_function( std::string name, const sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>& slot);
00475
00476 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00477 bool add_function( std::string name, const sigc::slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& slot);
00478
00479 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00480 bool add_function( std::string name, const sigc::slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& slot);
00481
00482 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00483 bool add_function( std::string name, const sigc::slot7<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>& slot);
00484
00485 bool remove_function( std::string name );
00486
00487 protected:
00494 std::map<std::string,any> m_slots;
00495
00496 sigc::signal<void> m_signal_clear;
00497 sigc::signal<void> m_signal_periodic;
00498 sigc::signal<void> m_signal_reset;
00499 sigc::signal<void> m_signal_rule_firing;
00500 sigc::signal<void> m_signal_agenda_changed;
00501 sigc::signal<void> m_signal_globals_changed;
00502
00504 typedef struct Job {
00506 Job( int p, long int rl ) : priority(p), runlimit(rl) { }
00507
00509 bool operator<( const Job& other ) const { return priority < other.priority; }
00510
00512 int priority;
00513
00518 long int runlimit;
00519 } Job;
00520
00521 Glib::Thread* m_run_thread;
00522 std::priority_queue<Job> m_run_queue;
00523 Glib::Mutex m_mutex_run_queue;
00524 Glib::Mutex m_mutex_run;
00525 Glib::Mutex m_mutex_threaded_run;
00526 Glib::Mutex m_mutex_run_signal;
00527 sigc::signal<void, long int> m_signal_run;
00538 std::map<std::string, char *> m_func_restr;
00539
00541 void threaded_run();
00542
00543 static std::map<void*, Environment*> m_environment_map;
00544
00545
00546 static void clear_callback( void* env );
00547 static void periodic_callback( void* env );
00548 static void reset_callback( void* env );
00549 static void rule_firing_callback( void* end );
00550
00551 static void* strcallback( void* theEnv );
00552
00553 template < typename T_arg1 >
00554 static void* strcallback( void* theEnv );
00555
00556 template < typename T_arg1, typename T_arg2 >
00557 static void* strcallback( void* theEnv );
00558
00559 template < typename T_arg1, typename T_arg2, typename T_arg3 >
00560 static void* strcallback( void* theEnv );
00561
00562 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00563 static void* strcallback( void* theEnv );
00564
00565 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00566 static void* strcallback( void* theEnv );
00567
00568 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00569 static void* strcallback( void* theEnv );
00570
00571 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00572 static void* strcallback( void* theEnv );
00573
00574 template < typename T_return >
00575 static T_return callback( void* theEnv );
00576
00577 template < typename T_return, typename T_arg1 >
00578 static T_return callback( void* theEnv );
00579
00580 template < typename T_return, typename T_arg1, typename T_arg2 >
00581 static T_return callback( void* theEnv );
00582
00583 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00584 static T_return callback( void* theEnv );
00585
00586 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00587 static T_return callback( void* theEnv );
00588
00589 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00590 static T_return callback( void* theEnv );
00591
00592 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00593 static T_return callback( void* theEnv );
00594
00595 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00596 static T_return callback( void* theEnv );
00597
00598 static void callback_multifield( void* theEnv, void *rv);
00599
00600 template <typename T_arg1>
00601 static void callback_multifield( void* theEnv, void *rv );
00602
00603 template <typename T_arg1, typename T_arg2>
00604 static void callback_multifield( void* theEnv, void *rv );
00605
00606 template <typename T_arg1, typename T_arg2, typename T_arg3>
00607 static void callback_multifield( void* theEnv, void *rv );
00608
00609 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00610 static void callback_multifield( void* theEnv, void *rv );
00611
00612 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00613 typename T_arg5>
00614 static void callback_multifield( void* theEnv, void *rv );
00615
00616 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00617 typename T_arg5, typename T_arg6>
00618 static void callback_multifield( void* theEnv, void *rv );
00619
00620 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00621 typename T_arg5, typename T_arg6, typename T_arg7>
00622 static void callback_multifield( void* theEnv, void *rv );
00623
00624 int ( *get_callback( const sigc::slot0<std::string>& slot ))( void* )
00625 { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback; }
00626
00627 template < typename T_arg1 >
00628 int ( *get_callback( const sigc::slot1<std::string,T_arg1>& slot ))( void* )
00629 { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1>; }
00630
00631 template < typename T_arg1, typename T_arg2 >
00632 int ( *get_callback( const sigc::slot2<std::string,T_arg1,T_arg2>& slot ))( void* )
00633 { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1,T_arg2>; }
00634
00635 template < typename T_arg1, typename T_arg2, typename T_arg3 >
00636 int ( *get_callback( const sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00637 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3>; }
00638
00639 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00640 int ( *get_callback( const sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00641 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4>; }
00642
00643 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00644 int ( *get_callback( const sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00645 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00646
00647 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00648 int ( *get_callback( const sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00649 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00650
00651 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00652 int ( *get_callback( const sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00653 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00654
00655 int ( *get_callback( const sigc::slot0<Values>& slot ))( void* )
00656 { return (int (*) (void*)) (void (*) (void*, void*)) callback_multifield; }
00657
00658 template <typename T_arg1>
00659 int ( *get_callback( const sigc::slot1<Values,T_arg1>& slot ))( void* )
00660 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1>; }
00661
00662 template <typename T_arg1, typename T_arg2>
00663 int ( *get_callback( const sigc::slot2<Values,T_arg1,T_arg2>& slot ))( void* )
00664 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2>; }
00665
00666 template <typename T_arg1, typename T_arg2, typename T_arg3>
00667 int ( *get_callback( const sigc::slot3<Values,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00668 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3>; }
00669
00670 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00671 int ( *get_callback( const sigc::slot4<Values,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00672 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4>; }
00673
00674 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00675 int ( *get_callback( const sigc::slot5<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00676 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00677
00678 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00679 int ( *get_callback( const sigc::slot6<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00680 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00681
00682 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00683 int ( *get_callback( const sigc::slot7<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00684 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00685
00686
00687 template < typename T_return >
00688 int ( *get_callback( const sigc::slot0<T_return>& slot ))( void* )
00689 { return (int (*) (void*)) ( T_return ( * ) ( void* ) ) callback<T_return>; }
00690
00691 template < typename T_return, typename T_arg1 >
00692 int ( *get_callback( const sigc::slot1<T_return,T_arg1>& slot ))( void* )
00693 { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1>; }
00694
00695 template < typename T_return, typename T_arg1, typename T_arg2 >
00696 int ( *get_callback( const sigc::slot2<T_return,T_arg1,T_arg2>& slot ))( void* )
00697 { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1,T_arg2>; }
00698
00699 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00700 int ( *get_callback( const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00701 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3>; }
00702
00703 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00704 int ( *get_callback( const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00705 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4>; }
00706
00707 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00708 int ( *get_callback( const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00709 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00710
00711 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00712 int ( *get_callback( const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00713 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00714
00715 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00716 int ( *get_callback( const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00717 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00718
00719 char * get_function_restriction(std::string &name);
00720
00721 template <typename T_arg1>
00722 char * get_function_restriction(std::string &name);
00723
00724 template <typename T_arg1, typename T_arg2>
00725 char * get_function_restriction(std::string &name);
00726
00727 template <typename T_arg1, typename T_arg2, typename T_arg3>
00728 char * get_function_restriction(std::string &name);
00729
00730 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00731 char * get_function_restriction(std::string &name);
00732
00733 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00734 char * get_function_restriction(std::string &name);
00735
00736 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00737 char * get_function_restriction(std::string &name);
00738
00739 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00740 char * get_function_restriction(std::string &name);
00741
00742
00743 static int get_arg_count( void* env );
00744 static void* get_function_context( void* env );
00745 static void set_return_values( void *env, void *rv, const Values &v);
00746 static void* add_symbol( const char* s );
00747
00748
00749 };
00750
00751
00752 inline char *
00753 Environment::get_function_restriction(std::string &name) {
00754 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00755 char *restr = (char *)malloc(4); m_func_restr[name] = restr;
00756 snprintf(restr, 4, "00u");
00757 return restr;
00758 }
00759
00760 template <typename T_arg1>
00761 inline char *
00762 Environment::get_function_restriction(std::string &name) {
00763 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00764 char *restr = (char *)malloc(5); m_func_restr[name] = restr;
00765 snprintf(restr, 5, "11u%c", get_argument_code<T_arg1>());
00766 return restr;
00767 }
00768
00769 template <typename T_arg1, typename T_arg2>
00770 inline char *
00771 Environment::get_function_restriction(std::string &name) {
00772 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00773 char *restr = (char *)malloc(6); m_func_restr[name] = restr;
00774 snprintf(restr, 6, "22u%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>());
00775 return restr;
00776 }
00777
00778 template <typename T_arg1, typename T_arg2, typename T_arg3>
00779 inline char *
00780 Environment::get_function_restriction(std::string &name) {
00781 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00782 char *restr = (char *)malloc(7); m_func_restr[name] = restr;
00783 snprintf(restr, 7, "33u%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00784 get_argument_code<T_arg3>());
00785 return restr;
00786 }
00787
00788 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00789 inline char *
00790 Environment::get_function_restriction(std::string &name) {
00791 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00792 char *restr = (char *)malloc(8); m_func_restr[name] = restr;
00793 snprintf(restr, 8, "44u%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00794 get_argument_code<T_arg3>(), get_argument_code<T_arg4>());
00795 return restr;
00796 }
00797
00798 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00799 typename T_arg5>
00800 inline char *
00801 Environment::get_function_restriction(std::string &name) {
00802 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00803 char *restr = (char *)malloc(9); m_func_restr[name] = restr;
00804 snprintf(restr, 9, "55u%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00805 get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>());
00806 return restr;
00807 }
00808
00809 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00810 typename T_arg5, typename T_arg6>
00811 inline char *
00812 Environment::get_function_restriction(std::string &name) {
00813 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00814 char *restr = (char *)malloc(10); m_func_restr[name] = restr;
00815 snprintf(restr, 10, "66u%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00816 get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
00817 get_argument_code<T_arg6>());
00818 return restr;
00819 }
00820
00821 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00822 typename T_arg5, typename T_arg6, typename T_arg7>
00823 inline char *
00824 Environment::get_function_restriction(std::string &name) {
00825 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
00826 char *restr = (char *)malloc(11); m_func_restr[name] = restr;
00827 snprintf(restr, 11, "77u%c%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00828 get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
00829 get_argument_code<T_arg6>(), get_argument_code<T_arg7>());
00830 return restr;
00831 }
00832
00833
00834 template < typename T_return>
00835 inline
00836 T_return Environment::callback( void* theEnv ) {
00837 sigc::slot0<T_return>* cb;
00838 void * cbptr = get_function_context( theEnv );
00839 if ( cbptr ) {
00840 if ( get_arg_count( theEnv ) != 0 )
00841 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 0" );
00842 cb = static_cast<sigc::slot0<T_return>*>( cbptr );
00843 return ( *cb ) ();
00844 }
00845 throw;
00846 }
00847
00848 template < typename T_return, typename T_arg1 >
00849 inline
00850 T_return Environment::callback( void* theEnv ) {
00851 sigc::slot1<T_return,T_arg1>* cb;
00852 void * cbptr = get_function_context( theEnv );
00853 T_arg1 arg1;
00854 if ( cbptr ) {
00855 if ( get_arg_count( theEnv ) != 1 )
00856 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
00857 get_argument( theEnv, 1, arg1 );
00858 cb = static_cast<sigc::slot1<T_return,T_arg1>*>( cbptr );
00859 return ( *cb ) ( arg1 );
00860 }
00861 throw;
00862 }
00863
00864 template < typename T_return, typename T_arg1, typename T_arg2 >
00865 inline
00866 T_return Environment::callback( void* theEnv ) {
00867 sigc::slot2<T_return, T_arg1, T_arg2>* cb;
00868 void * cbptr = get_function_context( theEnv );
00869 T_arg1 arg1;
00870 T_arg2 arg2;
00871 if ( cbptr ) {
00872 if ( get_arg_count( theEnv ) != 2 )
00873 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
00874 get_argument( theEnv, 1, arg1 );
00875 get_argument( theEnv, 2, arg2 );
00876 cb = static_cast<sigc::slot2<T_return, T_arg1, T_arg2>*>( cbptr );
00877 return ( *cb ) ( arg1, arg2 );
00878 }
00879 throw;
00880 }
00881
00882 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00883 inline
00884 T_return Environment::callback( void* theEnv ) {
00885 sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* cb;
00886 void * cbptr = get_function_context( theEnv );
00887 T_arg1 arg1;
00888 T_arg2 arg2;
00889 T_arg3 arg3;
00890 if ( cbptr ) {
00891 if ( get_arg_count( theEnv ) != 3 )
00892 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
00893 get_argument( theEnv, 1, arg1 );
00894 get_argument( theEnv, 2, arg2 );
00895 get_argument( theEnv, 3, arg3 );
00896 cb = static_cast<sigc::slot3<T_return, T_arg1, T_arg2,T_arg3>*>( cbptr );
00897 return ( *cb ) ( arg1, arg2, arg3 );
00898 }
00899 throw;
00900 }
00901
00902 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00903 inline
00904 T_return Environment::callback( void* theEnv ) {
00905 sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
00906 void * cbptr = get_function_context( theEnv );
00907 T_arg1 arg1;
00908 T_arg2 arg2;
00909 T_arg3 arg3;
00910 T_arg4 arg4;
00911 if ( cbptr ) {
00912 if ( get_arg_count( theEnv ) != 4 )
00913 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
00914 get_argument( theEnv, 1, arg1 );
00915 get_argument( theEnv, 2, arg2 );
00916 get_argument( theEnv, 3, arg3 );
00917 get_argument( theEnv, 4, arg4 );
00918 cb = static_cast<sigc::slot4<T_return, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
00919 return ( *cb ) ( arg1, arg2, arg3, arg4 );
00920 }
00921 throw;
00922 }
00923
00924 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00925 inline
00926 T_return Environment::callback( void* theEnv ) {
00927 sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
00928 void * cbptr = get_function_context( theEnv );
00929 T_arg1 arg1;
00930 T_arg2 arg2;
00931 T_arg3 arg3;
00932 T_arg4 arg4;
00933 T_arg5 arg5;
00934 if ( cbptr ) {
00935 if ( get_arg_count( theEnv ) != 5 )
00936 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
00937 get_argument( theEnv, 1, arg1 );
00938 get_argument( theEnv, 2, arg2 );
00939 get_argument( theEnv, 3, arg3 );
00940 get_argument( theEnv, 4, arg4 );
00941 get_argument( theEnv, 5, arg5 );
00942 cb = static_cast<sigc::slot5<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
00943 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5 );
00944 }
00945 throw;
00946 }
00947
00948 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00949 inline
00950 T_return Environment::callback( void* theEnv ) {
00951 sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
00952 void * cbptr = get_function_context( theEnv );
00953 T_arg1 arg1;
00954 T_arg2 arg2;
00955 T_arg3 arg3;
00956 T_arg4 arg4;
00957 T_arg5 arg5;
00958 T_arg6 arg6;
00959 if ( cbptr ) {
00960 if ( get_arg_count( theEnv ) != 6 )
00961 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
00962 get_argument( theEnv, 1, arg1 );
00963 get_argument( theEnv, 2, arg2 );
00964 get_argument( theEnv, 3, arg3 );
00965 get_argument( theEnv, 4, arg4 );
00966 get_argument( theEnv, 5, arg5 );
00967 get_argument( theEnv, 6, arg6 );
00968 cb = static_cast<sigc::slot6<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
00969 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 );
00970 }
00971 throw;
00972 }
00973
00974 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00975 inline
00976 T_return Environment::callback( void* theEnv ) {
00977 sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
00978 void * cbptr = get_function_context( theEnv );
00979 T_arg1 arg1;
00980 T_arg2 arg2;
00981 T_arg3 arg3;
00982 T_arg4 arg4;
00983 T_arg5 arg5;
00984 T_arg6 arg6;
00985 T_arg7 arg7;
00986 if ( cbptr ) {
00987 if ( get_arg_count( theEnv ) != 7 )
00988 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
00989 get_argument( theEnv, 1, arg1 );
00990 get_argument( theEnv, 2, arg2 );
00991 get_argument( theEnv, 3, arg3 );
00992 get_argument( theEnv, 4, arg4 );
00993 get_argument( theEnv, 5, arg5 );
00994 get_argument( theEnv, 6, arg6 );
00995 get_argument( theEnv, 7, arg7 );
00996 cb = static_cast<sigc::slot7<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
00997 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 );
00998 }
00999 throw;
01000 }
01001
01002 inline
01003 void Environment::callback_multifield( void* theEnv, void *rv) {
01004 sigc::slot0<Values>* cb;
01005 void * cbptr = get_function_context( theEnv );
01006 if ( cbptr ) {
01007 if ( get_arg_count( theEnv ) != 0 )
01008 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 0" );
01009 cb = static_cast<sigc::slot0<Values>*>( cbptr );
01010 Values v = ( *cb ) ();
01011 set_return_values(theEnv, rv, v);
01012 return;
01013 }
01014 throw;
01015 }
01016
01017 template <typename T_arg1>
01018 inline
01019 void Environment::callback_multifield( void* theEnv, void *rv) {
01020 sigc::slot1<Values, T_arg1>* cb;
01021 void * cbptr = get_function_context( theEnv );
01022 T_arg1 arg1;
01023 if ( cbptr ) {
01024 if ( get_arg_count( theEnv ) != 1 )
01025 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 1" );
01026 cb = static_cast<sigc::slot1<Values, T_arg1>*>( cbptr );
01027 get_argument(theEnv, 1, arg1);
01028 Values v = ( *cb ) (arg1);
01029 set_return_values(theEnv, rv, v);
01030 return;
01031 }
01032 throw;
01033 }
01034
01035 template <typename T_arg1, typename T_arg2>
01036 inline
01037 void Environment::callback_multifield( void* theEnv, void *rv) {
01038 sigc::slot2<Values, T_arg1, T_arg2>* cb;
01039 void * cbptr = get_function_context( theEnv );
01040 T_arg1 arg1;
01041 T_arg2 arg2;
01042 if ( cbptr ) {
01043 if ( get_arg_count( theEnv ) != 2 )
01044 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 2" );
01045 cb = static_cast<sigc::slot2<Values, T_arg1, T_arg2>*>( cbptr );
01046 get_argument(theEnv, 1, arg1);
01047 get_argument(theEnv, 2, arg2);
01048 Values v = ( *cb ) (arg1, arg2);
01049 set_return_values(theEnv, rv, v);
01050 return;
01051 }
01052 throw;
01053 }
01054
01055
01056 template <typename T_arg1, typename T_arg2, typename T_arg3>
01057 inline
01058 void Environment::callback_multifield( void* theEnv, void *rv) {
01059 sigc::slot3<Values, T_arg1, T_arg2, T_arg3>* cb;
01060 void * cbptr = get_function_context( theEnv );
01061 T_arg1 arg1;
01062 T_arg2 arg2;
01063 T_arg3 arg3;
01064 if ( cbptr ) {
01065 if ( get_arg_count( theEnv ) != 3 )
01066 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 3" );
01067 cb = static_cast<sigc::slot3<Values, T_arg1, T_arg2, T_arg3>*>( cbptr );
01068 get_argument(theEnv, 1, arg1);
01069 get_argument(theEnv, 2, arg2);
01070 get_argument(theEnv, 3, arg3);
01071 Values v = ( *cb ) (arg1, arg2, arg3);
01072 set_return_values(theEnv, rv, v);
01073 return;
01074 }
01075 throw;
01076 }
01077
01078 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
01079 inline
01080 void Environment::callback_multifield( void* theEnv, void *rv) {
01081 sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>* cb;
01082 void * cbptr = get_function_context( theEnv );
01083 T_arg1 arg1;
01084 T_arg2 arg2;
01085 T_arg3 arg3;
01086 T_arg4 arg4;
01087 if ( cbptr ) {
01088 if ( get_arg_count( theEnv ) != 4 )
01089 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 4" );
01090 cb = static_cast<sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>*>(cbptr);
01091 get_argument(theEnv, 1, arg1);
01092 get_argument(theEnv, 2, arg2);
01093 get_argument(theEnv, 3, arg3);
01094 get_argument(theEnv, 4, arg4);
01095 Values v = ( *cb ) (arg1, arg2, arg3, arg4);
01096 set_return_values(theEnv, rv, v);
01097 return;
01098 }
01099 throw;
01100 }
01101
01102 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01103 typename T_arg5>
01104 inline
01105 void Environment::callback_multifield( void* theEnv, void *rv) {
01106 sigc::slot5<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* cb;
01107 void * cbptr = get_function_context( theEnv );
01108 T_arg1 arg1;
01109 T_arg2 arg2;
01110 T_arg3 arg3;
01111 T_arg4 arg4;
01112 T_arg5 arg5;
01113 if ( cbptr ) {
01114 if ( get_arg_count( theEnv ) != 5 )
01115 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 5" );
01116 cb = static_cast<sigc::slot5<Values, T_arg1, T_arg2, T_arg3,
01117 T_arg4, T_arg5>*>(cbptr);
01118 get_argument(theEnv, 1, arg1);
01119 get_argument(theEnv, 2, arg2);
01120 get_argument(theEnv, 3, arg3);
01121 get_argument(theEnv, 4, arg4);
01122 get_argument(theEnv, 5, arg5);
01123 Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5);
01124 set_return_values(theEnv, rv, v);
01125 return;
01126 }
01127 throw;
01128 }
01129
01130
01131 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01132 typename T_arg5, typename T_arg6>
01133 inline
01134 void Environment::callback_multifield( void* theEnv, void *rv) {
01135 sigc::slot6<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* cb;
01136 void * cbptr = get_function_context( theEnv );
01137 T_arg1 arg1;
01138 T_arg2 arg2;
01139 T_arg3 arg3;
01140 T_arg4 arg4;
01141 T_arg5 arg5;
01142 T_arg6 arg6;
01143 if ( cbptr ) {
01144 if ( get_arg_count( theEnv ) != 6 )
01145 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 6" );
01146 cb = static_cast<sigc::slot6<Values, T_arg1, T_arg2, T_arg3,
01147 T_arg4, T_arg5, T_arg6>*>(cbptr);
01148 get_argument(theEnv, 1, arg1);
01149 get_argument(theEnv, 2, arg2);
01150 get_argument(theEnv, 3, arg3);
01151 get_argument(theEnv, 4, arg4);
01152 get_argument(theEnv, 5, arg5);
01153 get_argument(theEnv, 6, arg6);
01154 Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6);
01155 set_return_values(theEnv, rv, v);
01156 return;
01157 }
01158 throw;
01159 }
01160
01161 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01162 typename T_arg5, typename T_arg6, typename T_arg7>
01163 inline
01164 void Environment::callback_multifield( void* theEnv, void *rv) {
01165 sigc::slot7<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* cb;
01166 void * cbptr = get_function_context( theEnv );
01167 T_arg1 arg1;
01168 T_arg2 arg2;
01169 T_arg3 arg3;
01170 T_arg4 arg4;
01171 T_arg5 arg5;
01172 T_arg6 arg6;
01173 T_arg7 arg7;
01174 if ( cbptr ) {
01175 if ( get_arg_count( theEnv ) != 7 )
01176 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 7" );
01177 cb = static_cast<sigc::slot7<Values, T_arg1, T_arg2, T_arg3,
01178 T_arg4, T_arg5, T_arg6, T_arg7>*>(cbptr);
01179 get_argument(theEnv, 1, arg1);
01180 get_argument(theEnv, 2, arg2);
01181 get_argument(theEnv, 3, arg3);
01182 get_argument(theEnv, 4, arg4);
01183 get_argument(theEnv, 5, arg5);
01184 get_argument(theEnv, 6, arg6);
01185 get_argument(theEnv, 7, arg7);
01186 Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6, arg7);
01187 set_return_values(theEnv, rv, v);
01188 return;
01189 }
01190 throw;
01191 }
01192
01193
01194 inline
01195 void* Environment::strcallback( void* theEnv ) {
01196 sigc::slot0<std::string>* cb;
01197 void * cbptr = get_function_context( theEnv );
01198 if ( cbptr ) {
01199 if ( get_arg_count( theEnv ) != 0 )
01200 throw std::logic_error( "clipsmm/string: wrong # args on slot callback; expected 0" );
01201 cb = static_cast<sigc::slot0<std::string>*>( cbptr );
01202 return add_symbol( ( ( *cb ) ( )).c_str() );
01203 }
01204 throw;
01205 }
01206
01207 template < typename T_arg1 >
01208 inline
01209 void* Environment::strcallback( void* theEnv ) {
01210 sigc::slot1<std::string,T_arg1>* cb;
01211 void * cbptr = get_function_context( theEnv );
01212 T_arg1 arg1;
01213 if ( cbptr ) {
01214 if ( get_arg_count( theEnv ) != 1 )
01215 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
01216 get_argument( theEnv, 1, arg1 );
01217 cb = static_cast<sigc::slot1<std::string,T_arg1>*>( cbptr );
01218 return add_symbol( ( ( *cb ) ( arg1 )).c_str() );
01219 }
01220 throw;
01221 }
01222
01223 template < typename T_arg1, typename T_arg2 >
01224 inline
01225 void* Environment::strcallback( void* theEnv ) {
01226 sigc::slot2<std::string, T_arg1, T_arg2>* cb;
01227 void * cbptr = get_function_context( theEnv );
01228 T_arg1 arg1;
01229 T_arg2 arg2;
01230 if ( cbptr ) {
01231 if ( get_arg_count( theEnv ) != 2 )
01232 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
01233 get_argument( theEnv, 1, arg1 );
01234 get_argument( theEnv, 2, arg2 );
01235 cb = static_cast<sigc::slot2<std::string, T_arg1, T_arg2>*>( cbptr );
01236 return add_symbol( ( ( *cb ) ( arg1, arg2 )).c_str() );
01237 }
01238 throw;
01239 }
01240
01241 template < typename T_arg1, typename T_arg2, typename T_arg3 >
01242 inline
01243 void* Environment::strcallback( void* theEnv ) {
01244 sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>* cb;
01245 void * cbptr = get_function_context( theEnv );
01246 T_arg1 arg1;
01247 T_arg2 arg2;
01248 T_arg3 arg3;
01249 if ( cbptr ) {
01250 if ( get_arg_count( theEnv ) != 3 )
01251 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
01252 get_argument( theEnv, 1, arg1 );
01253 get_argument( theEnv, 2, arg2 );
01254 get_argument( theEnv, 3, arg3 );
01255 cb = static_cast<sigc::slot3<std::string, T_arg1, T_arg2,T_arg3>*>( cbptr );
01256 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3 )).c_str() );
01257 }
01258 throw;
01259 }
01260
01261 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
01262 inline
01263 void* Environment::strcallback( void* theEnv ) {
01264 sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
01265 void * cbptr = get_function_context( theEnv );
01266 T_arg1 arg1;
01267 T_arg2 arg2;
01268 T_arg3 arg3;
01269 T_arg4 arg4;
01270 std::string s;
01271 if ( cbptr ) {
01272 if ( get_arg_count( theEnv ) != 4 )
01273 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
01274 get_argument( theEnv, 1, arg1 );
01275 get_argument( theEnv, 2, arg2 );
01276 get_argument( theEnv, 3, arg3 );
01277 get_argument( theEnv, 4, arg4 );
01278 cb = static_cast<sigc::slot4<std::string, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
01279 s = ( *cb ) ( arg1, arg2, arg3, arg4 );
01280 return add_symbol( s.c_str() );
01281 }
01282 throw;
01283 }
01284
01285 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
01286 inline
01287 void* Environment::strcallback( void* theEnv ) {
01288 sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
01289 void * cbptr = get_function_context( theEnv );
01290 T_arg1 arg1;
01291 T_arg2 arg2;
01292 T_arg3 arg3;
01293 T_arg4 arg4;
01294 T_arg5 arg5;
01295 if ( cbptr ) {
01296 if ( get_arg_count( theEnv ) != 5 )
01297 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
01298 get_argument( theEnv, 1, arg1 );
01299 get_argument( theEnv, 2, arg2 );
01300 get_argument( theEnv, 3, arg3 );
01301 get_argument( theEnv, 4, arg4 );
01302 get_argument( theEnv, 5, arg5 );
01303 cb = static_cast<sigc::slot5<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
01304 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5 )).c_str() );
01305 }
01306 throw;
01307 }
01308
01309 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
01310 inline
01311 void* Environment::strcallback( void* theEnv ) {
01312 sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
01313 void * cbptr = get_function_context( theEnv );
01314 T_arg1 arg1;
01315 T_arg2 arg2;
01316 T_arg3 arg3;
01317 T_arg4 arg4;
01318 T_arg5 arg5;
01319 T_arg6 arg6;
01320 if ( cbptr ) {
01321 if ( get_arg_count( theEnv ) != 6 )
01322 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
01323 get_argument( theEnv, 1, arg1 );
01324 get_argument( theEnv, 2, arg2 );
01325 get_argument( theEnv, 3, arg3 );
01326 get_argument( theEnv, 4, arg4 );
01327 get_argument( theEnv, 5, arg5 );
01328 get_argument( theEnv, 6, arg6 );
01329 cb = static_cast<sigc::slot6<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
01330 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 )).c_str() );
01331 }
01332 throw;
01333 }
01334
01335 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
01336 inline
01337 void* Environment::strcallback( void* theEnv ) {
01338 sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
01339 void * cbptr = get_function_context( theEnv );
01340 T_arg1 arg1;
01341 T_arg2 arg2;
01342 T_arg3 arg3;
01343 T_arg4 arg4;
01344 T_arg5 arg5;
01345 T_arg6 arg6;
01346 T_arg7 arg7;
01347 if ( cbptr ) {
01348 if ( get_arg_count( theEnv ) != 7 )
01349 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
01350 get_argument( theEnv, 1, arg1 );
01351 get_argument( theEnv, 2, arg2 );
01352 get_argument( theEnv, 3, arg3 );
01353 get_argument( theEnv, 4, arg4 );
01354 get_argument( theEnv, 5, arg5 );
01355 get_argument( theEnv, 6, arg6 );
01356 get_argument( theEnv, 7, arg7 );
01357 cb = static_cast<sigc::slot7<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
01358 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 )).c_str() );
01359 }
01360 throw;
01361 }
01362
01363 template < typename T_return >
01364 inline
01365 bool Environment::add_function( std::string name, const sigc::slot0<T_return>& slot) {
01366 char retcode = get_return_code<T_return>( );
01367 char *argstring = get_function_restriction(name);
01368 sigc::slot0<T_return>* scb = new sigc::slot0<T_return>(slot);
01369 any holder = CLIPSPointer<sigc::slot0<T_return> >(scb);
01370 m_slots[name] = holder;
01371 return ( EnvDefineFunction2WithContext( m_cobj,
01372 const_cast<char*>( name.c_str() ),
01373 retcode,
01374 get_callback(slot),
01375 const_cast<char*>( name.c_str() ),
01376 argstring,
01377 ( void* ) scb ) );
01378 }
01379
01380 template < typename T_return, typename T_arg1 >
01381 inline
01382 bool Environment::add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot) {
01383 char retcode = get_return_code<T_return>( );
01384 char *argstring = get_function_restriction<T_arg1>(name);
01385 sigc::slot1<T_return, T_arg1>* scb = new sigc::slot1<T_return, T_arg1>(slot);
01386 any holder = CLIPSPointer<sigc::slot1<T_return, T_arg1> >(scb);
01387 m_slots[name] = holder;
01388 return ( EnvDefineFunction2WithContext( m_cobj,
01389 const_cast<char*>( name.c_str() ),
01390 retcode,
01391 get_callback(slot),
01392 const_cast<char*>( name.c_str() ),
01393 argstring,
01394 scb ) );
01395 }
01396
01397 template < typename T_return, typename T_arg1, typename T_arg2 >
01398 inline
01399 bool Environment::add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot) {
01400 char retcode = get_return_code<T_return>( );
01401 char *argstring = get_function_restriction<T_arg1,T_arg2>(name);
01402 sigc::slot2<T_return, T_arg1, T_arg2>* scb = new sigc::slot2<T_return, T_arg1, T_arg2>(slot);
01403 any holder = CLIPSPointer<sigc::slot2<T_return, T_arg1, T_arg2> >(scb);
01404 m_slots[name] = holder;
01405 return ( EnvDefineFunction2WithContext( m_cobj,
01406 const_cast<char*>( name.c_str() ),
01407 retcode,
01408 get_callback(slot),
01409 const_cast<char*>( name.c_str() ),
01410 argstring,
01411 scb ) );
01412 }
01413
01414 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
01415 inline
01416 bool Environment::add_function( std::string name, const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot) {
01417 char retcode = get_return_code<T_return>( );
01418 char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3>(name);
01419 sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* scb =
01420 new sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>(slot);
01421 any holder = CLIPSPointer<sigc::slot3<T_return,T_arg1,T_arg2,T_arg3> >(scb);
01422 m_slots[name] = holder;
01423 return ( EnvDefineFunction2WithContext( m_cobj,
01424 const_cast<char*>( name.c_str() ),
01425 retcode,
01426 get_callback(slot),
01427 const_cast<char*>( name.c_str() ),
01428 argstring,
01429 scb )
01430 );
01431 }
01432
01433 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
01434 inline
01435 bool Environment::add_function( std::string name, const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot) {
01436 char retcode = get_return_code<T_return>( );
01437 char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4>(name);
01438 sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* scb =
01439 new sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>(slot);
01440 any holder = CLIPSPointer<sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4> >(scb);
01441 m_slots[name] = holder;
01442 return ( EnvDefineFunction2WithContext( m_cobj,
01443 const_cast<char*>( name.c_str() ),
01444 retcode,
01445 get_callback(slot),
01446 const_cast<char*>( name.c_str() ),
01447 argstring,
01448 scb )
01449 );
01450 }
01451
01452 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
01453 inline
01454 bool Environment::add_function( std::string name,
01455 const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot) {
01456 char retcode = get_return_code<T_return>( );
01457 char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(name);
01458 sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* scb =
01459 new sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(slot);
01460 any holder = CLIPSPointer<sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> >(scb);
01461 m_slots[name] = holder;
01462 return ( EnvDefineFunction2WithContext( m_cobj,
01463 const_cast<char*>( name.c_str() ),
01464 retcode,
01465 get_callback(slot),
01466 const_cast<char*>( name.c_str() ),
01467 argstring,
01468 scb )
01469 );
01470 }
01471
01472 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
01473 inline
01474 bool Environment::add_function( std::string name,
01475 const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot) {
01476 char retcode = get_return_code<T_return>( );
01477 char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(name);
01478 sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* scb =
01479 new sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(slot);
01480 any holder = CLIPSPointer<sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> >(scb);
01481 m_slots[name] = holder;
01482 return ( EnvDefineFunction2WithContext( m_cobj,
01483 const_cast<char*>( name.c_str() ),
01484 retcode,
01485 get_callback(slot),
01486 const_cast<char*>( name.c_str() ),
01487 argstring,
01488 scb )
01489 );
01490 }
01491
01492 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
01493 inline
01494 bool Environment::add_function( std::string name,
01495 const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot) {
01496 char retcode = get_return_code<T_return>( );
01497 char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(name);
01498 sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* scb =
01499 new sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(slot);
01500 any holder = CLIPSPointer<sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> >(scb);
01501 m_slots[name] = holder;
01502 return ( EnvDefineFunction2WithContext( m_cobj,
01503 const_cast<char*>( name.c_str() ),
01504 retcode,
01505 get_callback(slot),
01506 const_cast<char*>( name.c_str() ),
01507 argstring,
01508 scb )
01509 );
01510 }
01511
01512 }
01513
01514
01515 #endif