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-2013 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>
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
48extern "C" {
49 int EnvDefineFunction2WithContext( void *, const char *, int, int ( * ) ( void * ), const char *, const char *, void * );
50}
51
52namespace CLIPS {
53
57 class Environment: public Object {
58 public:
60
62
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 );
259 Fact::pointer assert_fact_f( const char *format, ... );
260
261 void clear_focus_stack();
262
271
272 DefaultFacts::pointer get_default_facts( const std::string& default_facts_name );
273
275 std::vector<std::string> get_default_facts_names();
276
278 std::vector<std::string> get_default_facts_names( const Module& module );
279
281 std::vector<std::string> get_default_facts_names( Module::pointer module );
282
284
285 Template::pointer get_template( const std::string& template_name );
286
288 std::vector<std::string> get_template_names();
289
291 std::vector<std::string> get_template_names( const Module& module );
292
294 std::vector<std::string> get_template_names( Module::pointer module );
295
297
298 Rule::pointer get_rule( const std::string& rule_name );
299
301 std::vector<std::string> get_rule_names();
302
304 std::vector<std::string> get_rule_names( const Module& module );
305
307 std::vector<std::string> get_rule_names( Module::pointer module );
308
310
311 void remove_rules();
312
313 Module::pointer get_module( const std::string& module_name );
314
316
317 std::vector<std::string> get_module_names();
318
320
326 void refresh_agenda();
327
333 void refresh_agenda( const Module& module );
334
340 void refresh_agenda( Module::pointer module );
341
347 void reorder_agenda();
348
354 void reorder_agenda( const Module& module );
355
361 void reorder_agenda( Module::pointer module );
362
372 long int run( long int runlimit = -1 );
373
392 void run_threaded( long int runlimit = -1, int priority = 0 );
393
395 void join_run_thread();
396
398 sigc::signal<void, long int> signal_run();
399
402
408
411
417
427
429
430 std::vector<std::string> get_focus_stack();
431
433
434 Global::pointer get_global( const std::string& global_name );
435
437
439 std::vector<std::string> get_globals_names();
440
442 std::vector<std::string> get_globals_names( const Module& module );
443
445 std::vector<std::string> get_globals_names( Module::pointer module );
446
448
449 Function::pointer get_function( const std::string& function_name );
450
452
454 std::vector<std::string> get_function_names();
455
457 std::vector<std::string> get_function_names( const Module& module );
458
460 std::vector<std::string> get_function_names( Module::pointer module );
461
462 sigc::signal<void> signal_clear();
463 sigc::signal<void> signal_periodic();
464 sigc::signal<void> signal_reset();
465 sigc::signal<void> signal_rule_firing();
466 sigc::signal<void> signal_agenda_changed();
467 sigc::signal<void> signal_globals_changed();
468
469 template < typename T_return >
470 bool add_function( std::string name, const sigc::slot0<T_return>& slot);
471
472 template < typename T_return, typename T_arg1 >
473 bool add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot);
474
475 template < typename T_return, typename T_arg1, typename T_arg2 >
476 bool add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot);
477
478 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
479 bool add_function( std::string name, const sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>& slot);
480
481 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
482 bool add_function( std::string name, const sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>& slot);
483
484 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
485 bool add_function( std::string name, const sigc::slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& slot);
486
487 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
488 bool add_function( std::string name, const sigc::slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& slot);
489
490 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 >
491 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);
492
493 bool remove_function( std::string name );
494
495 protected:
502 std::map<std::string,any> m_slots;
503
504 sigc::signal<void> m_signal_clear;
505 sigc::signal<void> m_signal_periodic;
506 sigc::signal<void> m_signal_reset;
507 sigc::signal<void> m_signal_rule_firing;
508 sigc::signal<void> m_signal_agenda_changed;
509 sigc::signal<void> m_signal_globals_changed;
510
512 typedef struct Job {
514 Job( int p, long int rl ) : priority(p), runlimit(rl) { }
515
517 bool operator<( const Job& other ) const { return priority < other.priority; }
518
521
526 long int runlimit;
528
529 Glib::Thread* m_run_thread;
530 std::priority_queue<Job> m_run_queue;
531 Glib::Mutex m_mutex_run_queue;
532 Glib::Mutex m_mutex_run;
534 Glib::Mutex m_mutex_run_signal;
535 sigc::signal<void, long int> m_signal_run;
546 std::map<std::string, char *> m_func_restr;
547
549 void threaded_run();
550
551 static std::map<void*, Environment*> m_environment_map;
552
553
554 static void clear_callback( void* env );
555 static void periodic_callback( void* env );
556 static void reset_callback( void* env );
557 static void rule_firing_callback( void* end );
558
559 static void* strcallback( void* theEnv );
560
561 template < typename T_arg1 >
562 static void* strcallback( void* theEnv );
563
564 template < typename T_arg1, typename T_arg2 >
565 static void* strcallback( void* theEnv );
566
567 template < typename T_arg1, typename T_arg2, typename T_arg3 >
568 static void* strcallback( void* theEnv );
569
570 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
571 static void* strcallback( void* theEnv );
572
573 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
574 static void* strcallback( void* theEnv );
575
576 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
577 static void* strcallback( void* theEnv );
578
579 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
580 static void* strcallback( void* theEnv );
581
582 template < typename T_return >
583 static T_return callback( void* theEnv );
584
585 template < typename T_return, typename T_arg1 >
586 static T_return callback( void* theEnv );
587
588 template < typename T_return, typename T_arg1, typename T_arg2 >
589 static T_return callback( void* theEnv );
590
591 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
592 static T_return callback( void* theEnv );
593
594 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
595 static T_return callback( void* theEnv );
596
597 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
598 static T_return callback( void* theEnv );
599
600 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
601 static T_return callback( void* theEnv );
602
603 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 >
604 static T_return callback( void* theEnv );
605
606 static void callback_multifield( void* theEnv, void *rv);
607
608 template <typename T_arg1>
609 static void callback_multifield( void* theEnv, void *rv );
610
611 template <typename T_arg1, typename T_arg2>
612 static void callback_multifield( void* theEnv, void *rv );
613
614 template <typename T_arg1, typename T_arg2, typename T_arg3>
615 static void callback_multifield( void* theEnv, void *rv );
616
617 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
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>
622 static void callback_multifield( void* theEnv, void *rv );
623
624 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
625 typename T_arg5, typename T_arg6>
626 static void callback_multifield( void* theEnv, void *rv );
627
628 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
629 typename T_arg5, typename T_arg6, typename T_arg7>
630 static void callback_multifield( void* theEnv, void *rv );
631
632
633 static void callback_unknown( void* theEnv, void *rv);
634
635 template <typename T_arg1>
636 static void callback_unknown( void* theEnv, void *rv );
637
638 template <typename T_arg1, typename T_arg2>
639 static void callback_unknown( void* theEnv, void *rv );
640
641 template <typename T_arg1, typename T_arg2, typename T_arg3>
642 static void callback_unknown( void* theEnv, void *rv );
643
644 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
645 static void callback_unknown( void* theEnv, void *rv );
646
647 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
648 typename T_arg5>
649 static void callback_unknown( void* theEnv, void *rv );
650
651 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
652 typename T_arg5, typename T_arg6>
653 static void callback_unknown( void* theEnv, void *rv );
654
655 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
656 typename T_arg5, typename T_arg6, typename T_arg7>
657 static void callback_unknown( void* theEnv, void *rv );
658
659 int ( *get_callback( const sigc::slot0<std::string>& slot ))( void* )
660 { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback; }
661
662 template < typename T_arg1 >
663 int ( *get_callback( const sigc::slot1<std::string,T_arg1>& slot ))( void* )
664 { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1>; }
665
666 template < typename T_arg1, typename T_arg2 >
667 int ( *get_callback( const sigc::slot2<std::string,T_arg1,T_arg2>& slot ))( void* )
668 { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1,T_arg2>; }
669
670 template < typename T_arg1, typename T_arg2, typename T_arg3 >
671 int ( *get_callback( const sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>& slot ))( void* )
672 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3>; }
673
674 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
675 int ( *get_callback( const sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
676 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4>; }
677
678 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
679 int ( *get_callback( const sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
680 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
681
682 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
683 int ( *get_callback( const sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
684 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
685
686 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
687 int ( *get_callback( const sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
688 { return (int(*)(void*)) (void* (*)(void*)) strcallback<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
689
690 int ( *get_callback( const sigc::slot0<Values>& slot ))( void* )
691 { return (int (*) (void*)) (void (*) (void*, void*)) callback_multifield; }
692
693 template <typename T_arg1>
694 int ( *get_callback( const sigc::slot1<Values,T_arg1>& slot ))( void* )
695 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1>; }
696
697 template <typename T_arg1, typename T_arg2>
698 int ( *get_callback( const sigc::slot2<Values,T_arg1,T_arg2>& slot ))( void* )
699 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2>; }
700
701 template <typename T_arg1, typename T_arg2, typename T_arg3>
702 int ( *get_callback( const sigc::slot3<Values,T_arg1,T_arg2,T_arg3>& slot ))( void* )
703 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3>; }
704
705 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
706 int ( *get_callback( const sigc::slot4<Values,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
707 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4>; }
708
709 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
710 int ( *get_callback( const sigc::slot5<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
711 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
712
713 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
714 int ( *get_callback( const sigc::slot6<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
715 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
716
717 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
718 int ( *get_callback( const sigc::slot7<Values,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
719 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_multifield<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
720
721
722 int ( *get_callback( const sigc::slot0<Value>& slot ))( void* )
723 { return (int (*) (void*)) (void (*) (void*, void*)) callback_unknown; }
724
725 template <typename T_arg1>
726 int ( *get_callback( const sigc::slot1<Value,T_arg1>& slot ))( void* )
727 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1>; }
728
729 template <typename T_arg1, typename T_arg2>
730 int ( *get_callback( const sigc::slot2<Value,T_arg1,T_arg2>& slot ))( void* )
731 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2>; }
732
733 template <typename T_arg1, typename T_arg2, typename T_arg3>
734 int ( *get_callback( const sigc::slot3<Value,T_arg1,T_arg2,T_arg3>& slot ))( void* )
735 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3>; }
736
737 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
738 int ( *get_callback( const sigc::slot4<Value,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
739 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4>; }
740
741 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
742 int ( *get_callback( const sigc::slot5<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
743 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
744
745 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
746 int ( *get_callback( const sigc::slot6<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
747 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
748
749 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
750 int ( *get_callback( const sigc::slot7<Value,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
751 { return (int (*) (void*)) ( void ( * ) ( void*, void* ) ) callback_unknown<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
752
753
754 template < typename T_return >
755 int ( *get_callback( const sigc::slot0<T_return>& slot ))( void* )
756 { return (int (*) (void*)) ( T_return ( * ) ( void* ) ) callback<T_return>; }
757
758 template < typename T_return, typename T_arg1 >
759 int ( *get_callback( const sigc::slot1<T_return,T_arg1>& slot ))( void* )
760 { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1>; }
761
762 template < typename T_return, typename T_arg1, typename T_arg2 >
763 int ( *get_callback( const sigc::slot2<T_return,T_arg1,T_arg2>& slot ))( void* )
764 { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1,T_arg2>; }
765
766 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
767 int ( *get_callback( const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot ))( void* )
768 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3>; }
769
770 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
771 int ( *get_callback( const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
772 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4>; }
773
774 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
775 int ( *get_callback( const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
776 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }
777
778 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
779 int ( *get_callback( const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
780 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }
781
782 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 >
783 int ( *get_callback( const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
784 { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }
785
786 char * get_function_restriction(std::string &name);
787
788 template <typename T_arg1>
789 char * get_function_restriction(std::string &name);
790
791 template <typename T_arg1, typename T_arg2>
792 char * get_function_restriction(std::string &name);
793
794 template <typename T_arg1, typename T_arg2, typename T_arg3>
795 char * get_function_restriction(std::string &name);
796
797 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
798 char * get_function_restriction(std::string &name);
799
800 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5>
801 char * get_function_restriction(std::string &name);
802
803 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6>
804 char * get_function_restriction(std::string &name);
805
806 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7>
807 char * get_function_restriction(std::string &name);
808
809
810 static int get_arg_count( void* env );
811 static void* get_function_context( void* env );
812 static void set_return_values( void *env, void *rv, const Values &v);
813 static void set_return_value( void *env, void *rv, const Value &v);
814 static void* add_symbol( void *env, const char* s );
815
816
817 };
818
819
820 inline char *
822 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
823 char *restr = (char *)malloc(4); m_func_restr[name] = restr;
824 snprintf(restr, 4, "00u");
825 return restr;
826 }
827
828 template <typename T_arg1>
829 inline char *
831 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
832 char *restr = (char *)malloc(5); m_func_restr[name] = restr;
833 snprintf(restr, 5, "11u%c", get_argument_code<T_arg1>());
834 return restr;
835 }
836
837 template <typename T_arg1, typename T_arg2>
838 inline char *
840 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
841 char *restr = (char *)malloc(6); m_func_restr[name] = restr;
842 snprintf(restr, 6, "22u%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>());
843 return restr;
844 }
845
846 template <typename T_arg1, typename T_arg2, typename T_arg3>
847 inline char *
849 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
850 char *restr = (char *)malloc(7); m_func_restr[name] = restr;
851 snprintf(restr, 7, "33u%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
853 return restr;
854 }
855
856 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
857 inline char *
859 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
860 char *restr = (char *)malloc(8); m_func_restr[name] = restr;
861 snprintf(restr, 8, "44u%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
863 return restr;
864 }
865
866 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
867 typename T_arg5>
868 inline char *
870 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
871 char *restr = (char *)malloc(9); m_func_restr[name] = restr;
872 snprintf(restr, 9, "55u%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
874 return restr;
875 }
876
877 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
878 typename T_arg5, typename T_arg6>
879 inline char *
881 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
882 char *restr = (char *)malloc(10); m_func_restr[name] = restr;
883 snprintf(restr, 10, "66u%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
886 return restr;
887 }
888
889 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
890 typename T_arg5, typename T_arg6, typename T_arg7>
891 inline char *
893 if (m_func_restr.find(name) != m_func_restr.end()) free(m_func_restr[name]);
894 char *restr = (char *)malloc(11); m_func_restr[name] = restr;
895 snprintf(restr, 11, "77u%c%c%c%c%c%c%c", get_argument_code<T_arg1>(), get_argument_code<T_arg2>(),
898 return restr;
899 }
900
901
902 template < typename T_return>
903 inline
904 T_return Environment::callback( void* theEnv ) {
905 sigc::slot0<T_return>* cb;
906 void * cbptr = get_function_context( theEnv );
907 if ( cbptr ) {
908 if ( get_arg_count( theEnv ) != 0 )
909 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 0" );
910 cb = static_cast<sigc::slot0<T_return>*>( cbptr );
911 return ( *cb ) ();
912 }
913 throw;
914 }
915
916 template < typename T_return, typename T_arg1 >
917 inline
918 T_return Environment::callback( void* theEnv ) {
919 sigc::slot1<T_return,T_arg1>* cb;
920 void * cbptr = get_function_context( theEnv );
921 T_arg1 arg1;
922 if ( cbptr ) {
923 if ( get_arg_count( theEnv ) != 1 )
924 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
925 get_argument( theEnv, 1, arg1 );
926 cb = static_cast<sigc::slot1<T_return,T_arg1>*>( cbptr );
927 return ( *cb ) ( arg1 );
928 }
929 throw;
930 }
931
932 template < typename T_return, typename T_arg1, typename T_arg2 >
933 inline
934 T_return Environment::callback( void* theEnv ) {
935 sigc::slot2<T_return, T_arg1, T_arg2>* cb;
936 void * cbptr = get_function_context( theEnv );
937 T_arg1 arg1;
938 T_arg2 arg2;
939 if ( cbptr ) {
940 if ( get_arg_count( theEnv ) != 2 )
941 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
942 get_argument( theEnv, 1, arg1 );
943 get_argument( theEnv, 2, arg2 );
944 cb = static_cast<sigc::slot2<T_return, T_arg1, T_arg2>*>( cbptr );
945 return ( *cb ) ( arg1, arg2 );
946 }
947 throw;
948 }
949
950 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
951 inline
952 T_return Environment::callback( void* theEnv ) {
953 sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* cb;
954 void * cbptr = get_function_context( theEnv );
955 T_arg1 arg1;
956 T_arg2 arg2;
957 T_arg3 arg3;
958 if ( cbptr ) {
959 if ( get_arg_count( theEnv ) != 3 )
960 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
961 get_argument( theEnv, 1, arg1 );
962 get_argument( theEnv, 2, arg2 );
963 get_argument( theEnv, 3, arg3 );
964 cb = static_cast<sigc::slot3<T_return, T_arg1, T_arg2,T_arg3>*>( cbptr );
965 return ( *cb ) ( arg1, arg2, arg3 );
966 }
967 throw;
968 }
969
970 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
971 inline
972 T_return Environment::callback( void* theEnv ) {
973 sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
974 void * cbptr = get_function_context( theEnv );
975 T_arg1 arg1;
976 T_arg2 arg2;
977 T_arg3 arg3;
978 T_arg4 arg4;
979 if ( cbptr ) {
980 if ( get_arg_count( theEnv ) != 4 )
981 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
982 get_argument( theEnv, 1, arg1 );
983 get_argument( theEnv, 2, arg2 );
984 get_argument( theEnv, 3, arg3 );
985 get_argument( theEnv, 4, arg4 );
986 cb = static_cast<sigc::slot4<T_return, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
987 return ( *cb ) ( arg1, arg2, arg3, arg4 );
988 }
989 throw;
990 }
991
992 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
993 inline
994 T_return Environment::callback( void* theEnv ) {
995 sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
996 void * cbptr = get_function_context( theEnv );
997 T_arg1 arg1;
998 T_arg2 arg2;
999 T_arg3 arg3;
1000 T_arg4 arg4;
1001 T_arg5 arg5;
1002 if ( cbptr ) {
1003 if ( get_arg_count( theEnv ) != 5 )
1004 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
1005 get_argument( theEnv, 1, arg1 );
1006 get_argument( theEnv, 2, arg2 );
1007 get_argument( theEnv, 3, arg3 );
1008 get_argument( theEnv, 4, arg4 );
1009 get_argument( theEnv, 5, arg5 );
1010 cb = static_cast<sigc::slot5<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
1011 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5 );
1012 }
1013 throw;
1014 }
1015
1016 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
1017 inline
1018 T_return Environment::callback( void* theEnv ) {
1019 sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
1020 void * cbptr = get_function_context( theEnv );
1021 T_arg1 arg1;
1022 T_arg2 arg2;
1023 T_arg3 arg3;
1024 T_arg4 arg4;
1025 T_arg5 arg5;
1026 T_arg6 arg6;
1027 if ( cbptr ) {
1028 if ( get_arg_count( theEnv ) != 6 )
1029 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
1030 get_argument( theEnv, 1, arg1 );
1031 get_argument( theEnv, 2, arg2 );
1032 get_argument( theEnv, 3, arg3 );
1033 get_argument( theEnv, 4, arg4 );
1034 get_argument( theEnv, 5, arg5 );
1035 get_argument( theEnv, 6, arg6 );
1036 cb = static_cast<sigc::slot6<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
1037 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 );
1038 }
1039 throw;
1040 }
1041
1042 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 >
1043 inline
1044 T_return Environment::callback( void* theEnv ) {
1045 sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
1046 void * cbptr = get_function_context( theEnv );
1047 T_arg1 arg1;
1048 T_arg2 arg2;
1049 T_arg3 arg3;
1050 T_arg4 arg4;
1051 T_arg5 arg5;
1052 T_arg6 arg6;
1053 T_arg7 arg7;
1054 if ( cbptr ) {
1055 if ( get_arg_count( theEnv ) != 7 )
1056 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
1057 get_argument( theEnv, 1, arg1 );
1058 get_argument( theEnv, 2, arg2 );
1059 get_argument( theEnv, 3, arg3 );
1060 get_argument( theEnv, 4, arg4 );
1061 get_argument( theEnv, 5, arg5 );
1062 get_argument( theEnv, 6, arg6 );
1063 get_argument( theEnv, 7, arg7 );
1064 cb = static_cast<sigc::slot7<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
1065 return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 );
1066 }
1067 throw;
1068 }
1069
1070 inline
1071 void Environment::callback_multifield( void* theEnv, void *rv) {
1072 sigc::slot0<Values>* cb;
1073 void * cbptr = get_function_context( theEnv );
1074 if ( cbptr ) {
1075 if ( get_arg_count( theEnv ) != 0 )
1076 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 0" );
1077 cb = static_cast<sigc::slot0<Values>*>( cbptr );
1078 Values v = ( *cb ) ();
1079 set_return_values(theEnv, rv, v);
1080 return;
1081 }
1082 throw;
1083 }
1084
1085 template <typename T_arg1>
1086 inline
1087 void Environment::callback_multifield( void* theEnv, void *rv) {
1088 sigc::slot1<Values, T_arg1>* cb;
1089 void * cbptr = get_function_context( theEnv );
1090 T_arg1 arg1;
1091 if ( cbptr ) {
1092 if ( get_arg_count( theEnv ) != 1 )
1093 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 1" );
1094 cb = static_cast<sigc::slot1<Values, T_arg1>*>( cbptr );
1095 get_argument(theEnv, 1, arg1);
1096 Values v = ( *cb ) (arg1);
1097 set_return_values(theEnv, rv, v);
1098 return;
1099 }
1100 throw;
1101 }
1102
1103 template <typename T_arg1, typename T_arg2>
1104 inline
1105 void Environment::callback_multifield( void* theEnv, void *rv) {
1106 sigc::slot2<Values, T_arg1, T_arg2>* cb;
1107 void * cbptr = get_function_context( theEnv );
1108 T_arg1 arg1;
1109 T_arg2 arg2;
1110 if ( cbptr ) {
1111 if ( get_arg_count( theEnv ) != 2 )
1112 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 2" );
1113 cb = static_cast<sigc::slot2<Values, T_arg1, T_arg2>*>( cbptr );
1114 get_argument(theEnv, 1, arg1);
1115 get_argument(theEnv, 2, arg2);
1116 Values v = ( *cb ) (arg1, arg2);
1117 set_return_values(theEnv, rv, v);
1118 return;
1119 }
1120 throw;
1121 }
1122
1123
1124 template <typename T_arg1, typename T_arg2, typename T_arg3>
1125 inline
1126 void Environment::callback_multifield( void* theEnv, void *rv) {
1127 sigc::slot3<Values, T_arg1, T_arg2, T_arg3>* cb;
1128 void * cbptr = get_function_context( theEnv );
1129 T_arg1 arg1;
1130 T_arg2 arg2;
1131 T_arg3 arg3;
1132 if ( cbptr ) {
1133 if ( get_arg_count( theEnv ) != 3 )
1134 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 3" );
1135 cb = static_cast<sigc::slot3<Values, T_arg1, T_arg2, T_arg3>*>( cbptr );
1136 get_argument(theEnv, 1, arg1);
1137 get_argument(theEnv, 2, arg2);
1138 get_argument(theEnv, 3, arg3);
1139 Values v = ( *cb ) (arg1, arg2, arg3);
1140 set_return_values(theEnv, rv, v);
1141 return;
1142 }
1143 throw;
1144 }
1145
1146 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
1147 inline
1148 void Environment::callback_multifield( void* theEnv, void *rv) {
1149 sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>* cb;
1150 void * cbptr = get_function_context( theEnv );
1151 T_arg1 arg1;
1152 T_arg2 arg2;
1153 T_arg3 arg3;
1154 T_arg4 arg4;
1155 if ( cbptr ) {
1156 if ( get_arg_count( theEnv ) != 4 )
1157 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 4" );
1158 cb = static_cast<sigc::slot4<Values, T_arg1, T_arg2, T_arg3, T_arg4>*>(cbptr);
1159 get_argument(theEnv, 1, arg1);
1160 get_argument(theEnv, 2, arg2);
1161 get_argument(theEnv, 3, arg3);
1162 get_argument(theEnv, 4, arg4);
1163 Values v = ( *cb ) (arg1, arg2, arg3, arg4);
1164 set_return_values(theEnv, rv, v);
1165 return;
1166 }
1167 throw;
1168 }
1169
1170 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1171 typename T_arg5>
1172 inline
1173 void Environment::callback_multifield( void* theEnv, void *rv) {
1174 sigc::slot5<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* cb;
1175 void * cbptr = get_function_context( theEnv );
1176 T_arg1 arg1;
1177 T_arg2 arg2;
1178 T_arg3 arg3;
1179 T_arg4 arg4;
1180 T_arg5 arg5;
1181 if ( cbptr ) {
1182 if ( get_arg_count( theEnv ) != 5 )
1183 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 5" );
1184 cb = static_cast<sigc::slot5<Values, T_arg1, T_arg2, T_arg3,
1185 T_arg4, T_arg5>*>(cbptr);
1186 get_argument(theEnv, 1, arg1);
1187 get_argument(theEnv, 2, arg2);
1188 get_argument(theEnv, 3, arg3);
1189 get_argument(theEnv, 4, arg4);
1190 get_argument(theEnv, 5, arg5);
1191 Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5);
1192 set_return_values(theEnv, rv, v);
1193 return;
1194 }
1195 throw;
1196 }
1197
1198
1199 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1200 typename T_arg5, typename T_arg6>
1201 inline
1202 void Environment::callback_multifield( void* theEnv, void *rv) {
1203 sigc::slot6<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* cb;
1204 void * cbptr = get_function_context( theEnv );
1205 T_arg1 arg1;
1206 T_arg2 arg2;
1207 T_arg3 arg3;
1208 T_arg4 arg4;
1209 T_arg5 arg5;
1210 T_arg6 arg6;
1211 if ( cbptr ) {
1212 if ( get_arg_count( theEnv ) != 6 )
1213 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 6" );
1214 cb = static_cast<sigc::slot6<Values, T_arg1, T_arg2, T_arg3,
1215 T_arg4, T_arg5, T_arg6>*>(cbptr);
1216 get_argument(theEnv, 1, arg1);
1217 get_argument(theEnv, 2, arg2);
1218 get_argument(theEnv, 3, arg3);
1219 get_argument(theEnv, 4, arg4);
1220 get_argument(theEnv, 5, arg5);
1221 get_argument(theEnv, 6, arg6);
1222 Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6);
1223 set_return_values(theEnv, rv, v);
1224 return;
1225 }
1226 throw;
1227 }
1228
1229 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1230 typename T_arg5, typename T_arg6, typename T_arg7>
1231 inline
1232 void Environment::callback_multifield( void* theEnv, void *rv) {
1233 sigc::slot7<Values, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* cb;
1234 void * cbptr = get_function_context( theEnv );
1235 T_arg1 arg1;
1236 T_arg2 arg2;
1237 T_arg3 arg3;
1238 T_arg4 arg4;
1239 T_arg5 arg5;
1240 T_arg6 arg6;
1241 T_arg7 arg7;
1242 if ( cbptr ) {
1243 if ( get_arg_count( theEnv ) != 7 )
1244 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 7" );
1245 cb = static_cast<sigc::slot7<Values, T_arg1, T_arg2, T_arg3,
1246 T_arg4, T_arg5, T_arg6, T_arg7>*>(cbptr);
1247 get_argument(theEnv, 1, arg1);
1248 get_argument(theEnv, 2, arg2);
1249 get_argument(theEnv, 3, arg3);
1250 get_argument(theEnv, 4, arg4);
1251 get_argument(theEnv, 5, arg5);
1252 get_argument(theEnv, 6, arg6);
1253 get_argument(theEnv, 7, arg7);
1254 Values v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1255 set_return_values(theEnv, rv, v);
1256 return;
1257 }
1258 throw;
1259 }
1260
1261
1262 // **************************************************************************************
1263
1264 inline
1265 void Environment::callback_unknown( void* theEnv, void *rv) {
1266 sigc::slot0<Value>* cb;
1267 void * cbptr = get_function_context( theEnv );
1268 if ( cbptr ) {
1269 if ( get_arg_count( theEnv ) != 0 )
1270 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 0" );
1271 cb = static_cast<sigc::slot0<Value>*>( cbptr );
1272 Value v = ( *cb ) ();
1273 set_return_value(theEnv, rv, v);
1274 return;
1275 }
1276 throw;
1277 }
1278
1279 template <typename T_arg1>
1280 inline
1281 void Environment::callback_unknown( void* theEnv, void *rv) {
1282 sigc::slot1<Value, T_arg1>* cb;
1283 void * cbptr = get_function_context( theEnv );
1284 T_arg1 arg1;
1285 if ( cbptr ) {
1286 if ( get_arg_count( theEnv ) != 1 )
1287 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 1" );
1288 cb = static_cast<sigc::slot1<Value, T_arg1>*>( cbptr );
1289 get_argument(theEnv, 1, arg1);
1290 Value v = ( *cb ) (arg1);
1291 set_return_value(theEnv, rv, v);
1292 return;
1293 }
1294 throw;
1295 }
1296
1297 template <typename T_arg1, typename T_arg2>
1298 inline
1299 void Environment::callback_unknown( void* theEnv, void *rv) {
1300 sigc::slot2<Value, T_arg1, T_arg2>* cb;
1301 void * cbptr = get_function_context( theEnv );
1302 T_arg1 arg1;
1303 T_arg2 arg2;
1304 if ( cbptr ) {
1305 if ( get_arg_count( theEnv ) != 2 )
1306 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 2" );
1307 cb = static_cast<sigc::slot2<Value, T_arg1, T_arg2>*>( cbptr );
1308 get_argument(theEnv, 1, arg1);
1309 get_argument(theEnv, 2, arg2);
1310 Value v = ( *cb ) (arg1, arg2);
1311 set_return_value(theEnv, rv, v);
1312 return;
1313 }
1314 throw;
1315 }
1316
1317
1318 template <typename T_arg1, typename T_arg2, typename T_arg3>
1319 inline
1320 void Environment::callback_unknown( void* theEnv, void *rv) {
1321 sigc::slot3<Value, T_arg1, T_arg2, T_arg3>* cb;
1322 void * cbptr = get_function_context( theEnv );
1323 T_arg1 arg1;
1324 T_arg2 arg2;
1325 T_arg3 arg3;
1326 if ( cbptr ) {
1327 if ( get_arg_count( theEnv ) != 3 )
1328 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 3" );
1329 cb = static_cast<sigc::slot3<Value, T_arg1, T_arg2, T_arg3>*>( cbptr );
1330 get_argument(theEnv, 1, arg1);
1331 get_argument(theEnv, 2, arg2);
1332 get_argument(theEnv, 3, arg3);
1333 Value v = ( *cb ) (arg1, arg2, arg3);
1334 set_return_value(theEnv, rv, v);
1335 return;
1336 }
1337 throw;
1338 }
1339
1340 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4>
1341 inline
1342 void Environment::callback_unknown( void* theEnv, void *rv) {
1343 sigc::slot4<Value, T_arg1, T_arg2, T_arg3, T_arg4>* cb;
1344 void * cbptr = get_function_context( theEnv );
1345 T_arg1 arg1;
1346 T_arg2 arg2;
1347 T_arg3 arg3;
1348 T_arg4 arg4;
1349 if ( cbptr ) {
1350 if ( get_arg_count( theEnv ) != 4 )
1351 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 4" );
1352 cb = static_cast<sigc::slot4<Value, T_arg1, T_arg2, T_arg3, T_arg4>*>(cbptr);
1353 get_argument(theEnv, 1, arg1);
1354 get_argument(theEnv, 2, arg2);
1355 get_argument(theEnv, 3, arg3);
1356 get_argument(theEnv, 4, arg4);
1357 Value v = ( *cb ) (arg1, arg2, arg3, arg4);
1358 set_return_value(theEnv, rv, v);
1359 return;
1360 }
1361 throw;
1362 }
1363
1364 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1365 typename T_arg5>
1366 inline
1367 void Environment::callback_unknown( void* theEnv, void *rv) {
1368 sigc::slot5<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>* cb;
1369 void * cbptr = get_function_context( theEnv );
1370 T_arg1 arg1;
1371 T_arg2 arg2;
1372 T_arg3 arg3;
1373 T_arg4 arg4;
1374 T_arg5 arg5;
1375 if ( cbptr ) {
1376 if ( get_arg_count( theEnv ) != 5 )
1377 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 5" );
1378 cb = static_cast<sigc::slot5<Value, T_arg1, T_arg2, T_arg3,
1379 T_arg4, T_arg5>*>(cbptr);
1380 get_argument(theEnv, 1, arg1);
1381 get_argument(theEnv, 2, arg2);
1382 get_argument(theEnv, 3, arg3);
1383 get_argument(theEnv, 4, arg4);
1384 get_argument(theEnv, 5, arg5);
1385 Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5);
1386 set_return_value(theEnv, rv, v);
1387 return;
1388 }
1389 throw;
1390 }
1391
1392
1393 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1394 typename T_arg5, typename T_arg6>
1395 inline
1396 void Environment::callback_unknown( void* theEnv, void *rv) {
1397 sigc::slot6<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>* cb;
1398 void * cbptr = get_function_context( theEnv );
1399 T_arg1 arg1;
1400 T_arg2 arg2;
1401 T_arg3 arg3;
1402 T_arg4 arg4;
1403 T_arg5 arg5;
1404 T_arg6 arg6;
1405 if ( cbptr ) {
1406 if ( get_arg_count( theEnv ) != 6 )
1407 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 6" );
1408 cb = static_cast<sigc::slot6<Value, T_arg1, T_arg2, T_arg3,
1409 T_arg4, T_arg5, T_arg6>*>(cbptr);
1410 get_argument(theEnv, 1, arg1);
1411 get_argument(theEnv, 2, arg2);
1412 get_argument(theEnv, 3, arg3);
1413 get_argument(theEnv, 4, arg4);
1414 get_argument(theEnv, 5, arg5);
1415 get_argument(theEnv, 6, arg6);
1416 Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6);
1417 set_return_value(theEnv, rv, v);
1418 return;
1419 }
1420 throw;
1421 }
1422
1423 template <typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4,
1424 typename T_arg5, typename T_arg6, typename T_arg7>
1425 inline
1426 void Environment::callback_unknown( void* theEnv, void *rv) {
1427 sigc::slot7<Value, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>* cb;
1428 void * cbptr = get_function_context( theEnv );
1429 T_arg1 arg1;
1430 T_arg2 arg2;
1431 T_arg3 arg3;
1432 T_arg4 arg4;
1433 T_arg5 arg5;
1434 T_arg6 arg6;
1435 T_arg7 arg7;
1436 if ( cbptr ) {
1437 if ( get_arg_count( theEnv ) != 7 )
1438 throw std::logic_error( "clipsmm/mf: wrong # args on slot callback; expected 7" );
1439 cb = static_cast<sigc::slot7<Value, T_arg1, T_arg2, T_arg3,
1440 T_arg4, T_arg5, T_arg6, T_arg7>*>(cbptr);
1441 get_argument(theEnv, 1, arg1);
1442 get_argument(theEnv, 2, arg2);
1443 get_argument(theEnv, 3, arg3);
1444 get_argument(theEnv, 4, arg4);
1445 get_argument(theEnv, 5, arg5);
1446 get_argument(theEnv, 6, arg6);
1447 get_argument(theEnv, 7, arg7);
1448 Value v = ( *cb ) (arg1, arg2, arg3, arg4, arg5, arg6, arg7);
1449 set_return_value(theEnv, rv, v);
1450 return;
1451 }
1452 throw;
1453 }
1454
1455 // **************************************************************************************
1456
1457
1458 inline
1459 void* Environment::strcallback( void* theEnv ) {
1460 sigc::slot0<std::string>* cb;
1461 void * cbptr = get_function_context( theEnv );
1462 if ( cbptr ) {
1463 if ( get_arg_count( theEnv ) != 0 )
1464 throw std::logic_error( "clipsmm/string: wrong # args on slot callback; expected 0" );
1465 cb = static_cast<sigc::slot0<std::string>*>( cbptr );
1466 return add_symbol( theEnv, ( ( *cb ) ( )).c_str() );
1467 }
1468 throw;
1469 }
1470
1471 template < typename T_arg1 >
1472 inline
1473 void* Environment::strcallback( void* theEnv ) {
1474 sigc::slot1<std::string,T_arg1>* cb;
1475 void * cbptr = get_function_context( theEnv );
1476 T_arg1 arg1;
1477 if ( cbptr ) {
1478 if ( get_arg_count( theEnv ) != 1 )
1479 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
1480 get_argument( theEnv, 1, arg1 );
1481 cb = static_cast<sigc::slot1<std::string,T_arg1>*>( cbptr );
1482 return add_symbol( theEnv, ( ( *cb ) ( arg1 )).c_str() );
1483 }
1484 throw;
1485 }
1486
1487 template < typename T_arg1, typename T_arg2 >
1488 inline
1489 void* Environment::strcallback( void* theEnv ) {
1490 sigc::slot2<std::string, T_arg1, T_arg2>* cb;
1491 void * cbptr = get_function_context( theEnv );
1492 T_arg1 arg1;
1493 T_arg2 arg2;
1494 if ( cbptr ) {
1495 if ( get_arg_count( theEnv ) != 2 )
1496 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
1497 get_argument( theEnv, 1, arg1 );
1498 get_argument( theEnv, 2, arg2 );
1499 cb = static_cast<sigc::slot2<std::string, T_arg1, T_arg2>*>( cbptr );
1500 return add_symbol( theEnv, ( ( *cb ) ( arg1, arg2 )).c_str() );
1501 }
1502 throw;
1503 }
1504
1505 template < typename T_arg1, typename T_arg2, typename T_arg3 >
1506 inline
1507 void* Environment::strcallback( void* theEnv ) {
1508 sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>* cb;
1509 void * cbptr = get_function_context( theEnv );
1510 T_arg1 arg1;
1511 T_arg2 arg2;
1512 T_arg3 arg3;
1513 if ( cbptr ) {
1514 if ( get_arg_count( theEnv ) != 3 )
1515 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
1516 get_argument( theEnv, 1, arg1 );
1517 get_argument( theEnv, 2, arg2 );
1518 get_argument( theEnv, 3, arg3 );
1519 cb = static_cast<sigc::slot3<std::string, T_arg1, T_arg2,T_arg3>*>( cbptr );
1520 return add_symbol( theEnv, ( ( *cb ) ( arg1, arg2, arg3 )).c_str() );
1521 }
1522 throw;
1523 }
1524
1525 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
1526 inline
1527 void* Environment::strcallback( void* theEnv ) {
1528 sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
1529 void * cbptr = get_function_context( theEnv );
1530 T_arg1 arg1;
1531 T_arg2 arg2;
1532 T_arg3 arg3;
1533 T_arg4 arg4;
1534 std::string s;
1535 if ( cbptr ) {
1536 if ( get_arg_count( theEnv ) != 4 )
1537 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
1538 get_argument( theEnv, 1, arg1 );
1539 get_argument( theEnv, 2, arg2 );
1540 get_argument( theEnv, 3, arg3 );
1541 get_argument( theEnv, 4, arg4 );
1542 cb = static_cast<sigc::slot4<std::string, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
1543 s = ( *cb ) ( arg1, arg2, arg3, arg4 );
1544 return add_symbol( theEnv, s.c_str() );
1545 }
1546 throw;
1547 }
1548
1549 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
1550 inline
1551 void* Environment::strcallback( void* theEnv ) {
1552 sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
1553 void * cbptr = get_function_context( theEnv );
1554 T_arg1 arg1;
1555 T_arg2 arg2;
1556 T_arg3 arg3;
1557 T_arg4 arg4;
1558 T_arg5 arg5;
1559 if ( cbptr ) {
1560 if ( get_arg_count( theEnv ) != 5 )
1561 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
1562 get_argument( theEnv, 1, arg1 );
1563 get_argument( theEnv, 2, arg2 );
1564 get_argument( theEnv, 3, arg3 );
1565 get_argument( theEnv, 4, arg4 );
1566 get_argument( theEnv, 5, arg5 );
1567 cb = static_cast<sigc::slot5<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
1568 return add_symbol( theEnv, ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5 )).c_str() );
1569 }
1570 throw;
1571 }
1572
1573 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
1574 inline
1575 void* Environment::strcallback( void* theEnv ) {
1576 sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
1577 void * cbptr = get_function_context( theEnv );
1578 T_arg1 arg1;
1579 T_arg2 arg2;
1580 T_arg3 arg3;
1581 T_arg4 arg4;
1582 T_arg5 arg5;
1583 T_arg6 arg6;
1584 if ( cbptr ) {
1585 if ( get_arg_count( theEnv ) != 6 )
1586 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
1587 get_argument( theEnv, 1, arg1 );
1588 get_argument( theEnv, 2, arg2 );
1589 get_argument( theEnv, 3, arg3 );
1590 get_argument( theEnv, 4, arg4 );
1591 get_argument( theEnv, 5, arg5 );
1592 get_argument( theEnv, 6, arg6 );
1593 cb = static_cast<sigc::slot6<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
1594 return add_symbol( theEnv, ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 )).c_str() );
1595 }
1596 throw;
1597 }
1598
1599 template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
1600 inline
1601 void* Environment::strcallback( void* theEnv ) {
1602 sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
1603 void * cbptr = get_function_context( theEnv );
1604 T_arg1 arg1;
1605 T_arg2 arg2;
1606 T_arg3 arg3;
1607 T_arg4 arg4;
1608 T_arg5 arg5;
1609 T_arg6 arg6;
1610 T_arg7 arg7;
1611 if ( cbptr ) {
1612 if ( get_arg_count( theEnv ) != 7 )
1613 throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
1614 get_argument( theEnv, 1, arg1 );
1615 get_argument( theEnv, 2, arg2 );
1616 get_argument( theEnv, 3, arg3 );
1617 get_argument( theEnv, 4, arg4 );
1618 get_argument( theEnv, 5, arg5 );
1619 get_argument( theEnv, 6, arg6 );
1620 get_argument( theEnv, 7, arg7 );
1621 cb = static_cast<sigc::slot7<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
1622 return add_symbol( theEnv, ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 )).c_str() );
1623 }
1624 throw;
1625 }
1626
1627template < typename T_return >
1628 inline
1629 bool Environment::add_function( std::string name, const sigc::slot0<T_return>& slot) {
1630 char retcode = get_return_code<T_return>( );
1631 char *argstring = get_function_restriction(name);
1632 sigc::slot0<T_return>* scb = new sigc::slot0<T_return>(slot);
1634 m_slots[name] = holder;
1636 name.c_str(),
1637 retcode,
1638 get_callback(slot),
1639 name.c_str(),
1640 argstring,
1641 ( void* ) scb ) );
1642 }
1643
1644 template < typename T_return, typename T_arg1 >
1645 inline
1646 bool Environment::add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot) {
1647 char retcode = get_return_code<T_return>( );
1648 char *argstring = get_function_restriction<T_arg1>(name);
1649 sigc::slot1<T_return, T_arg1>* scb = new sigc::slot1<T_return, T_arg1>(slot);
1651 m_slots[name] = holder;
1653 name.c_str(),
1654 retcode,
1655 get_callback(slot),
1656 name.c_str(),
1657 argstring,
1658 scb ) );
1659 }
1660
1661 template < typename T_return, typename T_arg1, typename T_arg2 >
1662 inline
1663 bool Environment::add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot) {
1664 char retcode = get_return_code<T_return>( );
1665 char *argstring = get_function_restriction<T_arg1,T_arg2>(name);
1666 sigc::slot2<T_return, T_arg1, T_arg2>* scb = new sigc::slot2<T_return, T_arg1, T_arg2>(slot);
1668 m_slots[name] = holder;
1670 name.c_str(),
1671 retcode,
1672 get_callback(slot),
1673 name.c_str(),
1674 argstring,
1675 scb ) );
1676 }
1677
1678 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
1679 inline
1680 bool Environment::add_function( std::string name, const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot) {
1681 char retcode = get_return_code<T_return>( );
1682 char *argstring = get_function_restriction<T_arg1,T_arg2,T_arg3>(name);
1683 sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* scb =
1684 new sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>(slot);
1686 m_slots[name] = holder;
1688 name.c_str(),
1689 retcode,
1690 get_callback(slot),
1691 name.c_str(),
1692 argstring,
1693 scb )
1694 );
1695 }
1696
1697 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
1698 inline
1699 bool Environment::add_function( std::string name, const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot) {
1700 char retcode = get_return_code<T_return>( );
1702 sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* scb =
1703 new sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>(slot);
1705 m_slots[name] = holder;
1707 name.c_str(),
1708 retcode,
1709 get_callback(slot),
1710 name.c_str(),
1711 argstring,
1712 scb )
1713 );
1714 }
1715
1716 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
1717 inline
1718 bool Environment::add_function( std::string name,
1719 const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot) {
1720 char retcode = get_return_code<T_return>( );
1722 sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* scb =
1723 new sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(slot);
1725 m_slots[name] = holder;
1727 name.c_str(),
1728 retcode,
1729 get_callback(slot),
1730 name.c_str(),
1731 argstring,
1732 scb )
1733 );
1734 }
1735
1736 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
1737 inline
1738 bool Environment::add_function( std::string name,
1739 const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot) {
1740 char retcode = get_return_code<T_return>( );
1742 sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* scb =
1743 new sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(slot);
1745 m_slots[name] = holder;
1747 name.c_str(),
1748 retcode,
1749 get_callback(slot),
1750 name.c_str(),
1751 argstring,
1752 scb )
1753 );
1754 }
1755
1756 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 >
1757 inline
1758 bool Environment::add_function( std::string name,
1759 const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot) {
1760 char retcode = get_return_code<T_return>( );
1762 sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* scb =
1763 new sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(slot);
1765 m_slots[name] = holder;
1767 name.c_str(),
1768 retcode,
1769 get_callback(slot),
1770 name.c_str(),
1771 argstring,
1772 scb )
1773 );
1774 }
1775
1776}
1777
1778
1779#endif
CLIPSPointer< Activation > pointer
Definition activation.h:33
CLIPSPointer< DefaultFacts > pointer
Definition defaultfacts.h:33
Definition environment.h:57
Activation::pointer get_activation_list_head()
Definition environment.cpp:520
static void callback_multifield(void *theEnv, void *rv)
Definition environment.h:1071
int load(const std::string &filename)
Loads a set of constructs into the CLIPS data base.
Definition environment.cpp:88
bool use_dynamic_constraint_checking(bool use=true)
Sets the dynamic constraint checking behavior.
Definition environment.cpp:237
Function::pointer get_function(const std::string &function_name)
Definition environment.cpp:679
sigc::signal< void > signal_globals_changed()
Definition environment.cpp:771
bool save(const std::string &filename)
Saves a set of constructs to the specified file.
Definition environment.cpp:98
bool dribble_off()
Turns off the storing of dribble information.
Definition environment.cpp:107
Glib::Mutex m_mutex_threaded_run
Mutex that locks when a threaded run is executing.
Definition environment.h:533
DefaultFacts::pointer get_default_facts_list_head()
Definition environment.cpp:322
std::vector< std::string > get_default_facts_names()
Gets a list of default facts names from all modules.
Definition environment.cpp:295
Glib::Mutex m_mutex_run_signal
Mutex that protects against multiple signal emits.
Definition environment.h:534
~Environment()
Definition environment.cpp:50
static void set_return_values(void *env, void *rv, const Values &v)
Definition environment.cpp:804
Module::pointer get_current_module()
Definition environment.cpp:494
static T_return callback(void *theEnv)
Definition environment.h:904
bool is_dribble_active()
Determines if the storing of dribble information is active.
Definition environment.cpp:103
sigc::signal< void, long int > signal_run()
Signal emitted when the rules are executed.
Definition environment.cpp:183
bool fact_duplication_enabled()
Returns the current state of the fact duplication behavior.
Definition environment.cpp:257
static void * strcallback(void *theEnv)
Definition environment.h:1459
Fact::pointer assert_fact(const std::string &factstring)
Definition environment.cpp:434
long int run(long int runlimit=-1)
Allows rules to execute.
Definition environment.cpp:130
sigc::signal< void, long int > m_signal_run
Signal emitted when a job is run.
Definition environment.h:535
Glib::Mutex m_mutex_run_queue
Mutex that protects access to the run queue.
Definition environment.h:531
bool build(const std::string &construct)
Allows a construct to be defined.
Definition environment.cpp:80
bool remove_function(std::string name)
Definition environment.cpp:621
static void * get_function_context(void *env)
Definition environment.cpp:800
Global::pointer get_global_list_head()
Definition environment.cpp:640
void set_as_current()
Definition environment.cpp:215
bool auto_float_dividend_enabled()
Returns the current state of the auto-float dividend behavior.
Definition environment.cpp:225
bool incremental_reset_enabled()
Definition environment.cpp:474
void reorder_agenda()
Reorders the agenda for all modules.
Definition environment.cpp:544
Rule::pointer get_rule_list_head()
Definition environment.cpp:419
Module::pointer get_focused_module()
Definition environment.cpp:504
Fact::pointer assert_fact_f(const char *format,...)
Definition environment.cpp:454
void clear()
Clears the environment.
Definition environment.cpp:84
static void * add_symbol(void *env, const char *s)
Definition environment.cpp:856
static int get_arg_count(void *env)
Definition environment.cpp:796
Values evaluate(const std::string &expression)
Evaluates and expression and returns a vector of the results.
Definition environment.cpp:595
std::vector< std::string > get_focus_stack()
Definition environment.cpp:514
DefaultFacts::pointer get_default_facts(const std::string &default_facts_name)
Definition environment.cpp:285
bool use_static_constraint_checking(bool use=true)
Sets the static constraint checking behavior.
Definition environment.cpp:253
static std::map< void *, Environment * > m_environment_map
Definition environment.h:551
Function::pointer get_function_list_head()
Definition environment.cpp:687
std::vector< std::string > get_function_names()
Gets a list of function names from all modules.
Definition environment.cpp:697
bool use_fact_duplication(bool use=true)
Sets the static constraint checking behavior.
Definition environment.cpp:261
static void rule_firing_callback(void *end)
Definition environment.cpp:791
Global::pointer get_global(const std::string &global_name)
Definition environment.cpp:632
Glib::Thread * m_run_thread
A pointer to the currently running thread.
Definition environment.h:529
ConflictResolution get_conflict_resolution_strategy()
Gets the current conflict resolution strategy.
Definition environment.cpp:568
static void callback_unknown(void *theEnv, void *rv)
Definition environment.h:1265
Glib::Mutex m_mutex_run
Mutex that protects against multiple executions.
Definition environment.h:532
sigc::signal< void > signal_periodic()
Definition environment.cpp:731
void clear_focus_stack()
Definition environment.cpp:220
Module::pointer get_module(const std::string &module_name)
Definition environment.cpp:484
static void set_return_value(void *env, void *rv, const Value &v)
Definition environment.cpp:851
bool static_constraint_checking_enabled()
Returns the current state of the static constraint checking behavior.
Definition environment.cpp:249
sigc::signal< void > m_signal_rule_firing
Definition environment.h:507
sigc::signal< void > m_signal_globals_changed
Definition environment.h:509
SalienceEvaluation get_salience_evaluation()
Gets the salience evaluation mode.
Definition environment.cpp:558
CLIPSPointer< Environment > pointer
Definition environment.h:59
Module::pointer get_module_list_head()
Definition environment.cpp:585
void remove_rules()
Definition environment.cpp:429
sigc::signal< void > m_signal_reset
Definition environment.h:506
Environment()
Definition environment.cpp:33
bool dribble_on(const std::string &dribble_file)
Allows the dribble function of CLIPS to be turned on.
Definition environment.cpp:111
std::vector< std::string > get_globals_names()
Gets a list of global names from all modules.
Definition environment.cpp:650
bool use_sequence_operator_recognition(bool use=true)
Sets the sequence operator recognition behavior.
Definition environment.cpp:245
Values function(const std::string &function_name, const std::string &arguments=std::string())
Evaluates a CLIPS function.
Definition environment.cpp:606
bool use_auto_float_dividend(bool use=true)
Sets the auto-float dividend behavior.
Definition environment.cpp:229
Fact::pointer get_facts()
TODO Facts.
Definition environment.cpp:275
struct CLIPS::Environment::Job Job
Encapsulates the concept of a CLIPS job.
Rule::pointer get_rule(const std::string &rule_name)
Definition environment.cpp:382
bool dynamic_constraint_checking_enabled()
Returns the current state of the dynamic constraint checking behavior.
Definition environment.cpp:233
int(*)(void *) get_callback(const sigc::slot0< std::string > &slot)
Definition environment.h:659
void threaded_run()
Protected method that does the actual work.
Definition environment.cpp:187
sigc::signal< void > m_signal_periodic
Definition environment.h:505
bool check_agenda_changed()
TODO ListDefmodules.
Definition environment.cpp:746
sigc::signal< void > m_signal_clear
Definition environment.h:504
char * get_function_restriction(std::string &name)
Definition environment.h:821
bool use_global_reset(bool use=true)
Definition environment.cpp:269
std::priority_queue< Job > m_run_queue
A priority queue of jobs to run.
Definition environment.h:530
bool batch_evaluate(const std::string &filename)
Evaluates a series of commands in the specified file.
Definition environment.cpp:68
int is_watched(const std::string &item)
Determine if an item is being watched.
Definition environment.cpp:116
void join_run_thread()
Waits until the execution thread is finished.
Definition environment.cpp:163
void refresh_agenda()
Refreshes the agenda for all modules.
Definition environment.cpp:530
static void clear_callback(void *env)
Definition environment.cpp:776
bool binary_load(const std::string &filename)
Loads a binary image of constructs into the CLIPS data base.
Definition environment.cpp:72
bool sequence_operator_recognition_enabled()
Returns the current state of the sequence operator recognition behavior.
Definition environment.cpp:241
std::vector< std::string > get_module_names()
Definition environment.cpp:578
static void reset_callback(void *env)
Definition environment.cpp:786
Template::pointer get_template(const std::string &template_name)
Definition environment.cpp:332
bool binary_save(const std::string &filename)
Saves a binary image of constructs from the CLIPS data base.
Definition environment.cpp:76
std::vector< std::string > get_rule_names()
Gets a list of rule names from all modules.
Definition environment.cpp:392
std::map< std::string, any > m_slots
Holds any dynamically created slots.
Definition environment.h:502
bool watch(const std::string &item)
Definition environment.cpp:120
bool unwatch(const std::string &item)
Definition environment.cpp:125
bool check_globals_changed()
Definition environment.cpp:761
ConflictResolution set_conflict_resolution_strategy(ConflictResolution cr)
Sets the conflict resolution strategy.
Definition environment.cpp:573
std::map< std::string, char * > m_func_restr
Map from function name to restrictions.
Definition environment.h:546
std::vector< std::string > get_template_names()
Gets a list of template names from all modules.
Definition environment.cpp:345
sigc::signal< void > signal_agenda_changed()
Definition environment.cpp:756
bool global_reset_enable()
Definition environment.cpp:265
static void periodic_callback(void *env)
Definition environment.cpp:781
sigc::signal< void > signal_reset()
Definition environment.cpp:736
void reset()
Resets the CLIPS environment.
Definition environment.cpp:93
bool use_incremental_reset(bool use=true)
Definition environment.cpp:479
sigc::signal< void > signal_rule_firing()
Definition environment.cpp:741
bool add_function(std::string name, const sigc::slot0< T_return > &slot)
Definition environment.h:1629
void run_threaded(long int runlimit=-1, int priority=0)
Executes rules in a separate thread.
Definition environment.cpp:142
sigc::signal< void > m_signal_agenda_changed
Definition environment.h:508
SalienceEvaluation set_salience_evaluation(SalienceEvaluation se)
Sets the salience evaluation mode.
Definition environment.cpp:563
sigc::signal< void > signal_clear()
Definition environment.cpp:726
Template::pointer get_template_list_head()
Definition environment.cpp:372
CLIPSPointer< Fact > pointer
Definition fact.h:36
CLIPSPointer< Function > pointer
Definition function.h:32
CLIPSPointer< Global > pointer
Definition global.h:33
Definition module.h:29
CLIPSPointer< Module > pointer
Definition module.h:31
Definition object.h:32
void * m_cobj
The underlying CLIPS C object.
Definition object.h:45
CLIPSPointer< Rule > pointer
Definition rule.h:31
CLIPSPointer< Template > pointer
Definition template.h:44
Definition value.h:44
Definition any.h:47
int EnvDefineFunction2WithContext(void *, const char *, int, int(*)(void *), const char *, const char *, void *)
Definition activation.cpp:29
void get_argument(void *env, int argposition, void *&value)
Definition utility.cpp:71
char get_return_code()
Definition utility.h:52
std::vector< Value > Values
Definition value.h:278
char get_argument_code()
Definition utility.h:67
SalienceEvaluation
Definition enum.h:27
ConflictResolution
Definition enum.h:36
#define CLIPSPointer
Definition pointer.h:28
Encapsulates the concept of a CLIPS job.
Definition environment.h:512
Job(int p, long int rl)
Constructor that takes a priority and a CLIPS runlimit.
Definition environment.h:514
bool operator<(const Job &other) const
Comparison operator that compares the priority member.
Definition environment.h:517
long int runlimit
How many rules should fire.
Definition environment.h:526
int priority
The priority of this job.
Definition environment.h:520

Generated on Wed Jul 17 2024 00:00:00 for clipsmm by doxygen 1.12.0