environment.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2006 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the clipsmm library.                             *
 *                                                                         *
 *   The clipsmm library is free software; you can redistribute it and/or  *
 *   modify it under the terms of the GNU General Public License           *
 *   version 3 as published by the Free Software Foundation.               *
 *                                                                         *
 *   The clipsmm library is distributed in the hope that it will be        *
 *   useful, but WITHOUT ANY WARRANTY; without even the implied warranty   *
 *   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   *
 *   General Public License for more details.                              *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this software. If not see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
#ifndef CLIPSENVIRONMENT_H
#define CLIPSENVIRONMENT_H

#include <string>
#include <map>
#include <typeinfo>
#include <stdexcept>
#include <map>
#include <queue>

#include <iostream>

#include <sigc++/sigc++.h>
#include <glibmm.h>

#include <clipsmm/enum.h>
#include <clipsmm/object.h>

#include <clipsmm/activation.h>
#include <clipsmm/defaultfacts.h>
#include <clipsmm/fact.h>
#include <clipsmm/function.h>
#include <clipsmm/global.h>
#include <clipsmm/module.h>
#include <clipsmm/rule.h>
#include <clipsmm/template.h>

#include <clipsmm/utility.h>
#include <clipsmm/any.h>

extern "C" {
  int EnvDefineFunction2WithContext( void *, char *, int, int ( * ) ( void * ), char *, char *, void * );
}

namespace CLIPS {

  class Environment: public Object {
    public:
      typedef CLIPSPointer<Environment> pointer;

      Environment();

      ~Environment();

      bool batch_evaluate( const std::string& filename );

      bool binary_load( const std::string& filename );

      bool binary_save( const std::string& filename );

      bool build( const std::string& construct );

      void clear( );

      Values evaluate( const std::string& expression );

      Values function( const std::string& function_name, const std::string& arguments=std::string() );

      int load( const std::string& filename );

      void reset();

      bool save( const std::string& filename );

      bool auto_float_dividend_enabled();

      bool use_auto_float_dividend( bool use = true );

      bool dynamic_constraint_checking_enabled();

      bool use_dynamic_constraint_checking( bool use = true );

      bool sequence_operator_recognition_enabled();

      bool use_sequence_operator_recognition( bool use = true );

      bool static_constraint_checking_enabled();

      bool use_static_constraint_checking( bool use = true );

      bool fact_duplication_enabled();

      bool use_fact_duplication( bool use = true );

      bool incremental_reset_enabled();

      bool use_incremental_reset( bool use = true );

      bool global_reset_enable();

      bool use_global_reset( bool use=true );

      bool is_dribble_active( );

      bool dribble_off( );

      bool dribble_on( const std::string& dribble_file );

      int is_watched( const std::string& item );

      bool watch( const std::string& item );

      bool unwatch( const std::string& item );

      void set_as_current();

      Fact::pointer assert_fact( const std::string& factstring );

      void clear_focus_stack();

      DefaultFacts::pointer get_default_facts( const std::string& default_facts_name );

      std::vector<std::string> get_default_facts_names();

      std::vector<std::string> get_default_facts_names( const Module& module );

      std::vector<std::string> get_default_facts_names( Module::pointer module );

      DefaultFacts::pointer get_default_facts_list_head();

      Template::pointer get_template( const std::string& template_name );

      std::vector<std::string> get_template_names();

      std::vector<std::string> get_template_names( const Module& module );

      std::vector<std::string> get_template_names( Module::pointer module );

      Template::pointer get_template_list_head();

      Rule::pointer get_rule( const std::string& rule_name );

      std::vector<std::string> get_rule_names();

      std::vector<std::string> get_rule_names( const Module& module );

      std::vector<std::string> get_rule_names( Module::pointer module );

      Rule::pointer get_rule_list_head();

      void remove_rules();

      Module::pointer get_module( const std::string& module_name );

      Module::pointer get_current_module();

      std::vector<std::string> get_module_names();

      Module::pointer get_module_list_head();

      void refresh_agenda();

      void refresh_agenda( const Module& module );

      void refresh_agenda( Module::pointer module );

      void reorder_agenda();

      void reorder_agenda( const Module& module );

      void reorder_agenda( Module::pointer module );

      long int run( long int runlimit = -1 );

      void run_threaded( long int runlimit = -1, int priority = 0 );

      void join_run_thread();

      sigc::signal<void, long int> signal_run();

      SalienceEvaluation get_salience_evaluation();

      SalienceEvaluation set_salience_evaluation( SalienceEvaluation se );

      ConflictResolution get_conflict_resolution_strategy();

      ConflictResolution set_conflict_resolution_strategy( ConflictResolution cr );

      bool check_agenda_changed();

      Module::pointer get_focused_module();

      std::vector<std::string> get_focus_stack();

      Activation::pointer get_activation_list_head();

      Global::pointer get_global( const std::string& global_name );

      Global::pointer get_global_list_head();

      std::vector<std::string> get_globals_names();

      std::vector<std::string> get_globals_names( const Module& module );

      std::vector<std::string> get_globals_names( Module::pointer module );

      bool check_globals_changed();

      Function::pointer get_function( const std::string& function_name );

      Function::pointer get_function_list_head();

      std::vector<std::string> get_function_names();

      std::vector<std::string> get_function_names( const Module& module );

      std::vector<std::string> get_function_names( Module::pointer module );

      sigc::signal<void> signal_clear();
      sigc::signal<void> signal_periodic();
      sigc::signal<void> signal_reset();
      sigc::signal<void> signal_rule_firing();
      sigc::signal<void> signal_agenda_changed();
      sigc::signal<void> signal_globals_changed();

      template < typename T_return >
      bool add_function( std::string name, const sigc::slot0<T_return>& slot);

      template < typename T_return, typename T_arg1 >
      bool add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot);

      template < typename T_return, typename T_arg1, typename T_arg2 >
      bool add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot);

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
      bool add_function( std::string name, const sigc::slot3<T_return, T_arg1, T_arg2, T_arg3>& slot);

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
      bool add_function( std::string name, const sigc::slot4<T_return, T_arg1, T_arg2, T_arg3, T_arg4>& slot);

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
      bool add_function( std::string name, const sigc::slot5<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>& slot);

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
      bool add_function( std::string name, const sigc::slot6<T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>& slot);

      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 >
      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);

      bool remove_function( std::string name );

    protected:
      std::map<std::string,any> m_slots;

      sigc::signal<void> m_signal_clear;
      sigc::signal<void> m_signal_periodic;
      sigc::signal<void> m_signal_reset;
      sigc::signal<void> m_signal_rule_firing;
      sigc::signal<void> m_signal_agenda_changed;
      sigc::signal<void> m_signal_globals_changed;

      typedef struct Job {
        Job( int p, long int rl ) : priority(p), runlimit(rl) { }

        bool operator<( const Job& other ) const { return priority < other.priority; }

        int priority;

        long int runlimit;
      } Job;

      Glib::Thread* m_run_thread; 
      std::priority_queue<Job> m_run_queue; 
      Glib::Mutex m_mutex_run_queue; 
      Glib::Mutex m_mutex_run; 
      Glib::Mutex m_mutex_threaded_run; 
      Glib::Mutex m_mutex_run_signal; 
      sigc::signal<void, long int> m_signal_run; 
      void threaded_run();

      static std::map<void*, Environment*> m_environment_map;


      static void clear_callback( void* env );
      static void periodic_callback( void* env );
      static void reset_callback( void* env );
      static void rule_firing_callback( void* end );

      static void* strcallback( void* theEnv );

      template < typename T_arg1 >
      static void* strcallback( void* theEnv );

      template < typename T_arg1, typename T_arg2 >
      static void* strcallback( void* theEnv );

      template < typename T_arg1, typename T_arg2, typename T_arg3 >
      static void* strcallback( void* theEnv );

      template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
      static void* strcallback( void* theEnv );

      template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
      static void* strcallback( void* theEnv );

      template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
      static void* strcallback( void* theEnv );

      template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
      static void* strcallback( void* theEnv );

      template < typename T_return >
      static T_return callback( void* theEnv );

      template < typename T_return, typename T_arg1 >
      static T_return callback( void* theEnv );

      template < typename T_return, typename T_arg1, typename T_arg2 >
      static T_return callback( void* theEnv );

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
      static T_return callback( void* theEnv );

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
      static T_return callback( void* theEnv );

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
      static T_return callback( void* theEnv );

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
      static T_return callback( void* theEnv );

      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 >
      static T_return callback( void* theEnv );

      int ( *get_callback( const sigc::slot0<std::string>& slot ))( void* )
        { return ( int ( * ) ( void* ) ) ( std::string ( * ) ( void* ) ) callback<std::string>; }

      template < typename T_arg1 >
      int ( *get_callback( const sigc::slot1<std::string,T_arg1>& slot ))( void* )
        { return ( int ( * ) ( void* ) ) ( std::string ( * ) ( void* ) ) callback<std::string,T_arg1>; }

      template < typename T_arg1, typename T_arg2 >
      int ( *get_callback( const sigc::slot2<std::string,T_arg1,T_arg2>& slot ))( void* )
        { return ( int ( * ) ( void* ) ) ( void* ( * ) ( void* ) ) strcallback<T_arg1,T_arg2>; }

      template < typename T_arg1, typename T_arg2, typename T_arg3 >
      int ( *get_callback( const sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>& slot ))( void* )
        { return (int(*)(void*)) (std::string(*)(void*)) callback<std::string,T_arg1,T_arg2,T_arg3>; }

      template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
      int ( *get_callback( const sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
        { return (int(*)(void*)) (std::string(*)(void*)) callback<std::string,T_arg1,T_arg2,T_arg3,T_arg4>; }

      template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
      int ( *get_callback( const sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
        { return (int(*)(void*)) (std::string(*)(void*)) callback<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }

      template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
      int ( *get_callback( const sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
        { return (int(*)(void*)) (std::string(*)(void*)) callback<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }

      template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
      int ( *get_callback( const sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
        { return (int(*)(void*)) (std::string(*)(void*)) callback<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }

      template < typename T_return >
      int ( *get_callback( const sigc::slot0<T_return>& slot ))( void* )
        { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return>; }

      template < typename T_return, typename T_arg1 >
      int ( *get_callback( const sigc::slot1<T_return,T_arg1>& slot ))( void* )
        { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1>; }

      template < typename T_return, typename T_arg1, typename T_arg2 >
      int ( *get_callback( const sigc::slot2<T_return,T_arg1,T_arg2>& slot ))( void* )
        { return ( int ( * ) ( void* ) ) ( T_return ( * ) ( void* ) ) callback<T_return,T_arg1,T_arg2>; }

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
      int ( *get_callback( const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot ))( void* )
        { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3>; }

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
      int ( *get_callback( const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot ))( void* )
        { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4>; }

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
      int ( *get_callback( const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot ))( void* )
        { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>; }

      template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
      int ( *get_callback( const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot ))( void* )
        { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>; }

      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 >
      int ( *get_callback( const sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& slot ))( void* )
        { return (int(*)(void*)) (T_return(*)(void*)) callback<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>; }

      static int get_arg_count( void* env );
      static void* get_function_context( void* env );
      static void* add_symbol( const char* s );


  };

  template < typename T_return>
  inline
  T_return Environment::callback( void* theEnv ) {
    sigc::slot0<T_return>* cb;
    void * cbptr = get_function_context( theEnv );
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 0 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 0" );
      cb = static_cast<sigc::slot0<T_return>*>( cbptr );
      return ( *cb ) ();
    }
    throw;
  }

  template < typename T_return, typename T_arg1 >
  inline
  T_return Environment::callback( void* theEnv ) {
    sigc::slot1<T_return,T_arg1>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 1 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
      get_argument( theEnv, 1, arg1 );
      cb = static_cast<sigc::slot1<T_return,T_arg1>*>( cbptr );
      return ( *cb ) ( arg1 );
    }
    throw;
  }

  template < typename T_return, typename T_arg1, typename T_arg2 >
  inline
  T_return Environment::callback( void* theEnv ) {
    sigc::slot2<T_return, T_arg1, T_arg2>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    T_arg2 arg2;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 2 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
      get_argument( theEnv, 1, arg1 );
      get_argument( theEnv, 2, arg2 );
      cb = static_cast<sigc::slot2<T_return, T_arg1, T_arg2>*>( cbptr );
      return ( *cb ) ( arg1, arg2 );
    }
    throw;
  }

  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
  inline
  T_return Environment::callback( void* theEnv ) {
    sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    T_arg2 arg2;
    T_arg3 arg3;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 3 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
      get_argument( theEnv, 1, arg1 );
      get_argument( theEnv, 2, arg2 );
      get_argument( theEnv, 3, arg3 );
      cb = static_cast<sigc::slot3<T_return, T_arg1, T_arg2,T_arg3>*>( cbptr );
      return ( *cb ) ( arg1, arg2, arg3 );
    }
    throw;
  }

  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
  inline
  T_return Environment::callback( void* theEnv ) {
    sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    T_arg2 arg2;
    T_arg3 arg3;
    T_arg4 arg4;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 4 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
      get_argument( theEnv, 1, arg1 );
      get_argument( theEnv, 2, arg2 );
      get_argument( theEnv, 3, arg3 );
      get_argument( theEnv, 4, arg4 );
      cb = static_cast<sigc::slot4<T_return, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
      return ( *cb ) ( arg1, arg2, arg3, arg4 );
    }
    throw;
  }

  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
  inline
  T_return Environment::callback( void* theEnv ) {
    sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    T_arg2 arg2;
    T_arg3 arg3;
    T_arg4 arg4;
    T_arg5 arg5;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 5 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
      get_argument( theEnv, 1, arg1 );
      get_argument( theEnv, 2, arg2 );
      get_argument( theEnv, 3, arg3 );
      get_argument( theEnv, 4, arg4 );
      get_argument( theEnv, 5, arg5 );
      cb = static_cast<sigc::slot5<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
      return ( *cb ) ( arg1, arg2, arg3, arg4, arg5 );
    }
    throw;
  }

 template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
 inline
 T_return Environment::callback( void* theEnv ) {
   sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
   void * cbptr = get_function_context( theEnv );
   T_arg1 arg1;
   T_arg2 arg2;
   T_arg3 arg3;
   T_arg4 arg4;
   T_arg5 arg5;
   T_arg6 arg6;
   if ( cbptr ) {
     if ( get_arg_count( theEnv ) != 6 )
       throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
     get_argument( theEnv, 1, arg1 );
     get_argument( theEnv, 2, arg2 );
     get_argument( theEnv, 3, arg3 );
     get_argument( theEnv, 4, arg4 );
     get_argument( theEnv, 5, arg5 );
     get_argument( theEnv, 6, arg6 );
     cb = static_cast<sigc::slot6<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
     return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 );
   }
   throw;
 }

  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 >
  inline
  T_return Environment::callback( void* theEnv ) {
    sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    T_arg2 arg2;
    T_arg3 arg3;
    T_arg4 arg4;
    T_arg5 arg5;
    T_arg6 arg6;
    T_arg7 arg7;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 7 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
      get_argument( theEnv, 1, arg1 );
      get_argument( theEnv, 2, arg2 );
      get_argument( theEnv, 3, arg3 );
      get_argument( theEnv, 4, arg4 );
      get_argument( theEnv, 5, arg5 );
      get_argument( theEnv, 6, arg6 );
      get_argument( theEnv, 7, arg7 );
      cb = static_cast<sigc::slot7<T_return, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
      return ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 );
    }
    throw;
  }

  inline
  void* Environment::strcallback( void* theEnv ) {
    sigc::slot0<std::string>* cb;
    void * cbptr = get_function_context( theEnv );
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 0 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 0" );
      cb = static_cast<sigc::slot0<std::string>*>( cbptr );
      return add_symbol( ( ( *cb ) ( )).c_str() );
    }
    throw;
  }

  template < typename T_arg1 >
  inline
  void* Environment::strcallback( void* theEnv ) {
    sigc::slot1<std::string,T_arg1>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 1 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 1" );
      get_argument( theEnv, 1, arg1 );
      cb = static_cast<sigc::slot1<std::string,T_arg1>*>( cbptr );
      return add_symbol( ( ( *cb ) ( arg1 )).c_str() );
    }
    throw;
  }

  template < typename T_arg1, typename T_arg2 >
  inline
  void* Environment::strcallback( void* theEnv ) {
    sigc::slot2<std::string, T_arg1, T_arg2>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    T_arg2 arg2;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 2 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 2" );
      get_argument( theEnv, 1, arg1 );
      get_argument( theEnv, 2, arg2 );
      cb = static_cast<sigc::slot2<std::string, T_arg1, T_arg2>*>( cbptr );
      return add_symbol( ( ( *cb ) ( arg1, arg2 )).c_str() );
    }
    throw;
  }

  template < typename T_arg1, typename T_arg2, typename T_arg3 >
  inline
  void* Environment::strcallback( void* theEnv ) {
    sigc::slot3<std::string,T_arg1,T_arg2,T_arg3>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    T_arg2 arg2;
    T_arg3 arg3;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 3 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 3" );
      get_argument( theEnv, 1, arg1 );
      get_argument( theEnv, 2, arg2 );
      get_argument( theEnv, 3, arg3 );
      cb = static_cast<sigc::slot3<std::string, T_arg1, T_arg2,T_arg3>*>( cbptr );
      return add_symbol( ( ( *cb ) ( arg1, arg2, arg3 )).c_str() );
    }
    throw;
  }

  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
  inline
  void* Environment::strcallback( void* theEnv ) {
    sigc::slot4<std::string,T_arg1,T_arg2,T_arg3,T_arg4>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    T_arg2 arg2;
    T_arg3 arg3;
    T_arg4 arg4;
    std::string s;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 4 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 4" );
      get_argument( theEnv, 1, arg1 );
    std::cout << "Arg1: " << arg1 << std::endl;
      get_argument( theEnv, 2, arg2 );
    std::cout << "Arg2: " << arg2 << std::endl;
      get_argument( theEnv, 3, arg3 );
    std::cout << "Arg3: " << arg3 << std::endl;
      get_argument( theEnv, 4, arg4 );
    std::cout << "Arg4: " << arg4 << std::endl;
      cb = static_cast<sigc::slot4<std::string, T_arg1, T_arg2,T_arg3,T_arg4>*>( cbptr );
      s = ( *cb ) ( arg1, arg2, arg3, arg4 );
    std::cout << "Adding: " << s << std::endl;
      return add_symbol( s.c_str() );
    }
    throw;
  }

  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
  inline
  void* Environment::strcallback( void* theEnv ) {
    sigc::slot5<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    T_arg2 arg2;
    T_arg3 arg3;
    T_arg4 arg4;
    T_arg5 arg5;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 5 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 5" );
      get_argument( theEnv, 1, arg1 );
      get_argument( theEnv, 2, arg2 );
      get_argument( theEnv, 3, arg3 );
      get_argument( theEnv, 4, arg4 );
      get_argument( theEnv, 5, arg5 );
      cb = static_cast<sigc::slot5<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5>*>( cbptr );
      return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5 )).c_str() );
    }
    throw;
  }

  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
  inline
  void* Environment::strcallback( void* theEnv ) {
    sigc::slot6<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    T_arg2 arg2;
    T_arg3 arg3;
    T_arg4 arg4;
    T_arg5 arg5;
    T_arg6 arg6;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 6 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 6" );
      get_argument( theEnv, 1, arg1 );
      get_argument( theEnv, 2, arg2 );
      get_argument( theEnv, 3, arg3 );
      get_argument( theEnv, 4, arg4 );
      get_argument( theEnv, 5, arg5 );
      get_argument( theEnv, 6, arg6 );
      cb = static_cast<sigc::slot6<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>*>( cbptr );
      return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6 )).c_str() );
    }
    throw;
  }

  template < typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6, typename T_arg7 >
  inline
  void* Environment::strcallback( void* theEnv ) {
    sigc::slot7<std::string,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* cb;
    void * cbptr = get_function_context( theEnv );
    T_arg1 arg1;
    T_arg2 arg2;
    T_arg3 arg3;
    T_arg4 arg4;
    T_arg5 arg5;
    T_arg6 arg6;
    T_arg7 arg7;
    if ( cbptr ) {
      if ( get_arg_count( theEnv ) != 7 )
        throw std::logic_error( "clipsmm: wrong # args on slot callback; expected 7" );
      get_argument( theEnv, 1, arg1 );
      get_argument( theEnv, 2, arg2 );
      get_argument( theEnv, 3, arg3 );
      get_argument( theEnv, 4, arg4 );
      get_argument( theEnv, 5, arg5 );
      get_argument( theEnv, 6, arg6 );
      get_argument( theEnv, 7, arg7 );
      cb = static_cast<sigc::slot7<std::string, T_arg1, T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>*>( cbptr );
      return add_symbol( ( ( *cb ) ( arg1, arg2, arg3, arg4, arg5, arg6, arg7 )).c_str() );
    }
    throw;
  }

template < typename T_return >
  inline
  bool Environment::add_function( std::string name, const sigc::slot0<T_return>& slot) {
    char retcode = get_return_code<T_return>( );
    char argstring[ 10 ] = { '0', '0', 'u', 0x00 };
    sigc::slot0<T_return>* scb = new sigc::slot0<T_return>(slot);
    any holder = CLIPSPointer<sigc::slot0<T_return> >(scb);
    m_slots[name] = holder;
    return ( EnvDefineFunction2WithContext( m_cobj,
                                 const_cast<char*>( name.c_str() ),
                                 retcode,
                                 get_callback(slot),
                                 const_cast<char*>( name.c_str() ),
                                 argstring,
                                 ( void* ) scb ) );
  }

  template < typename T_return, typename T_arg1 >
  inline
  bool Environment::add_function( std::string name, const sigc::slot1<T_return, T_arg1>& slot) {
    char retcode = get_return_code<T_return>( );
    char argstring[ 10 ] = { '1', '1', 'u', 0x00 };
    argstring[ 3 ] = get_argument_code<T_arg1>( );
    sigc::slot1<T_return, T_arg1>* scb = new sigc::slot1<T_return, T_arg1>(slot);
    any holder = CLIPSPointer<sigc::slot1<T_return, T_arg1> >(scb);
    m_slots[name] = holder;
    return ( EnvDefineFunction2WithContext( m_cobj,
                                 const_cast<char*>( name.c_str() ),
                                 retcode,
                                 get_callback(slot),
                                 const_cast<char*>( name.c_str() ),
                                 argstring,
                                 scb ) );
  }

  template < typename T_return, typename T_arg1, typename T_arg2 >
  inline
  bool Environment::add_function( std::string name, const sigc::slot2<T_return, T_arg1, T_arg2>& slot) {
    char retcode = get_return_code<T_return>( );
    char argstring[ 10 ] = { '2', '2', 'u', 0x00 };
    argstring[ 3 ] = get_argument_code<T_arg1>( );
    argstring[ 4 ] = get_argument_code<T_arg2>( );
    sigc::slot2<T_return, T_arg1, T_arg2>* scb = new sigc::slot2<T_return, T_arg1, T_arg2>(slot);
    any holder = CLIPSPointer<sigc::slot2<T_return, T_arg1, T_arg2> >(scb);
    m_slots[name] = holder;
    return ( EnvDefineFunction2WithContext( m_cobj,
                                 const_cast<char*>( name.c_str() ),
                                 retcode,
                                 get_callback(slot),
                                 const_cast<char*>( name.c_str() ),
                                 argstring,
                                 scb ) );
  }

  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3 >
  inline
  bool Environment::add_function( std::string name, const sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>& slot) {
    char retcode = get_return_code<T_return>( );
    char argstring[ 10 ] = { '3', '3', 'u', 0x00 };
    argstring[ 3 ] = get_argument_code<T_arg1>( );
    argstring[ 4 ] = get_argument_code<T_arg2>( );
    argstring[ 5 ] = get_argument_code<T_arg3>( );
    sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>* scb =
        new sigc::slot3<T_return,T_arg1,T_arg2,T_arg3>(slot);
    any holder = CLIPSPointer<sigc::slot3<T_return,T_arg1,T_arg2,T_arg3> >(scb);
    m_slots[name] = holder;
    return ( EnvDefineFunction2WithContext( m_cobj,
                                 const_cast<char*>( name.c_str() ),
                                 retcode,
                                 get_callback(slot),
                                 const_cast<char*>( name.c_str() ),
                                 argstring,
                                 scb )
           );
  }

  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4 >
  inline
  bool Environment::add_function( std::string name, const sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>& slot) {
    char retcode = get_return_code<T_return>( );
    char argstring[ 10 ] = { '4', '4', 'u', 0x00 };
    argstring[ 3 ] = get_argument_code<T_arg1>( );
    argstring[ 4 ] = get_argument_code<T_arg2>( );
    argstring[ 5 ] = get_argument_code<T_arg3>( );
    argstring[ 6 ] = get_argument_code<T_arg4>( );
    sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>* scb =
        new sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4>(slot);
    any holder = CLIPSPointer<sigc::slot4<T_return,T_arg1,T_arg2,T_arg3,T_arg4> >(scb);
    m_slots[name] = holder;
    return ( EnvDefineFunction2WithContext( m_cobj,
                                 const_cast<char*>( name.c_str() ),
                                 retcode,
                                 get_callback(slot),
                                 const_cast<char*>( name.c_str() ),
                                 argstring,
                                 scb )
           );
  }

  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5 >
  inline
  bool Environment::add_function( std::string name,
                              const sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& slot) {
    char retcode = get_return_code<T_return>( );
    char argstring[ 10 ] = { '5', '5', 'u', 0x00 };
    argstring[ 3 ] = get_argument_code<T_arg1>( );
    argstring[ 4 ] = get_argument_code<T_arg2>( );
    argstring[ 5 ] = get_argument_code<T_arg3>( );
    argstring[ 6 ] = get_argument_code<T_arg4>( );
    argstring[ 7 ] = get_argument_code<T_arg5>( );
    sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>* scb =
        new sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>(slot);
    any holder = CLIPSPointer<sigc::slot5<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5> >(scb);
    m_slots[name] = holder;
    return ( EnvDefineFunction2WithContext( m_cobj,
                                 const_cast<char*>( name.c_str() ),
                                 retcode,
                                 get_callback(slot),
                                 const_cast<char*>( name.c_str() ),
                                 argstring,
                                 scb )
           );
  }

  template < typename T_return, typename T_arg1, typename T_arg2, typename T_arg3, typename T_arg4, typename T_arg5, typename T_arg6 >
  inline
  bool Environment::add_function( std::string name,
                              const sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& slot) {
    char retcode = get_return_code<T_return>( );
    char argstring[ 10 ] = { '6', '6', 'u', 0x00 };
    argstring[ 3 ] = get_argument_code<T_arg1>( );
    argstring[ 4 ] = get_argument_code<T_arg2>( );
    argstring[ 5 ] = get_argument_code<T_arg3>( );
    argstring[ 6 ] = get_argument_code<T_arg4>( );
    argstring[ 7 ] = get_argument_code<T_arg5>( );
    argstring[ 8 ] = get_argument_code<T_arg6>( );
    sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>* scb =
        new sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>(slot);
    any holder = CLIPSPointer<sigc::slot6<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6> >(scb);
    m_slots[name] = holder;
    return ( EnvDefineFunction2WithContext( m_cobj,
                                 const_cast<char*>( name.c_str() ),
                                 retcode,
                                 get_callback(slot),
                                 const_cast<char*>( name.c_str() ),
                                 argstring,
                                 scb )
           );
  }

  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 >
  inline
  bool Environment::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) {
    char retcode = get_return_code<T_return>( );
    char argstring[ 10 ] = { '7', '7', 'u', 0x00 };
    argstring[ 3 ] = get_argument_code<T_arg1>( );
    argstring[ 4 ] = get_argument_code<T_arg2>( );
    argstring[ 5 ] = get_argument_code<T_arg3>( );
    argstring[ 6 ] = get_argument_code<T_arg4>( );
    argstring[ 7 ] = get_argument_code<T_arg5>( );
    argstring[ 8 ] = get_argument_code<T_arg6>( );
    argstring[ 9 ] = get_argument_code<T_arg7>( );
    sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>* scb =
        new sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>(slot);
    any holder = CLIPSPointer<sigc::slot7<T_return,T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7> >(scb);
    m_slots[name] = holder;
    return ( EnvDefineFunction2WithContext( m_cobj,
                                 const_cast<char*>( name.c_str() ),
                                 retcode,
                                 get_callback(slot),
                                 const_cast<char*>( name.c_str() ),
                                 argstring,
                                 scb )
           );
  }


}



#endif