Java ASSyntax类代码示例

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
@Override
public Agent process(Pred directive, Agent outerContent, Agent innerContent) {
    try {
        Term goal = directive.getTerm(0);
        Pred subDir;
        if (directive.getArity() > 1) {
            subDir = Pred.parsePred(directive.getTerm(1).toString());
        } else {
            subDir = Pred.parsePred("bdg("+goal+")");
        }
        Directive sd = DirectiveProcessor.getDirective(subDir.getFunctor());

        // apply sub directive
        Agent newAg = sd.process((Pred)subDir, outerContent, innerContent); 
        if (newAg != null) {

            // add +!g : true <- !!g.
            newAg.getPL().add(ASSyntax.parsePlan("+!"+goal+" <- !!"+goal+"."));
            
            return newAg;
        }
    } catch (Exception e) {
        logger.log(Level.SEVERE,"Directive error.", e);
    }
    return null;
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
@Override
public Agent process(Pred directive, Agent outerContent, Agent innerContent) {
    try {
        Term goal = directive.getTerm(0);
        Term motivation = directive.getTerm(1);
        Pred subDir = Pred.parsePred("bc("+goal+")");
        //logger.fine("parameters="+goal+","+motivation+","+subDir);
        Directive sd = DirectiveProcessor.getDirective(subDir.getFunctor());

        // apply sub directive
        Agent newAg = sd.process(subDir, outerContent, innerContent); 
        if (newAg != null) {

            // add -m : true <- .succeed_goal(g).
            newAg.getPL().add(ASSyntax.parsePlan("-"+motivation+" <- .succeed_goal("+goal+")."));
            
            return newAg;
        }
    } catch (Exception e) {
        logger.log(Level.SEVERE,"Directive error.", e);
    }
    return null;
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
@Override
public Agent process(Pred directive, Agent outerContent, Agent innerContent) {
    try {
        // apply DG in the inner plans
        Agent newAg = super.process(directive, outerContent, innerContent); 
        if (newAg != null) {

            Term goal = directive.getTerm(0);

            // add -!g : true <- !!g.
            newAg.getPL().add(ASSyntax.parsePlan("-!"+goal+" <- !!"+goal+"."));
            
            return newAg;
        }
    } catch (Exception e) {
        logger.log(Level.SEVERE,"Directive error.", e);
    }
    return null;
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
@Override
public Agent process(Pred directive, Agent outerContent, Agent innerContent) {
    try {
        Term goal = directive.getTerm(0);
        Term fail = directive.getTerm(1);
        Pred subDir = Pred.parsePred("bc("+goal+")");
        //logger.fine("parameters="+goal+","+fail+","+subDir);
        Directive sd = DirectiveProcessor.getDirective(subDir.getFunctor());

        // apply sub directive
        Agent newAg = sd.process(subDir, outerContent, innerContent); 
        if (newAg != null) {

            // add +f : true <- .fail_goal(g).
            newAg.getPL().add(ASSyntax.parsePlan("+"+fail+" <- .fail_goal("+goal+")."));
            
            return newAg;
        }
    } catch (Exception e) {
        logger.log(Level.SEVERE,"Directive error.", e);
    }
    return null;
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
public void makeVarsAnnon(Literal l, Unifier un) {
    try {
        for (int i=0; i<l.getArity(); i++) {
            Term t = l.getTerm(i);
            if (t.isString()) {
                StringTerm st = (StringTerm)t;
                Matcher matcher = regex.matcher(st.getString());
                StringBuffer sb = new StringBuffer();

                while (matcher.find()) {
                    String sVar = matcher.group();
                    sVar = sVar.substring(2, sVar.length() - 1);
                    Term v = ASSyntax.parseTerm(sVar);
                    if (v.isVar()) {
                        VarTerm to = ((Structure)l).varToReplace(v, un);
                        matcher.appendReplacement(sb, "#{"+to.toString()+"}");
                    }
                }
                matcher.appendTail(sb);
                l.setTerm(i, new StringTermImpl(sb.toString()));
            }
        }
    } catch (ParseException pe) {
        pe.printStackTrace();
    }
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
@Override
public Object execute(TransitionSystem ts, final Unifier un, final Term[] args) throws Exception {
    checkArguments(args);
    
    // case 1, no vars
    if (!args[0].isVar() && args[1].isString()) {
        return args[0].toString().equals( ((StringTerm)args[1]).getString() );
    }
    
    // case 2, second is var
    if (!args[0].isVar() && args[1].isVar()) {
        return un.unifies(new StringTermImpl(args[0].toString()), args[1]);
    }
    
    // case 3, first is var
    if (args[0].isVar() && args[1].isString()) {
        return un.unifies(args[0], ASSyntax.parseTerm( ((StringTerm)args[1]).getString() ));
    }
    
    throw new JasonException("invalid case of term2string");
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
protected void addInitialGoalsFromProjectInBB() {
    String sGoals = getTS().getSettings().getUserParameter(Settings.INIT_GOALS);
    if (sGoals != null) {
        try {
            for (Term t: ASSyntax.parseList("["+sGoals+"]")) {
                Literal g = ((Literal)t).forceFullLiteralImpl();
                g.makeVarsAnnon();
                if (! g.hasSource())
                    g.addAnnot(BeliefBase.TSelf);
                getTS().getC().addAchvGoal(g,Intention.EmptyInt);            
            }
        } catch (Exception e) {
            logger.log(Level.WARNING, "Initial goals from project '["+sGoals+"]' is not a list of literals.");
        }
    }
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
/**
 * Creates a new message object based on a string that 
 * follows the format of the toString of Message class.
 * 
 * @author Rogier
 * @param msg the string message
 * @return the parsed Message
 */
public static Message parseMsg(String msg) throws ParseException {
    int one, two;
    Message newmsg = new Message();
    if (msg.startsWith("<")) {
        one = msg.indexOf(",");
        int arrowIndex = msg.indexOf("->");
        if ((arrowIndex > 0) && (one > arrowIndex)) { // If there is an arrow before the first comma
            newmsg.msgId = msg.substring(1, arrowIndex);
            newmsg.inReplyTo = msg.substring(arrowIndex + 2, one);
        } else { // If not (either there is no arrow, or there is one behind the first comma)
            newmsg.msgId = msg.substring(1, one);
        }
        two = msg.indexOf(",", one + 1);
        newmsg.sender = msg.substring(one + 1, two);
        one = msg.indexOf(",", two + 1);
        newmsg.ilForce = msg.substring(two + 1, one);
        two = msg.indexOf(",", one + 1);
        newmsg.receiver = msg.substring(one + 1, two);
        one = msg.indexOf(">", two + 1);
        String content = msg.substring(two + 1, one);
        newmsg.propCont = ASSyntax.parseTerm(content);
    }
    return newmsg;
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
private void generateGoalStateEvent(final Literal goal, final TEType type, final GoalStates state, final String reason) {
    ts.runAtBeginOfNextCycle(new Runnable() {
        public void run() {
            Literal newGoal = goal.forceFullLiteralImpl().copy();
            Literal stateAnnot = ASSyntax.createLiteral("state", new Atom(state.toString()));
            if (reason != null)
                stateAnnot.addAnnot( ASSyntax.createStructure("reason", new StringTermImpl(reason)));
            newGoal.addAnnot( stateAnnot );
            Trigger eEnd = new Trigger(TEOperator.goalState, type, newGoal);
            if (ts.getAg().getPL().hasCandidatePlan(eEnd))
                ts.getC().insertMetaEvent(new Event(eEnd, null));
            
        }
    });
    ts.getUserAgArch().wakeUpDeliberate();
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
public void testObTerm() {
    ObjectTerm term = new ObjectTermImpl("test");
    assertTrue(term.equals(term));

    assertTrue(new Unifier().unifies(new ObjectTermImpl("test"), new ObjectTermImpl("test")));
    String string = "test";
    assertTrue(new Unifier().unifies(new ObjectTermImpl(string), new ObjectTermImpl(string)));

    BeliefBase base = new DefaultBeliefBase();
    base.add(ASSyntax.createLiteral("test", new ObjectTermImpl("test")));
    Iterator<Literal> iterator = base.getCandidateBeliefs(ASSyntax.createLiteral("test", new ObjectTermImpl("test")), new Unifier());
    assertTrue(iterator != null && iterator.hasNext());

    Literal result = iterator.next();
    assertTrue(result.getFunctor().equals("test"));
    assertTrue(result.getTerm(0).getClass().equals(ObjectTermImpl.class));
    assertTrue(result.getTerm(0).equals(new ObjectTermImpl("test")));

    assertFalse(iterator.hasNext());

}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
public void testUnify2() throws ParseException {
    Unifier u = new Unifier();
    u.unifies(new VarTerm("X"), new NumberTermImpl(3));
    Term e1 = ASSyntax.parseTerm("X-1");
    e1 = e1.capply(u);
    assertTrue(u.unifies(new NumberTermImpl(2), e1));
    assertTrue(u.unifies(e1, new NumberTermImpl(2)));
    assertTrue(u.unifies(new NumberTermImpl(2), e1.clone()));

    u.unifies(new VarTerm("Y"), new NumberTermImpl(1));
    Term e2 = ASSyntax.parseTerm("Y+1");
    e2 = e2.capply(u);
    assertFalse(e1.isLiteral());
    assertFalse(e2.isLiteral());
    assertTrue(u.unifies(e2, e1));
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
public void testCompare() throws ParseException {
    Literal p1 = ASSyntax.parseLiteral("ns1::a");
    Literal p2 = ASSyntax.parseLiteral("ns2::b");
    Literal p3 = ASSyntax.parseLiteral("ns2::a");
    
    //assertNotSame(p1.getPredicateIndicator().hashCode(), p2.getPredicateIndicator().hashCode() );
    //assertNotSame(p1.getPredicateIndicator().hashCode(), p3.getPredicateIndicator().hashCode() );
    assertNotSame(p1.hashCode(), p3.hashCode() );
    
    assertEquals(p1.compareTo(p2), -1);
    assertEquals(p1.compareTo(null), -1);
    assertEquals(p2.compareTo(p1), 1);
    assertEquals(p1.compareTo(p1), 0);

    p1 = ASSyntax.parseLiteral("ns1::a");
    p2 = ASSyntax.parseLiteral("ns1::b");
    
    assertEquals(p1.compareTo(p2), -1);
    assertEquals(p1.compareTo(null), -1);
    assertEquals(p2.compareTo(p1), 1);
    assertEquals(p1.compareTo(p1), 0);
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
public void testRelevant() throws JasonException, ParseException {
    PlanLibrary pl = new PlanLibrary();
    pl.add(Plan.parse("+p(0) <- .print(a)."));
    pl.add(Plan.parse("+p(X) : X > 0 <- .print(a)."));
    
    pl.add(Plan.parse("+!p(0) <- .print(a)."));
    pl.add(Plan.parse("+!p(X) : X > 0 <- .print(a)."));

    pl.add(Plan.parse("+!X <- .print(a)."));
    
    List<Plan> pls = pl.getCandidatePlans(ASSyntax.parseTrigger("+p(3)"));
    assertEquals(2, pls.size());

    pls = pl.getCandidatePlans(ASSyntax.parseTrigger("+!p(3)"));
    assertEquals(3, pls.size());    

    pls = pl.getCandidatePlans(ASSyntax.parseTrigger("+!bla"));
    assertEquals(1, pls.size());    

    pls = pl.getCandidatePlans(ASSyntax.parseTrigger("+bla"));
    assertNull(pls);    
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
public void testPlanTermWithVarBody() throws ParseException {
    Term pt = ASSyntax.parseTerm("{ +!g : c <- B }");
    assertEquals("{ +!g : c <- B }", pt.toString());
    assertTrue(pt instanceof Plan);
    
    Unifier u = new Unifier();
    u.unifies(new VarTerm("B"), ASSyntax.parseTerm("{ .print(a); .print(b); .print(c) }"));
    pt = pt.capply(u);
    assertEquals("{ +!g : c <- .print(a); .print(b); .print(c) }", pt.toString());
    pt = ASSyntax.parseTerm("{ +!g : c <- B; a1; B }");
    pt = pt.capply(u);
    assertEquals("{ +!g : c <- .print(a); .print(b); .print(c); a1; .print(a); .print(b); .print(c) }", pt.toString());
    
    pt = ASSyntax.parseTerm("{ +!g : c <- .print(0); B; B; .print(d); C }");
    u.unifies(new VarTerm("C"), ASSyntax.parseTerm("{ a1 }"));
    pt = pt.capply(u);
    assertEquals(9, ((Plan)pt).getBody().getPlanSize());
    assertEquals("{ +!g : c <- .print(0); .print(a); .print(b); .print(c); .print(a); .print(b); .print(c); .print(d); a1 }", pt.toString());
}
 

import jason.asSyntax.ASSyntax; //导入依赖的package包/类
public void testLogCons2() {
    Agent ag = new Agent();
    ag.initAg();
    
    Rule r = new Rule(Literal.parseLiteral("r([],a(X),b(X,4))"), Literal.parseLiteral("true"));
    ag.getBB().add(r);

    Iterator<Unifier> iun = Literal.parseLiteral("r([],a(20),X)").logicalConsequence(ag, new Unifier());
    //assertEquals(iun.next().get("X").toString(),"b(20,4)");
    assertTrue(iun.hasNext());
    Literal result = Literal.parseLiteral("r([],a(20),X)");
    Unifier u = iun.next();
    assertTrue(u.get("X").isStructure());
    assertEquals( ((Structure)u.get("X")).getArity(), 2);
    assertEquals( ((Structure)u.get("X")).getFunctor(), "b");
    assertEquals(result.capply(u), Literal.parseLiteral("r([],a(20),b(20,4))"));
    
    iun = Literal.parseLiteral("r([],a(20),b(X,Y))").logicalConsequence(ag, new Unifier());
    u = iun.next();
    assertEquals(u.get("X"), ASSyntax.createNumber(20));
    assertEquals(u.get("Y"), ASSyntax.createNumber(4));

}