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);
}
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)
{
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 override Object getValue(Rete engine, int valueType)
{
initParams();
IReturnVector rval = func.executeFunction(engine, params_Renamed);
return(rval.firstReturnValue().BigDecimalValue);
}
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);
}
private void OnCommand(object sender, CommandEventArgs args)
{
try
{
postMessageEvent(new MessageEventArgs(EventType.COMMAND, args.Command, args.ChannelID));
IReturnVector result = interpreter.executeCommand(args.Command);
postMessageEvent(new MessageEventArgs(EventType.RESULT, result, args.ChannelID));
}
catch (Exception e)
{
postMessageEvent(new MessageEventArgs(EventType.ERROR, e, args.ChannelID));
}
}
/// <summary> TODO we may want to check the value type and throw and exception
/// for now just getting it to work.
/// </summary>
public override Object getValue(Rete engine, int valueType)
{
if (params_Renamed != null)
{
this.engine = engine;
lookUpFunction();
IReturnVector rval = func.executeFunction(engine, params_Renamed);
return(rval.firstReturnValue().BigDecimalValue);
}
else
{
return(null);
}
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
IReturnVector result = null;
if (params_Renamed != null && params_Renamed.Length > 0)
{
String command = (String)params_Renamed[0].getValue(engine, Constants.STRING_TYPE);
if (command != null)
{
result = eval(engine, command);
}
}
return(result);
}
/// <summary> The method uses the function to evaluate the fact
/// </summary>
/// <param name="">factInstance
/// </param>
/// <returns>
///
/// </returns>
public virtual bool evaluate(IFact factInstance, Rete engine)
{
for (int idx = 0; idx < params_Renamed.Length; idx++)
{
if (params_Renamed[idx] is BoundParam)
{
((BoundParam)params_Renamed[idx]).Facts = new IFact[] { factInstance };
}
}
IReturnVector rv = function.executeFunction(engine, params_Renamed);
IReturnValue rval = rv.firstReturnValue();
return(rval.BooleanValue);
}
/// <summary> Assert will first pass the facts to the parameters. Once the
/// parameters are set, it should call execute to Get the result.
/// </summary>
public override void assertLeft(Index linx, Rete engine, IWorkingMemory mem)
{
IGenericMap <Object, Object> leftmem = (IGenericMap <Object, Object>)mem.getBetaLeftMemory(this);
if (!leftmem.ContainsKey(linx))
{
Parameters = linx.Facts;
IReturnVector rv = func.executeFunction(engine, params_Renamed);
if (rv.firstReturnValue().BooleanValue)
{
IBetaMemory bmem = new BetaMemoryImpl(linx);
leftmem.Put(bmem.Index, bmem);
propogateAssert(linx, engine, mem);
}
}
}
protected void parse(Rete engine, CLIPSParser parser, IList factlist)
{
Object itm = null;
try
{
while ((itm = parser.basicExpr()) != null)
{
// System.Console.WriteLine("obj is " + itm.getClass().Name);
if (itm is Defrule)
{
Defrule rule = (Defrule)itm;
engine.RuleCompiler.addRule(rule);
}
else if (itm is Deftemplate)
{
Deftemplate dt = (Deftemplate)itm;
Console.WriteLine("template=" + dt.Name);
engine.declareTemplate(dt);
}
else if (itm is FunctionAction)
{
FunctionAction fa = (FunctionAction)itm;
}
else if (itm is IFunction)
{
IReturnVector rv = ((IFunction)itm).executeFunction(engine, null);
IEnumerator itr = rv.Iterator;
while (itr.MoveNext())
{
IReturnValue rval = (IReturnValue)itr.Current;
Console.WriteLine(rval.StringValue);
}
}
}
}
catch
{
// Console.WriteLine(e.Message);
parser.ReInit(Console.OpenStandardInput());
}
}
public virtual bool evaluate(IFact[] left, IFact right, Rete engine)
{
if (function != null)
{
IReturnVector rv = function.executeFunction(engine, params_Renamed);
return(rv.firstReturnValue().BooleanValue);
}
else if (left.Length > leftrow)
{
if (left[leftrow] == right)
{
return(false);
}
return(Evaluate.evaluate(operator_Renamed, left[leftrow].getSlotValue(leftIndex), right.getSlotValue(rightIndex)));
}
else
{
return(false);
}
}
public virtual IReturnVector eval(Rete engine, String command)
{
IReturnVector result = null;
try
{
CLIPSParser parser = new CLIPSParser(engine, new MemoryStream(ASCIIEncoding.ASCII.GetBytes(command)));
CLIPSInterpreter interpreter = new CLIPSInterpreter(engine);
Object expr = null;
while ((expr = parser.basicExpr()) != null)
{
result = interpreter.executeCommand(expr);
}
}
catch (ParseException e)
{
// we should report the error
Trace.WriteLine(e.Message);
}
return(result);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
double dval = 0;
if (params_Renamed != null)
{
if (params_Renamed.Length == 1)
{
if (params_Renamed[0] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[0];
dval = n.DoubleValue;
dval = System.Math.Cos(dval);
}
else if (params_Renamed[0] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[0];
dval = bp.DoubleValue;
dval = System.Math.Cos(dval);
}
else if (params_Renamed[0] is FunctionParam2)
{
FunctionParam2 n = (FunctionParam2)params_Renamed[0];
n.Engine = engine;
n.lookUpFunction();
IReturnVector rval = (IReturnVector)n.Value;
dval = rval.firstReturnValue().DoubleValue;
dval = System.Math.Cos(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)
{
Object o = null;
Object ro = null;
String methodname = null;
Type[] argsclass = null;
Object[] args = null;
if (params_Renamed != null)
{
if (params_Renamed[0] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[0];
o = n.Value;
}
else if (params_Renamed[0] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[0];
o = 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;
o = rval.firstReturnValue().Value;
}
if (params_Renamed[1] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[1];
methodname = n.StringValue;
}
else if (params_Renamed[1] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[1];
methodname = (String)engine.getBinding(bp.VariableName);
}
else if (params_Renamed[1] is FunctionParam2)
{
FunctionParam2 n = (FunctionParam2)params_Renamed[1];
n.Engine = engine;
n.lookUpFunction();
IReturnVector rval = (IReturnVector)n.Value;
methodname = rval.firstReturnValue().StringValue;
}
if (params_Renamed.Length > 2)
{
argsclass = new Type[params_Renamed.Length - 1];
args = new Object[params_Renamed.Length - 1];
}
for (int idx = 2; idx < params_Renamed.Length; idx++)
{
if (params_Renamed[idx] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[idx];
argsclass[idx - 1] = n.Value.GetType();
args[idx - 1] = n.Value;
}
else if (params_Renamed[idx] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[idx];
argsclass[idx - 1] = engine.getBinding(bp.VariableName).GetType();
args[idx - 1] = engine.getBinding(bp.VariableName);
}
else if (params_Renamed[idx] is FunctionParam2)
{
FunctionParam2 n = (FunctionParam2)params_Renamed[idx];
n.Engine = engine;
n.lookUpFunction();
IReturnVector rval = (IReturnVector)n.Value;
argsclass[idx - 1] = rval.firstReturnValue().Value.GetType();
args[idx - 1] = rval.firstReturnValue().Value;
}
}
try
{
Type classDefinition = o.GetType();
MethodInfo method = classDefinition.GetMethod(methodname, (Type[])argsclass);
ro = method.Invoke(o, (Object[])args);
}
catch (UnauthorizedAccessException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (SecurityException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (MethodAccessException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (ArgumentException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (TargetInvocationException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.OBJECT_TYPE, ro);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Object result = null;
if (params_Renamed != null)
{
if (params_Renamed.Length >= 3)
{
bool conditionValue = false;
if (params_Renamed[0] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[0];
conditionValue = n.BooleanValue;
}
else if (params_Renamed[0] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[0];
conditionValue = ((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;
conditionValue = rval.firstReturnValue().BooleanValue;
}
if (params_Renamed[1] is ValueParam && "then".Equals(params_Renamed[1].StringValue))
{
bool elseExpressions = false;
for (int i = 2; i < params_Renamed.Length; ++i)
{
if (params_Renamed[i] is ValueParam && "else".Equals(params_Renamed[i].StringValue))
{
elseExpressions = true;
}
else
{
if ((conditionValue && !elseExpressions) || (!conditionValue && elseExpressions))
{
if (params_Renamed[i] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[i];
result = n.Value;
}
else if (params_Renamed[i] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[i];
result = engine.getBinding(bp.VariableName);
}
else if (params_Renamed[i] is FunctionParam2)
{
FunctionParam2 n = (FunctionParam2)params_Renamed[i];
n.Engine = engine;
n.lookUpFunction();
IReturnVector rval = (IReturnVector)n.Value;
if (rval.size() > 0)
{
result = rval.firstReturnValue().Value;
}
}
}
}
}
}
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.OBJECT_TYPE, result);
ret.addReturnValue(rv);
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 first = null;
if (params_Renamed[0] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[0];
first = n.Value;
}
else if (params_Renamed[0] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[0];
first = (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;
first = rval.firstReturnValue().Value;
}
bool eval = true;
for (int idx = 1; idx < params_Renamed.Length; idx++)
{
Object right = null;
if (params_Renamed[idx] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[idx];
right = n.Value;
}
else if (params_Renamed[idx] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[idx];
right = engine.getBinding(bp.VariableName);
}
else if (params_Renamed[idx] is FunctionParam2)
{
FunctionParam2 n = (FunctionParam2)params_Renamed[idx];
n.Engine = engine;
n.lookUpFunction();
IReturnVector rval = (IReturnVector)n.Value;
right = rval.firstReturnValue().Value;
}
if (first == null && right != null)
{
eval = false;
break;
}
else if (first != null && !first.Equals(right))
{
eval = false;
break;
}
}
eq = eval;
}
DefaultReturnValue rv = new DefaultReturnValue(Constants.BOOLEAN_OBJECT, eq);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Object o = null;
String classname = null;
Type[] argsclass = null;
Object[] args = null;
if (params_Renamed != null)
{
if (params_Renamed[0] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[0];
classname = n.StringValue;
}
else if (params_Renamed[0] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[0];
classname = (String)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;
classname = rval.firstReturnValue().StringValue;
}
args = new Object[params_Renamed.Length - 1];
for (int idx = 1; idx < params_Renamed.Length; idx++)
{
if (params_Renamed[idx] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[idx];
args[idx - 1] = n.Value;
}
else if (params_Renamed[idx] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[idx];
args[idx - 1] = engine.getBinding(bp.VariableName);
}
else if (params_Renamed[idx] is FunctionParam2)
{
FunctionParam2 n = (FunctionParam2)params_Renamed[idx];
n.Engine = engine;
n.lookUpFunction();
IReturnVector rval = (IReturnVector)n.Value;
args[idx - 1] = rval.firstReturnValue().Value;
}
}
try
{
Type classDefinition = classnameResolver.resolveClass(classname);
ConstructorInfo foundConstructor = null;
for (int idx = 0; idx < classDefinition.GetConstructors().Length; idx++)
{
ConstructorInfo constructor = classDefinition.GetConstructors()[idx];
ParameterInfo[] parameterClasses = constructor.GetParameters();
if (parameterClasses.Length == args.Length)
{
bool match = true;
for (int i = 0; i < parameterClasses.Length; ++i)
{
match &= (parameterClasses[i].GetType().IsInstanceOfType(args[i]) || args[i] == null);
}
if (match)
{
foundConstructor = constructor;
break;
}
}
}
if (foundConstructor != null)
{
o = foundConstructor.Invoke(args);
}
}
catch (UnauthorizedAccessException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (SecurityException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (ArgumentException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (TargetInvocationException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (Exception e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.OBJECT_TYPE, o);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
Object o = null;
String classname = null;
if (params_Renamed != null && params_Renamed.Length == 1)
{
if (params_Renamed[0] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[0];
classname = n.StringValue;
}
else if (params_Renamed[0] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[0];
classname = (String)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;
classname = rval.firstReturnValue().StringValue;
}
try
{
Type classDefinition = classnameResolver.resolveClass(classname);
o = CreateNewInstance(classDefinition);
if (o is IFunctionGroup)
{
engine.declareFunctionGroup((IFunctionGroup)o);
}
}
catch (UnauthorizedAccessException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (SecurityException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (ArgumentException e)
{
// TODO Auto-generated catch block
System.Diagnostics.Trace.WriteLine(e.Message);
}
catch (Exception e)
{
// TODO Auto-generated catch block
Trace.WriteLine(e.Message);
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.OBJECT_TYPE, o);
ret.addReturnValue(rv);
return(ret);
}
public virtual IReturnVector executeFunction(Rete engine, IParameter[] params_Renamed)
{
String sval = new String("".ToCharArray());
if (params_Renamed != null)
{
if (params_Renamed.Length == 1)
{
if (params_Renamed[0] is ValueParam)
{
ValueParam n = (ValueParam)params_Renamed[0];
sval = n.StringValue;
IFunction aFunction = engine.findFunction(sval);
if (aFunction != null)
{
sval = aFunction.toPPString(null, 0);
}
else
{
sval = toPPString(null, 0);
}
}
else if (params_Renamed[0] is BoundParam)
{
BoundParam bp = (BoundParam)params_Renamed[0];
sval = bp.StringValue;
IFunction aFunction = engine.findFunction(sval);
if (aFunction != null)
{
sval = aFunction.toPPString(null, 0);
}
else
{
sval = toPPString(null, 0);
}
}
else if (params_Renamed[0] is FunctionParam2)
{
FunctionParam2 n = (FunctionParam2)params_Renamed[0];
n.Engine = engine;
n.lookUpFunction();
IReturnVector rval = (IReturnVector)n.Value;
sval = rval.firstReturnValue().StringValue;
IFunction aFunction = engine.findFunction(sval);
if (aFunction != null)
{
sval = aFunction.toPPString(null, 0);
}
else
{
sval = toPPString(null, 0);
}
}
}
else
{
sval = toPPString(null, 0);
}
}
DefaultReturnVector ret = new DefaultReturnVector();
DefaultReturnValue rv = new DefaultReturnValue(Constants.STRING_TYPE, sval);
ret.addReturnValue(rv);
return(ret);
}
public override void Run()
{
while (true)
{
if (Enclosing_Instance.commandQueue.Count == 0)
{
try
{
Thread.Sleep(new TimeSpan(10000 * 10));
}
catch (ThreadInterruptedException e)
{
// TODO Auto-generated catch block
//SupportClass.WriteStackTrace(e, Console.Error);
}
catch (Exception e)
{
//SupportClass.WriteStackTrace(e, Console.Error);
return;
}
}
else
{
CommandObject schabau = (CommandObject)Enclosing_Instance.commandQueue[0];
Enclosing_Instance.commandQueue.RemoveAt(0);
if (schabau != null)
{
Enclosing_Instance.currentChannelId = schabau.channelId;
try
{
Enclosing_Instance.messageQueue.Add(new MessageEvent(MessageEvent.COMMAND, schabau.command, Enclosing_Instance.currentChannelId));
IReturnVector result = Enclosing_Instance.interpreter.executeCommand(schabau.command);
Enclosing_Instance.messageQueue.Add(new MessageEvent(MessageEvent.RESULT, result, Enclosing_Instance.currentChannelId));
}
catch (Exception e)
{
Enclosing_Instance.postMessageEvent(new MessageEvent(MessageEvent.ERROR, e, Enclosing_Instance.currentChannelId));
}
finally
{
Enclosing_Instance.currentChannelId = null;
}
}
}
MessageEvent[] evts = (MessageEvent[])Enclosing_Instance.messageQueue.ToArray(typeof(MessageEvent));
ArrayList allMessages = new ArrayList(evts);
Enclosing_Instance.messageQueue.Clear();
for (int i = 0; i < allMessages.Count; ++i)
{
MessageEvent event_Renamed = (MessageEvent)allMessages[i];
lock (Enclosing_Instance.idToChannel)
{
IEnumerator ch = Enclosing_Instance.idToChannel.Values.GetEnumerator();
while (ch.MoveNext())
{
ICommunicationChannel channel = (ICommunicationChannel)ch.Current;
if (InterestType.ALL == channel.Interest || (InterestType.MINE == channel.Interest) && channel.ChannelId.Equals(event_Renamed.ChannelId))
{
IList messageList = (IList)Enclosing_Instance.idToMessages.Get(channel.ChannelId);
if (messageList != null)
{
messageList.Add(event_Renamed);
}
}
}
}
}
}
}
