clips-sys 0.4.0

Bindgen generated wrapper for CLIPS (clipsrules.net)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

#pragma once

#include "clipscpp.h"
#include "CLIPSNET_Agenda.h"
#include "CLIPSNET_Exceptions.h"
#include "CLIPSNET_FactInstance.h"
#include "CLIPSNET_FocusStack.h"
#include "CLIPSNET_Module.h"
#include "CLIPSNET_Values.h"
#include "CLIPSNET_Router.h"
#include "CLIPSNET_ParserErrorCallback.h"
#include "CLIPSNET_PeriodicCallback.h"
#include "CLIPSNET_UserFunction.h"

using namespace System;
using namespace System::Collections;
using namespace CLIPS;

namespace CLIPSNET
  {
   ref class Router;
   ref class CaptureRouter;
   ref class Environment;

   //public delegate void PeriodicCallbackDelegate();
   //public delegate void ParserErrorCallbackDelegate();

   /*######################################*/
   /* DelegatePeriodicCallback declaration */
   /*######################################*/
   /*
   ref class DelegatePeriodicCallback : PeriodicCallback
     {
      public:
        DelegatePeriodicCallback();
        void Callback (void) override;

      event PeriodicCallbackDelegate ^ CallbackEvents;
     };
     */
   /*#########################################*/
   /* DelegateParserErrorCallback declaration */
   /*#########################################*/
   /*
   ref class DelegateParserErrorCallback : ParserErrorCallback
     {
      public:
        DelegateParserErrorCallback();
        void Callback (String ^,String ^,String ^,long) override;

      event ParserErrorCallbackDelegate ^ CallbackEvents;
     };
     */
  
   public ref class LoadParserErrorCallback : ParserErrorCallback
     {
      public:
        LoadParserErrorCallback(Environment ^);
        void LoadParserErrorCallback::Callback(String ^,String ^,String ^,long) override;

      private:
        Environment ^ env;
     };

   /*###################*/
   /* Environment class */
   /*###################*/

   public ref class Environment 
     {
      public:
        Environment();
        ~Environment();

        //event PeriodicCallbackDelegate ^ PeriodicCallbackEvent;
        //event ParserErrorCallbackDelegate ^ ParserErrorCallbackEvent;
        
        static String ^ CharStarToString(const char *);

        void Clear();
        void Load(String ^);
        void LoadFromString(String ^);
        void LoadFromResource(String ^,String ^);
        void Build(String ^);

        void Reset();
        long long Run();
        long long Run(long long);
        
        FactAddressValue ^ AssertString(String ^);
        InstanceAddressValue ^ MakeInstance(String ^);

        FactAddressValue ^ FindFact(String ^);
        FactAddressValue ^ FindFact(String ^,String ^,String ^);
        List<FactAddressValue ^> ^ FindAllFacts(String ^);
        List<FactAddressValue ^> ^ FindAllFacts(String ^,String ^,String ^);

        InstanceAddressValue ^ FindInstance(String ^);
        InstanceAddressValue ^ FindInstance(String ^,String ^,String ^);
        List<InstanceAddressValue ^> ^ FindAllInstances(String ^);
        List<InstanceAddressValue ^> ^ FindAllInstances(String ^,String ^,String ^);
        
        PrimitiveValue ^ Eval(String ^);
        
        void Watch(String ^);
        void Unwatch(String ^);
        bool GetWatchItem(String ^);
        void SetWatchItem(String ^,bool);
        
        void AddUserFunction(String ^,UserFunction ^);
        void AddUserFunction(String ^,String ^,unsigned short,unsigned short,String ^,UserFunction ^);
        void RemoveUserFunction(String ^);
        
        void AddRouter(Router ^);
        void DeleteRouter(Router ^);
        void ActivateRouter(Router ^);
        void DeactivateRouter(Router ^);
        void Write(String ^,String ^);
        void Write(String ^);
        void WriteLine(String ^,String ^);
        void WriteLine(String ^);
        
        void CommandLoop();

        void SetParserErrorCallback(ParserErrorCallback ^);
        
        void AddPeriodicCallback(String ^,int ,PeriodicCallback ^);

        bool GetHaltExecution();
        void SetHaltExecution(bool);
        void SetHaltCommandLoopBatch(bool);
        bool GetHaltRules();
        void SetHaltRules(bool);
        bool GetEvaluationError();
        void SetEvaluationError(bool);
        bool ChangeDirectory(String ^);
        void RemovePeriodicCallback(String ^);
        bool EnablePeriodicFunctions(bool);
        size_t InputBufferCount();
        String ^ GetInputBuffer();
        void SetInputBuffer(String ^);
        bool InputBufferContainsCommand();
        void AppendToDribble(String ^);
        void CommandLoopOnceThenBatch();
        void PrintBanner();
        void PrintPrompt();
        Dictionary<unsigned long long,BitArray ^> ^ GetFactScopes();
        List<FactInstance ^> ^ GetFactList();
        Dictionary<unsigned long long,BitArray ^> ^ GetInstanceScopes();
        List<FactInstance ^> ^ GetInstanceList();
		List<Module ^> ^ GetModuleList();
        FocusStack ^ GetFocusStack();
        Agenda ^ GetAgenda(String ^);
        Agenda ^ GetAgenda(Focus ^);
        bool GetAgendaChanged();
        void SetAgendaChanged(bool);
        bool GetFocusChanged();
        void SetFocusChanged(bool);
        bool GetFactListChanged();
        void SetFactListChanged(bool);
        bool GetInstancesChanged();
        void SetInstancesChanged(bool);
        virtual String^ ToString() override;
        void CallNextPrintRouter(Router ^,String ^,String ^);
        CaptureRouter ^ CaptureStart();
        void CaptureEnd(CaptureRouter ^,bool);
        InstanceAddressValue ^ FindInstanceByName(String ^);
        void AddError(String ^,long,String ^);

        static const String ^ FACTS = gcnew String("facts");
        static const String ^ RULES = gcnew String("rules");
        static const String ^ DEFFUNCTIONS = gcnew String("deffunctions");
        static const String ^ COMPILATIONS = gcnew String("compilations");
        static const String ^ INSTANCES = gcnew String("instances");
        static const String ^ SLOTS = gcnew String("slots");
        static const String ^ ACTIVATIONS = gcnew String("activations");
        static const String ^ STATISTICS = gcnew String("statistics");
        static const String ^ FOCUS = gcnew String("focus");
        static const String ^ GENERIC_FUNCTIONS = gcnew String("generic-functions");
        static const String ^ METHODS = gcnew String("methods");
        static const String ^ GLOBALS = gcnew String("globals");
        static const String ^ MESSAGES = gcnew String("messages");
        static const String ^ MESSAGE_HANDLERS = gcnew String("message-handlers");
        static const String ^ NONE = gcnew String("none");
        static const String ^ ALL = gcnew String("all");

      protected:
        !Environment();
        void CheckForErrors(String ^);
        void StringLoader(String ^);

      private:
        CLIPSCPPEnv *m_Env;
        LoadParserErrorCallback ^ errorCallback;
        List<CLIPSLineError ^> ^ errorList;
     };
  };