environment.h Source File

Go to the documentation of this file.
00001 /***************************************************************************
00002  *   Copyright (C) 2006 by Rick L. Vinyard, Jr.  <rvinyard@cs.nmsu.edu>    *
00003  *   Copyright (C) 2011-2013 by Tim Niemueller [http://www.niemueller.de]  *
00004  *                                                                         *
00005  *   This file is part of the clipsmm library.                             *
00006  *                                                                         *
00007  *   The clipsmm library is free software; you can redistribute it and/or  *
00008  *   modify it under the terms of the GNU General Public License           *
00009  *   version 3 as published by the Free Software Foundation.               *
00010  *                                                                         *
00011  *   The clipsmm library is distributed in the hope that it will be        *
00012  *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty   *
00013  *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   *
00014  *   General Public License for more details.                              *
00015  *                                                                         *
00016  *   You should have received a copy of the GNU General Public License     *
00017  *   along with this software. If not see <http://www.gnu.org/licenses/>.  *
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( Fact::pointer fact );
00259       Fact::pointer assert_fact_f( const char *format, ... );
00260 
00261       void clear_focus_stack();
00262 
00270       Fact::pointer get_facts();
00271 
00272       DefaultFacts::pointer get_default_facts( const std::string& default_facts_name );
00273 
00275       std::vector<std::string> get_default_facts_names();
00276 
00278       std::vector<std::string> get_default_facts_names( const Module& module );
00279 
00281       std::vector<std::string> get_default_facts_names( Module::pointer module );
00282 
00283       DefaultFacts::pointer get_default_facts_list_head();
00284 
00285       Template::pointer get_template( const std::string& template_name );
00286 
00288       std::vector<std::string> get_template_names();
00289 
00291       std::vector<std::string> get_template_names( const Module& module );
00292 
00294       std::vector<std::string> get_template_names( Module::pointer module );
00295 
00296       Template::pointer get_template_list_head();
00297 
00298       Rule::pointer get_rule( const std::string& rule_name );
00299 
00301       std::vector<std::string> get_rule_names();
00302 
00304       std::vector<std::string> get_rule_names( const Module& module );
00305 
00307       std::vector<std::string> get_rule_names( Module::pointer module );
00308 
00309       Rule::pointer get_rule_list_head();
00310 
00311       void remove_rules();
00312 
00313       Module::pointer get_module( const std::string& module_name );
00314 
00315       Module::pointer get_current_module();
00316 
00317       std::vector<std::string> get_module_names();
00318 
00319       Module::pointer get_module_list_head();
00320 
00326       void refresh_agenda();
00327 
00333       void refresh_agenda( const Module& module );
00334 
00340       void refresh_agenda( Module::pointer module );
00341 
00347       void reorder_agenda();
00348 
00354       void reorder_agenda( const Module& module );
00355 
00361       void reorder_agenda( Module::pointer module );
00362 
00372       long int run( long int runlimit = -1 );
00373 
00392       void run_threaded( long int runlimit = -1, int priority = 0 );
00393 
00395       void join_run_thread();
00396 
00398       sigc::signal<void, long int> signal_run();
00399 
00401       SalienceEvaluation get_salience_evaluation();
00402 
00407       SalienceEvaluation set_salience_evaluation( SalienceEvaluation se );
00408 
00410       ConflictResolution get_conflict_resolution_strategy();
00411 
00416       ConflictResolution set_conflict_resolution_strategy( ConflictResolution cr );
00417 
00426       bool check_agenda_changed();
00427 
00428       Module::pointer get_focused_module();
00429 
00430       std::vector<std::string> get_focus_stack();
00431 
00432       Activation::pointer get_activation_list_head();
00433 
00434       Global::pointer get_global( const std::string& global_name );
00435 
00436       Global::pointer get_global_list_head();
00437 
00439       std::vector<std::string> get_globals_names();
00440 
00442       std::vector<std::string> get_globals_names( const Module& module );
00443 
00445       std::vector<std::string> get_globals_names( Module::pointer module );
00446 
00447       bool check_globals_changed();
00448 
00449       Function::pointer get_function( const std::string& function_name );
00450 
00451       Function::pointer get_function_list_head();
00452 
00454       std::vector<std::string> get_function_names();
00455 
00457       std::vector<std::string> get_function_names( const Module& module );
00458 
00460       std::vector<std::string> get_function_names( Module::pointer module );
00461 
00462       sigc::signal<void> signal_clear();
00463       sigc::signal<void> signal_periodic();
00464       sigc::signal<void> signal_reset();
00465       sigc::signal<void> signal_rule_firing();
00466       sigc::signal<void> signal_agenda_changed();
00467       sigc::signal<void> signal_globals_changed();
00468 
00469       template < typename T_return >
00470       bool add_function( std::string name, const sigc::slot0<T_return>& slot);
00471 
00472       template < typename T_return, typename T_arg1 >
00473       bool add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot);
00474 
00475       template < typename T_return, typename T_arg1, typename T_arg2 >
00476       bool add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot);
00477 
00478       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00479       bool add_function( std::string name, const sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>& slot);
00480 
00481       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00482       bool add_function( std::string name, const sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>& slot);
00483 
00484       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00485       bool add_function( std::string name, const sigc::slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& slot);
00486 
00487       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00488       bool add_function( std::string name, const sigc::slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& slot);
00489 
00490       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 >
00491       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);
00492 
00493       bool remove_function( std::string name );
00494 
00495     protected:
00502       std::map<std::string,any> m_slots;
00503 
00504       sigc::signal<void> m_signal_clear;
00505       sigc::signal<void> m_signal_periodic;
00506       sigc::signal<void> m_signal_reset;
00507       sigc::signal<void> m_signal_rule_firing;
00508       sigc::signal<void> m_signal_agenda_changed;
00509       sigc::signal<void> m_signal_globals_changed;
00510 
00512       typedef struct Job {
00514         Job( int p, long int rl ) : priority(p), runlimit(rl) { }
00515 
00517         bool operator<( const Job& other ) const { return priority < other.priority; }
00518 
00520         int priority;
00521 
00526         long int runlimit;
00527       } Job;
00528 
00529       Glib::Thread* m_run_thread; 
00530       std::priority_queue<Job> m_run_queue; 
00531       Glib::Mutex m_mutex_run_queue; 
00532       Glib::Mutex m_mutex_run; 
00533       Glib::Mutex m_mutex_threaded_run; 
00534       Glib::Mutex m_mutex_run_signal; 
00535       sigc::signal<void, long int> m_signal_run; 
00546       std::map<std::string, char *> m_func_restr;
00547 
00549       void threaded_run();
00550 
00551       static std::map<void*, Environment*> m_environment_map;
00552 
00553 
00554       static void clear_callback( void* env );
00555       static void periodic_callback( void* env );
00556       static void reset_callback( void* env );
00557       static void rule_firing_callback( void* end );
00558 
00559       static void* strcallback( void* theEnv );
00560 
00561       template < typename T_arg1 >
00562       static void* strcallback( void* theEnv );
00563 
00564       template < typename T_arg1, typename T_arg2 >
00565       static void* strcallback( void* theEnv );
00566 
00567       template < typename T_arg1, typename T_arg2, typename T_arg3 >
00568       static void* strcallback( void* theEnv );
00569 
00570       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00571       static void* strcallback( void* theEnv );
00572 
00573       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00574       static void* strcallback( void* theEnv );
00575 
00576       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00577       static void* strcallback( void* theEnv );
00578 
00579       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00580       static void* strcallback( void* theEnv );
00581 
00582       template < typename T_return >
00583       static T_return callback( void* theEnv );
00584 
00585       template < typename T_return, typename T_arg1 >
00586       static T_return callback( void* theEnv );
00587 
00588       template < typename T_return, typename T_arg1, typename T_arg2 >
00589       static T_return callback( void* theEnv );
00590 
00591       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00592       static T_return callback( void* theEnv );
00593 
00594       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00595       static T_return callback( void* theEnv );
00596 
00597       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00598       static T_return callback( void* theEnv );
00599 
00600       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00601       static T_return callback( void* theEnv );
00602 
00603       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 >
00604       static T_return callback( void* theEnv );
00605 
00606       static void callback_multifield( void* theEnv, void *rv);
00607 
00608       template <typename T_arg1>
00609       static void callback_multifield( void* theEnv, void *rv );
00610 
00611       template <typename T_arg1, typename T_arg2>
00612       static void callback_multifield( void* theEnv, void *rv );
00613 
00614       template <typename T_arg1, typename T_arg2, typename T_arg3>
00615       static void callback_multifield( void* theEnv, void *rv );
00616 
00617       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
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>
00622       static void callback_multifield( void* theEnv, void *rv );
00623 
00624       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00625         typename T_arg5, typename T_arg6>
00626       static void callback_multifield( void* theEnv, void *rv );
00627 
00628       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00629         typename T_arg5, typename T_arg6, typename T_arg7>
00630       static void callback_multifield( void* theEnv, void *rv );
00631 
00632       int ( *get_callback( const sigc::slot0<std::string>& slot ))( void* )
00633         { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback; }
00634 
00635       template < typename T_arg1 >
00636       int ( *get_callback( const sigc::slot1<std::string,T_arg1>& slot ))( void* )
00637         { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1>; }
00638 
00639       template < typename T_arg1, typename T_arg2 >
00640       int ( *get_callback( const sigc::slot2<std::string,T_arg1,T_arg2>& slot ))( void* )
00641         { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1,T_arg2>; }
00642 
00643       template < typename T_arg1, typename T_arg2, typename T_arg3 >
00644       int ( *get_callback( const sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00645         { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3>; }
00646 
00647       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00648       int ( *get_callback( const sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00649         { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4>; }
00650 
00651       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00652       int ( *get_callback( const sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00653         { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00654 
00655       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00656       int ( *get_callback( const sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00657         { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00658 
00659       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00660       int ( *get_callback( const sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00661         { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00662 
00663       int ( *get_callback( const sigc::slot0<Values>& slot ))( void* )
00664       { return  (int (*) (void*)) (void (*) (void*, void*)) callback_multifield; }
00665 
00666       template <typename T_arg1>
00667       int ( *get_callback( const sigc::slot1<Values,T_arg1>& slot ))( void* )
00668       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1>; }
00669 
00670       template <typename T_arg1, typename T_arg2>
00671       int ( *get_callback( const sigc::slot2<Values,T_arg1,T_arg2>& slot ))( void* )
00672       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2>; }
00673 
00674       template <typename T_arg1, typename T_arg2, typename T_arg3>
00675         int ( *get_callback( const sigc::slot3<Values,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00676       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3>; }
00677 
00678       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00679         int ( *get_callback( const sigc::slot4<Values,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00680       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4>; }
00681 
00682       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00683         int ( *get_callback( const sigc::slot5<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00684       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00685 
00686       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00687         int ( *get_callback( const sigc::slot6<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00688       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00689 
00690       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00691         int ( *get_callback( const sigc::slot7<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00692       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00693 
00694 
00695       template < typename T_return >
00696       int ( *get_callback( const sigc::slot0<T_return>& slot ))( void* )
00697         { return (int (*) (void*)) ( T_return ( * ) ( void* ) ) callback<T_return>; }
00698 
00699       template < typename T_return, typename T_arg1 >
00700       int ( *get_callback( const sigc::slot1<T_return,T_arg1>& slot ))( void* )
00701         { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1>; }
00702 
00703       template < typename T_return, typename T_arg1, typename T_arg2 >
00704       int ( *get_callback( const sigc::slot2<T_return,T_arg1,T_arg2>& slot ))( void* )
00705         { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1,T_arg2>; }
00706 
00707       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00708       int ( *get_callback( const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00709         { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3>; }
00710 
00711       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00712       int ( *get_callback( const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00713         { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4>; }
00714 
00715       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00716       int ( *get_callback( const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00717         { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00718 
00719       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00720       int ( *get_callback( const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00721         { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00722 
00723       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 >
00724       int ( *get_callback( const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00725         { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00726 
00727       char * get_function_restriction(std::string &name);
00728 
00729       template <typename T_arg1>
00730         char * get_function_restriction(std::string &name);
00731 
00732       template <typename T_arg1, typename T_arg2>
00733         char * get_function_restriction(std::string &name);
00734 
00735       template <typename T_arg1, typename T_arg2, typename T_arg3>
00736         char * get_function_restriction(std::string &name);
00737 
00738       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00739         char * get_function_restriction(std::string &name);
00740 
00741       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00742         char * get_function_restriction(std::string &name);
00743 
00744       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00745         char * get_function_restriction(std::string &name);
00746 
00747       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00748         char * get_function_restriction(std::string &name);
00749 
00750 
00751       static int get_arg_count( void* env );
00752       static void* get_function_context( void* env );
00753       static void  set_return_values( void *env, void *rv, const Values &v);
00754       static void* add_symbol( const char* s );
00755 
00756 
00757   };
00758 
00759 
00760   inline char *
00761   Environment::get_function_restriction(std::string &name) {
00762     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00763     char *restr = (char *)malloc(4); m_func_restr[name] = restr;
00764     snprintf(restr, 4, "00u");
00765     return restr;
00766   }
00767 
00768   template <typename T_arg1>
00769   inline char *
00770   Environment::get_function_restriction(std::string &name) {
00771     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00772     char *restr = (char *)malloc(5); m_func_restr[name] = restr;
00773     snprintf(restr, 5, "11u%c", get_argument_code<T_arg1>());
00774     return restr;
00775   }
00776 
00777   template <typename T_arg1, typename T_arg2>
00778   inline char *
00779   Environment::get_function_restriction(std::string &name) {
00780     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00781     char *restr = (char *)malloc(6); m_func_restr[name] = restr;
00782     snprintf(restr, 6, "22u%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>());
00783     return restr;
00784   }
00785 
00786   template <typename T_arg1, typename T_arg2, typename T_arg3>
00787   inline char *
00788   Environment::get_function_restriction(std::string &name) {
00789     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00790     char *restr = (char *)malloc(7); m_func_restr[name] = restr;
00791     snprintf(restr, 7, "33u%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00792              get_argument_code<T_arg3>());
00793     return restr;
00794   }
00795 
00796   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00797   inline char *
00798   Environment::get_function_restriction(std::string &name) {
00799     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00800     char *restr = (char *)malloc(8); m_func_restr[name] = restr;
00801     snprintf(restr, 8, "44u%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00802              get_argument_code<T_arg3>(), get_argument_code<T_arg4>());
00803     return restr;
00804   }
00805 
00806   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00807     typename T_arg5>
00808   inline char *
00809   Environment::get_function_restriction(std::string &name) {
00810     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00811     char *restr = (char *)malloc(9); m_func_restr[name] = restr;
00812     snprintf(restr, 9, "55u%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00813              get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>());
00814     return restr;
00815   }
00816 
00817   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00818     typename T_arg5, typename T_arg6>
00819   inline char *
00820   Environment::get_function_restriction(std::string &name) {
00821     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00822     char *restr = (char *)malloc(10); m_func_restr[name] = restr;
00823     snprintf(restr, 10, "66u%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00824              get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
00825              get_argument_code<T_arg6>());
00826     return restr;
00827   }
00828 
00829   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00830     typename T_arg5, typename T_arg6, typename T_arg7>
00831   inline char *
00832   Environment::get_function_restriction(std::string &name) {
00833     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00834     char *restr = (char *)malloc(11); m_func_restr[name] = restr;
00835     snprintf(restr, 11, "77u%c%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00836              get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
00837              get_argument_code<T_arg6>(), get_argument_code<T_arg7>());
00838     return restr;
00839   }
00840 
00841 
00842   template < typename T_return>
00843   inline
00844   T_return Environment::callback( void* theEnv ) {
00845     sigc::slot0<T_return>* cb;
00846     void * cbptr = get_function_context( theEnv );
00847     if ( cbptr ) {
00848       if ( get_arg_count( theEnv ) != 0 )
00849         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 0" );
00850       cb = static_cast<sigc::slot0<T_return>*>( cbptr );
00851       return ( *cb ) ();
00852     }
00853     throw;
00854   }
00855 
00856   template < typename T_return, typename T_arg1 >
00857   inline
00858   T_return Environment::callback( void* theEnv ) {
00859     sigc::slot1<T_return,T_arg1>* cb;
00860     void * cbptr = get_function_context( theEnv );
00861     T_arg1 arg1;
00862     if ( cbptr ) {
00863       if ( get_arg_count( theEnv ) != 1 )
00864         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
00865       get_argument( theEnv, 1, arg1 );
00866       cb = static_cast<sigc::slot1<T_return,T_arg1>*>( cbptr );
00867       return ( *cb ) ( arg1 );
00868     }
00869     throw;
00870   }
00871 
00872   template < typename T_return, typename T_arg1, typename T_arg2 >
00873   inline
00874   T_return Environment::callback( void* theEnv ) {
00875     sigc::slot2<T_return, T_arg1, T_arg2>* cb;
00876     void * cbptr = get_function_context( theEnv );
00877     T_arg1 arg1;
00878     T_arg2 arg2;
00879     if ( cbptr ) {
00880       if ( get_arg_count( theEnv ) != 2 )
00881         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
00882       get_argument( theEnv, 1, arg1 );
00883       get_argument( theEnv, 2, arg2 );
00884       cb = static_cast<sigc::slot2<T_return, T_arg1, T_arg2>*>( cbptr );
00885       return ( *cb ) ( arg1, arg2 );
00886     }
00887     throw;
00888   }
00889 
00890   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00891   inline
00892   T_return Environment::callback( void* theEnv ) {
00893     sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* cb;
00894     void * cbptr = get_function_context( theEnv );
00895     T_arg1 arg1;
00896     T_arg2 arg2;
00897     T_arg3 arg3;
00898     if ( cbptr ) {
00899       if ( get_arg_count( theEnv ) != 3 )
00900         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
00901       get_argument( theEnv, 1, arg1 );
00902       get_argument( theEnv, 2, arg2 );
00903       get_argument( theEnv, 3, arg3 );
00904       cb = static_cast<sigc::slot3<T_return, T_arg1, T_arg2,T_arg3>*>( cbptr );
00905       return ( *cb ) ( arg1, arg2, arg3 );
00906     }
00907     throw;
00908   }
00909 
00910   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00911   inline
00912   T_return Environment::callback( void* theEnv ) {
00913     sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
00914     void * cbptr = get_function_context( theEnv );
00915     T_arg1 arg1;
00916     T_arg2 arg2;
00917     T_arg3 arg3;
00918     T_arg4 arg4;
00919     if ( cbptr ) {
00920       if ( get_arg_count( theEnv ) != 4 )
00921         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
00922       get_argument( theEnv, 1, arg1 );
00923       get_argument( theEnv, 2, arg2 );
00924       get_argument( theEnv, 3, arg3 );
00925       get_argument( theEnv, 4, arg4 );
00926       cb = static_cast<sigc::slot4<T_return, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
00927       return ( *cb ) ( arg1, arg2, arg3, arg4 );
00928     }
00929     throw;
00930   }
00931 
00932   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00933   inline
00934   T_return Environment::callback( void* theEnv ) {
00935     sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
00936     void * cbptr = get_function_context( theEnv );
00937     T_arg1 arg1;
00938     T_arg2 arg2;
00939     T_arg3 arg3;
00940     T_arg4 arg4;
00941     T_arg5 arg5;
00942     if ( cbptr ) {
00943       if ( get_arg_count( theEnv ) != 5 )
00944         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
00945       get_argument( theEnv, 1, arg1 );
00946       get_argument( theEnv, 2, arg2 );
00947       get_argument( theEnv, 3, arg3 );
00948       get_argument( theEnv, 4, arg4 );
00949       get_argument( theEnv, 5, arg5 );
00950       cb = static_cast<sigc::slot5<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
00951       return ( *cb ) ( arg1, arg2, arg3, arg4, arg5 );
00952     }
00953     throw;
00954   }
00955 
00956  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00957  inline
00958  T_return Environment::callback( void* theEnv ) {
00959    sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
00960    void * cbptr = get_function_context( theEnv );
00961    T_arg1 arg1;
00962    T_arg2 arg2;
00963    T_arg3 arg3;
00964    T_arg4 arg4;
00965    T_arg5 arg5;
00966    T_arg6 arg6;
00967    if ( cbptr ) {
00968      if ( get_arg_count( theEnv ) != 6 )
00969        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
00970      get_argument( theEnv, 1, arg1 );
00971      get_argument( theEnv, 2, arg2 );
00972      get_argument( theEnv, 3, arg3 );
00973      get_argument( theEnv, 4, arg4 );
00974      get_argument( theEnv, 5, arg5 );
00975      get_argument( theEnv, 6, arg6 );
00976      cb = static_cast<sigc::slot6<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
00977      return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 );
00978    }
00979    throw;
00980  }
00981 
00982   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 >
00983   inline
00984   T_return Environment::callback( void* theEnv ) {
00985     sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
00986     void * cbptr = get_function_context( theEnv );
00987     T_arg1 arg1;
00988     T_arg2 arg2;
00989     T_arg3 arg3;
00990     T_arg4 arg4;
00991     T_arg5 arg5;
00992     T_arg6 arg6;
00993     T_arg7 arg7;
00994     if ( cbptr ) {
00995       if ( get_arg_count( theEnv ) != 7 )
00996         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
00997       get_argument( theEnv, 1, arg1 );
00998       get_argument( theEnv, 2, arg2 );
00999       get_argument( theEnv, 3, arg3 );
01000       get_argument( theEnv, 4, arg4 );
01001       get_argument( theEnv, 5, arg5 );
01002       get_argument( theEnv, 6, arg6 );
01003       get_argument( theEnv, 7, arg7 );
01004       cb = static_cast<sigc::slot7<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
01005       return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 );
01006     }
01007     throw;
01008   }
01009 
01010   inline
01011   void Environment::callback_multifield( void* theEnv, void *rv) {
01012     sigc::slot0<Values>* cb;
01013     void * cbptr = get_function_context( theEnv );
01014     if ( cbptr ) {
01015       if ( get_arg_count( theEnv ) != 0 )
01016         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 0" );
01017       cb = static_cast<sigc::slot0<Values>*>( cbptr );
01018       Values v = ( *cb ) ();
01019       set_return_values(theEnv, rv, v);
01020       return;
01021     }
01022     throw;
01023   }
01024 
01025   template <typename T_arg1>
01026   inline
01027   void Environment::callback_multifield( void* theEnv, void *rv) {
01028     sigc::slot1<Values, T_arg1>* cb;
01029     void * cbptr = get_function_context( theEnv );
01030     T_arg1 arg1;
01031     if ( cbptr ) {
01032       if ( get_arg_count( theEnv ) != 1 )
01033         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 1" );
01034       cb = static_cast<sigc::slot1<Values, T_arg1>*>( cbptr );
01035       get_argument(theEnv, 1, arg1);
01036       Values v = ( *cb ) (arg1);
01037       set_return_values(theEnv, rv, v);
01038       return;
01039     }
01040     throw;
01041   }
01042 
01043   template <typename T_arg1, typename T_arg2>
01044   inline
01045   void Environment::callback_multifield( void* theEnv, void *rv) {
01046     sigc::slot2<Values, T_arg1, T_arg2>* cb;
01047     void * cbptr = get_function_context( theEnv );
01048     T_arg1 arg1;
01049     T_arg2 arg2;
01050     if ( cbptr ) {
01051       if ( get_arg_count( theEnv ) != 2 )
01052         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 2" );
01053       cb = static_cast<sigc::slot2<Values, T_arg1, T_arg2>*>( cbptr );
01054       get_argument(theEnv, 1, arg1);
01055       get_argument(theEnv, 2, arg2);
01056       Values v = ( *cb ) (arg1, arg2);
01057       set_return_values(theEnv, rv, v);
01058       return;
01059     }
01060     throw;
01061   }
01062 
01063 
01064   template <typename T_arg1, typename T_arg2, typename T_arg3>
01065   inline
01066   void Environment::callback_multifield( void* theEnv, void *rv) {
01067     sigc::slot3<Values, T_arg1, T_arg2, T_arg3>* cb;
01068     void * cbptr = get_function_context( theEnv );
01069     T_arg1 arg1;
01070     T_arg2 arg2;
01071     T_arg3 arg3;
01072     if ( cbptr ) {
01073       if ( get_arg_count( theEnv ) != 3 )
01074         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 3" );
01075       cb = static_cast<sigc::slot3<Values, T_arg1, T_arg2, T_arg3>*>( cbptr );
01076       get_argument(theEnv, 1, arg1);
01077       get_argument(theEnv, 2, arg2);
01078       get_argument(theEnv, 3, arg3);
01079       Values v = ( *cb ) (arg1, arg2, arg3);
01080       set_return_values(theEnv, rv, v);
01081       return;
01082     }
01083     throw;
01084   }
01085 
01086   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
01087   inline
01088   void Environment::callback_multifield( void* theEnv, void *rv) {
01089     sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>* cb;
01090     void * cbptr = get_function_context( theEnv );
01091     T_arg1 arg1;
01092     T_arg2 arg2;
01093     T_arg3 arg3;
01094     T_arg4 arg4;
01095     if ( cbptr ) {
01096       if ( get_arg_count( theEnv ) != 4 )
01097         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 4" );
01098       cb = static_cast<sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>*>(cbptr);
01099       get_argument(theEnv, 1, arg1);
01100       get_argument(theEnv, 2, arg2);
01101       get_argument(theEnv, 3, arg3);
01102       get_argument(theEnv, 4, arg4);
01103       Values v = ( *cb ) (arg1, arg2, arg3, arg4);
01104       set_return_values(theEnv, rv, v);
01105       return;
01106     }
01107     throw;
01108   }
01109 
01110   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01111     typename T_arg5>
01112   inline
01113   void Environment::callback_multifield( void* theEnv, void *rv) {
01114       sigc::slot5<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* cb;
01115     void * cbptr = get_function_context( theEnv );
01116     T_arg1 arg1;
01117     T_arg2 arg2;
01118     T_arg3 arg3;
01119     T_arg4 arg4;
01120     T_arg5 arg5;
01121     if ( cbptr ) {
01122       if ( get_arg_count( theEnv ) != 5 )
01123         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 5" );
01124       cb = static_cast<sigc::slot5<Values, T_arg1, T_arg2, T_arg3,
01125         T_arg4, T_arg5>*>(cbptr);
01126       get_argument(theEnv, 1, arg1);
01127       get_argument(theEnv, 2, arg2);
01128       get_argument(theEnv, 3, arg3);
01129       get_argument(theEnv, 4, arg4);
01130       get_argument(theEnv, 5, arg5);
01131       Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5);
01132       set_return_values(theEnv, rv, v);
01133       return;
01134     }
01135     throw;
01136   }
01137 
01138 
01139   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01140     typename T_arg5, typename T_arg6>
01141   inline
01142   void Environment::callback_multifield( void* theEnv, void *rv) {
01143     sigc::slot6<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* cb;
01144     void * cbptr = get_function_context( theEnv );
01145     T_arg1 arg1;
01146     T_arg2 arg2;
01147     T_arg3 arg3;
01148     T_arg4 arg4;
01149     T_arg5 arg5;
01150     T_arg6 arg6;
01151     if ( cbptr ) {
01152       if ( get_arg_count( theEnv ) != 6 )
01153         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 6" );
01154       cb = static_cast<sigc::slot6<Values, T_arg1, T_arg2, T_arg3,
01155         T_arg4, T_arg5, T_arg6>*>(cbptr);
01156       get_argument(theEnv, 1, arg1);
01157       get_argument(theEnv, 2, arg2);
01158       get_argument(theEnv, 3, arg3);
01159       get_argument(theEnv, 4, arg4);
01160       get_argument(theEnv, 5, arg5);
01161       get_argument(theEnv, 6, arg6);
01162       Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6);
01163       set_return_values(theEnv, rv, v);
01164       return;
01165     }
01166     throw;
01167   }
01168 
01169   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01170     typename T_arg5, typename T_arg6, typename T_arg7>
01171   inline
01172   void Environment::callback_multifield( void* theEnv, void *rv) {
01173     sigc::slot7<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* cb;
01174     void * cbptr = get_function_context( theEnv );
01175     T_arg1 arg1;
01176     T_arg2 arg2;
01177     T_arg3 arg3;
01178     T_arg4 arg4;
01179     T_arg5 arg5;
01180     T_arg6 arg6;
01181     T_arg7 arg7;
01182     if ( cbptr ) {
01183       if ( get_arg_count( theEnv ) != 7 )
01184         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 7" );
01185       cb = static_cast<sigc::slot7<Values, T_arg1, T_arg2, T_arg3,
01186         T_arg4, T_arg5, T_arg6, T_arg7>*>(cbptr);
01187       get_argument(theEnv, 1, arg1);
01188       get_argument(theEnv, 2, arg2);
01189       get_argument(theEnv, 3, arg3);
01190       get_argument(theEnv, 4, arg4);
01191       get_argument(theEnv, 5, arg5);
01192       get_argument(theEnv, 6, arg6);
01193       get_argument(theEnv, 7, arg7);
01194       Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6, arg7);
01195       set_return_values(theEnv, rv, v);
01196       return;
01197     }
01198     throw;
01199   }
01200 
01201 
01202   inline
01203   void* Environment::strcallback( void* theEnv ) {
01204     sigc::slot0<std::string>* cb;
01205     void * cbptr = get_function_context( theEnv );
01206     if ( cbptr ) {
01207       if ( get_arg_count( theEnv ) != 0 )
01208         throw std::logic_error( "clipsmm/string: wrong # args on slot callback; expected 0" );
01209       cb = static_cast<sigc::slot0<std::string>*>( cbptr );
01210       return add_symbol( ( ( *cb ) ( )).c_str() );
01211     }
01212     throw;
01213   }
01214 
01215   template < typename T_arg1 >
01216   inline
01217   void* Environment::strcallback( void* theEnv ) {
01218     sigc::slot1<std::string,T_arg1>* cb;
01219     void * cbptr = get_function_context( theEnv );
01220     T_arg1 arg1;
01221     if ( cbptr ) {
01222       if ( get_arg_count( theEnv ) != 1 )
01223         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
01224       get_argument( theEnv, 1, arg1 );
01225       cb = static_cast<sigc::slot1<std::string,T_arg1>*>( cbptr );
01226       return add_symbol( ( ( *cb ) ( arg1 )).c_str() );
01227     }
01228     throw;
01229   }
01230 
01231   template < typename T_arg1, typename T_arg2 >
01232   inline
01233   void* Environment::strcallback( void* theEnv ) {
01234     sigc::slot2<std::string, T_arg1, T_arg2>* cb;
01235     void * cbptr = get_function_context( theEnv );
01236     T_arg1 arg1;
01237     T_arg2 arg2;
01238     if ( cbptr ) {
01239       if ( get_arg_count( theEnv ) != 2 )
01240         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
01241       get_argument( theEnv, 1, arg1 );
01242       get_argument( theEnv, 2, arg2 );
01243       cb = static_cast<sigc::slot2<std::string, T_arg1, T_arg2>*>( cbptr );
01244       return add_symbol( ( ( *cb ) ( arg1, arg2 )).c_str() );
01245     }
01246     throw;
01247   }
01248 
01249   template < typename T_arg1, typename T_arg2, typename T_arg3 >
01250   inline
01251   void* Environment::strcallback( void* theEnv ) {
01252     sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>* cb;
01253     void * cbptr = get_function_context( theEnv );
01254     T_arg1 arg1;
01255     T_arg2 arg2;
01256     T_arg3 arg3;
01257     if ( cbptr ) {
01258       if ( get_arg_count( theEnv ) != 3 )
01259         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
01260       get_argument( theEnv, 1, arg1 );
01261       get_argument( theEnv, 2, arg2 );
01262       get_argument( theEnv, 3, arg3 );
01263       cb = static_cast<sigc::slot3<std::string, T_arg1, T_arg2,T_arg3>*>( cbptr );
01264       return add_symbol( ( ( *cb ) ( arg1, arg2, arg3 )).c_str() );
01265     }
01266     throw;
01267   }
01268 
01269   template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
01270   inline
01271   void* Environment::strcallback( void* theEnv ) {
01272     sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
01273     void * cbptr = get_function_context( theEnv );
01274     T_arg1 arg1;
01275     T_arg2 arg2;
01276     T_arg3 arg3;
01277     T_arg4 arg4;
01278     std::string s;
01279     if ( cbptr ) {
01280       if ( get_arg_count( theEnv ) != 4 )
01281         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
01282       get_argument( theEnv, 1, arg1 );
01283       get_argument( theEnv, 2, arg2 );
01284       get_argument( theEnv, 3, arg3 );
01285       get_argument( theEnv, 4, arg4 );
01286       cb = static_cast<sigc::slot4<std::string, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
01287       s = ( *cb ) ( arg1, arg2, arg3, arg4 );
01288       return add_symbol( s.c_str() );
01289     }
01290     throw;
01291   }
01292 
01293   template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
01294   inline
01295   void* Environment::strcallback( void* theEnv ) {
01296     sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
01297     void * cbptr = get_function_context( theEnv );
01298     T_arg1 arg1;
01299     T_arg2 arg2;
01300     T_arg3 arg3;
01301     T_arg4 arg4;
01302     T_arg5 arg5;
01303     if ( cbptr ) {
01304       if ( get_arg_count( theEnv ) != 5 )
01305         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
01306       get_argument( theEnv, 1, arg1 );
01307       get_argument( theEnv, 2, arg2 );
01308       get_argument( theEnv, 3, arg3 );
01309       get_argument( theEnv, 4, arg4 );
01310       get_argument( theEnv, 5, arg5 );
01311       cb = static_cast<sigc::slot5<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
01312       return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5 )).c_str() );
01313     }
01314     throw;
01315   }
01316 
01317   template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
01318   inline
01319   void* Environment::strcallback( void* theEnv ) {
01320     sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
01321     void * cbptr = get_function_context( theEnv );
01322     T_arg1 arg1;
01323     T_arg2 arg2;
01324     T_arg3 arg3;
01325     T_arg4 arg4;
01326     T_arg5 arg5;
01327     T_arg6 arg6;
01328     if ( cbptr ) {
01329       if ( get_arg_count( theEnv ) != 6 )
01330         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
01331       get_argument( theEnv, 1, arg1 );
01332       get_argument( theEnv, 2, arg2 );
01333       get_argument( theEnv, 3, arg3 );
01334       get_argument( theEnv, 4, arg4 );
01335       get_argument( theEnv, 5, arg5 );
01336       get_argument( theEnv, 6, arg6 );
01337       cb = static_cast<sigc::slot6<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
01338       return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 )).c_str() );
01339     }
01340     throw;
01341   }
01342 
01343   template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
01344   inline
01345   void* Environment::strcallback( void* theEnv ) {
01346     sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
01347     void * cbptr = get_function_context( theEnv );
01348     T_arg1 arg1;
01349     T_arg2 arg2;
01350     T_arg3 arg3;
01351     T_arg4 arg4;
01352     T_arg5 arg5;
01353     T_arg6 arg6;
01354     T_arg7 arg7;
01355     if ( cbptr ) {
01356       if ( get_arg_count( theEnv ) != 7 )
01357         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
01358       get_argument( theEnv, 1, arg1 );
01359       get_argument( theEnv, 2, arg2 );
01360       get_argument( theEnv, 3, arg3 );
01361       get_argument( theEnv, 4, arg4 );
01362       get_argument( theEnv, 5, arg5 );
01363       get_argument( theEnv, 6, arg6 );
01364       get_argument( theEnv, 7, arg7 );
01365       cb = static_cast<sigc::slot7<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
01366       return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 )).c_str() );
01367     }
01368     throw;
01369   }
01370 
01371 template < typename T_return >
01372   inline
01373   bool Environment::add_function( std::string name, const sigc::slot0<T_return>& slot) {
01374     char retcode = get_return_code<T_return>( );
01375     char *argstring = get_function_restriction(name);
01376     sigc::slot0<T_return>* scb = new sigc::slot0<T_return>(slot);
01377     any holder = CLIPSPointer<sigc::slot0<T_return> >(scb);
01378     m_slots[name] = holder;
01379     return ( EnvDefineFunction2WithContext( m_cobj,
01380                                  const_cast<char*>( name.c_str() ),
01381                                  retcode,
01382                                  get_callback(slot),
01383                                  const_cast<char*>( name.c_str() ),
01384                                  argstring,
01385                                  ( void* ) scb ) );
01386   }
01387 
01388   template < typename T_return, typename T_arg1 >
01389   inline
01390   bool Environment::add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot) {
01391     char retcode = get_return_code<T_return>( );
01392     char *argstring = get_function_restriction<T_arg1>(name);
01393     sigc::slot1<T_return, T_arg1>* scb = new sigc::slot1<T_return, T_arg1>(slot);
01394     any holder = CLIPSPointer<sigc::slot1<T_return, T_arg1> >(scb);
01395     m_slots[name] = holder;
01396     return ( EnvDefineFunction2WithContext( m_cobj,
01397                                  const_cast<char*>( name.c_str() ),
01398                                  retcode,
01399                                  get_callback(slot),
01400                                  const_cast<char*>( name.c_str() ),
01401                                  argstring,
01402                                  scb ) );
01403   }
01404 
01405   template < typename T_return, typename T_arg1, typename T_arg2 >
01406   inline
01407   bool Environment::add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot) {
01408     char retcode = get_return_code<T_return>( );
01409     char *argstring = get_function_restriction<T_arg1,T_arg2>(name);
01410     sigc::slot2<T_return, T_arg1, T_arg2>* scb = new sigc::slot2<T_return, T_arg1, T_arg2>(slot);
01411     any holder = CLIPSPointer<sigc::slot2<T_return, T_arg1, T_arg2> >(scb);
01412     m_slots[name] = holder;
01413     return ( EnvDefineFunction2WithContext( m_cobj,
01414                                  const_cast<char*>( name.c_str() ),
01415                                  retcode,
01416                                  get_callback(slot),
01417                                  const_cast<char*>( name.c_str() ),
01418                                  argstring,
01419                                  scb ) );
01420   }
01421 
01422   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
01423   inline
01424   bool Environment::add_function( std::string name, const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot) {
01425     char retcode = get_return_code<T_return>( );
01426     char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3>(name);
01427     sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* scb =
01428         new sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>(slot);
01429     any holder = CLIPSPointer<sigc::slot3<T_return,T_arg1,T_arg2,T_arg3> >(scb);
01430     m_slots[name] = holder;
01431     return ( EnvDefineFunction2WithContext( m_cobj,
01432                                  const_cast<char*>( name.c_str() ),
01433                                  retcode,
01434                                  get_callback(slot),
01435                                  const_cast<char*>( name.c_str() ),
01436                                  argstring,
01437                                  scb )
01438            );
01439   }
01440 
01441   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
01442   inline
01443   bool Environment::add_function( std::string name, const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot) {
01444     char retcode = get_return_code<T_return>( );
01445     char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4>(name);
01446     sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* scb =
01447         new sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>(slot);
01448     any holder = CLIPSPointer<sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4> >(scb);
01449     m_slots[name] = holder;
01450     return ( EnvDefineFunction2WithContext( m_cobj,
01451                                  const_cast<char*>( name.c_str() ),
01452                                  retcode,
01453                                  get_callback(slot),
01454                                  const_cast<char*>( name.c_str() ),
01455                                  argstring,
01456                                  scb )
01457            );
01458   }
01459 
01460   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
01461   inline
01462   bool Environment::add_function( std::string name,
01463                               const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot) {
01464     char retcode = get_return_code<T_return>( );
01465     char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(name);
01466     sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* scb =
01467         new sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(slot);
01468     any holder = CLIPSPointer<sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> >(scb);
01469     m_slots[name] = holder;
01470     return ( EnvDefineFunction2WithContext( m_cobj,
01471                                  const_cast<char*>( name.c_str() ),
01472                                  retcode,
01473                                  get_callback(slot),
01474                                  const_cast<char*>( name.c_str() ),
01475                                  argstring,
01476                                  scb )
01477            );
01478   }
01479 
01480   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
01481   inline
01482   bool Environment::add_function( std::string name,
01483                               const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot) {
01484     char retcode = get_return_code<T_return>( );
01485     char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(name);
01486     sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* scb =
01487         new sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(slot);
01488     any holder = CLIPSPointer<sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> >(scb);
01489     m_slots[name] = holder;
01490     return ( EnvDefineFunction2WithContext( m_cobj,
01491                                  const_cast<char*>( name.c_str() ),
01492                                  retcode,
01493                                  get_callback(slot),
01494                                  const_cast<char*>( name.c_str() ),
01495                                  argstring,
01496                                  scb )
01497            );
01498   }
01499 
01500   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 >
01501   inline
01502   bool Environment::add_function( std::string name,
01503                                   const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot) {
01504     char retcode = get_return_code<T_return>( );
01505     char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(name);
01506     sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* scb =
01507         new sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(slot);
01508     any holder = CLIPSPointer<sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> >(scb);
01509     m_slots[name] = holder;
01510     return ( EnvDefineFunction2WithContext( m_cobj,
01511                                  const_cast<char*>( name.c_str() ),
01512                                  retcode,
01513                                  get_callback(slot),
01514                                  const_cast<char*>( name.c_str() ),
01515                                  argstring,
01516                                  scb )
01517            );
01518   }
01519 
01520 }
01521 
01522 
01523 #endif
clipsmm - C++ CLIPS Interface Library
