public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
// the first thing we do is set the values
DefaultReturnVector ret = new DefaultReturnVector();
if (params_Renamed.Length == inputParams.Length)
{
for (int idx = 0; idx < inputParams.Length; idx++)
{
BoundParam bp = (BoundParam)inputParams[idx];
bindings.Put(bp.VariableName, params_Renamed[idx].Value);
}
engine.pushScope(this);
for (int idx = 0; idx < functionParams.Length; idx++)
{
ret = (DefaultReturnVector)internalFunction[idx].executeFunction(engine, functionParams[idx]);
}
engine.popScope();
return(ret);
}
else
{
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, false);
ret.addReturnValue(rv);
DefaultReturnValue rv2 = new DefaultReturnValue(Constants.STRING_TYPE, "incorrect number of parameters");
ret.addReturnValue(rv2);
return(ret);
}
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
int count = 0;
if (params_Renamed != null && params_Renamed.Length == 1)
{
int fc = params_Renamed[0].IntValue;
try
{
count = engine.fire(fc);
}
catch (ExecuteException e)
{
Trace.WriteLine(e.Message);
}
}
else
{
count = engine.fire();
}
// engine.writeMessage(String.valueOf(count) + Constants.LINEBREAK,"t");
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.INTEGER_OBJECT, count);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool exec = false;
String mode = "normal";
DefaultReturnVector rv = new DefaultReturnVector();
if (params_Renamed != null && params_Renamed.Length == 1)
{
exec = true;
ValueParam vp = (ValueParam)params_Renamed[0];
if (vp.StringValue.Equals("true", StringComparison.InvariantCultureIgnoreCase))
{
engine.CurrentFocus.Lazy = true;
mode = "lazy";
}
else if (vp.StringValue.Equals("false", StringComparison.InvariantCultureIgnoreCase))
{
engine.CurrentFocus.Lazy = false;
}
}
DefaultReturnValue drv = new DefaultReturnValue(Constants.STRING_TYPE, mode);
rv.addReturnValue(drv);
return(rv);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool removed = true;
if (params_Renamed.Length == 1)
{
String template = params_Renamed[0].StringValue;
ITemplate t = engine.CurrentFocus.getTemplate(template);
if (!t.inUse())
{
engine.CurrentFocus.removeTemplate(t, engine, engine.WorkingMemory);
}
else
{
removed = false;
}
}
else
{
removed = false;
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, removed);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
DefaultReturnVector ret = new DefaultReturnVector();
int index = -1;
if (params_Renamed != null && params_Renamed.Length == 2)
{
Object first = params_Renamed[0].Value;
Object[] second = (Object[])params_Renamed[1].Value;
for (int idx = 0; idx < second.Length; idx++)
{
if (first.Equals(second[idx]))
{
index = idx;
break;
}
}
}
if (index > -1)
{
DefaultReturnValue rv = new DefaultReturnValue(Constants.INTEGER_OBJECT, index);
ret.addReturnValue(rv);
}
else
{
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, false);
ret.addReturnValue(rv);
}
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
IList fgroups = engine.FunctionGroups;
IEnumerator itr = fgroups.GetEnumerator();
int counter = 0;
while (itr.MoveNext())
{
// we iterate over the function groups and print out the
// functions in each group
IFunctionGroup fg = (IFunctionGroup)itr.Current;
engine.writeMessage("++++ " + fg.Name + " ++++" + Constants.LINEBREAK, "t");
IEnumerator listitr = fg.listFunctions().GetEnumerator();
while (listitr.MoveNext())
{
IFunction f = (IFunction)listitr.Current;
engine.writeMessage(" " + f.Name + Constants.LINEBREAK, "t");
counter++;
}
}
engine.writeMessage(counter + " functions" + Constants.LINEBREAK, "t");
DefaultReturnVector ret = new DefaultReturnVector();
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
if (params_Renamed != null && params_Renamed.Length > 0)
{
FileInfo dir = new FileInfo(params_Renamed[0].StringValue);
if (Directory.Exists(dir.FullName))
{
FileInfo[] files = dir.Directory.GetFiles();
for (int idx = 0; idx < files.Length; idx++)
{
if (Directory.Exists(files[idx].FullName))
{
engine.writeMessage("d " + files[idx] + Constants.LINEBREAK);
}
else
{
engine.writeMessage("- " + files[idx] + Constants.LINEBREAK);
}
}
engine.writeMessage(files.Length + " files in the directory" + Constants.LINEBREAK, "t");
}
else
{
}
}
DefaultReturnVector ret = new DefaultReturnVector();
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
DefaultReturnVector ret = new DefaultReturnVector();
int index = - 1;
if (params_Renamed != null && params_Renamed.Length == 2)
{
Object first = params_Renamed[0].Value;
Object[] second = (Object[]) params_Renamed[1].Value;
for (int idx = 0; idx < second.Length; idx++)
{
if (first.Equals(second[idx]))
{
index = idx;
break;
}
}
}
if (index > - 1)
{
DefaultReturnValue rv = new DefaultReturnValue(Constants.INTEGER_OBJECT, index);
ret.addReturnValue(rv);
}
else
{
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, false);
ret.addReturnValue(rv);
}
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool eval = false;
if (params_Renamed.Length == 2)
{
Object param1 = null;
if (params_Renamed[0] is BoundParam && params_Renamed[1] is BoundParam)
{
param1 = ((BoundParam) params_Renamed[0]).ObjectRef;
try
{
Type clazz = classnameResolver.resolveClass(((BoundParam) params_Renamed[1]).StringValue);
eval = clazz.IsInstanceOfType(param1);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, eval);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool removed = true;
if (params_Renamed.Length == 1)
{
String rl = params_Renamed[0].StringValue;
Defrule defrl = (Defrule)engine.CurrentFocus.findRule(rl);
if (defrl != null)
{
engine.CurrentFocus.removeRule(defrl, engine, engine.WorkingMemory);
}
else
{
removed = false;
}
}
else
{
removed = false;
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, removed);
ret.addReturnValue(rv);
return(ret);
}
/* (non-Javadoc)
* @see woolfel.engine.rete.Function#executeFunction(woolfel.engine.Creshendo.Util.Rete.Rete, woolfel.engine.rete.Parameter[])
*/
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Object rtn = null;
DefaultReturnVector drv = new DefaultReturnVector();
if (engine != null && params_Renamed != null && params_Renamed.Length == 3)
{
BoundParam bp = (BoundParam)params_Renamed[0];
StringParam slot = (StringParam)params_Renamed[1];
ValueParam val = (ValueParam)params_Renamed[2];
Object instance = bp.ObjectRef;
Defclass dc = engine.findDefclass(instance);
// we check to make sure the Defclass exists
if (dc != null)
{
MethodInfo getm = dc.getWriteMethod(slot.StringValue);
try
{
rtn = getm.Invoke(instance, (Object[])new Object[] { val });
int rtype = getMethodReturnType(getm);
DefaultReturnValue rvalue = new DefaultReturnValue(rtype, rtn);
drv.addReturnValue(rvalue);
}
catch (UnauthorizedAccessException e)
{
// TODO we should handle error, for now not implemented
}
catch (TargetInvocationException e)
{
// TODO we should handle error, for now not implemented
}
}
}
return(drv);
}
/// <summary>
/// method does the actual work of creating a CLIPSParser and parsing
/// the file.
/// </summary>
/// <param name="engine">The engine.</param>
/// <param name="ins">The ins.</param>
/// <param name="rv">The rv.</param>
public virtual void parse(Rete engine, Stream ins, DefaultReturnVector rv)
{
try
{
CLIPSParser parser = new CLIPSParser(engine, ins);
Object expr = null;
while ((expr = parser.basicExpr()) != null)
{
if (expr is Defrule)
{
Defrule rl = (Defrule)expr;
engine.RuleCompiler.addRule(rl);
}
else if (expr is Deftemplate)
{
Deftemplate dft = (Deftemplate)expr;
engine.CurrentFocus.addTemplate(dft, engine, engine.WorkingMemory);
}
else if (expr is IFunction)
{
IFunction fnc = (IFunction)expr;
fnc.executeFunction(engine, null);
}
}
if (rv != null)
{
rv.addReturnValue(new DefaultReturnValue(Constants.BOOLEAN_OBJECT, true));
}
}
catch (ParseException e)
{
engine.writeMessage(e.Message + Constants.LINEBREAK, Constants.DEFAULT_OUTPUT);
}
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
DefaultReturnVector ret = new DefaultReturnVector();
engine.writeMessage(Constants.VERSION + Constants.LINEBREAK, Constants.DEFAULT_OUTPUT);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool load = false;
if (params_Renamed != null && params_Renamed.Length > 0)
{
for (int idx = 0; idx < params_Renamed.Length; idx++)
{
String func = params_Renamed[idx].StringValue;
try
{
engine.declareFunction(func);
load = true;
}
catch (Exception e)
{
load = false;
}
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, load);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Decimal bdval = new Decimal(0);
if (params_Renamed.Length == 1)
{
if (params_Renamed[0] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[0];
bdval = n.BigDecimalValue;
}
else if (params_Renamed[0] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[0];
bdval = (Decimal)engine.getBinding(bp.VariableName);
}
else if (params_Renamed[0] is FunctionParam2)
{
FunctionParam2 n = (FunctionParam2)params_Renamed[0];
n.Engine = engine;
n.lookUpFunction();
IReturnVector rval = (IReturnVector)n.Value;
bdval = rval.firstReturnValue().BigDecimalValue;
}
double bdh = System.Math.Log(Decimal.ToDouble(bdval)); //.pow(Math.E, bdval.doubleValue());
bdval = new Decimal(bdh);
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BIG_DECIMAL, bdval);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, true);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
String asrt = "";
if (params_Renamed.Length >= 1 && params_Renamed[0].Value != null)
{
Object obj = params_Renamed[0].Value;
String template = "";
if (params_Renamed.Length == 2 && params_Renamed[1].StringValue != null)
{
template = params_Renamed[1].StringValue;
}
try
{
engine.assertObject(obj, template, false, true);
asrt = "true";
}
catch (AssertException e)
{
// we should log this and output an error
asrt = "false";
}
}
else
{
asrt = "false";
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.STRING_TYPE, asrt);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool eval = false;
if (params_Renamed.Length == 2)
{
Object param1 = null;
if (params_Renamed[0] is BoundParam && params_Renamed[1] is BoundParam)
{
param1 = ((BoundParam)params_Renamed[0]).ObjectRef;
try
{
Type clazz = classnameResolver.resolveClass(((BoundParam)params_Renamed[1]).StringValue);
eval = clazz.IsInstanceOfType(param1);
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, eval);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool boolVal = true;
if (params_Renamed != null)
{
if (params_Renamed.Length == 1)
{
if (params_Renamed[0] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[0];
boolVal = n.BooleanValue;
}
else if (params_Renamed[0] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[0];
boolVal = ((Boolean)engine.getBinding(bp.VariableName));
}
else if (params_Renamed[0] is FunctionParam2)
{
FunctionParam2 n = (FunctionParam2)params_Renamed[0];
n.Engine = engine;
n.lookUpFunction();
IReturnVector rval = (IReturnVector)n.Value;
boolVal = rval.firstReturnValue().BooleanValue;
}
boolVal = (boolVal == false);
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, boolVal);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
DefaultReturnVector ret = new DefaultReturnVector();
bool add = false;
if (engine.findFunction(name) == null)
{
// first we Get the actual function from the shell function
IFunction[] functions = new IFunction[this.functions.Count];
IParameter[][] parameters = new IParameter[this.functions.Count][];
for (int i = 0; i < functions.Length; ++i)
{
ShellFunction sf = (ShellFunction)this.functions[i];
functions[i] = engine.findFunction(sf.Name);
parameters[i] = sf.Parameters;
}
InterpretedFunction intrfunc = new InterpretedFunction(name, this.parameters, functions, parameters);
intrfunc.configureFunction(engine);
engine.declareFunction(intrfunc);
add = true;
}
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, add);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool bound = false;
if (params_Renamed.Length == 2)
{
String name = params_Renamed[0].StringValue;
Object val = null;
if (params_Renamed[1] is ValueParam)
{
val = params_Renamed[1].Value;
}
else if (params_Renamed[1] is FunctionParam2)
{
FunctionParam2 fp2 = (FunctionParam2)params_Renamed[1];
fp2.Engine = engine;
fp2.lookUpFunction();
DefaultReturnVector drv = (DefaultReturnVector)fp2.Value;
val = drv.firstReturnValue().Value;
}
engine.setBindingValue(name, val);
bound = true;
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, bound);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
double dval = _random.NextDouble();
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.DOUBLE_PRIM_TYPE, dval);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Process rt = Process.GetCurrentProcess();
long total = GC.GetTotalMemory(false);
engine.writeMessage("Total memory " + (total/1024).ToString() + "Kb | " + (total/1024/1024).ToString() + "Mb" + Constants.LINEBREAK, "t");
DefaultReturnVector ret = new DefaultReturnVector();
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, true);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
String asrt = "";
if (params_Renamed.Length > 0)
{
Deffact fact = null;
if (params_Renamed[0].Value is Deffact)
{
fact = (Deffact)params_Renamed[0].Value;
}
else
{
Deftemplate tmpl = (Deftemplate)engine.CurrentFocus.getTemplate(params_Renamed[0].StringValue);
if (tmpl == null)
{
throw new AssertException("Deftemplate named " + params_Renamed[0].StringValue + " was not found.");
}
fact = (Deffact)tmpl.createFact((Object[])params_Renamed[1].Value, -1);
}
if (fact.hasBinding())
{
fact.resolveValues(engine, triggerFacts);
fact = fact.cloneFact();
}
try
{
engine.assertFact(fact);
// if the fact id is still -1, it means it wasn't asserted
// if it was asserted, we return the fact id, otherwise
// we return "false".
if (fact.FactId > 0)
{
asrt = fact.FactId.ToString();
}
else
{
asrt = "false";
}
}
catch (AssertException e)
{
// we should log this and output an error
asrt = "false";
}
}
else
{
asrt = "false";
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.STRING_TYPE, asrt);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
double dval = _random.NextDouble();
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.DOUBLE_PRIM_TYPE, dval);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Process rt = Process.GetCurrentProcess();
GC.Collect();
DefaultReturnVector ret = new DefaultReturnVector();
return(ret);
}
/// <summary> The method expects an array of ShellBoundParam. The method will use
/// StringBuffer to resolve the binding and print out 1 binding per
/// line.
/// </summary>
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
//Decimal time = new Decimal((DateTime.Now.Ticks - 621355968000000000)/10000);
Decimal time = new Decimal(DateTime.Now.Ticks);
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BIG_DECIMAL, time);
ret.addReturnValue(rv);
return ret;
}
/// <summary> The method expects an array of ShellBoundParam. The method will use
/// StringBuffer to resolve the binding and print out 1 binding per
/// line.
/// </summary>
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
//Decimal time = new Decimal((DateTime.Now.Ticks - 621355968000000000)/10000);
Decimal time = new Decimal(DateTime.Now.Ticks);
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BIG_DECIMAL, time);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Decimal bdval = new Decimal(0);
if (params_Renamed != null)
{
if (params_Renamed[0] is ValueParam)
{
bdval = params_Renamed[0].BigDecimalValue;
}
else if (params_Renamed[0] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[0];
bdval = (Decimal)engine.getBinding(bp.VariableName);
}
else if (params_Renamed[0] is FunctionParam2)
{
FunctionParam2 n = (FunctionParam2)params_Renamed[0];
n.Engine = engine;
n.lookUpFunction();
IReturnVector rval = (IReturnVector)n.Value;
bdval = rval.firstReturnValue().BigDecimalValue;
}
for (int idx = 1; idx < params_Renamed.Length; idx++)
{
if (params_Renamed[idx] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[idx];
Decimal bd = n.BigDecimalValue;
bdval = Decimal.Multiply(bdval, bd);
}
else if (params_Renamed[idx] is FunctionParam2)
{
FunctionParam2 n = (FunctionParam2)params_Renamed[idx];
n.Engine = engine;
n.lookUpFunction();
IReturnVector rval = (IReturnVector)n.Value;
Decimal bd = rval.firstReturnValue().BigDecimalValue;
if (idx == 0)
{
bdval = bd;
}
else
{
bdval = Decimal.Multiply(bdval, bd);
}
}
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BIG_DECIMAL, bdval);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
engine.writeMessage("fire ET=" + ProfileStats.fireTime + " ms" + Constants.LINEBREAK, "t");
engine.writeMessage("assert ET=" + ProfileStats.assertTime + " ms" + Constants.LINEBREAK, "t");
engine.writeMessage("retract ET=" + ProfileStats.retractTime + " ms" + Constants.LINEBREAK, "t");
engine.writeMessage("Add Activation ET=" + ProfileStats.addActivation + " ms" + Constants.LINEBREAK, "t");
engine.writeMessage("Remove Activation ET=" + ProfileStats.rmActivation + " ms" + Constants.LINEBREAK, "t");
engine.writeMessage("Activation added=" + ProfileStats.addcount + Constants.LINEBREAK, "t");
engine.writeMessage("Activation removed=" + ProfileStats.rmcount + Constants.LINEBREAK, "t");
DefaultReturnVector ret = new DefaultReturnVector();
return ret;
}
/// <summary> TODO - I need to finish this, so it can print out a node
/// in a pretty format
/// </summary>
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
if (params_Renamed != null && params_Renamed.Length > 0)
{
for (int idx = 0; idx < params_Renamed.Length; idx++)
{
}
}
DefaultReturnVector rv = new DefaultReturnVector();
return(rv);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
String focus = null;
if (params_Renamed.Length == 0)
{
focus = engine.CurrentFocus.ModuleName;
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.STRING_TYPE, focus);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool sp = true;
if (params_Renamed != null && params_Renamed.Length >= 2)
{
String val = params_Renamed[0].StringValue;
if (val.Equals("off"))
{
// turn off spooling
String name = params_Renamed[1].StringValue;
TextWriter writer = engine.removePrintWriter(name);
if (writer != null)
{
writer.Flush();
writer.Close();
}
}
else
{
// turn on spooling
// we expected a file name
String spname = params_Renamed[0].StringValue;
String fname = params_Renamed[1].StringValue;
try
{
FileInfo nfile = new FileInfo(fname);
nfile.Create();
FileStream fos = new FileStream(nfile.FullName, FileMode.Create);
StreamWriter writer = new StreamWriter(fos);
engine.addPrintWriter(spname, writer);
}
catch (FileNotFoundException e)
{
// we should report it
sp = false;
}
catch (IOException e)
{
sp = false;
}
}
}
else
{
sp = false;
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, sp);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Process rt = Process.GetCurrentProcess();
long free = GC.GetTotalMemory(false);
long total = GC.GetTotalMemory(false);
long used = total - free;
used = used/1024/1024;
total = total/1024;
long mbtotal = total/1024;
engine.writeMessage(used.ToString() + "Mb used of " + mbtotal.ToString() + "Mb " + Constants.LINEBREAK, "t");
DefaultReturnVector ret = new DefaultReturnVector();
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
String txt = null;
if (params_Renamed != null && params_Renamed.Length == 1)
{
txt = params_Renamed[0].StringValue;
txt = txt.Trim();
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.STRING_TYPE, txt);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
int len = 0;
if (params_Renamed != null && params_Renamed.Length == 1)
{
String txt = params_Renamed[0].StringValue;
len = txt.Length;
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.INTEGER_OBJECT, len);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
engine.writeMessage("fire ET=" + ProfileStats.fireTime + " ms" + Constants.LINEBREAK, "t");
engine.writeMessage("assert ET=" + ProfileStats.assertTime + " ms" + Constants.LINEBREAK, "t");
engine.writeMessage("retract ET=" + ProfileStats.retractTime + " ms" + Constants.LINEBREAK, "t");
engine.writeMessage("Add Activation ET=" + ProfileStats.addActivation + " ms" + Constants.LINEBREAK, "t");
engine.writeMessage("Remove Activation ET=" + ProfileStats.rmActivation + " ms" + Constants.LINEBREAK, "t");
engine.writeMessage("Activation added=" + ProfileStats.addcount + Constants.LINEBREAK, "t");
engine.writeMessage("Activation removed=" + ProfileStats.rmcount + Constants.LINEBREAK, "t");
DefaultReturnVector ret = new DefaultReturnVector();
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
if (params_Renamed != null && params_Renamed.Length > 0)
{
for (int idx = 0; idx < params_Renamed.Length; idx++)
{
IRule rls = engine.CurrentFocus.findRule(params_Renamed[idx].StringValue);
engine.writeMessage(rls.toPPString(), "t");
}
}
DefaultReturnVector rv = new DefaultReturnVector();
return rv;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
int eq = - 1;
if (params_Renamed != null && params_Renamed.Length == 2)
{
String val = params_Renamed[0].StringValue;
String val2 = params_Renamed[1].StringValue;
eq = val.CompareTo(val2);
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.INTEGER_OBJECT, eq);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Process rt = Process.GetCurrentProcess();
long free = GC.GetTotalMemory(false);
long total = GC.GetTotalMemory(false);
double percentfree = ((double) free/(double) total)*100;
free = free/1024;
total = total/1024;
long mbtotal = total/1024;
String freestr = percentfree.ToString().Substring(0, (4) - (0));
engine.writeMessage(free.ToString() + "Kb - " + freestr + "% free of " + mbtotal.ToString() + "Mb / " + total.ToString() + "Kb " + Constants.LINEBREAK, "t");
DefaultReturnVector ret = new DefaultReturnVector();
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
if (params_Renamed != null && params_Renamed.Length > 0)
{
for (int idx = 0; idx < params_Renamed.Length; idx++)
{
IRule rls = engine.CurrentFocus.findRule(params_Renamed[idx].StringValue);
engine.writeMessage(rls.toPPString(), "t");
}
}
DefaultReturnVector rv = new DefaultReturnVector();
return(rv);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
IList modules = (IList) engine.WorkingMemory.Modules;
int count = modules.Count;
IEnumerator itr = modules.GetEnumerator();
while (itr.MoveNext())
{
IModule r = (IModule) itr.Current;
engine.writeMessage(r.ModuleName + Constants.LINEBREAK, "t");
}
engine.writeMessage("for a total of " + count + Constants.LINEBREAK, "t");
DefaultReturnVector rv = new DefaultReturnVector();
return rv;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
DefaultReturnVector rv = new DefaultReturnVector();
if (params_Renamed != null && params_Renamed.Length >= 1)
{
for (int idx = 0; idx < params_Renamed.Length; idx++)
{
if (params_Renamed[idx] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[idx];
Deffact fact = (Deffact)bp.Fact;
try
{
if (bp.ObjectBinding)
{
engine.retractObject(fact.ObjectInstance);
}
else
{
engine.retractFact(fact);
}
DefaultReturnValue rval = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, true);
rv.addReturnValue(rval);
}
catch (RetractException e)
{
DefaultReturnValue rval = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, false);
rv.addReturnValue(rval);
}
}
else if (params_Renamed[idx] is ValueParam)
{
Decimal bi = params_Renamed[idx].BigDecimalValue;
try
{
engine.retractById(Decimal.ToInt64(bi));
DefaultReturnValue rval = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, true);
rv.addReturnValue(rval);
}
catch (RetractException e)
{
DefaultReturnValue rval = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, false);
rv.addReturnValue(rval);
}
}
}
}
return(rv);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
IList modules = (IList) engine.WorkingMemory.Modules;
int count = modules.Count;
IEnumerator itr = modules.GetEnumerator();
while (itr.MoveNext())
{
IModule r = (IModule) itr.Current;
engine.writeMessage(r.ModuleName + Constants.LINEBREAK, "t");
}
engine.writeMessage("for a total of " + count + Constants.LINEBREAK, "t");
DefaultReturnVector rv = new DefaultReturnVector();
return rv;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
int index = - 1;
if (params_Renamed != null && params_Renamed.Length == 2)
{
String val = params_Renamed[0].StringValue;
String pt = params_Renamed[1].StringValue;
index = val.IndexOf(pt);
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.INTEGER_OBJECT, index);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
DefaultReturnVector rv = new DefaultReturnVector();
if (params_Renamed != null && params_Renamed.Length >= 1)
{
for (int idx = 0; idx < params_Renamed.Length; idx++)
{
if (params_Renamed[idx] is BoundParam)
{
BoundParam bp = (BoundParam) params_Renamed[idx];
Deffact fact = (Deffact) bp.Fact;
try
{
if (bp.ObjectBinding)
{
engine.retractObject(fact.ObjectInstance);
}
else
{
engine.retractFact(fact);
}
DefaultReturnValue rval = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, true);
rv.addReturnValue(rval);
}
catch (RetractException e)
{
DefaultReturnValue rval = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, false);
rv.addReturnValue(rval);
}
}
else if (params_Renamed[idx] is ValueParam)
{
Decimal bi = params_Renamed[idx].BigDecimalValue;
try
{
engine.retractById(Decimal.ToInt64(bi));
DefaultReturnValue rval = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, true);
rv.addReturnValue(rval);
}
catch (RetractException e)
{
DefaultReturnValue rval = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, false);
rv.addReturnValue(rval);
}
}
}
}
return rv;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
String sub = null;
if (params_Renamed != null && params_Renamed.Length == 3)
{
int begin = params_Renamed[0].IntValue;
int end = params_Renamed[1].IntValue;
String txt = params_Renamed[2].StringValue;
sub = txt.Substring(begin, (end) - (begin));
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.STRING_TYPE, sub);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Decimal bdval = 0;
double bdh = 0.0;
if (params_Renamed.Length == 1)
{
bdval = (Decimal) params_Renamed[0].getValue(engine, Constants.BIG_DECIMAL);
bdh = System.Math.Sqrt(Decimal.ToDouble(bdval));
bdval = new Decimal(bdh);
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BIG_DECIMAL, bdval);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool eval = false;
Decimal left;
Decimal right;
if (params_Renamed != null)
{
left = params_Renamed[0].BigDecimalValue;
right = (Decimal) params_Renamed[1].getValue(engine, Constants.BIG_DECIMAL);
eval = (Decimal.ToDouble(left) <= Decimal.ToDouble(right));
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, eval);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
double dval = 0;
if (params_Renamed != null)
{
if (params_Renamed.Length == 1)
{
dval = Decimal.ToDouble(((Decimal) params_Renamed[0].getValue(engine, Constants.BIG_DECIMAL)));
dval = System.Math.Asin(dval);
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.DOUBLE_PRIM_TYPE, dval);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Decimal bdval = new Decimal(0);
if (params_Renamed != null)
{
for (int idx = 0; idx < params_Renamed.Length; idx++)
{
Decimal bd = (Decimal) params_Renamed[idx].getValue(engine, Constants.BIG_DECIMAL);
bdval = Decimal.Add(bdval, bd);
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BIG_DECIMAL, bdval);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Decimal bdval = 0;
if (params_Renamed != null)
{
bdval = (Decimal) params_Renamed[0].getValue(engine, Constants.BIG_DECIMAL);
for (int idx = 1; idx < params_Renamed.Length; idx++)
{
Decimal bd = (Decimal) params_Renamed[idx].getValue(engine, Constants.BIG_DECIMAL);
bdval = secureDivide(bdval, bd);
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.DOUBLE_PRIM_TYPE, bdval);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool load = false;
if (params_Renamed != null && params_Renamed.Length > 0)
{
for (int idx = 0; idx < params_Renamed.Length; idx++)
{
String func = params_Renamed[idx].StringValue;
engine.declareFunctionGroup(func);
load = true;
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, load);
ret.addReturnValue(rv);
return ret;
}
/// <summary> method will attempt to load one or more files. If batch is called without
/// any parameters, the function does nothing and just returns.
/// </summary>
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
DefaultReturnVector rv = new DefaultReturnVector();
if (params_Renamed != null && params_Renamed.Length > 0)
{
for (int idx = 0; idx < params_Renamed.Length; idx++)
{
try
{
String input = params_Renamed[idx].StringValue;
Stream inStream;
// Check for a protocol indicator at the beginning of the
// String. If we have one use a URL.
if (Regex.IsMatch(input, "^[a-zA-Z]+://.*"))
{
Uri url = new Uri(input);
inStream = ((HttpWebRequest) WebRequest.Create(url)).GetResponse().GetResponseStream();
// Otherwise treat it as normal file on the Filesystem
}
else
{
inStream = new FileStream(new FileInfo(input).FullName, FileMode.Open, FileAccess.Read);
}
parse(engine, inStream, rv);
inStream.Close();
if (inStream is IDisposable)
{
inStream.Dispose();
}
}
catch (FileNotFoundException e)
{
// we should report the error
rv.addReturnValue(new DefaultReturnValue(Constants.BOOLEAN_OBJECT, false));
engine.writeMessage(e.Message + Constants.LINEBREAK, Constants.DEFAULT_OUTPUT);
}
catch (IOException e)
{
rv.addReturnValue(new DefaultReturnValue(Constants.BOOLEAN_OBJECT, false));
engine.writeMessage(e.Message + Constants.LINEBREAK, Constants.DEFAULT_OUTPUT);
}
}
}
return rv;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
String retstr = null;
if (params_Renamed != null && params_Renamed.Length == 3)
{
String txt = params_Renamed[0].StringValue;
String regx = params_Renamed[1].StringValue;
String repl = params_Renamed[2].StringValue;
//retstr = txt.replaceFirst(regx, repl);
// TODO
retstr = txt.Replace(regx, repl);
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.STRING_TYPE, retstr);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool add = true;
if (params_Renamed.Length == 1)
{
engine.addModule(params_Renamed[0].StringValue);
engine.writeMessage("true", Constants.DEFAULT_OUTPUT);
}
else
{
add = false;
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, add);
ret.addReturnValue(rv);
DefaultReturnValue rv2 = new DefaultReturnValue(Constants.STRING_TYPE, params_Renamed[0].StringValue);
ret.addReturnValue(rv2);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
DefaultReturnVector ret = new DefaultReturnVector();
bool eq = false;
if (params_Renamed != null && params_Renamed.Length > 1)
{
Object constant = params_Renamed[0].getValue(engine, Constants.OBJECT_TYPE);
for (int idx = 1; idx < params_Renamed.Length; idx++)
{
if (constant.Equals(params_Renamed[idx].getValue(engine, Constants.OBJECT_TYPE)))
{
eq = true;
break;
}
}
}
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, eq);
ret.addReturnValue(rv);
return ret;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
bool saved = false;
bool sortid = true;
DefaultReturnVector rv = new DefaultReturnVector();
if (params_Renamed != null && params_Renamed.Length >= 1)
{
if (params_Renamed[1] != null && params_Renamed[1].StringValue.Equals("template"))
{
sortid = false;
}
try
{
StreamWriter writer = new StreamWriter(params_Renamed[0].StringValue);
System.Collections.Generic.IList<Object> facts = engine.AllFacts;
Object[] sorted = null;
if (sortid)
{
sorted = FactUtils.sortFacts(facts);
}
else
{
sorted = FactUtils.sortFactsByTemplate(facts);
}
for (int idx = 0; idx < sorted.Length; idx++)
{
Deffact ft = (Deffact) sorted[idx];
writer.Write(ft.toPPString() + Constants.LINEBREAK);
}
writer.Close();
saved = true;
}
catch (IOException e)
{
// we should log this
}
}
DefaultReturnValue drv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, saved);
rv.addReturnValue(drv);
return rv;
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
DefaultReturnVector ret = new DefaultReturnVector();
if (params_Renamed != null && params_Renamed.Length == 1)
{
if (params_Renamed[0].StringValue.Equals("objects"))
{
engine.clearObjects();
}
else if (params_Renamed[0].StringValue.Equals("deffacts"))
{
engine.clearFacts();
}
}
else
{
engine.clearAll();
}
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, true);
ret.addReturnValue(rv);
return ret;
}
