clipsmm - C++ CLIPS Interface Library

clipsmm logo

environment.h

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 
00633       static void callback_unknown( void* theEnv, void *rv);
00634 
00635       template <typename T_arg1>
00636       static void callback_unknown( void* theEnv, void *rv );
00637 
00638       template <typename T_arg1, typename T_arg2>
00639       static void callback_unknown( void* theEnv, void *rv );
00640 
00641       template <typename T_arg1, typename T_arg2, typename T_arg3>
00642       static void callback_unknown( void* theEnv, void *rv );
00643 
00644       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00645       static void callback_unknown( void* theEnv, void *rv );
00646 
00647       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00648         typename T_arg5>
00649       static void callback_unknown( void* theEnv, void *rv );
00650 
00651       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00652         typename T_arg5, typename T_arg6>
00653       static void callback_unknown( void* theEnv, void *rv );
00654 
00655       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00656         typename T_arg5, typename T_arg6, typename T_arg7>
00657       static void callback_unknown( void* theEnv, void *rv );
00658 
00659       int ( *get_callback( const sigc::slot0<std::string>& slot ))( void* )
00660         { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback; }
00661 
00662       template < typename T_arg1 >
00663       int ( *get_callback( const sigc::slot1<std::string,T_arg1>& slot ))( void* )
00664         { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1>; }
00665 
00666       template < typename T_arg1, typename T_arg2 >
00667       int ( *get_callback( const sigc::slot2<std::string,T_arg1,T_arg2>& slot ))( void* )
00668         { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1,T_arg2>; }
00669 
00670       template < typename T_arg1, typename T_arg2, typename T_arg3 >
00671       int ( *get_callback( const sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00672         { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3>; }
00673 
00674       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00675       int ( *get_callback( const sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00676         { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4>; }
00677 
00678       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00679       int ( *get_callback( const sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00680         { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00681 
00682       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00683       int ( *get_callback( const sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00684         { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00685 
00686       template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
00687       int ( *get_callback( const sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00688         { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00689 
00690       int ( *get_callback( const sigc::slot0<Values>& slot ))( void* )
00691       { return  (int (*) (void*)) (void (*) (void*, void*)) callback_multifield; }
00692 
00693       template <typename T_arg1>
00694       int ( *get_callback( const sigc::slot1<Values,T_arg1>& slot ))( void* )
00695       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1>; }
00696 
00697       template <typename T_arg1, typename T_arg2>
00698       int ( *get_callback( const sigc::slot2<Values,T_arg1,T_arg2>& slot ))( void* )
00699       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2>; }
00700 
00701       template <typename T_arg1, typename T_arg2, typename T_arg3>
00702         int ( *get_callback( const sigc::slot3<Values,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00703       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3>; }
00704 
00705       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00706         int ( *get_callback( const sigc::slot4<Values,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00707       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4>; }
00708 
00709       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00710         int ( *get_callback( const sigc::slot5<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00711       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00712 
00713       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00714         int ( *get_callback( const sigc::slot6<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00715       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00716 
00717       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00718         int ( *get_callback( const sigc::slot7<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00719       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00720 
00721 
00722       int ( *get_callback( const sigc::slot0<Value>& slot ))( void* )
00723       { return  (int (*) (void*)) (void (*) (void*, void*)) callback_unknown; }
00724 
00725       template <typename T_arg1>
00726       int ( *get_callback( const sigc::slot1<Value,T_arg1>& slot ))( void* )
00727       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1>; }
00728 
00729       template <typename T_arg1, typename T_arg2>
00730       int ( *get_callback( const sigc::slot2<Value,T_arg1,T_arg2>& slot ))( void* )
00731       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2>; }
00732 
00733       template <typename T_arg1, typename T_arg2, typename T_arg3>
00734         int ( *get_callback( const sigc::slot3<Value,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00735       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3>; }
00736 
00737       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00738         int ( *get_callback( const sigc::slot4<Value,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00739       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4>; }
00740 
00741       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00742         int ( *get_callback( const sigc::slot5<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00743       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00744 
00745       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00746         int ( *get_callback( const sigc::slot6<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00747       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00748 
00749       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00750         int ( *get_callback( const sigc::slot7<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00751       { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00752 
00753 
00754       template < typename T_return >
00755       int ( *get_callback( const sigc::slot0<T_return>& slot ))( void* )
00756         { return (int (*) (void*)) ( T_return ( * ) ( void* ) ) callback<T_return>; }
00757 
00758       template < typename T_return, typename T_arg1 >
00759       int ( *get_callback( const sigc::slot1<T_return,T_arg1>& slot ))( void* )
00760         { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1>; }
00761 
00762       template < typename T_return, typename T_arg1, typename T_arg2 >
00763       int ( *get_callback( const sigc::slot2<T_return,T_arg1,T_arg2>& slot ))( void* )
00764         { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1,T_arg2>; }
00765 
00766       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00767       int ( *get_callback( const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot ))( void* )
00768         { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3>; }
00769 
00770       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00771       int ( *get_callback( const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
00772         { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4>; }
00773 
00774       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00775       int ( *get_callback( const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
00776         { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
00777 
00778       template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
00779       int ( *get_callback( const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
00780         { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
00781 
00782       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 >
00783       int ( *get_callback( const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
00784         { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
00785 
00786       char * get_function_restriction(std::string &name);
00787 
00788       template <typename T_arg1>
00789         char * get_function_restriction(std::string &name);
00790 
00791       template <typename T_arg1, typename T_arg2>
00792         char * get_function_restriction(std::string &name);
00793 
00794       template <typename T_arg1, typename T_arg2, typename T_arg3>
00795         char * get_function_restriction(std::string &name);
00796 
00797       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00798         char * get_function_restriction(std::string &name);
00799 
00800       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
00801         char * get_function_restriction(std::string &name);
00802 
00803       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
00804         char * get_function_restriction(std::string &name);
00805 
00806       template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
00807         char * get_function_restriction(std::string &name);
00808 
00809 
00810       static int get_arg_count( void* env );
00811       static void* get_function_context( void* env );
00812       static void  set_return_values( void *env, void *rv, const Values &v);
00813       static void  set_return_value( void *env, void *rv, const Value &v);
00814       static void* add_symbol( const char* s );
00815 
00816 
00817   };
00818 
00819 
00820   inline char *
00821   Environment::get_function_restriction(std::string &name) {
00822     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00823     char *restr = (char *)malloc(4); m_func_restr[name] = restr;
00824     snprintf(restr, 4, "00u");
00825     return restr;
00826   }
00827 
00828   template <typename T_arg1>
00829   inline char *
00830   Environment::get_function_restriction(std::string &name) {
00831     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00832     char *restr = (char *)malloc(5); m_func_restr[name] = restr;
00833     snprintf(restr, 5, "11u%c", get_argument_code<T_arg1>());
00834     return restr;
00835   }
00836 
00837   template <typename T_arg1, typename T_arg2>
00838   inline char *
00839   Environment::get_function_restriction(std::string &name) {
00840     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00841     char *restr = (char *)malloc(6); m_func_restr[name] = restr;
00842     snprintf(restr, 6, "22u%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>());
00843     return restr;
00844   }
00845 
00846   template <typename T_arg1, typename T_arg2, typename T_arg3>
00847   inline char *
00848   Environment::get_function_restriction(std::string &name) {
00849     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00850     char *restr = (char *)malloc(7); m_func_restr[name] = restr;
00851     snprintf(restr, 7, "33u%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00852              get_argument_code<T_arg3>());
00853     return restr;
00854   }
00855 
00856   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
00857   inline char *
00858   Environment::get_function_restriction(std::string &name) {
00859     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00860     char *restr = (char *)malloc(8); m_func_restr[name] = restr;
00861     snprintf(restr, 8, "44u%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00862              get_argument_code<T_arg3>(), get_argument_code<T_arg4>());
00863     return restr;
00864   }
00865 
00866   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00867     typename T_arg5>
00868   inline char *
00869   Environment::get_function_restriction(std::string &name) {
00870     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00871     char *restr = (char *)malloc(9); m_func_restr[name] = restr;
00872     snprintf(restr, 9, "55u%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00873              get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>());
00874     return restr;
00875   }
00876 
00877   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00878     typename T_arg5, typename T_arg6>
00879   inline char *
00880   Environment::get_function_restriction(std::string &name) {
00881     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00882     char *restr = (char *)malloc(10); m_func_restr[name] = restr;
00883     snprintf(restr, 10, "66u%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00884              get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
00885              get_argument_code<T_arg6>());
00886     return restr;
00887   }
00888 
00889   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
00890     typename T_arg5, typename T_arg6, typename T_arg7>
00891   inline char *
00892   Environment::get_function_restriction(std::string &name) {
00893     if (m_func_restr.find(name) != m_func_restr.end())  free(m_func_restr[name]);
00894     char *restr = (char *)malloc(11); m_func_restr[name] = restr;
00895     snprintf(restr, 11, "77u%c%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
00896              get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
00897              get_argument_code<T_arg6>(), get_argument_code<T_arg7>());
00898     return restr;
00899   }
00900 
00901 
00902   template < typename T_return>
00903   inline
00904   T_return Environment::callback( void* theEnv ) {
00905     sigc::slot0<T_return>* cb;
00906     void * cbptr = get_function_context( theEnv );
00907     if ( cbptr ) {
00908       if ( get_arg_count( theEnv ) != 0 )
00909         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 0" );
00910       cb = static_cast<sigc::slot0<T_return>*>( cbptr );
00911       return ( *cb ) ();
00912     }
00913     throw;
00914   }
00915 
00916   template < typename T_return, typename T_arg1 >
00917   inline
00918   T_return Environment::callback( void* theEnv ) {
00919     sigc::slot1<T_return,T_arg1>* cb;
00920     void * cbptr = get_function_context( theEnv );
00921     T_arg1 arg1;
00922     if ( cbptr ) {
00923       if ( get_arg_count( theEnv ) != 1 )
00924         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
00925       get_argument( theEnv, 1, arg1 );
00926       cb = static_cast<sigc::slot1<T_return,T_arg1>*>( cbptr );
00927       return ( *cb ) ( arg1 );
00928     }
00929     throw;
00930   }
00931 
00932   template < typename T_return, typename T_arg1, typename T_arg2 >
00933   inline
00934   T_return Environment::callback( void* theEnv ) {
00935     sigc::slot2<T_return, T_arg1, T_arg2>* cb;
00936     void * cbptr = get_function_context( theEnv );
00937     T_arg1 arg1;
00938     T_arg2 arg2;
00939     if ( cbptr ) {
00940       if ( get_arg_count( theEnv ) != 2 )
00941         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
00942       get_argument( theEnv, 1, arg1 );
00943       get_argument( theEnv, 2, arg2 );
00944       cb = static_cast<sigc::slot2<T_return, T_arg1, T_arg2>*>( cbptr );
00945       return ( *cb ) ( arg1, arg2 );
00946     }
00947     throw;
00948   }
00949 
00950   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
00951   inline
00952   T_return Environment::callback( void* theEnv ) {
00953     sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* cb;
00954     void * cbptr = get_function_context( theEnv );
00955     T_arg1 arg1;
00956     T_arg2 arg2;
00957     T_arg3 arg3;
00958     if ( cbptr ) {
00959       if ( get_arg_count( theEnv ) != 3 )
00960         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
00961       get_argument( theEnv, 1, arg1 );
00962       get_argument( theEnv, 2, arg2 );
00963       get_argument( theEnv, 3, arg3 );
00964       cb = static_cast<sigc::slot3<T_return, T_arg1, T_arg2,T_arg3>*>( cbptr );
00965       return ( *cb ) ( arg1, arg2, arg3 );
00966     }
00967     throw;
00968   }
00969 
00970   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
00971   inline
00972   T_return Environment::callback( void* theEnv ) {
00973     sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
00974     void * cbptr = get_function_context( theEnv );
00975     T_arg1 arg1;
00976     T_arg2 arg2;
00977     T_arg3 arg3;
00978     T_arg4 arg4;
00979     if ( cbptr ) {
00980       if ( get_arg_count( theEnv ) != 4 )
00981         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
00982       get_argument( theEnv, 1, arg1 );
00983       get_argument( theEnv, 2, arg2 );
00984       get_argument( theEnv, 3, arg3 );
00985       get_argument( theEnv, 4, arg4 );
00986       cb = static_cast<sigc::slot4<T_return, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
00987       return ( *cb ) ( arg1, arg2, arg3, arg4 );
00988     }
00989     throw;
00990   }
00991 
00992   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
00993   inline
00994   T_return Environment::callback( void* theEnv ) {
00995     sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
00996     void * cbptr = get_function_context( theEnv );
00997     T_arg1 arg1;
00998     T_arg2 arg2;
00999     T_arg3 arg3;
01000     T_arg4 arg4;
01001     T_arg5 arg5;
01002     if ( cbptr ) {
01003       if ( get_arg_count( theEnv ) != 5 )
01004         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
01005       get_argument( theEnv, 1, arg1 );
01006       get_argument( theEnv, 2, arg2 );
01007       get_argument( theEnv, 3, arg3 );
01008       get_argument( theEnv, 4, arg4 );
01009       get_argument( theEnv, 5, arg5 );
01010       cb = static_cast<sigc::slot5<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
01011       return ( *cb ) ( arg1, arg2, arg3, arg4, arg5 );
01012     }
01013     throw;
01014   }
01015 
01016  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
01017  inline
01018  T_return Environment::callback( void* theEnv ) {
01019    sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
01020    void * cbptr = get_function_context( theEnv );
01021    T_arg1 arg1;
01022    T_arg2 arg2;
01023    T_arg3 arg3;
01024    T_arg4 arg4;
01025    T_arg5 arg5;
01026    T_arg6 arg6;
01027    if ( cbptr ) {
01028      if ( get_arg_count( theEnv ) != 6 )
01029        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
01030      get_argument( theEnv, 1, arg1 );
01031      get_argument( theEnv, 2, arg2 );
01032      get_argument( theEnv, 3, arg3 );
01033      get_argument( theEnv, 4, arg4 );
01034      get_argument( theEnv, 5, arg5 );
01035      get_argument( theEnv, 6, arg6 );
01036      cb = static_cast<sigc::slot6<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
01037      return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 );
01038    }
01039    throw;
01040  }
01041 
01042   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 >
01043   inline
01044   T_return Environment::callback( void* theEnv ) {
01045     sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
01046     void * cbptr = get_function_context( theEnv );
01047     T_arg1 arg1;
01048     T_arg2 arg2;
01049     T_arg3 arg3;
01050     T_arg4 arg4;
01051     T_arg5 arg5;
01052     T_arg6 arg6;
01053     T_arg7 arg7;
01054     if ( cbptr ) {
01055       if ( get_arg_count( theEnv ) != 7 )
01056         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
01057       get_argument( theEnv, 1, arg1 );
01058       get_argument( theEnv, 2, arg2 );
01059       get_argument( theEnv, 3, arg3 );
01060       get_argument( theEnv, 4, arg4 );
01061       get_argument( theEnv, 5, arg5 );
01062       get_argument( theEnv, 6, arg6 );
01063       get_argument( theEnv, 7, arg7 );
01064       cb = static_cast<sigc::slot7<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
01065       return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 );
01066     }
01067     throw;
01068   }
01069 
01070   inline
01071   void Environment::callback_multifield( void* theEnv, void *rv) {
01072     sigc::slot0<Values>* cb;
01073     void * cbptr = get_function_context( theEnv );
01074     if ( cbptr ) {
01075       if ( get_arg_count( theEnv ) != 0 )
01076         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 0" );
01077       cb = static_cast<sigc::slot0<Values>*>( cbptr );
01078       Values v = ( *cb ) ();
01079       set_return_values(theEnv, rv, v);
01080       return;
01081     }
01082     throw;
01083   }
01084 
01085   template <typename T_arg1>
01086   inline
01087   void Environment::callback_multifield( void* theEnv, void *rv) {
01088     sigc::slot1<Values, T_arg1>* cb;
01089     void * cbptr = get_function_context( theEnv );
01090     T_arg1 arg1;
01091     if ( cbptr ) {
01092       if ( get_arg_count( theEnv ) != 1 )
01093         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 1" );
01094       cb = static_cast<sigc::slot1<Values, T_arg1>*>( cbptr );
01095       get_argument(theEnv, 1, arg1);
01096       Values v = ( *cb ) (arg1);
01097       set_return_values(theEnv, rv, v);
01098       return;
01099     }
01100     throw;
01101   }
01102 
01103   template <typename T_arg1, typename T_arg2>
01104   inline
01105   void Environment::callback_multifield( void* theEnv, void *rv) {
01106     sigc::slot2<Values, T_arg1, T_arg2>* cb;
01107     void * cbptr = get_function_context( theEnv );
01108     T_arg1 arg1;
01109     T_arg2 arg2;
01110     if ( cbptr ) {
01111       if ( get_arg_count( theEnv ) != 2 )
01112         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 2" );
01113       cb = static_cast<sigc::slot2<Values, T_arg1, T_arg2>*>( cbptr );
01114       get_argument(theEnv, 1, arg1);
01115       get_argument(theEnv, 2, arg2);
01116       Values v = ( *cb ) (arg1, arg2);
01117       set_return_values(theEnv, rv, v);
01118       return;
01119     }
01120     throw;
01121   }
01122 
01123 
01124   template <typename T_arg1, typename T_arg2, typename T_arg3>
01125   inline
01126   void Environment::callback_multifield( void* theEnv, void *rv) {
01127     sigc::slot3<Values, T_arg1, T_arg2, T_arg3>* cb;
01128     void * cbptr = get_function_context( theEnv );
01129     T_arg1 arg1;
01130     T_arg2 arg2;
01131     T_arg3 arg3;
01132     if ( cbptr ) {
01133       if ( get_arg_count( theEnv ) != 3 )
01134         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 3" );
01135       cb = static_cast<sigc::slot3<Values, T_arg1, T_arg2, T_arg3>*>( cbptr );
01136       get_argument(theEnv, 1, arg1);
01137       get_argument(theEnv, 2, arg2);
01138       get_argument(theEnv, 3, arg3);
01139       Values v = ( *cb ) (arg1, arg2, arg3);
01140       set_return_values(theEnv, rv, v);
01141       return;
01142     }
01143     throw;
01144   }
01145 
01146   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
01147   inline
01148   void Environment::callback_multifield( void* theEnv, void *rv) {
01149     sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>* cb;
01150     void * cbptr = get_function_context( theEnv );
01151     T_arg1 arg1;
01152     T_arg2 arg2;
01153     T_arg3 arg3;
01154     T_arg4 arg4;
01155     if ( cbptr ) {
01156       if ( get_arg_count( theEnv ) != 4 )
01157         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 4" );
01158       cb = static_cast<sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>*>(cbptr);
01159       get_argument(theEnv, 1, arg1);
01160       get_argument(theEnv, 2, arg2);
01161       get_argument(theEnv, 3, arg3);
01162       get_argument(theEnv, 4, arg4);
01163       Values v = ( *cb ) (arg1, arg2, arg3, arg4);
01164       set_return_values(theEnv, rv, v);
01165       return;
01166     }
01167     throw;
01168   }
01169 
01170   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01171     typename T_arg5>
01172   inline
01173   void Environment::callback_multifield( void* theEnv, void *rv) {
01174       sigc::slot5<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* cb;
01175     void * cbptr = get_function_context( theEnv );
01176     T_arg1 arg1;
01177     T_arg2 arg2;
01178     T_arg3 arg3;
01179     T_arg4 arg4;
01180     T_arg5 arg5;
01181     if ( cbptr ) {
01182       if ( get_arg_count( theEnv ) != 5 )
01183         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 5" );
01184       cb = static_cast<sigc::slot5<Values, T_arg1, T_arg2, T_arg3,
01185         T_arg4, T_arg5>*>(cbptr);
01186       get_argument(theEnv, 1, arg1);
01187       get_argument(theEnv, 2, arg2);
01188       get_argument(theEnv, 3, arg3);
01189       get_argument(theEnv, 4, arg4);
01190       get_argument(theEnv, 5, arg5);
01191       Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5);
01192       set_return_values(theEnv, rv, v);
01193       return;
01194     }
01195     throw;
01196   }
01197 
01198 
01199   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01200     typename T_arg5, typename T_arg6>
01201   inline
01202   void Environment::callback_multifield( void* theEnv, void *rv) {
01203     sigc::slot6<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* cb;
01204     void * cbptr = get_function_context( theEnv );
01205     T_arg1 arg1;
01206     T_arg2 arg2;
01207     T_arg3 arg3;
01208     T_arg4 arg4;
01209     T_arg5 arg5;
01210     T_arg6 arg6;
01211     if ( cbptr ) {
01212       if ( get_arg_count( theEnv ) != 6 )
01213         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 6" );
01214       cb = static_cast<sigc::slot6<Values, T_arg1, T_arg2, T_arg3,
01215         T_arg4, T_arg5, T_arg6>*>(cbptr);
01216       get_argument(theEnv, 1, arg1);
01217       get_argument(theEnv, 2, arg2);
01218       get_argument(theEnv, 3, arg3);
01219       get_argument(theEnv, 4, arg4);
01220       get_argument(theEnv, 5, arg5);
01221       get_argument(theEnv, 6, arg6);
01222       Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6);
01223       set_return_values(theEnv, rv, v);
01224       return;
01225     }
01226     throw;
01227   }
01228 
01229   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01230     typename T_arg5, typename T_arg6, typename T_arg7>
01231   inline
01232   void Environment::callback_multifield( void* theEnv, void *rv) {
01233     sigc::slot7<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* cb;
01234     void * cbptr = get_function_context( theEnv );
01235     T_arg1 arg1;
01236     T_arg2 arg2;
01237     T_arg3 arg3;
01238     T_arg4 arg4;
01239     T_arg5 arg5;
01240     T_arg6 arg6;
01241     T_arg7 arg7;
01242     if ( cbptr ) {
01243       if ( get_arg_count( theEnv ) != 7 )
01244         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 7" );
01245       cb = static_cast<sigc::slot7<Values, T_arg1, T_arg2, T_arg3,
01246         T_arg4, T_arg5, T_arg6, T_arg7>*>(cbptr);
01247       get_argument(theEnv, 1, arg1);
01248       get_argument(theEnv, 2, arg2);
01249       get_argument(theEnv, 3, arg3);
01250       get_argument(theEnv, 4, arg4);
01251       get_argument(theEnv, 5, arg5);
01252       get_argument(theEnv, 6, arg6);
01253       get_argument(theEnv, 7, arg7);
01254       Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6, arg7);
01255       set_return_values(theEnv, rv, v);
01256       return;
01257     }
01258     throw;
01259   }
01260 
01261 
01262   // **************************************************************************************
01263 
01264   inline
01265   void Environment::callback_unknown( void* theEnv, void *rv) {
01266     sigc::slot0<Value>* cb;
01267     void * cbptr = get_function_context( theEnv );
01268     if ( cbptr ) {
01269       if ( get_arg_count( theEnv ) != 0 )
01270         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 0" );
01271       cb = static_cast<sigc::slot0<Value>*>( cbptr );
01272       Value v = ( *cb ) ();
01273       set_return_value(theEnv, rv, v);
01274       return;
01275     }
01276     throw;
01277   }
01278 
01279   template <typename T_arg1>
01280   inline
01281   void Environment::callback_unknown( void* theEnv, void *rv) {
01282     sigc::slot1<Value, T_arg1>* cb;
01283     void * cbptr = get_function_context( theEnv );
01284     T_arg1 arg1;
01285     if ( cbptr ) {
01286       if ( get_arg_count( theEnv ) != 1 )
01287         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 1" );
01288       cb = static_cast<sigc::slot1<Value, T_arg1>*>( cbptr );
01289       get_argument(theEnv, 1, arg1);
01290       Value v = ( *cb ) (arg1);
01291       set_return_value(theEnv, rv, v);
01292       return;
01293     }
01294     throw;
01295   }
01296 
01297   template <typename T_arg1, typename T_arg2>
01298   inline
01299   void Environment::callback_unknown( void* theEnv, void *rv) {
01300     sigc::slot2<Value, T_arg1, T_arg2>* cb;
01301     void * cbptr = get_function_context( theEnv );
01302     T_arg1 arg1;
01303     T_arg2 arg2;
01304     if ( cbptr ) {
01305       if ( get_arg_count( theEnv ) != 2 )
01306         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 2" );
01307       cb = static_cast<sigc::slot2<Value, T_arg1, T_arg2>*>( cbptr );
01308       get_argument(theEnv, 1, arg1);
01309       get_argument(theEnv, 2, arg2);
01310       Value v = ( *cb ) (arg1, arg2);
01311       set_return_value(theEnv, rv, v);
01312       return;
01313     }
01314     throw;
01315   }
01316 
01317 
01318   template <typename T_arg1, typename T_arg2, typename T_arg3>
01319   inline
01320   void Environment::callback_unknown( void* theEnv, void *rv) {
01321     sigc::slot3<Value, T_arg1, T_arg2, T_arg3>* cb;
01322     void * cbptr = get_function_context( theEnv );
01323     T_arg1 arg1;
01324     T_arg2 arg2;
01325     T_arg3 arg3;
01326     if ( cbptr ) {
01327       if ( get_arg_count( theEnv ) != 3 )
01328         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 3" );
01329       cb = static_cast<sigc::slot3<Value, T_arg1, T_arg2, T_arg3>*>( cbptr );
01330       get_argument(theEnv, 1, arg1);
01331       get_argument(theEnv, 2, arg2);
01332       get_argument(theEnv, 3, arg3);
01333       Value v = ( *cb ) (arg1, arg2, arg3);
01334       set_return_value(theEnv, rv, v);
01335       return;
01336     }
01337     throw;
01338   }
01339 
01340   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
01341   inline
01342   void Environment::callback_unknown( void* theEnv, void *rv) {
01343     sigc::slot4<Value, T_arg1, T_arg2, T_arg3, T_arg4>* cb;
01344     void * cbptr = get_function_context( theEnv );
01345     T_arg1 arg1;
01346     T_arg2 arg2;
01347     T_arg3 arg3;
01348     T_arg4 arg4;
01349     if ( cbptr ) {
01350       if ( get_arg_count( theEnv ) != 4 )
01351         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 4" );
01352       cb = static_cast<sigc::slot4<Value, T_arg1, T_arg2, T_arg3, T_arg4>*>(cbptr);
01353       get_argument(theEnv, 1, arg1);
01354       get_argument(theEnv, 2, arg2);
01355       get_argument(theEnv, 3, arg3);
01356       get_argument(theEnv, 4, arg4);
01357       Value v = ( *cb ) (arg1, arg2, arg3, arg4);
01358       set_return_value(theEnv, rv, v);
01359       return;
01360     }
01361     throw;
01362   }
01363 
01364   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01365     typename T_arg5>
01366   inline
01367   void Environment::callback_unknown( void* theEnv, void *rv) {
01368       sigc::slot5<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* cb;
01369     void * cbptr = get_function_context( theEnv );
01370     T_arg1 arg1;
01371     T_arg2 arg2;
01372     T_arg3 arg3;
01373     T_arg4 arg4;
01374     T_arg5 arg5;
01375     if ( cbptr ) {
01376       if ( get_arg_count( theEnv ) != 5 )
01377         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 5" );
01378       cb = static_cast<sigc::slot5<Value, T_arg1, T_arg2, T_arg3,
01379         T_arg4, T_arg5>*>(cbptr);
01380       get_argument(theEnv, 1, arg1);
01381       get_argument(theEnv, 2, arg2);
01382       get_argument(theEnv, 3, arg3);
01383       get_argument(theEnv, 4, arg4);
01384       get_argument(theEnv, 5, arg5);
01385       Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5);
01386       set_return_value(theEnv, rv, v);
01387       return;
01388     }
01389     throw;
01390   }
01391 
01392 
01393   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01394     typename T_arg5, typename T_arg6>
01395   inline
01396   void Environment::callback_unknown( void* theEnv, void *rv) {
01397     sigc::slot6<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* cb;
01398     void * cbptr = get_function_context( theEnv );
01399     T_arg1 arg1;
01400     T_arg2 arg2;
01401     T_arg3 arg3;
01402     T_arg4 arg4;
01403     T_arg5 arg5;
01404     T_arg6 arg6;
01405     if ( cbptr ) {
01406       if ( get_arg_count( theEnv ) != 6 )
01407         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 6" );
01408       cb = static_cast<sigc::slot6<Value, T_arg1, T_arg2, T_arg3,
01409         T_arg4, T_arg5, T_arg6>*>(cbptr);
01410       get_argument(theEnv, 1, arg1);
01411       get_argument(theEnv, 2, arg2);
01412       get_argument(theEnv, 3, arg3);
01413       get_argument(theEnv, 4, arg4);
01414       get_argument(theEnv, 5, arg5);
01415       get_argument(theEnv, 6, arg6);
01416       Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6);
01417       set_return_value(theEnv, rv, v);
01418       return;
01419     }
01420     throw;
01421   }
01422 
01423   template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
01424     typename T_arg5, typename T_arg6, typename T_arg7>
01425   inline
01426   void Environment::callback_unknown( void* theEnv, void *rv) {
01427     sigc::slot7<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* cb;
01428     void * cbptr = get_function_context( theEnv );
01429     T_arg1 arg1;
01430     T_arg2 arg2;
01431     T_arg3 arg3;
01432     T_arg4 arg4;
01433     T_arg5 arg5;
01434     T_arg6 arg6;
01435     T_arg7 arg7;
01436     if ( cbptr ) {
01437       if ( get_arg_count( theEnv ) != 7 )
01438         throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 7" );
01439       cb = static_cast<sigc::slot7<Value, T_arg1, T_arg2, T_arg3,
01440         T_arg4, T_arg5, T_arg6, T_arg7>*>(cbptr);
01441       get_argument(theEnv, 1, arg1);
01442       get_argument(theEnv, 2, arg2);
01443       get_argument(theEnv, 3, arg3);
01444       get_argument(theEnv, 4, arg4);
01445       get_argument(theEnv, 5, arg5);
01446       get_argument(theEnv, 6, arg6);
01447       get_argument(theEnv, 7, arg7);
01448       Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6, arg7);
01449       set_return_value(theEnv, rv, v);
01450       return;
01451     }
01452     throw;
01453   }
01454 
01455   // **************************************************************************************
01456 
01457 
01458   inline
01459   void* Environment::strcallback( void* theEnv ) {
01460     sigc::slot0<std::string>* cb;
01461     void * cbptr = get_function_context( theEnv );
01462     if ( cbptr ) {
01463       if ( get_arg_count( theEnv ) != 0 )
01464         throw std::logic_error( "clipsmm/string: wrong # args on slot callback; expected 0" );
01465       cb = static_cast<sigc::slot0<std::string>*>( cbptr );
01466       return add_symbol( ( ( *cb ) ( )).c_str() );
01467     }
01468     throw;
01469   }
01470 
01471   template < typename T_arg1 >
01472   inline
01473   void* Environment::strcallback( void* theEnv ) {
01474     sigc::slot1<std::string,T_arg1>* cb;
01475     void * cbptr = get_function_context( theEnv );
01476     T_arg1 arg1;
01477     if ( cbptr ) {
01478       if ( get_arg_count( theEnv ) != 1 )
01479         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
01480       get_argument( theEnv, 1, arg1 );
01481       cb = static_cast<sigc::slot1<std::string,T_arg1>*>( cbptr );
01482       return add_symbol( ( ( *cb ) ( arg1 )).c_str() );
01483     }
01484     throw;
01485   }
01486 
01487   template < typename T_arg1, typename T_arg2 >
01488   inline
01489   void* Environment::strcallback( void* theEnv ) {
01490     sigc::slot2<std::string, T_arg1, T_arg2>* cb;
01491     void * cbptr = get_function_context( theEnv );
01492     T_arg1 arg1;
01493     T_arg2 arg2;
01494     if ( cbptr ) {
01495       if ( get_arg_count( theEnv ) != 2 )
01496         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
01497       get_argument( theEnv, 1, arg1 );
01498       get_argument( theEnv, 2, arg2 );
01499       cb = static_cast<sigc::slot2<std::string, T_arg1, T_arg2>*>( cbptr );
01500       return add_symbol( ( ( *cb ) ( arg1, arg2 )).c_str() );
01501     }
01502     throw;
01503   }
01504 
01505   template < typename T_arg1, typename T_arg2, typename T_arg3 >
01506   inline
01507   void* Environment::strcallback( void* theEnv ) {
01508     sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>* cb;
01509     void * cbptr = get_function_context( theEnv );
01510     T_arg1 arg1;
01511     T_arg2 arg2;
01512     T_arg3 arg3;
01513     if ( cbptr ) {
01514       if ( get_arg_count( theEnv ) != 3 )
01515         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
01516       get_argument( theEnv, 1, arg1 );
01517       get_argument( theEnv, 2, arg2 );
01518       get_argument( theEnv, 3, arg3 );
01519       cb = static_cast<sigc::slot3<std::string, T_arg1, T_arg2,T_arg3>*>( cbptr );
01520       return add_symbol( ( ( *cb ) ( arg1, arg2, arg3 )).c_str() );
01521     }
01522     throw;
01523   }
01524 
01525   template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
01526   inline
01527   void* Environment::strcallback( void* theEnv ) {
01528     sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
01529     void * cbptr = get_function_context( theEnv );
01530     T_arg1 arg1;
01531     T_arg2 arg2;
01532     T_arg3 arg3;
01533     T_arg4 arg4;
01534     std::string s;
01535     if ( cbptr ) {
01536       if ( get_arg_count( theEnv ) != 4 )
01537         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
01538       get_argument( theEnv, 1, arg1 );
01539       get_argument( theEnv, 2, arg2 );
01540       get_argument( theEnv, 3, arg3 );
01541       get_argument( theEnv, 4, arg4 );
01542       cb = static_cast<sigc::slot4<std::string, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
01543       s = ( *cb ) ( arg1, arg2, arg3, arg4 );
01544       return add_symbol( s.c_str() );
01545     }
01546     throw;
01547   }
01548 
01549   template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
01550   inline
01551   void* Environment::strcallback( void* theEnv ) {
01552     sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
01553     void * cbptr = get_function_context( theEnv );
01554     T_arg1 arg1;
01555     T_arg2 arg2;
01556     T_arg3 arg3;
01557     T_arg4 arg4;
01558     T_arg5 arg5;
01559     if ( cbptr ) {
01560       if ( get_arg_count( theEnv ) != 5 )
01561         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
01562       get_argument( theEnv, 1, arg1 );
01563       get_argument( theEnv, 2, arg2 );
01564       get_argument( theEnv, 3, arg3 );
01565       get_argument( theEnv, 4, arg4 );
01566       get_argument( theEnv, 5, arg5 );
01567       cb = static_cast<sigc::slot5<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
01568       return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5 )).c_str() );
01569     }
01570     throw;
01571   }
01572 
01573   template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
01574   inline
01575   void* Environment::strcallback( void* theEnv ) {
01576     sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
01577     void * cbptr = get_function_context( theEnv );
01578     T_arg1 arg1;
01579     T_arg2 arg2;
01580     T_arg3 arg3;
01581     T_arg4 arg4;
01582     T_arg5 arg5;
01583     T_arg6 arg6;
01584     if ( cbptr ) {
01585       if ( get_arg_count( theEnv ) != 6 )
01586         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
01587       get_argument( theEnv, 1, arg1 );
01588       get_argument( theEnv, 2, arg2 );
01589       get_argument( theEnv, 3, arg3 );
01590       get_argument( theEnv, 4, arg4 );
01591       get_argument( theEnv, 5, arg5 );
01592       get_argument( theEnv, 6, arg6 );
01593       cb = static_cast<sigc::slot6<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
01594       return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 )).c_str() );
01595     }
01596     throw;
01597   }
01598 
01599   template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
01600   inline
01601   void* Environment::strcallback( void* theEnv ) {
01602     sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
01603     void * cbptr = get_function_context( theEnv );
01604     T_arg1 arg1;
01605     T_arg2 arg2;
01606     T_arg3 arg3;
01607     T_arg4 arg4;
01608     T_arg5 arg5;
01609     T_arg6 arg6;
01610     T_arg7 arg7;
01611     if ( cbptr ) {
01612       if ( get_arg_count( theEnv ) != 7 )
01613         throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
01614       get_argument( theEnv, 1, arg1 );
01615       get_argument( theEnv, 2, arg2 );
01616       get_argument( theEnv, 3, arg3 );
01617       get_argument( theEnv, 4, arg4 );
01618       get_argument( theEnv, 5, arg5 );
01619       get_argument( theEnv, 6, arg6 );
01620       get_argument( theEnv, 7, arg7 );
01621       cb = static_cast<sigc::slot7<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
01622       return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 )).c_str() );
01623     }
01624     throw;
01625   }
01626 
01627 template < typename T_return >
01628   inline
01629   bool Environment::add_function( std::string name, const sigc::slot0<T_return>& slot) {
01630     char retcode = get_return_code<T_return>( );
01631     char *argstring = get_function_restriction(name);
01632     sigc::slot0<T_return>* scb = new sigc::slot0<T_return>(slot);
01633     any holder = CLIPSPointer<sigc::slot0<T_return> >(scb);
01634     m_slots[name] = holder;
01635     return ( EnvDefineFunction2WithContext( m_cobj,
01636                                  const_cast<char*>( name.c_str() ),
01637                                  retcode,
01638                                  get_callback(slot),
01639                                  const_cast<char*>( name.c_str() ),
01640                                  argstring,
01641                                  ( void* ) scb ) );
01642   }
01643 
01644   template < typename T_return, typename T_arg1 >
01645   inline
01646   bool Environment::add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot) {
01647     char retcode = get_return_code<T_return>( );
01648     char *argstring = get_function_restriction<T_arg1>(name);
01649     sigc::slot1<T_return, T_arg1>* scb = new sigc::slot1<T_return, T_arg1>(slot);
01650     any holder = CLIPSPointer<sigc::slot1<T_return, T_arg1> >(scb);
01651     m_slots[name] = holder;
01652     return ( EnvDefineFunction2WithContext( m_cobj,
01653                                  const_cast<char*>( name.c_str() ),
01654                                  retcode,
01655                                  get_callback(slot),
01656                                  const_cast<char*>( name.c_str() ),
01657                                  argstring,
01658                                  scb ) );
01659   }
01660 
01661   template < typename T_return, typename T_arg1, typename T_arg2 >
01662   inline
01663   bool Environment::add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot) {
01664     char retcode = get_return_code<T_return>( );
01665     char *argstring = get_function_restriction<T_arg1,T_arg2>(name);
01666     sigc::slot2<T_return, T_arg1, T_arg2>* scb = new sigc::slot2<T_return, T_arg1, T_arg2>(slot);
01667     any holder = CLIPSPointer<sigc::slot2<T_return, T_arg1, T_arg2> >(scb);
01668     m_slots[name] = holder;
01669     return ( EnvDefineFunction2WithContext( m_cobj,
01670                                  const_cast<char*>( name.c_str() ),
01671                                  retcode,
01672                                  get_callback(slot),
01673                                  const_cast<char*>( name.c_str() ),
01674                                  argstring,
01675                                  scb ) );
01676   }
01677 
01678   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
01679   inline
01680   bool Environment::add_function( std::string name, const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot) {
01681     char retcode = get_return_code<T_return>( );
01682     char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3>(name);
01683     sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* scb =
01684         new sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>(slot);
01685     any holder = CLIPSPointer<sigc::slot3<T_return,T_arg1,T_arg2,T_arg3> >(scb);
01686     m_slots[name] = holder;
01687     return ( EnvDefineFunction2WithContext( m_cobj,
01688                                  const_cast<char*>( name.c_str() ),
01689                                  retcode,
01690                                  get_callback(slot),
01691                                  const_cast<char*>( name.c_str() ),
01692                                  argstring,
01693                                  scb )
01694            );
01695   }
01696 
01697   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
01698   inline
01699   bool Environment::add_function( std::string name, const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot) {
01700     char retcode = get_return_code<T_return>( );
01701     char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4>(name);
01702     sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* scb =
01703         new sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>(slot);
01704     any holder = CLIPSPointer<sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4> >(scb);
01705     m_slots[name] = holder;
01706     return ( EnvDefineFunction2WithContext( m_cobj,
01707                                  const_cast<char*>( name.c_str() ),
01708                                  retcode,
01709                                  get_callback(slot),
01710                                  const_cast<char*>( name.c_str() ),
01711                                  argstring,
01712                                  scb )
01713            );
01714   }
01715 
01716   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
01717   inline
01718   bool Environment::add_function( std::string name,
01719                               const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot) {
01720     char retcode = get_return_code<T_return>( );
01721     char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(name);
01722     sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* scb =
01723         new sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(slot);
01724     any holder = CLIPSPointer<sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> >(scb);
01725     m_slots[name] = holder;
01726     return ( EnvDefineFunction2WithContext( m_cobj,
01727                                  const_cast<char*>( name.c_str() ),
01728                                  retcode,
01729                                  get_callback(slot),
01730                                  const_cast<char*>( name.c_str() ),
01731                                  argstring,
01732                                  scb )
01733            );
01734   }
01735 
01736   template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
01737   inline
01738   bool Environment::add_function( std::string name,
01739                               const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot) {
01740     char retcode = get_return_code<T_return>( );
01741     char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(name);
01742     sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* scb =
01743         new sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(slot);
01744     any holder = CLIPSPointer<sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> >(scb);
01745     m_slots[name] = holder;
01746     return ( EnvDefineFunction2WithContext( m_cobj,
01747                                  const_cast<char*>( name.c_str() ),
01748                                  retcode,
01749                                  get_callback(slot),
01750                                  const_cast<char*>( name.c_str() ),
01751                                  argstring,
01752                                  scb )
01753            );
01754   }
01755 
01756   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 >
01757   inline
01758   bool Environment::add_function( std::string name,
01759                                   const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot) {
01760     char retcode = get_return_code<T_return>( );
01761     char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(name);
01762     sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* scb =
01763         new sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(slot);
01764     any holder = CLIPSPointer<sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> >(scb);
01765     m_slots[name] = holder;
01766     return ( EnvDefineFunction2WithContext( m_cobj,
01767                                  const_cast<char*>( name.c_str() ),
01768                                  retcode,
01769                                  get_callback(slot),
01770                                  const_cast<char*>( name.c_str() ),
01771                                  argstring,
01772                                  scb )
01773            );
01774   }
01775 
01776 }
01777 
01778 
01779 #endif

Generated on Thu Oct 24 13:08:08 2013 for clipsmm by doxygen 1.6.1