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

Generated on Sun Feb 12 2012 17:07:50 for clipsmm by doxygen 1.7.4