clipsmm - C++ CLIPS Interface Library

clipsmm logo
environment.h
Go to the documentation of this file.
1 /***************************************************************************
2  * Copyright (C) 2006 by Rick L. Vinyard, Jr. <rvinyard@cs.nmsu.edu> *
3  * Copyright (C) 2011 by Tim Niemueller [http://www.niemueller.de] *
4  * *
5  * This file is part of the clipsmm library. *
6  * *
7  * The clipsmm library is free software; you can redistribute it and/or *
8  * modify it under the terms of the GNU General Public License *
9  * version 3 as published by the Free Software Foundation. *
10  * *
11  * The clipsmm library is distributed in the hope that it will be *
12  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty *
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
14  * General Public License for more details. *
15  * *
16  * You should have received a copy of the GNU General Public License *
17  * along with this software. If not see <http://www.gnu.org/licenses/>. *
18  ***************************************************************************/
19 #ifndef CLIPSENVIRONMENT_H
20 #define CLIPSENVIRONMENT_H
21 
22 #include <string>
23 #include <map>
24 #include <stdexcept>
25 #include <map>
26 #include <queue>
27 
28 #include <cstdio>
29 
30 #include <sigc++/sigc++.h>
31 #include <glibmm.h>
32 
33 #include <clipsmm/enum.h>
34 #include <clipsmm/object.h>
35 
36 #include <clipsmm/activation.h>
37 #include <clipsmm/defaultfacts.h>
38 #include <clipsmm/fact.h>
39 #include <clipsmm/function.h>
40 #include <clipsmm/global.h>
41 #include <clipsmm/module.h>
42 #include <clipsmm/rule.h>
43 #include <clipsmm/template.h>
44 
45 #include <clipsmm/utility.h>
46 #include <clipsmm/any.h>
47 
48 extern "C" {
49  int EnvDefineFunction2WithContext( void *, char *, int, int ( * ) ( void * ), char *, char *, void * );
50 }
51 
52 namespace CLIPS {
53 
57  class Environment: public Object {
58  public:
59  typedef CLIPSPointer<Environment> pointer;
60 
61  Environment();
62 
63  ~Environment();
64 
69  bool batch_evaluate( const std::string& filename );
70 
75  bool binary_load( const std::string& filename );
76 
81  bool binary_save( const std::string& filename );
82 
87  bool build( const std::string& construct );
88 
92  void clear( );
93 
99  Values evaluate( const std::string& expression );
100 
106  Values function( const std::string& function_name, const std::string& arguments=std::string() );
107 
119  int load( const std::string& filename );
120 
124  void reset();
125 
130  bool save( const std::string& filename );
131 
139 
147  bool use_auto_float_dividend( bool use = true );
148 
156 
164  bool use_dynamic_constraint_checking( bool use = true );
165 
173 
181  bool use_sequence_operator_recognition( bool use = true );
182 
190 
197  bool use_static_constraint_checking( bool use = true );
198 
207 
214  bool use_fact_duplication( bool use = true );
215 
217 
218  bool use_incremental_reset( bool use = true );
219 
220  bool global_reset_enable();
221 
222  bool use_global_reset( bool use=true );
223 
228  bool is_dribble_active( );
229 
234  bool dribble_off( );
235 
240  bool dribble_on( const std::string& dribble_file );
241 
249  int is_watched( const std::string& item );
250 
251  bool watch( const std::string& item );
252 
253  bool unwatch( const std::string& item );
254 
255  void set_as_current();
256 
257  Fact::pointer assert_fact( const std::string& factstring );
258  Fact::pointer assert_fact_f( const char *format, ... );
259 
260  void clear_focus_stack();
261 
264  DefaultFacts::pointer get_default_facts( const std::string& default_facts_name );
265 
267  std::vector<std::string> get_default_facts_names();
268 
270  std::vector<std::string> get_default_facts_names( const Module& module );
271 
273  std::vector<std::string> get_default_facts_names( Module::pointer module );
274 
276 
277  Template::pointer get_template( const std::string& template_name );
278 
280  std::vector<std::string> get_template_names();
281 
283  std::vector<std::string> get_template_names( const Module& module );
284 
286  std::vector<std::string> get_template_names( Module::pointer module );
287 
289 
290  Rule::pointer get_rule( const std::string& rule_name );
291 
293  std::vector<std::string> get_rule_names();
294 
296  std::vector<std::string> get_rule_names( const Module& module );
297 
299  std::vector<std::string> get_rule_names( Module::pointer module );
300 
302 
303  void remove_rules();
304 
305  Module::pointer get_module( const std::string& module_name );
306 
308 
309  std::vector<std::string> get_module_names();
310 
312 
318  void refresh_agenda();
319 
325  void refresh_agenda( const Module& module );
326 
332  void refresh_agenda( Module::pointer module );
333 
339  void reorder_agenda();
340 
346  void reorder_agenda( const Module& module );
347 
353  void reorder_agenda( Module::pointer module );
354 
364  long int run( long int runlimit = -1 );
365 
384  void run_threaded( long int runlimit = -1, int priority = 0 );
385 
387  void join_run_thread();
388 
390  sigc::signal<void, long int> signal_run();
391 
394 
400 
403 
409 
418  bool check_agenda_changed();
419 
421 
422  std::vector<std::string> get_focus_stack();
423 
425 
426  Global::pointer get_global( const std::string& global_name );
427 
429 
431  std::vector<std::string> get_globals_names();
432 
434  std::vector<std::string> get_globals_names( const Module& module );
435 
437  std::vector<std::string> get_globals_names( Module::pointer module );
438 
439  bool check_globals_changed();
440 
441  Function::pointer get_function( const std::string& function_name );
442 
444 
446  std::vector<std::string> get_function_names();
447 
449  std::vector<std::string> get_function_names( const Module& module );
450 
452  std::vector<std::string> get_function_names( Module::pointer module );
453 
454  sigc::signal<void> signal_clear();
455  sigc::signal<void> signal_periodic();
456  sigc::signal<void> signal_reset();
457  sigc::signal<void> signal_rule_firing();
458  sigc::signal<void> signal_agenda_changed();
459  sigc::signal<void> signal_globals_changed();
460 
461  template < typename T_return >
462  bool add_function( std::string name, const sigc::slot0<T_return>& slot);
463 
464  template < typename T_return, typename T_arg1 >
465  bool add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot);
466 
467  template < typename T_return, typename T_arg1, typename T_arg2 >
468  bool add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot);
469 
470  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
471  bool add_function( std::string name, const sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>& slot);
472 
473  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
474  bool add_function( std::string name, const sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>& slot);
475 
476  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
477  bool add_function( std::string name, const sigc::slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& slot);
478 
479  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
480  bool add_function( std::string name, const sigc::slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& slot);
481 
482  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 >
483  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);
484 
485  bool remove_function( std::string name );
486 
487  protected:
494  std::map<std::string,any> m_slots;
495 
496  sigc::signal<void> m_signal_clear;
497  sigc::signal<void> m_signal_periodic;
498  sigc::signal<void> m_signal_reset;
499  sigc::signal<void> m_signal_rule_firing;
500  sigc::signal<void> m_signal_agenda_changed;
501  sigc::signal<void> m_signal_globals_changed;
502 
504  typedef struct Job {
506  Job( int p, long int rl ) : priority(p), runlimit(rl) { }
507 
509  bool operator<( const Job& other ) const { return priority < other.priority; }
510 
512  int priority;
513 
518  long int runlimit;
519  } Job;
520 
521  Glib::Thread* m_run_thread;
522  std::priority_queue<Job> m_run_queue;
523  Glib::Mutex m_mutex_run_queue;
524  Glib::Mutex m_mutex_run;
525  Glib::Mutex m_mutex_threaded_run;
526  Glib::Mutex m_mutex_run_signal;
527  sigc::signal<void, long int> m_signal_run;
538  std::map<std::string, char *> m_func_restr;
539 
541  void threaded_run();
542 
543  static std::map<void*, Environment*> m_environment_map;
544 
545 
546  static void clear_callback( void* env );
547  static void periodic_callback( void* env );
548  static void reset_callback( void* env );
549  static void rule_firing_callback( void* end );
550 
551  static void* strcallback( void* theEnv );
552 
553  template < typename T_arg1 >
554  static void* strcallback( void* theEnv );
555 
556  template < typename T_arg1, typename T_arg2 >
557  static void* strcallback( void* theEnv );
558 
559  template < typename T_arg1, typename T_arg2, typename T_arg3 >
560  static void* strcallback( void* theEnv );
561 
562  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
563  static void* strcallback( void* theEnv );
564 
565  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
566  static void* strcallback( void* theEnv );
567 
568  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
569  static void* strcallback( void* theEnv );
570 
571  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
572  static void* strcallback( void* theEnv );
573 
574  template < typename T_return >
575  static T_return callback( void* theEnv );
576 
577  template < typename T_return, typename T_arg1 >
578  static T_return callback( void* theEnv );
579 
580  template < typename T_return, typename T_arg1, typename T_arg2 >
581  static T_return callback( void* theEnv );
582 
583  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
584  static T_return callback( void* theEnv );
585 
586  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
587  static T_return callback( void* theEnv );
588 
589  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
590  static T_return callback( void* theEnv );
591 
592  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
593  static T_return callback( void* theEnv );
594 
595  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 >
596  static T_return callback( void* theEnv );
597 
598  static void callback_multifield( void* theEnv, void *rv);
599 
600  template <typename T_arg1>
601  static void callback_multifield( void* theEnv, void *rv );
602 
603  template <typename T_arg1, typename T_arg2>
604  static void callback_multifield( void* theEnv, void *rv );
605 
606  template <typename T_arg1, typename T_arg2, typename T_arg3>
607  static void callback_multifield( void* theEnv, void *rv );
608 
609  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
610  static void callback_multifield( void* theEnv, void *rv );
611 
612  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
613  typename T_arg5>
614  static void callback_multifield( void* theEnv, void *rv );
615 
616  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
617  typename T_arg5, typename T_arg6>
618  static void callback_multifield( void* theEnv, void *rv );
619 
620  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
621  typename T_arg5, typename T_arg6, typename T_arg7>
622  static void callback_multifield( void* theEnv, void *rv );
623 
624  int ( *get_callback( const sigc::slot0<std::string>& slot ))( void* )
625  { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback; }
626 
627  template < typename T_arg1 >
628  int ( *get_callback( const sigc::slot1<std::string,T_arg1>& slot ))( void* )
629  { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1>; }
630 
631  template < typename T_arg1, typename T_arg2 >
632  int ( *get_callback( const sigc::slot2<std::string,T_arg1,T_arg2>& slot ))( void* )
633  { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1,T_arg2>; }
634 
635  template < typename T_arg1, typename T_arg2, typename T_arg3 >
636  int ( *get_callback( const sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>& slot ))( void* )
637  { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3>; }
638 
639  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
640  int ( *get_callback( const sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
641  { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4>; }
642 
643  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
644  int ( *get_callback( const sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
645  { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
646 
647  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
648  int ( *get_callback( const sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
649  { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
650 
651  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
652  int ( *get_callback( const sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
653  { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
654 
655  int ( *get_callback( const sigc::slot0<Values>& slot ))( void* )
656  { return (int (*) (void*)) (void (*) (void*, void*)) callback_multifield; }
657 
658  template <typename T_arg1>
659  int ( *get_callback( const sigc::slot1<Values,T_arg1>& slot ))( void* )
660  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1>; }
661 
662  template <typename T_arg1, typename T_arg2>
663  int ( *get_callback( const sigc::slot2<Values,T_arg1,T_arg2>& slot ))( void* )
664  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2>; }
665 
666  template <typename T_arg1, typename T_arg2, typename T_arg3>
667  int ( *get_callback( const sigc::slot3<Values,T_arg1,T_arg2,T_arg3>& slot ))( void* )
668  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3>; }
669 
670  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
671  int ( *get_callback( const sigc::slot4<Values,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
672  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4>; }
673 
674  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
675  int ( *get_callback( const sigc::slot5<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
676  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
677 
678  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
679  int ( *get_callback( const sigc::slot6<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
680  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
681 
682  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
683  int ( *get_callback( const sigc::slot7<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
684  { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
685 
686 
687  template < typename T_return >
688  int ( *get_callback( const sigc::slot0<T_return>& slot ))( void* )
689  { return (int (*) (void*)) ( T_return ( * ) ( void* ) ) callback<T_return>; }
690 
691  template < typename T_return, typename T_arg1 >
692  int ( *get_callback( const sigc::slot1<T_return,T_arg1>& slot ))( void* )
693  { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1>; }
694 
695  template < typename T_return, typename T_arg1, typename T_arg2 >
696  int ( *get_callback( const sigc::slot2<T_return,T_arg1,T_arg2>& slot ))( void* )
697  { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1,T_arg2>; }
698 
699  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
700  int ( *get_callback( const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot ))( void* )
701  { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3>; }
702 
703  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
704  int ( *get_callback( const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
705  { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4>; }
706 
707  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
708  int ( *get_callback( const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
709  { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
710 
711  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
712  int ( *get_callback( const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
713  { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
714 
715  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 >
716  int ( *get_callback( const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
717  { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
718 
719  char * get_function_restriction(std::string &name);
720 
721  template <typename T_arg1>
722  char * get_function_restriction(std::string &name);
723 
724  template <typename T_arg1, typename T_arg2>
725  char * get_function_restriction(std::string &name);
726 
727  template <typename T_arg1, typename T_arg2, typename T_arg3>
728  char * get_function_restriction(std::string &name);
729 
730  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
731  char * get_function_restriction(std::string &name);
732 
733  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
734  char * get_function_restriction(std::string &name);
735 
736  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
737  char * get_function_restriction(std::string &name);
738 
739  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
740  char * get_function_restriction(std::string &name);
741 
742 
743  static int get_arg_count( void* env );
744  static void* get_function_context( void* env );
745  static void set_return_values( void *env, void *rv, const Values &v);
746  static void* add_symbol( const char* s );
747 
748 
749  };
750 
751 
752  inline char *
754  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
755  char *restr = (char *)malloc(4); m_func_restr[name] = restr;
756  snprintf(restr, 4, "00u");
757  return restr;
758  }
759 
760  template <typename T_arg1>
761  inline char *
762  Environment::get_function_restriction(std::string &name) {
763  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
764  char *restr = (char *)malloc(5); m_func_restr[name] = restr;
765  snprintf(restr, 5, "11u%c", get_argument_code<T_arg1>());
766  return restr;
767  }
768 
769  template <typename T_arg1, typename T_arg2>
770  inline char *
771  Environment::get_function_restriction(std::string &name) {
772  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
773  char *restr = (char *)malloc(6); m_func_restr[name] = restr;
774  snprintf(restr, 6, "22u%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>());
775  return restr;
776  }
777 
778  template <typename T_arg1, typename T_arg2, typename T_arg3>
779  inline char *
780  Environment::get_function_restriction(std::string &name) {
781  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
782  char *restr = (char *)malloc(7); m_func_restr[name] = restr;
783  snprintf(restr, 7, "33u%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
784  get_argument_code<T_arg3>());
785  return restr;
786  }
787 
788  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
789  inline char *
790  Environment::get_function_restriction(std::string &name) {
791  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
792  char *restr = (char *)malloc(8); m_func_restr[name] = restr;
793  snprintf(restr, 8, "44u%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
794  get_argument_code<T_arg3>(), get_argument_code<T_arg4>());
795  return restr;
796  }
797 
798  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
799  typename T_arg5>
800  inline char *
801  Environment::get_function_restriction(std::string &name) {
802  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
803  char *restr = (char *)malloc(9); m_func_restr[name] = restr;
804  snprintf(restr, 9, "55u%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
805  get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>());
806  return restr;
807  }
808 
809  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
810  typename T_arg5, typename T_arg6>
811  inline char *
812  Environment::get_function_restriction(std::string &name) {
813  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
814  char *restr = (char *)malloc(10); m_func_restr[name] = restr;
815  snprintf(restr, 10, "66u%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
816  get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
817  get_argument_code<T_arg6>());
818  return restr;
819  }
820 
821  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
822  typename T_arg5, typename T_arg6, typename T_arg7>
823  inline char *
824  Environment::get_function_restriction(std::string &name) {
825  if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
826  char *restr = (char *)malloc(11); m_func_restr[name] = restr;
827  snprintf(restr, 11, "77u%c%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
828  get_argument_code<T_arg3>(), get_argument_code<T_arg4>(), get_argument_code<T_arg5>(),
829  get_argument_code<T_arg6>(), get_argument_code<T_arg7>());
830  return restr;
831  }
832 
833 
834  template < typename T_return>
835  inline
836  T_return Environment::callback( void* theEnv ) {
837  sigc::slot0<T_return>* cb;
838  void * cbptr = get_function_context( theEnv );
839  if ( cbptr ) {
840  if ( get_arg_count( theEnv ) != 0 )
841  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 0" );
842  cb = static_cast<sigc::slot0<T_return>*>( cbptr );
843  return ( *cb ) ();
844  }
845  throw;
846  }
847 
848  template < typename T_return, typename T_arg1 >
849  inline
850  T_return Environment::callback( void* theEnv ) {
851  sigc::slot1<T_return,T_arg1>* cb;
852  void * cbptr = get_function_context( theEnv );
853  T_arg1 arg1;
854  if ( cbptr ) {
855  if ( get_arg_count( theEnv ) != 1 )
856  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
857  get_argument( theEnv, 1, arg1 );
858  cb = static_cast<sigc::slot1<T_return,T_arg1>*>( cbptr );
859  return ( *cb ) ( arg1 );
860  }
861  throw;
862  }
863 
864  template < typename T_return, typename T_arg1, typename T_arg2 >
865  inline
866  T_return Environment::callback( void* theEnv ) {
867  sigc::slot2<T_return, T_arg1, T_arg2>* cb;
868  void * cbptr = get_function_context( theEnv );
869  T_arg1 arg1;
870  T_arg2 arg2;
871  if ( cbptr ) {
872  if ( get_arg_count( theEnv ) != 2 )
873  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
874  get_argument( theEnv, 1, arg1 );
875  get_argument( theEnv, 2, arg2 );
876  cb = static_cast<sigc::slot2<T_return, T_arg1, T_arg2>*>( cbptr );
877  return ( *cb ) ( arg1, arg2 );
878  }
879  throw;
880  }
881 
882  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
883  inline
884  T_return Environment::callback( void* theEnv ) {
885  sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* cb;
886  void * cbptr = get_function_context( theEnv );
887  T_arg1 arg1;
888  T_arg2 arg2;
889  T_arg3 arg3;
890  if ( cbptr ) {
891  if ( get_arg_count( theEnv ) != 3 )
892  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
893  get_argument( theEnv, 1, arg1 );
894  get_argument( theEnv, 2, arg2 );
895  get_argument( theEnv, 3, arg3 );
896  cb = static_cast<sigc::slot3<T_return, T_arg1, T_arg2,T_arg3>*>( cbptr );
897  return ( *cb ) ( arg1, arg2, arg3 );
898  }
899  throw;
900  }
901 
902  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
903  inline
904  T_return Environment::callback( void* theEnv ) {
905  sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
906  void * cbptr = get_function_context( theEnv );
907  T_arg1 arg1;
908  T_arg2 arg2;
909  T_arg3 arg3;
910  T_arg4 arg4;
911  if ( cbptr ) {
912  if ( get_arg_count( theEnv ) != 4 )
913  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
914  get_argument( theEnv, 1, arg1 );
915  get_argument( theEnv, 2, arg2 );
916  get_argument( theEnv, 3, arg3 );
917  get_argument( theEnv, 4, arg4 );
918  cb = static_cast<sigc::slot4<T_return, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
919  return ( *cb ) ( arg1, arg2, arg3, arg4 );
920  }
921  throw;
922  }
923 
924  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
925  inline
926  T_return Environment::callback( void* theEnv ) {
927  sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
928  void * cbptr = get_function_context( theEnv );
929  T_arg1 arg1;
930  T_arg2 arg2;
931  T_arg3 arg3;
932  T_arg4 arg4;
933  T_arg5 arg5;
934  if ( cbptr ) {
935  if ( get_arg_count( theEnv ) != 5 )
936  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
937  get_argument( theEnv, 1, arg1 );
938  get_argument( theEnv, 2, arg2 );
939  get_argument( theEnv, 3, arg3 );
940  get_argument( theEnv, 4, arg4 );
941  get_argument( theEnv, 5, arg5 );
942  cb = static_cast<sigc::slot5<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
943  return ( *cb ) ( arg1, arg2, arg3, arg4, arg5 );
944  }
945  throw;
946  }
947 
948  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
949  inline
950  T_return Environment::callback( void* theEnv ) {
951  sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
952  void * cbptr = get_function_context( theEnv );
953  T_arg1 arg1;
954  T_arg2 arg2;
955  T_arg3 arg3;
956  T_arg4 arg4;
957  T_arg5 arg5;
958  T_arg6 arg6;
959  if ( cbptr ) {
960  if ( get_arg_count( theEnv ) != 6 )
961  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
962  get_argument( theEnv, 1, arg1 );
963  get_argument( theEnv, 2, arg2 );
964  get_argument( theEnv, 3, arg3 );
965  get_argument( theEnv, 4, arg4 );
966  get_argument( theEnv, 5, arg5 );
967  get_argument( theEnv, 6, arg6 );
968  cb = static_cast<sigc::slot6<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
969  return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 );
970  }
971  throw;
972  }
973 
974  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 >
975  inline
976  T_return Environment::callback( void* theEnv ) {
977  sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
978  void * cbptr = get_function_context( theEnv );
979  T_arg1 arg1;
980  T_arg2 arg2;
981  T_arg3 arg3;
982  T_arg4 arg4;
983  T_arg5 arg5;
984  T_arg6 arg6;
985  T_arg7 arg7;
986  if ( cbptr ) {
987  if ( get_arg_count( theEnv ) != 7 )
988  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
989  get_argument( theEnv, 1, arg1 );
990  get_argument( theEnv, 2, arg2 );
991  get_argument( theEnv, 3, arg3 );
992  get_argument( theEnv, 4, arg4 );
993  get_argument( theEnv, 5, arg5 );
994  get_argument( theEnv, 6, arg6 );
995  get_argument( theEnv, 7, arg7 );
996  cb = static_cast<sigc::slot7<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
997  return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 );
998  }
999  throw;
1000  }
1001 
1002  inline
1003  void Environment::callback_multifield( void* theEnv, void *rv) {
1004  sigc::slot0<Values>* cb;
1005  void * cbptr = get_function_context( theEnv );
1006  if ( cbptr ) {
1007  if ( get_arg_count( theEnv ) != 0 )
1008  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 0" );
1009  cb = static_cast<sigc::slot0<Values>*>( cbptr );
1010  Values v = ( *cb ) ();
1011  set_return_values(theEnv, rv, v);
1012  return;
1013  }
1014  throw;
1015  }
1016 
1017  template <typename T_arg1>
1018  inline
1019  void Environment::callback_multifield( void* theEnv, void *rv) {
1020  sigc::slot1<Values, T_arg1>* cb;
1021  void * cbptr = get_function_context( theEnv );
1022  T_arg1 arg1;
1023  if ( cbptr ) {
1024  if ( get_arg_count( theEnv ) != 1 )
1025  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 1" );
1026  cb = static_cast<sigc::slot1<Values, T_arg1>*>( cbptr );
1027  get_argument(theEnv, 1, arg1);
1028  Values v = ( *cb ) (arg1);
1029  set_return_values(theEnv, rv, v);
1030  return;
1031  }
1032  throw;
1033  }
1034 
1035  template <typename T_arg1, typename T_arg2>
1036  inline
1037  void Environment::callback_multifield( void* theEnv, void *rv) {
1038  sigc::slot2<Values, T_arg1, T_arg2>* cb;
1039  void * cbptr = get_function_context( theEnv );
1040  T_arg1 arg1;
1041  T_arg2 arg2;
1042  if ( cbptr ) {
1043  if ( get_arg_count( theEnv ) != 2 )
1044  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 2" );
1045  cb = static_cast<sigc::slot2<Values, T_arg1, T_arg2>*>( cbptr );
1046  get_argument(theEnv, 1, arg1);
1047  get_argument(theEnv, 2, arg2);
1048  Values v = ( *cb ) (arg1, arg2);
1049  set_return_values(theEnv, rv, v);
1050  return;
1051  }
1052  throw;
1053  }
1054 
1055 
1056  template <typename T_arg1, typename T_arg2, typename T_arg3>
1057  inline
1058  void Environment::callback_multifield( void* theEnv, void *rv) {
1059  sigc::slot3<Values, T_arg1, T_arg2, T_arg3>* cb;
1060  void * cbptr = get_function_context( theEnv );
1061  T_arg1 arg1;
1062  T_arg2 arg2;
1063  T_arg3 arg3;
1064  if ( cbptr ) {
1065  if ( get_arg_count( theEnv ) != 3 )
1066  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 3" );
1067  cb = static_cast<sigc::slot3<Values, T_arg1, T_arg2, T_arg3>*>( cbptr );
1068  get_argument(theEnv, 1, arg1);
1069  get_argument(theEnv, 2, arg2);
1070  get_argument(theEnv, 3, arg3);
1071  Values v = ( *cb ) (arg1, arg2, arg3);
1072  set_return_values(theEnv, rv, v);
1073  return;
1074  }
1075  throw;
1076  }
1077 
1078  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
1079  inline
1080  void Environment::callback_multifield( void* theEnv, void *rv) {
1081  sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>* cb;
1082  void * cbptr = get_function_context( theEnv );
1083  T_arg1 arg1;
1084  T_arg2 arg2;
1085  T_arg3 arg3;
1086  T_arg4 arg4;
1087  if ( cbptr ) {
1088  if ( get_arg_count( theEnv ) != 4 )
1089  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 4" );
1090  cb = static_cast<sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>*>(cbptr);
1091  get_argument(theEnv, 1, arg1);
1092  get_argument(theEnv, 2, arg2);
1093  get_argument(theEnv, 3, arg3);
1094  get_argument(theEnv, 4, arg4);
1095  Values v = ( *cb ) (arg1, arg2, arg3, arg4);
1096  set_return_values(theEnv, rv, v);
1097  return;
1098  }
1099  throw;
1100  }
1101 
1102  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1103  typename T_arg5>
1104  inline
1105  void Environment::callback_multifield( void* theEnv, void *rv) {
1106  sigc::slot5<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* cb;
1107  void * cbptr = get_function_context( theEnv );
1108  T_arg1 arg1;
1109  T_arg2 arg2;
1110  T_arg3 arg3;
1111  T_arg4 arg4;
1112  T_arg5 arg5;
1113  if ( cbptr ) {
1114  if ( get_arg_count( theEnv ) != 5 )
1115  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 5" );
1116  cb = static_cast<sigc::slot5<Values, T_arg1, T_arg2, T_arg3,
1117  T_arg4, T_arg5>*>(cbptr);
1118  get_argument(theEnv, 1, arg1);
1119  get_argument(theEnv, 2, arg2);
1120  get_argument(theEnv, 3, arg3);
1121  get_argument(theEnv, 4, arg4);
1122  get_argument(theEnv, 5, arg5);
1123  Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5);
1124  set_return_values(theEnv, rv, v);
1125  return;
1126  }
1127  throw;
1128  }
1129 
1130 
1131  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1132  typename T_arg5, typename T_arg6>
1133  inline
1134  void Environment::callback_multifield( void* theEnv, void *rv) {
1135  sigc::slot6<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* cb;
1136  void * cbptr = get_function_context( theEnv );
1137  T_arg1 arg1;
1138  T_arg2 arg2;
1139  T_arg3 arg3;
1140  T_arg4 arg4;
1141  T_arg5 arg5;
1142  T_arg6 arg6;
1143  if ( cbptr ) {
1144  if ( get_arg_count( theEnv ) != 6 )
1145  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 6" );
1146  cb = static_cast<sigc::slot6<Values, T_arg1, T_arg2, T_arg3,
1147  T_arg4, T_arg5, T_arg6>*>(cbptr);
1148  get_argument(theEnv, 1, arg1);
1149  get_argument(theEnv, 2, arg2);
1150  get_argument(theEnv, 3, arg3);
1151  get_argument(theEnv, 4, arg4);
1152  get_argument(theEnv, 5, arg5);
1153  get_argument(theEnv, 6, arg6);
1154  Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6);
1155  set_return_values(theEnv, rv, v);
1156  return;
1157  }
1158  throw;
1159  }
1160 
1161  template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1162  typename T_arg5, typename T_arg6, typename T_arg7>
1163  inline
1164  void Environment::callback_multifield( void* theEnv, void *rv) {
1165  sigc::slot7<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* cb;
1166  void * cbptr = get_function_context( theEnv );
1167  T_arg1 arg1;
1168  T_arg2 arg2;
1169  T_arg3 arg3;
1170  T_arg4 arg4;
1171  T_arg5 arg5;
1172  T_arg6 arg6;
1173  T_arg7 arg7;
1174  if ( cbptr ) {
1175  if ( get_arg_count( theEnv ) != 7 )
1176  throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 7" );
1177  cb = static_cast<sigc::slot7<Values, T_arg1, T_arg2, T_arg3,
1178  T_arg4, T_arg5, T_arg6, T_arg7>*>(cbptr);
1179  get_argument(theEnv, 1, arg1);
1180  get_argument(theEnv, 2, arg2);
1181  get_argument(theEnv, 3, arg3);
1182  get_argument(theEnv, 4, arg4);
1183  get_argument(theEnv, 5, arg5);
1184  get_argument(theEnv, 6, arg6);
1185  get_argument(theEnv, 7, arg7);
1186  Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1187  set_return_values(theEnv, rv, v);
1188  return;
1189  }
1190  throw;
1191  }
1192 
1193 
1194  inline
1195  void* Environment::strcallback( void* theEnv ) {
1196  sigc::slot0<std::string>* cb;
1197  void * cbptr = get_function_context( theEnv );
1198  if ( cbptr ) {
1199  if ( get_arg_count( theEnv ) != 0 )
1200  throw std::logic_error( "clipsmm/string: wrong # args on slot callback; expected 0" );
1201  cb = static_cast<sigc::slot0<std::string>*>( cbptr );
1202  return add_symbol( ( ( *cb ) ( )).c_str() );
1203  }
1204  throw;
1205  }
1206 
1207  template < typename T_arg1 >
1208  inline
1209  void* Environment::strcallback( void* theEnv ) {
1210  sigc::slot1<std::string,T_arg1>* cb;
1211  void * cbptr = get_function_context( theEnv );
1212  T_arg1 arg1;
1213  if ( cbptr ) {
1214  if ( get_arg_count( theEnv ) != 1 )
1215  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
1216  get_argument( theEnv, 1, arg1 );
1217  cb = static_cast<sigc::slot1<std::string,T_arg1>*>( cbptr );
1218  return add_symbol( ( ( *cb ) ( arg1 )).c_str() );
1219  }
1220  throw;
1221  }
1222 
1223  template < typename T_arg1, typename T_arg2 >
1224  inline
1225  void* Environment::strcallback( void* theEnv ) {
1226  sigc::slot2<std::string, T_arg1, T_arg2>* cb;
1227  void * cbptr = get_function_context( theEnv );
1228  T_arg1 arg1;
1229  T_arg2 arg2;
1230  if ( cbptr ) {
1231  if ( get_arg_count( theEnv ) != 2 )
1232  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
1233  get_argument( theEnv, 1, arg1 );
1234  get_argument( theEnv, 2, arg2 );
1235  cb = static_cast<sigc::slot2<std::string, T_arg1, T_arg2>*>( cbptr );
1236  return add_symbol( ( ( *cb ) ( arg1, arg2 )).c_str() );
1237  }
1238  throw;
1239  }
1240 
1241  template < typename T_arg1, typename T_arg2, typename T_arg3 >
1242  inline
1243  void* Environment::strcallback( void* theEnv ) {
1244  sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>* cb;
1245  void * cbptr = get_function_context( theEnv );
1246  T_arg1 arg1;
1247  T_arg2 arg2;
1248  T_arg3 arg3;
1249  if ( cbptr ) {
1250  if ( get_arg_count( theEnv ) != 3 )
1251  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
1252  get_argument( theEnv, 1, arg1 );
1253  get_argument( theEnv, 2, arg2 );
1254  get_argument( theEnv, 3, arg3 );
1255  cb = static_cast<sigc::slot3<std::string, T_arg1, T_arg2,T_arg3>*>( cbptr );
1256  return add_symbol( ( ( *cb ) ( arg1, arg2, arg3 )).c_str() );
1257  }
1258  throw;
1259  }
1260 
1261  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
1262  inline
1263  void* Environment::strcallback( void* theEnv ) {
1264  sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
1265  void * cbptr = get_function_context( theEnv );
1266  T_arg1 arg1;
1267  T_arg2 arg2;
1268  T_arg3 arg3;
1269  T_arg4 arg4;
1270  std::string s;
1271  if ( cbptr ) {
1272  if ( get_arg_count( theEnv ) != 4 )
1273  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
1274  get_argument( theEnv, 1, arg1 );
1275  get_argument( theEnv, 2, arg2 );
1276  get_argument( theEnv, 3, arg3 );
1277  get_argument( theEnv, 4, arg4 );
1278  cb = static_cast<sigc::slot4<std::string, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
1279  s = ( *cb ) ( arg1, arg2, arg3, arg4 );
1280  return add_symbol( s.c_str() );
1281  }
1282  throw;
1283  }
1284 
1285  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
1286  inline
1287  void* Environment::strcallback( void* theEnv ) {
1288  sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
1289  void * cbptr = get_function_context( theEnv );
1290  T_arg1 arg1;
1291  T_arg2 arg2;
1292  T_arg3 arg3;
1293  T_arg4 arg4;
1294  T_arg5 arg5;
1295  if ( cbptr ) {
1296  if ( get_arg_count( theEnv ) != 5 )
1297  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
1298  get_argument( theEnv, 1, arg1 );
1299  get_argument( theEnv, 2, arg2 );
1300  get_argument( theEnv, 3, arg3 );
1301  get_argument( theEnv, 4, arg4 );
1302  get_argument( theEnv, 5, arg5 );
1303  cb = static_cast<sigc::slot5<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
1304  return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5 )).c_str() );
1305  }
1306  throw;
1307  }
1308 
1309  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
1310  inline
1311  void* Environment::strcallback( void* theEnv ) {
1312  sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
1313  void * cbptr = get_function_context( theEnv );
1314  T_arg1 arg1;
1315  T_arg2 arg2;
1316  T_arg3 arg3;
1317  T_arg4 arg4;
1318  T_arg5 arg5;
1319  T_arg6 arg6;
1320  if ( cbptr ) {
1321  if ( get_arg_count( theEnv ) != 6 )
1322  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
1323  get_argument( theEnv, 1, arg1 );
1324  get_argument( theEnv, 2, arg2 );
1325  get_argument( theEnv, 3, arg3 );
1326  get_argument( theEnv, 4, arg4 );
1327  get_argument( theEnv, 5, arg5 );
1328  get_argument( theEnv, 6, arg6 );
1329  cb = static_cast<sigc::slot6<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
1330  return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 )).c_str() );
1331  }
1332  throw;
1333  }
1334 
1335  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
1336  inline
1337  void* Environment::strcallback( void* theEnv ) {
1338  sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
1339  void * cbptr = get_function_context( theEnv );
1340  T_arg1 arg1;
1341  T_arg2 arg2;
1342  T_arg3 arg3;
1343  T_arg4 arg4;
1344  T_arg5 arg5;
1345  T_arg6 arg6;
1346  T_arg7 arg7;
1347  if ( cbptr ) {
1348  if ( get_arg_count( theEnv ) != 7 )
1349  throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
1350  get_argument( theEnv, 1, arg1 );
1351  get_argument( theEnv, 2, arg2 );
1352  get_argument( theEnv, 3, arg3 );
1353  get_argument( theEnv, 4, arg4 );
1354  get_argument( theEnv, 5, arg5 );
1355  get_argument( theEnv, 6, arg6 );
1356  get_argument( theEnv, 7, arg7 );
1357  cb = static_cast<sigc::slot7<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
1358  return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 )).c_str() );
1359  }
1360  throw;
1361  }
1362 
1363 template < typename T_return >
1364  inline
1365  bool Environment::add_function( std::string name, const sigc::slot0<T_return>& slot) {
1366  char retcode = get_return_code<T_return>( );
1367  char *argstring = get_function_restriction(name);
1368  sigc::slot0<T_return>* scb = new sigc::slot0<T_return>(slot);
1369  any holder = CLIPSPointer<sigc::slot0<T_return> >(scb);
1370  m_slots[name] = holder;
1372  const_cast<char*>( name.c_str() ),
1373  retcode,
1374  get_callback(slot),
1375  const_cast<char*>( name.c_str() ),
1376  argstring,
1377  ( void* ) scb ) );
1378  }
1379 
1380  template < typename T_return, typename T_arg1 >
1381  inline
1382  bool Environment::add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot) {
1383  char retcode = get_return_code<T_return>( );
1384  char *argstring = get_function_restriction<T_arg1>(name);
1385  sigc::slot1<T_return, T_arg1>* scb = new sigc::slot1<T_return, T_arg1>(slot);
1386  any holder = CLIPSPointer<sigc::slot1<T_return, T_arg1> >(scb);
1387  m_slots[name] = holder;
1389  const_cast<char*>( name.c_str() ),
1390  retcode,
1391  get_callback(slot),
1392  const_cast<char*>( name.c_str() ),
1393  argstring,
1394  scb ) );
1395  }
1396 
1397  template < typename T_return, typename T_arg1, typename T_arg2 >
1398  inline
1399  bool Environment::add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot) {
1400  char retcode = get_return_code<T_return>( );
1401  char *argstring = get_function_restriction<T_arg1,T_arg2>(name);
1402  sigc::slot2<T_return, T_arg1, T_arg2>* scb = new sigc::slot2<T_return, T_arg1, T_arg2>(slot);
1403  any holder = CLIPSPointer<sigc::slot2<T_return, T_arg1, T_arg2> >(scb);
1404  m_slots[name] = holder;
1406  const_cast<char*>( name.c_str() ),
1407  retcode,
1408  get_callback(slot),
1409  const_cast<char*>( name.c_str() ),
1410  argstring,
1411  scb ) );
1412  }
1413 
1414  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
1415  inline
1416  bool Environment::add_function( std::string name, const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot) {
1417  char retcode = get_return_code<T_return>( );
1418  char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3>(name);
1419  sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* scb =
1420  new sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>(slot);
1421  any holder = CLIPSPointer<sigc::slot3<T_return,T_arg1,T_arg2,T_arg3> >(scb);
1422  m_slots[name] = holder;
1424  const_cast<char*>( name.c_str() ),
1425  retcode,
1426  get_callback(slot),
1427  const_cast<char*>( name.c_str() ),
1428  argstring,
1429  scb )
1430  );
1431  }
1432 
1433  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
1434  inline
1435  bool Environment::add_function( std::string name, const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot) {
1436  char retcode = get_return_code<T_return>( );
1437  char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4>(name);
1438  sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* scb =
1439  new sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>(slot);
1440  any holder = CLIPSPointer<sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4> >(scb);
1441  m_slots[name] = holder;
1443  const_cast<char*>( name.c_str() ),
1444  retcode,
1445  get_callback(slot),
1446  const_cast<char*>( name.c_str() ),
1447  argstring,
1448  scb )
1449  );
1450  }
1451 
1452  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
1453  inline
1454  bool Environment::add_function( std::string name,
1455  const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot) {
1456  char retcode = get_return_code<T_return>( );
1457  char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(name);
1458  sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* scb =
1459  new sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(slot);
1460  any holder = CLIPSPointer<sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> >(scb);
1461  m_slots[name] = holder;
1463  const_cast<char*>( name.c_str() ),
1464  retcode,
1465  get_callback(slot),
1466  const_cast<char*>( name.c_str() ),
1467  argstring,
1468  scb )
1469  );
1470  }
1471 
1472  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
1473  inline
1474  bool Environment::add_function( std::string name,
1475  const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot) {
1476  char retcode = get_return_code<T_return>( );
1477  char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(name);
1478  sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* scb =
1479  new sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(slot);
1480  any holder = CLIPSPointer<sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> >(scb);
1481  m_slots[name] = holder;
1483  const_cast<char*>( name.c_str() ),
1484  retcode,
1485  get_callback(slot),
1486  const_cast<char*>( name.c_str() ),
1487  argstring,
1488  scb )
1489  );
1490  }
1491 
1492  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 >
1493  inline
1494  bool Environment::add_function( std::string name,
1495  const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot) {
1496  char retcode = get_return_code<T_return>( );
1497  char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(name);
1498  sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* scb =
1499  new sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(slot);
1500  any holder = CLIPSPointer<sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> >(scb);
1501  m_slots[name] = holder;
1503  const_cast<char*>( name.c_str() ),
1504  retcode,
1505  get_callback(slot),
1506  const_cast<char*>( name.c_str() ),
1507  argstring,
1508  scb )
1509  );
1510  }
1511 
1512 }
1513 
1514 
1515 #endif

Generated on Thu Sep 27 2012 17:57:05 for clipsmm by doxygen 1.8.1.2