override public object Execute(Reasoner ts, Unifier un, ITerm[] args) { CheckArguments(args); if (args[0].IsList()) { // list reverse if (!args[1].IsVar() && !args[1].IsList()) { throw JasonityException.CreateWrongArgument(this, "last argument '" + args[1] + "' must be a list or a variable."); } return(un.Unifies(((IListTerm)args[0]).Reverse(), args[1])); } else { // string reverse if (!args[1].IsVar() && !args[1].IsString()) { throw JasonityException.CreateWrongArgument(this, "last argument '" + args[1] + "' must be a string or a variable."); } string vl = args [0].ToString(); if (args [0].IsString()) { vl = ((IStringTerm)args [0]).GetString(); } /*All this shit it's because c#'s StringBuilder doesn't have reverse method in */ char[] charArray = new StringBuilder(vl).ToString().ToCharArray(); Array.Reverse(charArray); /********************************************************************/ return(un.Unifies(new StringTermImpl(new string(charArray) /*new StringBuilder(vl).Reverse().ToString()*/), args[1])); } }
protected virtual void CheckArguments(ITerm[] args) { if (args.Length < GetMinArgs() || args.Length > GetMaxArgs()) { throw JasonityException.CreateWrongArgumentNb(this); } }
private Plan Transform2Plan(ITerm t) { Plan p = null; if (t.IsString()) { string sPlan = ((IStringTerm)t).GetString(); // remove quotes \" -> " StringBuilder sTemp = new StringBuilder(); for (int c = 0; c < sPlan.Length; c++) { if (sPlan.ElementAt(c) != '\\') { sTemp.Append(sPlan.ElementAt(c)); } } sPlan = sTemp.ToString(); p = AsSyntax.AsSyntax.ParsePlan(sPlan); } else if (t.GetType() == typeof(Plan)) { p = (Plan)t; } else { throw JasonityException.CreateWrongArgument(this, "The term '" + t + "' (" + t.GetType().Name + ") can not be used as a plan for .add_plan."); } if (p.GetLabel() != null && p.GetLabel().GetFunctor().StartsWith("l__")) { // if the label is automatic label, remove it p.DelLabel(); } return(p); }
protected override void CheckArguments(ITerm[] args) { base.CheckArguments(args); if (!args[0].IsAtom()) { throw JasonityException.CreateWrongArgument(this, "illocutionary force argument must be an atom"); } }
protected override void CheckArguments(ITerm[] args) { base.CheckArguments(args); if (!(args[0].GetType() == typeof(ILogicalFormula))) { throw JasonityException.CreateWrongArgument(this, "first argument must be a formula"); } }
override protected void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (!args[0].IsAtom() & !args[0].IsVar()) { throw JasonityException.CreateWrongArgument(this, "first argument must be an atom or variable."); } }
protected override void CheckArguments(ITerm[] args) { base.CheckArguments(args); //check number of arguments if (!args[0].IsString()) { throw JasonityException.CreateWrongArgument(this, "first argument must be a string (the format)"); } }
override protected void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (args.Length == 1 && !args[0].IsLiteral()) { throw JasonityException.CreateWrongArgument(this, "first argument must be a literal"); } }
protected override void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (!args[0].IsLiteral() && !args[0].IsVar()) { throw JasonityException.CreateWrongArgument(this, "first argument must be a literal or variable"); } }
override protected void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (!(args[0].GetType() == typeof(Atom))) { throw JasonityException.CreateWrongArgument(this, "first argument must be 'and' or 'or'."); } }
protected override void CheckArguments(ITerm[] args) { base.CheckArguments(args); if (!args[0].IsLiteral()) { throw JasonityException.CreateWrongArgument(this, "first argument must be a literal"); } }
protected override void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (!(args[1].GetType() == typeof(ILogicalFormula))) { throw JasonityException.CreateWrongArgument(this, "second argument must be a formula"); } }
override protected void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (!(args[0].IsList())) { throw JasonityException.CreateWrongArgument(this, "first argument must be a list"); } }
protected override void CheckArguments(ITerm[] args) { base.CheckArguments(args); if (args.Length > 0 && !args[0].IsLiteral() && !args[0].IsVar()) { throw JasonityException.CreateWrongArgument(this, "first argument '" + args[0] + "' must be a literal or variable"); } }
public override object Execute(Reasoner ts, Unifier un, ITerm[] args) { CheckArguments(args); Trigger te = null; try { te = Trigger.TryToGetTrigger(args[0]); } catch (ParseException e) {} if (te == null) { throw JasonityException.CreateWrongArgument(this, "first argument '" + args[0] + "' must follow the syntax of a trigger."); } IListTerm labels = new ListTermImpl(); IListTerm lt = new ListTermImpl(); IListTerm last = lt; if (!te.GetLiteral().HasSource()) { // the ts.relevantPlans requires a source to work properly te.SetLiteral(te.GetLiteral().ForceFullLiteralImpl()); te.GetLiteral().AddSource(new UnnamedVar()); } List <Option> rp = ts.RelevantPlans(te); if (rp != null) { foreach (Option opt in rp) { // remove sources (this IA is used for communication) Plan np = (Plan)opt.GetPlan().Clone(); if (np.GetLabel() != null) { np.GetLabel().DelSources(); } np.SetAsPlanTerm(true); np.MakeVarsAnnon(); last = last.Append(np); if (args.Length == 3) { labels.Add(np.GetLabel()); } } } bool ok = un.Unifies(lt, args[1]); // args[1] is a var; if (ok && args.Length == 3) { ok = un.Unifies(labels, args[2]); } return(ok); }
protected override void CheckArguments(ITerm[] args) { base.CheckArguments(args); if (!args[0].IsLiteral()) { if (!args[0].IsGround() && !args[0].IsRule()) { throw JasonityException.CreateWrongArgument(this, "first argument must be a ground literal (or rule)."); } } }
override protected void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (!args[0].IsNumeric() && !args[0].IsVar()) { throw JasonityException.CreateWrongArgument(this, "the first argument should be numeric or a variable -- not '" + args[0] + "'."); } if (!args[1].IsList() && !args[1].IsString()) { throw JasonityException.CreateWrongArgument(this, "the second argument should be a list or string and not '" + args[1] + "'."); } }
// improve the check of the arguments to also check the type of the arguments override protected void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (!args[0].IsList() && !args[0].IsVar()) { throw JasonityException.CreateWrongArgument(this, "first argument must be a list or a variable"); } if (!args[1].IsList()) { throw JasonityException.CreateWrongArgument(this, "second argument must be a list"); } }
override protected void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (!(args[0].GetType() == typeof(ILogicalFormula))) { throw JasonityException.CreateWrongArgument(this, "first argument (test) must be a logical formula."); } if (!args[1].IsPlanBody()) { throw JasonityException.CreateWrongArgument(this, "second argument must be a plan body term."); } }
override protected void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (!args[0].IsVar()) { throw JasonityException.CreateWrongArgument(this, "first argument must be a variable."); } if (args.Length == 2 && !args[1].IsNumeric()) { throw JasonityException.CreateWrongArgument(this, "second argument must be a number."); } }
protected override void CheckArguments(ITerm[] args) { base.CheckArguments(args); if (args.Length > 1 && !args[1].IsString()) { throw JasonityException.CreateWrongArgument(this, "second argument must be a string"); } if (args.Length == 3 && !args[2].IsList()) { throw JasonityException.CreateWrongArgument(this, "third argument must be a list"); } }
override protected void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (!args[0].IsAtom() && !args[0].IsList() && !args[0].IsString()) { throw JasonityException.CreateWrongArgument(this, "TO parameter ('" + args[0] + "') must be an atom, a string or a list of receivers!"); } if (!args[1].IsAtom()) { throw JasonityException.CreateWrongArgument(this, "illocutionary force parameter ('" + args[1] + "') must be an atom!"); } }
protected override void CheckArguments(ITerm[] args) { base.CheckArguments(args);// check number of arguments if (!args[0].IsList()) { throw JasonityException.CreateWrongArgument(this, "first argument '" + args[0] + "'is not a list."); } if (!args[1].IsList()) { throw JasonityException.CreateWrongArgument(this, "second argument '" + args[1] + "'is not a list."); } if (!args[2].IsVar() && !args[2].IsList()) { throw JasonityException.CreateWrongArgument(this, "last argument '" + args[2] + "'is not a list nor a variable."); } }
override protected void CheckArguments(ITerm[] args) { base.CheckArguments(args); // check number of arguments if (!args[1].IsNumeric()) { throw JasonityException.CreateWrongArgument(this, "second parameter ('" + args[1] + "') must be a number!"); } if (!args[2].IsNumeric()) { throw JasonityException.CreateWrongArgument(this, "third parameter ('" + args[2] + "') must be a number!"); } if (args.Length == 4 && !args[3].IsNumeric()) { throw JasonityException.CreateWrongArgument(this, "fourth parameter ('" + args[3] + "') must be a number!"); } }
protected override void CheckArguments(ITerm[] args) { base.CheckArguments(args); if (!(args[0].GetType() == typeof(ILogicalFormula))) { throw JasonityException.CreateWrongArgument(this, "first argument (test) must be a logical formula."); } if (!args[1].IsPlanBody()) { throw JasonityException.CreateWrongArgument(this, "second argument (test) must be a plan body term."); } if (args.Length == 3 && !args[2].IsPlanBody()) { throw JasonityException.CreateWrongArgument(this, "third argument (else) must be a plan body term."); } }
public void Run() { try { // add SI again in C.I if (1) it was not removed (2) is is not running (by some other reason) -- but this test does not apply to atomic intentions --, and (3) this wait was not dropped if (c.RemovePendingIntention(sEvt) == si && (si.IsAtomic() || !c.HasRunningIntention(si)) && !dropped) { if (stopByTimeout && (te != null || formula != null) && elapsedTimeTerm == null) { // fail the .wait by timeout if (si.IsSuspended()) { // if the intention was suspended by .suspend IPlanBody body = si.Peek().GetPlan().GetBody(); body.Add(1, new PlanBodyImpl(BodyType.Body_Type.internalAction, new InternalActionLiteral(".fail"))); c.AddPendingIntention(SuspendStdLib.SUSPENDED_INT + si.GetID(), si); } else { rs.GenerateDesireDeletion(si, (List <ITerm>)JasonityException.CreateBasicErrorAnnots("wait_timeout", "timeout in .wait")); } } else if (!si.IsFinished()) { si.Peek().RemoveCurrentStep(); if (elapsedTimeTerm != null) { long elapsedTime = DateTime.Now.Millisecond - startTime; //long elapsedTime = System.currentTimeMillis() - startTime; un.Unifies(elapsedTimeTerm, new NumberTermImpl(elapsedTime)); } if (si.IsSuspended()) { // if the intention was suspended by .suspend c.AddPendingIntention(SuspendStdLib.SUSPENDED_INT + si.GetID(), si); } else { c.ResumeIntention(si); } } } } catch (Exception e) { //rs.getLogger().log(Level.SEVERE, "Error at .wait thread", e); } }
public override object Execute(Reasoner reasoner, Unifier un, ITerm[] args) { IntendedPlan ip = reasoner.GetCircumstance().GetSelectedIntention().Peek(); IPlanBody whileia = ip.GetCurrentStep(); // if the IA has a backup unifier, use that (it is an object term) if (args.Length == 2) { // first execution of while CheckArguments(args); // add backup unifier in the IA whileia = new PlanBodyImpl(BodyType.Body_Type.internalAction, (ITerm)whileia.GetBodyTerm().Clone()); // Como uso el Clone de C# lo que clono son object que luego hay que castear... whileia.Add(ip.GetCurrentStep().GetBodyNext()); ((Structure)whileia.GetBodyTerm()).AddTerm(new ObjectTermImpl(un.Clone())); } else if (args.Length == 3) { // restore the unifier of previous iterations Unifier ubak = (Unifier)((IObjectTerm)args[2]).GetObject(); un.Clear(); un.Compose(ubak); } else { throw JasonityException.CreateWrongArgumentNb(this); } ILogicalFormula logExpr = (ILogicalFormula)args[0]; // perform one iteration of the loop IEnumerator <Unifier> iu = logExpr.LogicalConsequence(reasoner.GetAgent(), un); if (iu.MoveNext()) { un.Compose(iu.Current); // add in the current intention: // 1. the body argument and // 2. the while internal action after the execution of the body // (to test the loop again) IPlanBody whattoadd = (IPlanBody)args[1].Clone(); whattoadd.Add(whileia); // the add clones whileia whattoadd.SetAsBodyTerm(false); ip.InsertAsNextStep(whattoadd); } return(true); }
public override object Execute(Reasoner ts, Unifier un, ITerm[] args) { if (args[0].IsList()) { if (!args[args.Length - 1].IsVar() && !args[args.Length - 1].IsList()) { throw new JasonityException("Last argument of concat '" + args[args.Length - 1] + "'is not a list nor a variable."); } IListTerm result = args[0].Clone() as IListTerm; for (int i = 1; i < args.Length - 1; i++) { if (!args[i].IsList()) { throw JasonityException.CreateWrongArgument(this, "arg[" + i + "] is not a list"); } result.Concat((IListTerm)args[i].Clone()); } return(un.Unifies(result, args[args.Length - 1])); } else { if (!args[args.Length - 1].IsVar() && !args[args.Length - 1].IsString()) { throw JasonityException.CreateWrongArgument(this, "Last argument '" + args[args.Length - 1] + "' is not a string nor a variable."); } string vl = args[0].ToString(); if (args[0].IsString()) { vl = ((IStringTerm)args[0]).GetString(); } StringBuilder sr = new StringBuilder(vl); for (int i = 0; i < args.Length - 1; i++) { vl = args[i].ToString(); if (args[i].IsString()) { vl = ((IStringTerm)args[i]).GetString(); } sr.Append(vl); } return(un.Unifies(new StringTermImpl(sr.ToString()), args[args.Length - 1])); } }
public override object Execute(Reasoner r, Unifier un, ITerm[] args) { if (args.Length > 0) //add all arguments as annotations in the exception { //find message ITerm smgs = null; string msg = "FailStdLib"; foreach (ITerm t in args) { if (t.IsStructure() && ((Structure)t).GetFunctor().Equals("Error_Msg")) { smgs = t; ITerm tm = ((Structure)t).GetTerm(0); if (tm.IsString()) { msg = ((IStringTerm)tm).GetString(); } else { msg = tm.ToString(); } break; } } JasonityException e = new JasonityException(msg); foreach (ITerm t in args) { if (t != smgs) { e.AddErrorAnnot(t); } } throw e; } return(false); }
public override object Execute(Reasoner reasoner, Unifier un, ITerm[] args) { IntendedPlan im = reasoner.GetCircumstance().GetSelectedIntention().Peek(); IPlanBody foria = im.GetCurrentStep(); IEnumerator <Unifier> iu; if (args.Length == 2) { // first execution of while CheckArguments(args); // get all solutions for the loop // Note: you should get all solutions here, otherwise a concurrent modification will occur for the iterator ILogicalFormula logExpr = (ILogicalFormula)args[0]; iu = logExpr.LogicalConsequence(reasoner.GetAgent(), un); List <Unifier> allsol = new List <Unifier>(); while (iu.MoveNext()) { allsol.Add(iu.Current); } if (allsol.Count == 0) { return(true); } iu = allsol.GetEnumerator(); foria = new PlanBodyImpl(BodyType.Body_Type.internalAction, (ITerm)foria.GetBodyTerm().Clone()); // Como uso el Clone de C# lo que clono son object que luego hay que castear... foria.Add(im.GetCurrentStep().GetBodyNext()); Structure forstructure = (Structure)foria.GetBodyTerm(); forstructure.AddTerm(new ObjectTermImpl(iu)); // store all solutions forstructure.AddTerm(new ObjectTermImpl(un.Clone())); // backup original unifier } else if (args.Length == 4) { // restore the solutions iu = (IEnumerator <Unifier>)((IObjectTerm)args[2]).GetObject(); } else { throw JasonityException.CreateWrongArgumentNb(this); } un.Clear(); if (iu.MoveNext()) { // add in the current intention: // 1. the body argument of for and // 2. the for internal action after the execution of the body // (to perform the next iteration) un.Compose(iu.Current); IPlanBody whattoadd = (IPlanBody)args[1].Clone(); whattoadd.Add(foria); whattoadd.SetAsBodyTerm(false); im.InsertAsNextStep(whattoadd); } else { un.Compose((Unifier)((IObjectTerm)args[3]).GetObject()); } return(true); }