00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef CLIPSENVIRONMENT_H
00021 #define CLIPSENVIRONMENT_H
00022
00023 #include <string>
00024 #include <map>
00025 #include <typeinfo>
00026 #include <stdexcept>
00027 #include <map>
00028 #include <queue>
00029
00030 #include <iostream>
00031
00032 #include <sigc++/sigc++.h>
00033 #include <glibmm.h>
00034
00035 #include <clipsmm/enum.h>
00036 #include <clipsmm/object.h>
00037
00038 #include <clipsmm/activation.h>
00039 #include <clipsmm/defaultfacts.h>
00040 #include <clipsmm/fact.h>
00041 #include <clipsmm/function.h>
00042 #include <clipsmm/global.h>
00043 #include <clipsmm/module.h>
00044 #include <clipsmm/rule.h>
00045 #include <clipsmm/template.h>
00046
00047 #include <clipsmm/utility.h>
00048 #include <clipsmm/any.h>
00049
00050 extern "C" {
00051 int EnvDefineFunction2WithContext( void *, char *, int, int ( * ) ( void * ), char *, char *, void * );
00052 }
00053
00054 namespace CLIPS {
00055
00059 class Environment: public Object {
00060 public:
00061 typedef CLIPSPointer<Environment> pointer;
00062
00063 Environment();
00064
00065 ~Environment();
00066
00071 bool batch_evaluate( const std::string& filename );
00072
00077 bool binary_load( const std::string& filename );
00078
00083 bool binary_save( const std::string& filename );
00084
00089 bool build( const std::string& construct );
00090
00094 void clear( );
00095
00101 Values evaluate( const std::string& expression );
00102
00108 Values function( const std::string& function_name, const std::string& arguments=std::string() );
00109
00121 int load( const std::string& filename );
00122
00126 void reset();
00127
00132 bool save( const std::string& filename );
00133
00140 bool auto_float_dividend_enabled();
00141
00149 bool use_auto_float_dividend( bool use = true );
00150
00157 bool dynamic_constraint_checking_enabled();
00158
00166 bool use_dynamic_constraint_checking( bool use = true );
00167
00174 bool sequence_operator_recognition_enabled();
00175
00183 bool use_sequence_operator_recognition( bool use = true );
00184
00191 bool static_constraint_checking_enabled();
00192
00199 bool use_static_constraint_checking( bool use = true );
00200
00208 bool fact_duplication_enabled();
00209
00216 bool use_fact_duplication( bool use = true );
00217
00218 bool incremental_reset_enabled();
00219
00220 bool use_incremental_reset( bool use = true );
00221
00222 bool global_reset_enable();
00223
00224 bool use_global_reset( bool use=true );
00225
00230 bool is_dribble_active( );
00231
00236 bool dribble_off( );
00237
00242 bool dribble_on( const std::string& dribble_file );
00243
00251 int is_watched( const std::string& item );
00252
00253 bool watch( const std::string& item );
00254
00255 bool unwatch( const std::string& item );
00256
00257 void set_as_current();
00258
00259 Fact::pointer assert_fact( const std::string& factstring );
00260
00261 void clear_focus_stack();
00262
00265 DefaultFacts::pointer get_default_facts( const std::string& default_facts_name );
00266
00268 std::vector<std::string> get_default_facts_names();
00269
00271 std::vector<std::string> get_default_facts_names( const Module& module );
00272
00274 std::vector<std::string> get_default_facts_names( Module::pointer module );
00275
00276 DefaultFacts::pointer get_default_facts_list_head();
00277
00278 Template::pointer get_template( const std::string& template_name );
00279
00281 std::vector<std::string> get_template_names();
00282
00284 std::vector<std::string> get_template_names( const Module& module );
00285
00287 std::vector<std::string> get_template_names( Module::pointer module );
00288
00289 Template::pointer get_template_list_head();
00290
00291 Rule::pointer get_rule( const std::string& rule_name );
00292
00294 std::vector<std::string> get_rule_names();
00295
00297 std::vector<std::string> get_rule_names( const Module& module );
00298
00300 std::vector<std::string> get_rule_names( Module::pointer module );
00301
00302 Rule::pointer get_rule_list_head();
00303
00304 void remove_rules();
00305
00306 Module::pointer get_module( const std::string& module_name );
00307
00308 Module::pointer get_current_module();
00309
00310 std::vector<std::string> get_module_names();
00311
00312 Module::pointer get_module_list_head();
00313
00319 void refresh_agenda();
00320
00326 void refresh_agenda( const Module& module );
00327
00333 void refresh_agenda( Module::pointer module );
00334
00340 void reorder_agenda();
00341
00347 void reorder_agenda( const Module& module );
00348
00354 void reorder_agenda( Module::pointer module );
00355
00365 long int run( long int runlimit = -1 );
00366
00385 void run_threaded( long int runlimit = -1, int priority = 0 );
00386
00388 void join_run_thread();
00389
00391 sigc::signal<void, long int> signal_run();
00392
00394 SalienceEvaluation get_salience_evaluation();
00395
00400 SalienceEvaluation set_salience_evaluation( SalienceEvaluation se );
00401
00403 ConflictResolution get_conflict_resolution_strategy();
00404
00409 ConflictResolution set_conflict_resolution_strategy( ConflictResolution cr );
00410
00419 bool check_agenda_changed();
00420
00421 Module::pointer get_focused_module();
00422
00423 std::vector<std::string> get_focus_stack();
00424
00425 Activation::pointer get_activation_list_head();
00426
00427 Global::pointer get_global( const std::string& global_name );
00428
00429 Global::pointer get_global_list_head();
00430
00432 std::vector<std::string> get_globals_names();
00433
00435 std::vector<std::string> get_globals_names( const Module& module );
00436
00438 std::vector<std::string> get_globals_names( Module::pointer module );
00439
00440 bool check_globals_changed();
00441
00442 Function::pointer get_function( const std::string& function_name );
00443
00444 Function::pointer get_function_list_head();
00445
00447 std::vector<std::string> get_function_names();
00448
00450 std::vector<std::string> get_function_names( const Module& module );
00451
00453 std::vector<std::string> get_function_names( Module::pointer module );
00454
00455 sigc::signal<void> signal_clear();
00456 sigc::signal<void> signal_periodic();
00457 sigc::signal<void> signal_reset();
00458 sigc::signal<void> signal_rule_firing();
00459 sigc::signal<void> signal_agenda_changed();
00460 sigc::signal<void> signal_globals_changed();
00461
00462 template < typename T_return >
00463 bool add_function( std::string name, const sigc::slot0<T_return>& slot);
00464
00465 template < typename T_return, typename T_arg1 >
00466 bool add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot);
00467
00468 template < typename T_return, typename T_arg1, typename T_arg2 >
00469 bool add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot);
00470
00471 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00472 bool add_function( std::string name, const sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>& slot);
00473
00474 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00475 bool add_function( std::string name, const sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>& slot);
00476
00477 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00478 bool add_function( std::string name, const sigc::slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& slot);
00479
00480 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00481 bool add_function( std::string name, const sigc::slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& slot);
00482
00483 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 >
00484 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);
00485
00486 bool remove_function( std::string name );
00487
00488 protected:
00495 std::map<std::string,any> m_slots;
00496
00497 sigc::signal<void> m_signal_clear;
00498 sigc::signal<void> m_signal_periodic;
00499 sigc::signal<void> m_signal_reset;
00500 sigc::signal<void> m_signal_rule_firing;
00501 sigc::signal<void> m_signal_agenda_changed;
00502 sigc::signal<void> m_signal_globals_changed;
00503
00505 typedef struct Job {
00507 Job( int p, long int rl ) : priority(p), runlimit(rl) { }
00508
00510 bool operator<( const Job& other ) const { return priority < other.priority; }
00511
00513 int priority;
00514
00519 long int runlimit;
00520 } Job;
00521
00522 Glib::Thread* m_run_thread;
00523 std::priority_queue<Job> m_run_queue;
00524 Glib::Mutex m_mutex_run_queue;
00525 Glib::Mutex m_mutex_run;
00526 Glib::Mutex m_mutex_threaded_run;
00527 Glib::Mutex m_mutex_run_signal;
00528 sigc::signal<void, long int> m_signal_run;
00531 void threaded_run();
00532
00533 static std::map<void*, Environment*> m_environment_map;
00534
00535
00536 static void clear_callback( void* env );
00537 static void periodic_callback( void* env );
00538 static void reset_callback( void* env );
00539 static void rule_firing_callback( void* end );
00540
00541 static void* strcallback( void* theEnv );
00542
00543 template < typename T_arg1 >
00544 static void* strcallback( void* theEnv );
00545
00546 template < typename T_arg1, typename T_arg2 >
00547 static void* strcallback( void* theEnv );
00548
00549 template < typename T_arg1, typename T_arg2, typename T_arg3 >
00550 static void* strcallback( void* theEnv );
00551
00552 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00553 static void* strcallback( void* theEnv );
00554
00555 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00556 static void* strcallback( void* theEnv );
00557
00558 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00559 static void* strcallback( void* theEnv );
00560
00561 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00562 static void* strcallback( void* theEnv );
00563
00564 template < typename T_return >
00565 static T_return callback( void* theEnv );
00566
00567 template < typename T_return, typename T_arg1 >
00568 static T_return callback( void* theEnv );
00569
00570 template < typename T_return, typename T_arg1, typename T_arg2 >
00571 static T_return callback( void* theEnv );
00572
00573 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00574 static T_return callback( void* theEnv );
00575
00576 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00577 static T_return callback( void* theEnv );
00578
00579 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00580 static T_return callback( void* theEnv );
00581
00582 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00583 static T_return callback( void* theEnv );
00584
00585 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 >
00586 static T_return callback( void* theEnv );
00587
00588 int ( *get_callback( const sigc::slot0<std::string>& slot ))( void* )
00589 { return ( int ( * ) ( void* ) ) ( std::string ( * ) ( void* ) ) callback<std::string>; }
00590
00591 template < typename T_arg1 >
00592 int ( *get_callback( const sigc::slot1<std::string,T_arg1>& slot ))( void* )
00593 { return ( int ( * ) ( void* ) ) ( std::string ( * ) ( void* ) ) callback<std::string,T_arg1>; }
00594
00595 template < typename T_arg1, typename T_arg2 >
00596 int ( *get_callback( const sigc::slot2<std::string,T_arg1,T_arg2>& slot ))( void* )
00597 { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1,T_arg2>; }
00598
00599 template < typename T_arg1, typename T_arg2, typename T_arg3 >
00600 int ( *get_callback( const sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00601 { return (int(*)(void*)) (std::string(*)(void*)) callback<std::string,T_arg1,T_arg2,T_arg3>; }
00602
00603 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00604 int ( *get_callback( const sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00605 { return (int(*)(void*)) (std::string(*)(void*)) callback<std::string,T_arg1,T_arg2,T_arg3,T_arg4>; }
00606
00607 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00608 int ( *get_callback( const sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00609 { return (int(*)(void*)) (std::string(*)(void*)) callback<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00610
00611 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00612 int ( *get_callback( const sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00613 { return (int(*)(void*)) (std::string(*)(void*)) callback<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00614
00615 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00616 int ( *get_callback( const sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00617 { return (int(*)(void*)) (std::string(*)(void*)) callback<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00618
00619 template < typename T_return >
00620 int ( *get_callback( const sigc::slot0<T_return>& slot ))( void* )
00621 { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return>; }
00622
00623 template < typename T_return, typename T_arg1 >
00624 int ( *get_callback( const sigc::slot1<T_return,T_arg1>& slot ))( void* )
00625 { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1>; }
00626
00627 template < typename T_return, typename T_arg1, typename T_arg2 >
00628 int ( *get_callback( const sigc::slot2<T_return,T_arg1,T_arg2>& slot ))( void* )
00629 { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1,T_arg2>; }
00630
00631 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00632 int ( *get_callback( const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00633 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3>; }
00634
00635 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00636 int ( *get_callback( const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00637 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4>; }
00638
00639 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00640 int ( *get_callback( const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00641 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00642
00643 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00644 int ( *get_callback( const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00645 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00646
00647 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 >
00648 int ( *get_callback( const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00649 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00650
00651 static int get_arg_count( void* env );
00652 static void* get_function_context( void* env );
00653 static void* add_symbol( const char* s );
00654
00655
00656 };
00657
00658 template < typename T_return>
00659 inline
00660 T_return Environment::callback( void* theEnv ) {
00661 sigc::slot0<T_return>* cb;
00662 void * cbptr = get_function_context( theEnv );
00663 if ( cbptr ) {
00664 if ( get_arg_count( theEnv ) != 0 )
00665 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 0" );
00666 cb = static_cast<sigc::slot0<T_return>*>( cbptr );
00667 return ( *cb ) ();
00668 }
00669 throw;
00670 }
00671
00672 template < typename T_return, typename T_arg1 >
00673 inline
00674 T_return Environment::callback( void* theEnv ) {
00675 sigc::slot1<T_return,T_arg1>* cb;
00676 void * cbptr = get_function_context( theEnv );
00677 T_arg1 arg1;
00678 if ( cbptr ) {
00679 if ( get_arg_count( theEnv ) != 1 )
00680 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
00681 get_argument( theEnv, 1, arg1 );
00682 cb = static_cast<sigc::slot1<T_return,T_arg1>*>( cbptr );
00683 return ( *cb ) ( arg1 );
00684 }
00685 throw;
00686 }
00687
00688 template < typename T_return, typename T_arg1, typename T_arg2 >
00689 inline
00690 T_return Environment::callback( void* theEnv ) {
00691 sigc::slot2<T_return, T_arg1, T_arg2>* cb;
00692 void * cbptr = get_function_context( theEnv );
00693 T_arg1 arg1;
00694 T_arg2 arg2;
00695 if ( cbptr ) {
00696 if ( get_arg_count( theEnv ) != 2 )
00697 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
00698 get_argument( theEnv, 1, arg1 );
00699 get_argument( theEnv, 2, arg2 );
00700 cb = static_cast<sigc::slot2<T_return, T_arg1, T_arg2>*>( cbptr );
00701 return ( *cb ) ( arg1, arg2 );
00702 }
00703 throw;
00704 }
00705
00706 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00707 inline
00708 T_return Environment::callback( void* theEnv ) {
00709 sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* cb;
00710 void * cbptr = get_function_context( theEnv );
00711 T_arg1 arg1;
00712 T_arg2 arg2;
00713 T_arg3 arg3;
00714 if ( cbptr ) {
00715 if ( get_arg_count( theEnv ) != 3 )
00716 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
00717 get_argument( theEnv, 1, arg1 );
00718 get_argument( theEnv, 2, arg2 );
00719 get_argument( theEnv, 3, arg3 );
00720 cb = static_cast<sigc::slot3<T_return, T_arg1, T_arg2,T_arg3>*>( cbptr );
00721 return ( *cb ) ( arg1, arg2, arg3 );
00722 }
00723 throw;
00724 }
00725
00726 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00727 inline
00728 T_return Environment::callback( void* theEnv ) {
00729 sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
00730 void * cbptr = get_function_context( theEnv );
00731 T_arg1 arg1;
00732 T_arg2 arg2;
00733 T_arg3 arg3;
00734 T_arg4 arg4;
00735 if ( cbptr ) {
00736 if ( get_arg_count( theEnv ) != 4 )
00737 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
00738 get_argument( theEnv, 1, arg1 );
00739 get_argument( theEnv, 2, arg2 );
00740 get_argument( theEnv, 3, arg3 );
00741 get_argument( theEnv, 4, arg4 );
00742 cb = static_cast<sigc::slot4<T_return, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
00743 return ( *cb ) ( arg1, arg2, arg3, arg4 );
00744 }
00745 throw;
00746 }
00747
00748 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00749 inline
00750 T_return Environment::callback( void* theEnv ) {
00751 sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
00752 void * cbptr = get_function_context( theEnv );
00753 T_arg1 arg1;
00754 T_arg2 arg2;
00755 T_arg3 arg3;
00756 T_arg4 arg4;
00757 T_arg5 arg5;
00758 if ( cbptr ) {
00759 if ( get_arg_count( theEnv ) != 5 )
00760 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
00761 get_argument( theEnv, 1, arg1 );
00762 get_argument( theEnv, 2, arg2 );
00763 get_argument( theEnv, 3, arg3 );
00764 get_argument( theEnv, 4, arg4 );
00765 get_argument( theEnv, 5, arg5 );
00766 cb = static_cast<sigc::slot5<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
00767 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5 );
00768 }
00769 throw;
00770 }
00771
00772 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00773 inline
00774 T_return Environment::callback( void* theEnv ) {
00775 sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
00776 void * cbptr = get_function_context( theEnv );
00777 T_arg1 arg1;
00778 T_arg2 arg2;
00779 T_arg3 arg3;
00780 T_arg4 arg4;
00781 T_arg5 arg5;
00782 T_arg6 arg6;
00783 if ( cbptr ) {
00784 if ( get_arg_count( theEnv ) != 6 )
00785 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
00786 get_argument( theEnv, 1, arg1 );
00787 get_argument( theEnv, 2, arg2 );
00788 get_argument( theEnv, 3, arg3 );
00789 get_argument( theEnv, 4, arg4 );
00790 get_argument( theEnv, 5, arg5 );
00791 get_argument( theEnv, 6, arg6 );
00792 cb = static_cast<sigc::slot6<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
00793 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 );
00794 }
00795 throw;
00796 }
00797
00798 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 >
00799 inline
00800 T_return Environment::callback( void* theEnv ) {
00801 sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
00802 void * cbptr = get_function_context( theEnv );
00803 T_arg1 arg1;
00804 T_arg2 arg2;
00805 T_arg3 arg3;
00806 T_arg4 arg4;
00807 T_arg5 arg5;
00808 T_arg6 arg6;
00809 T_arg7 arg7;
00810 if ( cbptr ) {
00811 if ( get_arg_count( theEnv ) != 7 )
00812 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
00813 get_argument( theEnv, 1, arg1 );
00814 get_argument( theEnv, 2, arg2 );
00815 get_argument( theEnv, 3, arg3 );
00816 get_argument( theEnv, 4, arg4 );
00817 get_argument( theEnv, 5, arg5 );
00818 get_argument( theEnv, 6, arg6 );
00819 get_argument( theEnv, 7, arg7 );
00820 cb = static_cast<sigc::slot7<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
00821 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 );
00822 }
00823 throw;
00824 }
00825
00826 inline
00827 void* Environment::strcallback( void* theEnv ) {
00828 sigc::slot0<std::string>* cb;
00829 void * cbptr = get_function_context( theEnv );
00830 if ( cbptr ) {
00831 if ( get_arg_count( theEnv ) != 0 )
00832 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 0" );
00833 cb = static_cast<sigc::slot0<std::string>*>( cbptr );
00834 return add_symbol( ( ( *cb ) ( )).c_str() );
00835 }
00836 throw;
00837 }
00838
00839 template < typename T_arg1 >
00840 inline
00841 void* Environment::strcallback( void* theEnv ) {
00842 sigc::slot1<std::string,T_arg1>* cb;
00843 void * cbptr = get_function_context( theEnv );
00844 T_arg1 arg1;
00845 if ( cbptr ) {
00846 if ( get_arg_count( theEnv ) != 1 )
00847 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
00848 get_argument( theEnv, 1, arg1 );
00849 cb = static_cast<sigc::slot1<std::string,T_arg1>*>( cbptr );
00850 return add_symbol( ( ( *cb ) ( arg1 )).c_str() );
00851 }
00852 throw;
00853 }
00854
00855 template < typename T_arg1, typename T_arg2 >
00856 inline
00857 void* Environment::strcallback( void* theEnv ) {
00858 sigc::slot2<std::string, T_arg1, T_arg2>* cb;
00859 void * cbptr = get_function_context( theEnv );
00860 T_arg1 arg1;
00861 T_arg2 arg2;
00862 if ( cbptr ) {
00863 if ( get_arg_count( theEnv ) != 2 )
00864 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
00865 get_argument( theEnv, 1, arg1 );
00866 get_argument( theEnv, 2, arg2 );
00867 cb = static_cast<sigc::slot2<std::string, T_arg1, T_arg2>*>( cbptr );
00868 return add_symbol( ( ( *cb ) ( arg1, arg2 )).c_str() );
00869 }
00870 throw;
00871 }
00872
00873 template < typename T_arg1, typename T_arg2, typename T_arg3 >
00874 inline
00875 void* Environment::strcallback( void* theEnv ) {
00876 sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>* cb;
00877 void * cbptr = get_function_context( theEnv );
00878 T_arg1 arg1;
00879 T_arg2 arg2;
00880 T_arg3 arg3;
00881 if ( cbptr ) {
00882 if ( get_arg_count( theEnv ) != 3 )
00883 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
00884 get_argument( theEnv, 1, arg1 );
00885 get_argument( theEnv, 2, arg2 );
00886 get_argument( theEnv, 3, arg3 );
00887 cb = static_cast<sigc::slot3<std::string, T_arg1, T_arg2,T_arg3>*>( cbptr );
00888 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3 )).c_str() );
00889 }
00890 throw;
00891 }
00892
00893 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00894 inline
00895 void* Environment::strcallback( void* theEnv ) {
00896 sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
00897 void * cbptr = get_function_context( theEnv );
00898 T_arg1 arg1;
00899 T_arg2 arg2;
00900 T_arg3 arg3;
00901 T_arg4 arg4;
00902 std::string s;
00903 if ( cbptr ) {
00904 if ( get_arg_count( theEnv ) != 4 )
00905 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
00906 get_argument( theEnv, 1, arg1 );
00907 std::cout << "Arg1: " << arg1 << std::endl;
00908 get_argument( theEnv, 2, arg2 );
00909 std::cout << "Arg2: " << arg2 << std::endl;
00910 get_argument( theEnv, 3, arg3 );
00911 std::cout << "Arg3: " << arg3 << std::endl;
00912 get_argument( theEnv, 4, arg4 );
00913 std::cout << "Arg4: " << arg4 << std::endl;
00914 cb = static_cast<sigc::slot4<std::string, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
00915 s = ( *cb ) ( arg1, arg2, arg3, arg4 );
00916 std::cout << "Adding: " << s << std::endl;
00917 return add_symbol( s.c_str() );
00918 }
00919 throw;
00920 }
00921
00922 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00923 inline
00924 void* Environment::strcallback( void* theEnv ) {
00925 sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
00926 void * cbptr = get_function_context( theEnv );
00927 T_arg1 arg1;
00928 T_arg2 arg2;
00929 T_arg3 arg3;
00930 T_arg4 arg4;
00931 T_arg5 arg5;
00932 if ( cbptr ) {
00933 if ( get_arg_count( theEnv ) != 5 )
00934 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
00935 get_argument( theEnv, 1, arg1 );
00936 get_argument( theEnv, 2, arg2 );
00937 get_argument( theEnv, 3, arg3 );
00938 get_argument( theEnv, 4, arg4 );
00939 get_argument( theEnv, 5, arg5 );
00940 cb = static_cast<sigc::slot5<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
00941 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5 )).c_str() );
00942 }
00943 throw;
00944 }
00945
00946 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00947 inline
00948 void* Environment::strcallback( void* theEnv ) {
00949 sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
00950 void * cbptr = get_function_context( theEnv );
00951 T_arg1 arg1;
00952 T_arg2 arg2;
00953 T_arg3 arg3;
00954 T_arg4 arg4;
00955 T_arg5 arg5;
00956 T_arg6 arg6;
00957 if ( cbptr ) {
00958 if ( get_arg_count( theEnv ) != 6 )
00959 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
00960 get_argument( theEnv, 1, arg1 );
00961 get_argument( theEnv, 2, arg2 );
00962 get_argument( theEnv, 3, arg3 );
00963 get_argument( theEnv, 4, arg4 );
00964 get_argument( theEnv, 5, arg5 );
00965 get_argument( theEnv, 6, arg6 );
00966 cb = static_cast<sigc::slot6<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
00967 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 )).c_str() );
00968 }
00969 throw;
00970 }
00971
00972 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00973 inline
00974 void* Environment::strcallback( void* theEnv ) {
00975 sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
00976 void * cbptr = get_function_context( theEnv );
00977 T_arg1 arg1;
00978 T_arg2 arg2;
00979 T_arg3 arg3;
00980 T_arg4 arg4;
00981 T_arg5 arg5;
00982 T_arg6 arg6;
00983 T_arg7 arg7;
00984 if ( cbptr ) {
00985 if ( get_arg_count( theEnv ) != 7 )
00986 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
00987 get_argument( theEnv, 1, arg1 );
00988 get_argument( theEnv, 2, arg2 );
00989 get_argument( theEnv, 3, arg3 );
00990 get_argument( theEnv, 4, arg4 );
00991 get_argument( theEnv, 5, arg5 );
00992 get_argument( theEnv, 6, arg6 );
00993 get_argument( theEnv, 7, arg7 );
00994 cb = static_cast<sigc::slot7<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
00995 return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 )).c_str() );
00996 }
00997 throw;
00998 }
00999
01000 template < typename T_return >
01001 inline
01002 bool Environment::add_function( std::string name, const sigc::slot0<T_return>& slot) {
01003 char retcode = get_return_code<T_return>( );
01004 char argstring[ 10 ] = { '0', '0', 'u', 0x00 };
01005 sigc::slot0<T_return>* scb = new sigc::slot0<T_return>(slot);
01006 any holder = CLIPSPointer<sigc::slot0<T_return> >(scb);
01007 m_slots[name] = holder;
01008 return ( EnvDefineFunction2WithContext( m_cobj,
01009 const_cast<char*>( name.c_str() ),
01010 retcode,
01011 get_callback(slot),
01012 const_cast<char*>( name.c_str() ),
01013 argstring,
01014 ( void* ) scb ) );
01015 }
01016
01017 template < typename T_return, typename T_arg1 >
01018 inline
01019 bool Environment::add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot) {
01020 char retcode = get_return_code<T_return>( );
01021 char argstring[ 10 ] = { '1', '1', 'u', 0x00 };
01022 argstring[ 3 ] = get_argument_code<T_arg1>( );
01023 sigc::slot1<T_return, T_arg1>* scb = new sigc::slot1<T_return, T_arg1>(slot);
01024 any holder = CLIPSPointer<sigc::slot1<T_return, T_arg1> >(scb);
01025 m_slots[name] = holder;
01026 return ( EnvDefineFunction2WithContext( m_cobj,
01027 const_cast<char*>( name.c_str() ),
01028 retcode,
01029 get_callback(slot),
01030 const_cast<char*>( name.c_str() ),
01031 argstring,
01032 scb ) );
01033 }
01034
01035 template < typename T_return, typename T_arg1, typename T_arg2 >
01036 inline
01037 bool Environment::add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot) {
01038 char retcode = get_return_code<T_return>( );
01039 char argstring[ 10 ] = { '2', '2', 'u', 0x00 };
01040 argstring[ 3 ] = get_argument_code<T_arg1>( );
01041 argstring[ 4 ] = get_argument_code<T_arg2>( );
01042 sigc::slot2<T_return, T_arg1, T_arg2>* scb = new sigc::slot2<T_return, T_arg1, T_arg2>(slot);
01043 any holder = CLIPSPointer<sigc::slot2<T_return, T_arg1, T_arg2> >(scb);
01044 m_slots[name] = holder;
01045 return ( EnvDefineFunction2WithContext( m_cobj,
01046 const_cast<char*>( name.c_str() ),
01047 retcode,
01048 get_callback(slot),
01049 const_cast<char*>( name.c_str() ),
01050 argstring,
01051 scb ) );
01052 }
01053
01054 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
01055 inline
01056 bool Environment::add_function( std::string name, const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot) {
01057 char retcode = get_return_code<T_return>( );
01058 char argstring[ 10 ] = { '3', '3', 'u', 0x00 };
01059 argstring[ 3 ] = get_argument_code<T_arg1>( );
01060 argstring[ 4 ] = get_argument_code<T_arg2>( );
01061 argstring[ 5 ] = get_argument_code<T_arg3>( );
01062 sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* scb =
01063 new sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>(slot);
01064 any holder = CLIPSPointer<sigc::slot3<T_return,T_arg1,T_arg2,T_arg3> >(scb);
01065 m_slots[name] = holder;
01066 return ( EnvDefineFunction2WithContext( m_cobj,
01067 const_cast<char*>( name.c_str() ),
01068 retcode,
01069 get_callback(slot),
01070 const_cast<char*>( name.c_str() ),
01071 argstring,
01072 scb )
01073 );
01074 }
01075
01076 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
01077 inline
01078 bool Environment::add_function( std::string name, const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot) {
01079 char retcode = get_return_code<T_return>( );
01080 char argstring[ 10 ] = { '4', '4', 'u', 0x00 };
01081 argstring[ 3 ] = get_argument_code<T_arg1>( );
01082 argstring[ 4 ] = get_argument_code<T_arg2>( );
01083 argstring[ 5 ] = get_argument_code<T_arg3>( );
01084 argstring[ 6 ] = get_argument_code<T_arg4>( );
01085 sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* scb =
01086 new sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>(slot);
01087 any holder = CLIPSPointer<sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4> >(scb);
01088 m_slots[name] = holder;
01089 return ( EnvDefineFunction2WithContext( m_cobj,
01090 const_cast<char*>( name.c_str() ),
01091 retcode,
01092 get_callback(slot),
01093 const_cast<char*>( name.c_str() ),
01094 argstring,
01095 scb )
01096 );
01097 }
01098
01099 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
01100 inline
01101 bool Environment::add_function( std::string name,
01102 const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot) {
01103 char retcode = get_return_code<T_return>( );
01104 char argstring[ 10 ] = { '5', '5', 'u', 0x00 };
01105 argstring[ 3 ] = get_argument_code<T_arg1>( );
01106 argstring[ 4 ] = get_argument_code<T_arg2>( );
01107 argstring[ 5 ] = get_argument_code<T_arg3>( );
01108 argstring[ 6 ] = get_argument_code<T_arg4>( );
01109 argstring[ 7 ] = get_argument_code<T_arg5>( );
01110 sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* scb =
01111 new sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(slot);
01112 any holder = CLIPSPointer<sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> >(scb);
01113 m_slots[name] = holder;
01114 return ( EnvDefineFunction2WithContext( m_cobj,
01115 const_cast<char*>( name.c_str() ),
01116 retcode,
01117 get_callback(slot),
01118 const_cast<char*>( name.c_str() ),
01119 argstring,
01120 scb )
01121 );
01122 }
01123
01124 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
01125 inline
01126 bool Environment::add_function( std::string name,
01127 const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot) {
01128 char retcode = get_return_code<T_return>( );
01129 char argstring[ 10 ] = { '6', '6', 'u', 0x00 };
01130 argstring[ 3 ] = get_argument_code<T_arg1>( );
01131 argstring[ 4 ] = get_argument_code<T_arg2>( );
01132 argstring[ 5 ] = get_argument_code<T_arg3>( );
01133 argstring[ 6 ] = get_argument_code<T_arg4>( );
01134 argstring[ 7 ] = get_argument_code<T_arg5>( );
01135 argstring[ 8 ] = get_argument_code<T_arg6>( );
01136 sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* scb =
01137 new sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(slot);
01138 any holder = CLIPSPointer<sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> >(scb);
01139 m_slots[name] = holder;
01140 return ( EnvDefineFunction2WithContext( m_cobj,
01141 const_cast<char*>( name.c_str() ),
01142 retcode,
01143 get_callback(slot),
01144 const_cast<char*>( name.c_str() ),
01145 argstring,
01146 scb )
01147 );
01148 }
01149
01150 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 >
01151 inline
01152 bool Environment::add_function( std::string name,
01153 const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot) {
01154 char retcode = get_return_code<T_return>( );
01155 char argstring[ 10 ] = { '7', '7', 'u', 0x00 };
01156 argstring[ 3 ] = get_argument_code<T_arg1>( );
01157 argstring[ 4 ] = get_argument_code<T_arg2>( );
01158 argstring[ 5 ] = get_argument_code<T_arg3>( );
01159 argstring[ 6 ] = get_argument_code<T_arg4>( );
01160 argstring[ 7 ] = get_argument_code<T_arg5>( );
01161 argstring[ 8 ] = get_argument_code<T_arg6>( );
01162 argstring[ 9 ] = get_argument_code<T_arg7>( );
01163 sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* scb =
01164 new sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(slot);
01165 any holder = CLIPSPointer<sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> >(scb);
01166 m_slots[name] = holder;
01167 return ( EnvDefineFunction2WithContext( m_cobj,
01168 const_cast<char*>( name.c_str() ),
01169 retcode,
01170 get_callback(slot),
01171 const_cast<char*>( name.c_str() ),
01172 argstring,
01173 scb )
01174 );
01175 }
01176
01177
01178 }
01179
01180 #endif