environment.h

00001 /***************************************************************************
00002 *   clipsmm C++ wrapper for the CLIPS c library                           *
00003 *   Copyright (C) 2006 by Rick L. Vinyard, Jr.                            *
00004 *   rvinyard@cs.nmsu.edu                                                  *
00005 *                                                                         *
00006 *   This program is free software; you can redistribute it and/or modify  *
00007 *   it under the terms of version 2 of the GNU General Public License as  *
00008 *   published by the Free Software Foundation.                            *
00009 *                                                                         *
00010 *   This program is distributed in the hope that it will be useful,       *
00011 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00012 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
00013 *   GNU General Public License for more details.                          *
00014 *                                                                         *
00015 *   You should have received a copy of the GNU Lesser General Public      *
00016 *   License along with this library; if not, write to the                 *
00017 *   Free Software Foundation, Inc.,                                       *
00018 *   51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA              *
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

Generated on Sun Nov 12 11:55:35 2006 by  doxygen 1.5.1