Menu
▾
▴
[Jason-developers] SF.net SVN: jason:[1388] trunk
|
From: <jom...@us...> - 2008-09-29 14:34:55
|
Revision: 1388
http://jason.svn.sourceforge.net/jason/?rev=1388&view=rev
Author: jomifred
Date: 2008-09-29 14:34:41 +0000 (Mon, 29 Sep 2008)
Log Message:
-----------
add a factory (class ASSyntax) to create and parse terms and literals,
see API doc of ASSyntax for more info.
Modified Paths:
--------------
trunk/applications/as-unit-test/src/jason/asunit/TestAgent.java
trunk/build.xml
trunk/src/jason/asSyntax/ListTermImpl.java
trunk/src/jason/asSyntax/Literal.java
trunk/src/jason/asSyntax/Structure.java
trunk/src/jason/asSyntax/Trigger.java
trunk/src/test/ASParserTest.java
Added Paths:
-----------
trunk/src/jason/asSyntax/ASSyntax.java
Modified: trunk/applications/as-unit-test/src/jason/asunit/TestAgent.java
===================================================================
--- trunk/applications/as-unit-test/src/jason/asunit/TestAgent.java 2008-09-29 10:41:26 UTC (rev 1387)
+++ trunk/applications/as-unit-test/src/jason/asunit/TestAgent.java 2008-09-29 14:34:41 UTC (rev 1388)
@@ -9,6 +9,7 @@
import jason.asSemantics.Intention;
import jason.asSemantics.TransitionSystem;
import jason.asSemantics.Unifier;
+import jason.asSyntax.ASSyntax;
import jason.asSyntax.Literal;
import jason.asSyntax.LogExpr;
import jason.asSyntax.LogicalFormula;
@@ -89,7 +90,7 @@
public void addGoal(String g) {
try {
- addGoal(Literal.tryParsingLiteral(g));
+ addGoal(ASSyntax.parseLiteral(g));
} catch (Exception e) {
fail("Parsing '"+g+"' as literal for a goal failed!");
}
@@ -100,7 +101,7 @@
public void addBel(String bel) {
try {
- super.addBel(Literal.tryParsingLiteral(bel));
+ super.addBel(ASSyntax.parseLiteral(bel));
} catch (ParseException e) {
fail("Parsing '"+bel+"' as a belief!");
} catch (RevisionFailedException e) {
@@ -109,7 +110,7 @@
}
public void delBel(String bel) {
try {
- Literal l = Literal.tryParsingLiteral(bel);
+ Literal l = ASSyntax.parseLiteral(bel);
if (!l.hasSource()) {
l.addAnnot(BeliefBase.TSelf);
}
@@ -145,7 +146,7 @@
public void assertEvt(String te, int maxCycles) {
try {
- assertEvt(Trigger.tryParsingTrigger(te), maxCycles);
+ assertEvt(ASSyntax.parseTrigger(te), maxCycles);
} catch (ParseException e) {
fail("Parsing '"+te+"' as trigger failed!");
}
@@ -164,7 +165,7 @@
public void assertAct(String act, int maxCycles) {
try {
- assertAct(Structure.tryParsingStructure(act), maxCycles);
+ assertAct(ASSyntax.parseStructure(act), maxCycles);
} catch (ParseException e) {
fail("Parsing '"+act+"' as action failed!");
}
Modified: trunk/build.xml
===================================================================
--- trunk/build.xml 2008-09-29 10:41:26 UTC (rev 1387)
+++ trunk/build.xml 2008-09-29 14:34:41 UTC (rev 1388)
@@ -239,7 +239,7 @@
</not>
</condition>
- <target name="apidocsimple" unless="dot-ok" >
+ <target name="apidocsimple" unless="dot-ok" > <!-- stylesheetfile="doc/faq/faq.css" -->
<javadoc
destdir="${basedir}/doc/api"
packagenames="jason.*"
@@ -249,7 +249,7 @@
version="true"
author="true"
windowtitle="Jason - AgentSpeak Java Interpreter"
- stylesheetfile="doc/faq/faq.css">
+ >
<classpath refid="project.classpath" />
</javadoc>
</target>
@@ -264,7 +264,7 @@
version="true"
author="true"
windowtitle="Jason - AgentSpeak Java Interpreter"
- stylesheetfile="doc/faq/faq.css">
+ >
<classpath refid="project.classpath" />
<doclet name="org.umlgraph.doclet.UmlGraphDoc" path="lib/UMLGraph.jar">
<!--param name="-inferrel"/ -->
Added: trunk/src/jason/asSyntax/ASSyntax.java
===================================================================
--- trunk/src/jason/asSyntax/ASSyntax.java (rev 0)
+++ trunk/src/jason/asSyntax/ASSyntax.java 2008-09-29 14:34:41 UTC (rev 1388)
@@ -0,0 +1,150 @@
+package jason.asSyntax;
+
+import jason.asSyntax.parser.ParseException;
+import jason.asSyntax.parser.as2j;
+
+import java.io.StringReader;
+
+
+/**
+ Factory for objects used in Jason AgentSpeak syntax.
+
+ <p><b>Examples of Term</b>:
+ <pre>
+ import static jason.asSyntax.ASSyntax.*;
+
+ ...
+ Atom a = createAtom("a");
+ NumberTerm n = createNumber(3);
+ StringTerm s = createString("s");
+ Structure t = createStructure("p", createAtom("a")); // t = p(a)
+ ListTerm l = createList(); // empty list
+ ListTerm f = createList(createAtom("a"), createStructure("b", createNumber(5))); // f = [a,b(5)]
+
+ // or use a parsing (easier but slow)
+ Term n = parseTerm("5");
+ Term t = parseTerm("p(a)");
+ Term l = parseTerm("[a,b(5)]");
+ </pre>
+
+ <p><b>Examples of Literal</b>:
+ <pre>
+ import static jason.asSyntax.ASSyntax.*;
+
+ ...
+ // create the literal 'p'
+ Literal l1 = createLiteral("p");
+
+ // create the literal 'p(a,3)'
+ Literal l2 = createLiteral("p", createAtom("a"), createNumber(3));
+
+ // create the literal 'p(a,3)[s,"s"]'
+ Literal l3 = createLiteral("p", createAtom("a"), createNumber(3))
+ .addAnnots(createAtom("s"), createString("s"));
+
+ // create the literal '~p(a,3)[s,"s"]'
+ Literal l4 = createLiteral("p", createAtom("a"), createNumber(3))
+ .addAnnots(createAtom("s"), createString("s"))
+ .setNegated(Literal.LNeg);
+
+ // or use a parsing (easier but slow)
+ Literal l4 = parseLiteral("~p(a,3)[s]");
+ </pre>
+
+ @author Jomi
+
+ */
+public class ASSyntax {
+
+ /**
+ * Creates a new literal, the first argument is the functor (a string)
+ * and the n remainder arguments are terms. see documentation of this
+ * class for examples of use.
+ */
+ public static Literal createLiteral(String functor, Term... terms) {
+ return new LiteralImpl(functor).addTerms(terms);
+ }
+
+ /**
+ * Creates a new literal, the first argument is either Literal.LPos or Literal.LNeg,
+ * the second is the functor (a string),
+ * and the n remainder arguments are terms. see documentation of this
+ * class for examples of use.
+ */
+ public static Literal createLiteral(boolean positive, String functor, Term... terms) {
+ return new LiteralImpl(positive, functor).addTerms(terms);
+ }
+
+ /**
+ * Creates a new structure term, is the functor (a string),
+ * and the n remainder arguments are terms.
+ */
+ public static Literal createStructure(String functor, Term... terms) {
+ return new Structure(functor).addTerms(terms);
+ }
+
+ /** creates a new Atom term */
+ public static Atom createAtom(String functor) {
+ return new Atom(functor);
+ }
+
+ /** creates a new number term */
+ public static NumberTerm createNumber(double vl) {
+ return new NumberTermImpl(vl);
+ }
+
+ /** creates a new string term */
+ public static StringTerm createString(String s) {
+ return new StringTermImpl(s);
+ }
+
+ /** creates a new variable term */
+ public static VarTerm createVar(String functor) {
+ return new VarTerm(functor);
+ }
+
+ /** Creates a new list with n elements, n can be 0 */
+ public static ListTerm createList(Term... terms) {
+ ListTerm l = new ListTermImpl();
+ ListTerm tail = l;
+ for (Term t: terms)
+ tail = tail.append(t);
+ return l;
+ }
+
+
+ /** creates a new literal by parsing a string */
+ public static Literal parseLiteral(String sLiteral) throws ParseException {
+ return new as2j(new StringReader(sLiteral)).literal();
+ }
+
+ /** creates a new structure (a kind of term) by parsing a string */
+ public static Structure parseStructure(String sTerm) throws ParseException {
+ Term t = new as2j(new StringReader(sTerm)).term();
+ if (t instanceof Structure)
+ return (Structure)t;
+ else
+ return new Structure((Literal)t);
+ }
+
+ /** creates a new term by parsing a string */
+ public static Term parseTerm(String sTerm) throws ParseException {
+ return new as2j(new StringReader(sTerm)).term();
+ }
+
+ /** creates a new plan by parsing a string */
+ public static Plan parsePlan(String sPlan) throws ParseException {
+ return new as2j(new StringReader(sPlan)).plan();
+ }
+
+ /** creates a new trigger by parsing a string */
+ public static Trigger parseTrigger(String sTe) throws ParseException {
+ return new as2j(new StringReader(sTe)).trigger();
+ }
+
+ /** creates a new list by parsing a string */
+ public static ListTerm parseList(String sList) throws ParseException {
+ return new as2j(new StringReader(sList)).list();
+ }
+
+}
Modified: trunk/src/jason/asSyntax/ListTermImpl.java
===================================================================
--- trunk/src/jason/asSyntax/ListTermImpl.java 2008-09-29 10:41:26 UTC (rev 1387)
+++ trunk/src/jason/asSyntax/ListTermImpl.java 2008-09-29 14:34:41 UTC (rev 1388)
@@ -75,7 +75,7 @@
public static ListTerm parseList(String sList) {
as2j parser = new as2j(new StringReader(sList));
try {
- return (ListTerm)parser.list();
+ return parser.list();
} catch (Exception e) {
logger.log(Level.SEVERE,"Error parsing list "+sList,e);
return null;
Modified: trunk/src/jason/asSyntax/Literal.java
===================================================================
--- trunk/src/jason/asSyntax/Literal.java 2008-09-29 10:41:26 UTC (rev 1387)
+++ trunk/src/jason/asSyntax/Literal.java 2008-09-29 14:34:41 UTC (rev 1388)
@@ -27,7 +27,6 @@
import jason.architecture.AgArch;
import jason.asSemantics.Agent;
import jason.asSemantics.Unifier;
-import jason.asSyntax.parser.ParseException;
import jason.asSyntax.parser.as2j;
import java.io.StringReader;
@@ -48,28 +47,12 @@
LiteralImpl -- Pred + negation. This latter class supports all the operations of
the Literal interface.
- There are useful static methods in this class to create Literals.
+ <p>There are useful static methods in class {@link ASSyntax} to create Literals.
- Examples:
- <pre>
- // create the literal 'p'
- Literal l1 = Literal.create("p");
-
- // create the literal 'p(a,3)'
- Literal l2 = Literal.create("p", new Atom(a), new NumberTermImpl(3));
-
- // create the literal 'p(a,3)[s,"s"]'
- Literal l3 = Literal.create("p", new Atom("a"), new NumberTermImpl(3))
- .addAnnots(new Atom("s"), new StringTermImpl("s"));
-
- // create the literal '~p(a,3)[s,"s"]'
- Literal l4 = Literal.create("p", new Atom("a"), new NumberTermImpl(3))
- .addAnnots(new Atom("s"), new StringTermImpl("s"))
- .setNegated(Literal.LNeg);
- </pre>
@author jomi
+ @see ASSyntax
@see Atom
@see Structure
@see Pred
@@ -88,23 +71,7 @@
protected PredicateIndicator predicateIndicatorCache = null; // to not compute it all the time (is is called many many times)
- /** creates a literal copying data from other literal */
- public static Literal create(Literal l) {
- return new LiteralImpl(l);
- }
-
- /**
- * Creates a new literal, the first argument is the functor (a string)
- * and the n remainder arguments are terms. see documentation of this
- * class for example of use.
- */
- public static Literal create(String functor, Term... terms) {
- Literal l = new LiteralImpl(functor);
- l.addTerms(terms);
- return l;
- }
-
- /** creates a new literal by parsing a string */
+ /** creates a new literal by parsing a string -- ASSyntax.parseLiteral is preferred. */
public static Literal parseLiteral(String sLiteral) {
try {
as2j parser = new as2j(new StringReader(sLiteral));
@@ -115,10 +82,6 @@
}
}
- public static Literal tryParsingLiteral(String sLiteral) throws ParseException {
- return new as2j(new StringReader(sLiteral)).literal();
- }
-
public Literal copy() {
return (Literal)clone(); // should call the clone, that is overridden in subclasses
}
Modified: trunk/src/jason/asSyntax/Structure.java
===================================================================
--- trunk/src/jason/asSyntax/Structure.java 2008-09-29 10:41:26 UTC (rev 1387)
+++ trunk/src/jason/asSyntax/Structure.java 2008-09-29 14:34:41 UTC (rev 1388)
@@ -24,7 +24,6 @@
package jason.asSyntax;
import jason.asSemantics.Unifier;
-import jason.asSyntax.parser.ParseException;
import jason.asSyntax.parser.as2j;
import java.io.StringReader;
@@ -86,22 +85,15 @@
as2j parser = new as2j(new StringReader(sTerm));
try {
Term t = parser.term();
- if (t.isAtom())
- return new Structure((Atom)t);
- else
+ if (t instanceof Structure)
return (Structure)t;
+ else
+ return new Structure((Atom)t);
} catch (Exception e) {
logger.log(Level.SEVERE,"Error parsing structure " + sTerm,e);
return null;
}
}
- public static Structure tryParsingStructure(String sTerm) throws ParseException {
- Term t = new as2j(new StringReader(sTerm)).term();
- if (t.isAtom())
- return new Structure((Atom)t);
- else
- return (Structure)t;
- }
@Override
protected int calcHashCode() {
Modified: trunk/src/jason/asSyntax/Trigger.java
===================================================================
--- trunk/src/jason/asSyntax/Trigger.java 2008-09-29 10:41:26 UTC (rev 1387)
+++ trunk/src/jason/asSyntax/Trigger.java 2008-09-29 14:34:41 UTC (rev 1388)
@@ -25,7 +25,6 @@
package jason.asSyntax;
import jason.asSemantics.Unifier;
-import jason.asSyntax.parser.ParseException;
import jason.asSyntax.parser.as2j;
import java.io.StringReader;
@@ -85,10 +84,6 @@
}
}
- public static Trigger tryParsingTrigger(String sTe) throws ParseException {
- return new as2j(new StringReader(sTe)).trigger();
- }
-
public void setTrigOp(TEOperator op) {
operator = op;
piCache = null;
Modified: trunk/src/test/ASParserTest.java
===================================================================
--- trunk/src/test/ASParserTest.java 2008-09-29 10:41:26 UTC (rev 1387)
+++ trunk/src/test/ASParserTest.java 2008-09-29 14:34:41 UTC (rev 1388)
@@ -1,9 +1,15 @@
package test;
+import static jason.asSyntax.ASSyntax.createAtom;
+import static jason.asSyntax.ASSyntax.createLiteral;
+import static jason.asSyntax.ASSyntax.createNumber;
+import static jason.asSyntax.ASSyntax.createString;
import jason.architecture.AgArch;
import jason.asSemantics.Agent;
import jason.asSemantics.TransitionSystem;
import jason.asSemantics.Unifier;
+import jason.asSyntax.ASSyntax;
+import jason.asSyntax.ListTerm;
import jason.asSyntax.Literal;
import jason.asSyntax.LogExpr;
import jason.asSyntax.LogicalFormula;
@@ -11,6 +17,7 @@
import jason.asSyntax.Plan;
import jason.asSyntax.PlanBody;
import jason.asSyntax.RelExpr;
+import jason.asSyntax.parser.ParseException;
import jason.asSyntax.parser.as2j;
import jason.infra.centralised.CentralisedAgArch;
import jason.mas2j.MAS2JProject;
@@ -214,4 +221,35 @@
}
}
}
+
+ public void testFactory() throws ParseException {
+ // create the literal 'p'
+ Literal l = createLiteral("p");
+ assertEquals("p", l.toString());
+
+ // create the literal 'p(a,3)'
+ l = createLiteral("p", createAtom("a"), createNumber(3));
+ assertEquals("p(a,3)", l.toString());
+
+ // create the literal 'p(a,3)[s,"s"]'
+ l = createLiteral("p", createAtom("a"), createNumber(3))
+ .addAnnots(createAtom("s"), createString("s"));
+ assertEquals("p(a,3)[s,\"s\"]", l.toString());
+
+ // create the literal '~p(a,3)[s,"s"]'
+ l = createLiteral(Literal.LNeg, "p", createAtom("a"), createNumber(3))
+ .addAnnots(createAtom("s"), createString("s"));
+ assertEquals("~p(a,3)[s,\"s\"]", l.toString());
+ l = ASSyntax.parseLiteral(l.toString());
+ assertEquals("~p(a,3)[s,\"s\"]", l.toString());
+
+ ListTerm ll = ASSyntax.createList(); // empty list
+ assertEquals("[]", ll.toString());
+
+ ll = ASSyntax.createList(createAtom("a"), createLiteral("b", createNumber(5)));
+ assertEquals("[a,b(5)]", ll.toString());
+
+ ll = ASSyntax.parseList(ll.toString());
+ assertEquals("[a,b(5)]", ll.toString());
+ }
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
