public virtual void resolveTemplates(Rete.Rete engine)
{
ICondition[] cnds = Conditions;
for (int idx = 0; idx < cnds.Length; idx++)
{
ICondition cnd = cnds[idx];
if (cnd is ObjectCondition)
{
ObjectCondition oc = (ObjectCondition)cnd;
Deftemplate dft = (Deftemplate)engine.findTemplate(oc.TemplateName);
if (dft != null)
{
oc.Deftemplate = dft;
}
}
else if (cnd is ExistCondition)
{
ExistCondition exc = (ExistCondition)cnd;
Deftemplate dft = (Deftemplate)engine.findTemplate(exc.TemplateName);
if (dft != null)
{
exc.Deftemplate = dft;
}
}
else if (cnd is TemporalCondition)
{
TemporalCondition tempc = (TemporalCondition)cnd;
Deftemplate dft = (Deftemplate)engine.findTemplate(tempc.TemplateName);
if (dft != null)
{
tempc.Deftemplate = dft;
}
}
}
}
public static IList <Object> generateFacts(IRule rule, Rete.Rete engine)
{
List <Object> facts = new List <Object>();
if (rule != null)
{
ICondition[] conditions = rule.Conditions;
for (int idx = 0; idx < conditions.Length; idx++)
{
ICondition c = conditions[idx];
if (c is ObjectCondition)
{
ObjectCondition oc = (ObjectCondition)c;
Deftemplate tpl = (Deftemplate)engine.findTemplate(oc.TemplateName);
if (tpl.ClassName != null)
{
Object data = generateJavaFacts(oc, tpl, engine);
facts.Add(data);
}
else
{
IFact data = generateDeffact(oc, tpl, engine);
facts.Add(data);
}
}
else if (c is TestCondition)
{
}
}
}
return(facts);
}
/* (non-Javadoc)
* @see woolfel.engine.rule.Action#executeAction(woolfel.engine.Creshendo.Util.Rete.Rete, woolfel.engine.rete.Fact[])
*/
public virtual void executeAction(Rete.Rete engine, IFact[] facts)
{
// first we iterate over the parameters and pass the facts
// to the BoundParams.
for (int idx = 0; idx < parameters.Length; idx++)
{
if (parameters[idx] is BoundParam)
{
((BoundParam)parameters[idx]).Facts = facts;
}
else if (parameters[idx] is FunctionParam)
{
((FunctionParam)parameters[idx]).Facts = facts;
}
else if (parameters[idx] is FunctionParam2)
{
((FunctionParam2)parameters[idx]).Engine = engine;
}
}
// we treat AssertFunction a little different
if (faction is AssertFunction)
{
((AssertFunction)faction).TriggerFacts = facts;
}
else if (faction is ModifyFunction)
{
((ModifyFunction)faction).TriggerFacts = facts;
}
// now we find the function
faction.executeFunction(engine, parameters);
}
/// <summary>
/// </summary>
/// <param name="">cond
/// </param>
/// <param name="">templ
/// </param>
/// <param name="">engine
/// </param>
/// <returns>
///
/// </returns>
public static IFact generateDeffact(ObjectCondition cond, Deftemplate templ, Rete.Rete engine)
{
List <object> list = new List <Object>();
IConstraint[] cnstr = cond.Constraints;
for (int idx = 0; idx < cnstr.Length; idx++)
{
IConstraint cn = cnstr[idx];
if (cn is LiteralConstraint)
{
Slot s = new Slot(cn.Name, cn.Value);
list.Add(s);
}
else if (cn is PredicateConstraint)
{
PredicateConstraint pc = (PredicateConstraint)cn;
Object val = generatePredicateValue(pc);
Slot s = new Slot(cn.Name, val);
list.Add(s);
}
else if (cn is BoundConstraint)
{
// for now we do the simple thing and just set
// any bound slots to 1
Slot s = new Slot(cn.Name, 1);
list.Add(s);
}
}
IFact f = templ.createFact(list, engine.nextFactId());
return(f);
}
public virtual bool executeFunction(Rete.Rete engine, IParameter[] params_Renamed)
{
IReturnVector rv = func.executeFunction(engine, params_Renamed);
// we return the first ReturnValue
return(rv.firstReturnValue().BooleanValue);
}
/// <summary>
/// The constructor for a message router.
/// </summary>
/// <param name="engine">The engine.</param>
public MessageRouter(Rete.Rete engine)
{
InitBlock();
this.engine = engine;
interpreter = new CLIPSInterpreter(engine);
commandThread = new CommandThread(this);
commandThread.Start();
}
/// <summary>
/// The constructor for a message router.
/// </summary>
/// <param name="engine">The engine.</param>
public MessageRouter(Rete.Rete engine)
{
InitBlock();
this.engine = engine;
interpreter = new CLIPSInterpreter(engine);
commandThread = new CommandThread(this);
commandThread.Start();
}
public static String parseModuleName(IRule rule, Rete.Rete engine)
{
if (rule.Name.IndexOf("::") > 0)
{
String text = rule.Name;
String[] sp = text.Split("::".ToCharArray());
return(sp[0].ToUpper());
}
return(null);
}
public CLIPSParser(Rete.Rete eng, TextReader stream)
{
mcc_input_stream = new SimpleCharStream(stream, 1, 1);
token_source = new CLIPSParserTokenManager(mcc_input_stream);
token = new Token();
mcc_ntk = -1;
mcc_gen = 0;
for (int i = 0; i < 63; i++) mcc_la1[i] = -1;
for (int i = 0; i < mcc_2_rtns.Length; i++) mcc_2_rtns[i] = new MccCalls();
engine = eng;
}
/// <summary>
/// Evaluates a command given in any language that is supported by this
/// LanguageAdapter.
/// </summary>
/// <param name="engine">The engine.</param>
/// <param name="command">The command.</param>
/// <param name="language">The language.</param>
/// <returns>
/// The result returned from the Rete-engine in the given
/// language.
/// @throws ParseException
/// </returns>
public virtual String Evaluate(Rete.Rete engine, String command, String language)
{
StringReader reader = new StringReader(command);
StringWriter writer = new StringWriter();
//// CLIPSParser parser = new CLIPSParser(engine, reader, writer, false);
// parser.startParser();
// String res = writer.toString();
// parser = null;
return(null);
}
/// <summary> Configure will lookup the function and set it
/// </summary>
public virtual void configure(Rete.Rete engine, IRule util)
{
if (functionName != null && engine.findFunction(functionName) != null)
{
faction = engine.findFunction(functionName);
}
// now setup the BoundParameters if there are any
for (int idx = 0; idx < parameters.Length; idx++)
{
if (parameters[idx] is BoundParam)
{
BoundParam bp = (BoundParam)parameters[idx];
Binding bd = util.getBinding(bp.VariableName);
if (bd != null)
{
bp.Row = bd.LeftRow;
bp.Column = bd.LeftIndex;
}
}
else if (parameters[idx] is FunctionParam2)
{
FunctionParam2 fp2 = (FunctionParam2)parameters[idx];
fp2.configure(engine, util);
}
else if (parameters[idx] is ValueParam)
{
ValueParam vp = (ValueParam)parameters[idx];
// if the value is a deffact, we need to check and make sure
// the slots with BoundParam value are compiled properly
if (vp.Value is Deffact)
{
((Deffact)vp.Value).compileBinding(util);
}
}
}
// in the case of Assert, we do further compilation
if (faction is AssertFunction)
{
Deftemplate tmpl = (Deftemplate)engine.CurrentFocus.getTemplate(parameters[0].StringValue);
Deffact fact = (Deffact)tmpl.createFact((Object[])parameters[1].Value, -1);
fact.compileBinding(util);
parameters = new ValueParam[1];
parameters[0] = new ValueParam(Constants.OBJECT_TYPE, fact);
}
}
public CLIPSInterpreter(Rete.Rete engine)
{
this.engine = engine;
}
//$NON-NLS-1$
/// <summary>
/// </summary>
public TemplateValidation(Rete.Rete engine)
{
this.engine = engine;
}
public CLIPSParser_XXX(Rete.Rete eng, Stream stream)
: this(new StreamReader(stream))
{
//InitBlock();
engine = eng;
}
/// <summary>
/// The constructor for a message router.
/// </summary>
/// <param name="engine">The engine.</param>
public MessageRouter(Rete.Rete engine)
{
this.engine = engine;
this.engine.Message += engine_Message;
interpreter = new CLIPSInterpreter(engine);
}
/// <summary> The method uses Defclass, Class, Deftemplate and Rete to create a new
/// instance of the java object. Once the instance is created, the method
/// uses Defclass to look up the write method and calls it with the
/// appropriate value.
/// </summary>
/// <param name="">cond
/// </param>
/// <param name="">templ
/// </param>
/// <param name="">engine
/// </param>
/// <returns>
///
/// </returns>
public static Object generateJavaFacts(ObjectCondition cond, Deftemplate templ, Rete.Rete engine)
{
try
{
Type theclz = Type.GetType(templ.ClassName);
Defclass dfc = engine.findDefclass(theclz);
Object data = CreateNewInstance(theclz);
IConstraint[] cnstr = cond.Constraints;
for (int idx = 0; idx < cnstr.Length; idx++)
{
IConstraint cn = cnstr[idx];
if (cn is LiteralConstraint)
{
MethodInfo meth = dfc.getWriteMethod(cn.Name);
meth.Invoke(data, (Object[])new Object[] { cn.Value });
}
}
// for now the method doesn't inspect the bindings
// later on it needs to be added
return(data);
}
catch (UnauthorizedAccessException e)
{
return(null);
}
catch (ArgumentException e)
{
return(null);
}
catch (TargetInvocationException e)
{
return(null);
}
catch (Exception e)
{
return(null);
}
}
public virtual void close()
{
engine = null;
if (token != null)
{
token.clear();
token = null;
}
if (jj_nt != null)
{
jj_nt.clear();
jj_nt = null;
}
if (jj_scanpos != null)
{
jj_scanpos.clear();
jj_scanpos = null;
}
if (jj_lastpos != null)
{
jj_lastpos.clear();
jj_lastpos = null;
}
try
{
jj_input_stream.inputStream.Close();
}
catch (IOException e)
{
// later on log the error
}
}
public CLIPSInterpreter(Rete.Rete engine)
{
this.engine = engine;
}
/// <summary>
/// The constructor for a message router.
/// </summary>
/// <param name="engine">The engine.</param>
public MessageRouter(Rete.Rete engine)
{
this.engine = engine;
this.engine.Message += engine_Message;
interpreter = new CLIPSInterpreter(engine);
}
//$NON-NLS-1$
/// <summary>
/// </summary>
public TemplateValidation(Rete.Rete engine)
{
this.engine = engine;
}
