Java ASSyntax.createLiteral方法代码示例

import jason.asSyntax.ASSyntax; //导入方法依赖的package包/类
public void testMakeVarAnnon6() {
    UnnamedVar v1 = new UnnamedVar();
    UnnamedVar v2 = new UnnamedVar();
    
    Literal l = ASSyntax.createLiteral("p", v1, v2, ASSyntax.createList(v1,v2));
    l.makeVarsAnnon();
    
    // vars inside the list should be replaced as var placed in term0 and term1
    assertEquals(l.getTerm(0).toString(), ((ListTerm)l.getTerm(2)).get(0).toString());
}
 

import jason.asSyntax.ASSyntax; //导入方法依赖的package包/类
public void msgSent(Message m) {
    //getTS().getLogger().fine("Message:"+m);

    // add a belief in the agent mind
    // format: msgSent(time(YY,MM,DD,HH,MM,SS),id,irt,ilf,sender,receiver,content)

    Calendar now = new GregorianCalendar();
    Structure p = ASSyntax.createStructure("time",
                                           ASSyntax.createNumber(now.get(Calendar.YEAR)),
                                           ASSyntax.createNumber(now.get(Calendar.MONTH)),
                                           ASSyntax.createNumber(now.get(Calendar.DAY_OF_MONTH)),
                                           ASSyntax.createNumber(now.get(Calendar.HOUR)),
                                           ASSyntax.createNumber(now.get(Calendar.MINUTE)),
                                           ASSyntax.createNumber(now.get(Calendar.SECOND)));
    Literal e = ASSyntax.createLiteral("msg_sent", p);

    e.addTerm(new StringTermImpl(m.getMsgId()));
    if (m.getInReplyTo() == null) {
        e.addTerm(new Atom("nirt"));
    } else {
        e.addTerm(new StringTermImpl(m.getInReplyTo()));
    }
    e.addTerm(new Atom(m.getIlForce()));
    e.addTerm(new Atom(m.getSender()));
    e.addTerm(new Atom(m.getReceiver()));
    e.addTerm(new StringTermImpl(m.getPropCont().toString()));
    try {
        getTS().getAg().addBel(e);
    } catch (RevisionFailedException e1) {
        e1.printStackTrace();
    }
}
 

import jason.asSyntax.ASSyntax; //导入方法依赖的package包/类
void testFood(String agName, int ag, Atom where, int x, int y) {
    if (model.hasObject(FoodModel.FOOD, x, y)) {
        Literal f = ASSyntax.createLiteral("food",
                                           ASSyntax.createNumber(x),
                                           ASSyntax.createNumber(y),
                                           where,
                                           ASSyntax.createNumber(model.getFoodOwner(x, y)));
        addPercept(agName, f);
    }
}
 

import jason.asSyntax.ASSyntax; //导入方法依赖的package包/类
@Override
public boolean executeAction(String agName, Structure action) {
    actionCount++;
    Literal p = ASSyntax.createLiteral("executed_actions", ASSyntax.createNumber(actionCount));
    clearPercepts();
    addPercept(p);
    return true;
}
 

import jason.asSyntax.ASSyntax; //导入方法依赖的package包/类
protected void notifyActionFailure(ActionExec actionExec, Term reason, String msg) {
	// logger.info("notified failure for "+actionExec.getActionTerm()+" - reason: "+reason);
	actionExec.setResult(false);
	Literal descr = null;
	if (reason != null) {
		descr = ASSyntax.createLiteral("env_failure_reason", reason);
	}
	actionExec.setFailureReason(descr, msg);
	super.actionExecuted(actionExec);
}
 

import jason.asSyntax.ASSyntax; //导入方法依赖的package包/类
private void updateAgPercept(String agName, int ag) {
    clearPercepts(agName);
    // its location
    Location l = model.getAgPos(ag);
    Literal p = ASSyntax.createLiteral("pos",
                                       ASSyntax.createNumber(l.x),
                                       ASSyntax.createNumber(l.y),
                                       ASSyntax.createNumber(getStep()));
    addPercept(agName, p);

    Literal cg = ASSyntax.createLiteral("carrying_gold", ASSyntax.createNumber(model.getGoldsWithAg(ag)));
    addPercept(agName, cg);

    if (model.mayCarryMoreGold(ag)) {
        addPercept(agName, aCAP);
    }

    // what's around
    updateAgPercept(agName, ag, l.x - 1, l.y - 1);
    updateAgPercept(agName, ag, l.x - 1, l.y);
    updateAgPercept(agName, ag, l.x - 1, l.y + 1);
    updateAgPercept(agName, ag, l.x, l.y - 1);
    updateAgPercept(agName, ag, l.x, l.y);
    updateAgPercept(agName, ag, l.x, l.y + 1);
    updateAgPercept(agName, ag, l.x + 1, l.y - 1);
    updateAgPercept(agName, ag, l.x + 1, l.y);
    updateAgPercept(agName, ag, l.x + 1, l.y + 1);
}
 

import jason.asSyntax.ASSyntax; //导入方法依赖的package包/类
@Override
public Agent process(Pred directive, Agent outerContent, Agent innerContent) {
    try {
        Agent newAg = new Agent();
        newAg.initAg();
        
        Literal goal = Literal.parseLiteral(directive.getTerm(0).toString());

        // add +!g : g <- true.
        newAg.getPL().add(ASSyntax.parsePlan("+!"+goal+" : " +goal+"."));
        
        // change all inner plans
        int i = 0;
        for (Plan p: innerContent.getPL()) {
            if (p.getTrigger().isAchvGoal()) {
                Literal planGoal = p.getTrigger().getLiteral();
                if (new Unifier().unifies(planGoal, goal)) { // if the plan goal unifier the pattern goal
                    i++;
                    // create p__f(i,g)
                    Literal pi = ASSyntax.createLiteral("p__f", ASSyntax.createNumber(i), goal.copy());
                    
                    // change context to "not p__f(i,g) & c"
                    LogicalFormula context = p.getContext();
                    if (context == null) {
                        p.setContext(new LogExpr(LogicalOp.not, pi));
                    } else {
                        p.setContext(new LogExpr(new LogExpr(LogicalOp.not, pi), LogicalOp.and, context));
                    }
                    
                    // change body
                    // add +p__f(i,g)
                    PlanBody b1 = new PlanBodyImpl(BodyType.addBel, pi);
                    p.getBody().add(0, b1);
                    // add ?g
                    PlanBody b2 = new PlanBodyImpl(BodyType.test, planGoal.copy()); //goal.copy());
                    p.getBody().add(b2);
                }
            }
            newAg.getPL().add(p);
        }
        

        // add -!g : true <- !!g.
        newAg.getPL().add(ASSyntax.parsePlan("-!"+goal+" <- !!"+goal+"."));

        // add +g : true <- .abolish(p__f(_,g)); .succeed_goal(g).
        newAg.getPL().add(ASSyntax.parsePlan("+"+goal+" <- .abolish(p__f(_,"+goal+")); .succeed_goal("+goal+")."));

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

import jason.asSyntax.ASSyntax; //导入方法依赖的package包/类
public static Literal perceptToLiteral(Percept per) throws JasonException {
    Literal l = ASSyntax.createLiteral(per.getName());
    for (Parameter par: per.getParameters())
        l.addTerm(parameterToTerm(par));
    return l;
}
 

import jason.asSyntax.ASSyntax; //导入方法依赖的package包/类
private Literal createState(DeonticModality o) {
    Literal s = ASSyntax.createLiteral(o.getState().name(), o);
    s.addSource(NormAtom);
    return s;
}
 

import jason.asSyntax.ASSyntax; //导入方法依赖的package包/类
List<Literal> getGoalStates() {
    List<Literal> all = new ArrayList<Literal>();
    Term tSch = ASSyntax.createAtom(this.getId().getName());
    for (Goal g: spec.getGoals()) {
        Atom aGoal  = new Atom(g.getId());
        Literal lGoal = ASSyntax.createLiteral(g.getId());

        // add arguments
        // removed to keep it compatible with obligation event
        // goalArgValue obs property was added for that
        /*if (g.hasArguments()) {
            for (String arg: g.getArguments().keySet()) {
                String value = getSchState().getGoalArgValue(g.getId(), arg);
                if (value == null) {
                    lGoal.addTerm(new VarTerm(arg));
                } else {
                    try {
                        lGoal.addTerm(ASSyntax.parseTerm(value));
                    } catch (jason.asSyntax.parser.ParseException e) {
                        lGoal.addTerm(new StringTermImpl(value));
                    }
                }
            }
        }*/

        // state
        Atom aState = aWaiting;
        if (nengine.holds(new NPLLiteral(ASSyntax.createLiteral("satisfied", tSch, aGoal), orgState))) {
            aState = aSatisfied;
        } else if (nengine.holds(ASSyntax.createLiteral("well_formed", tSch)) &&
            nengine.holds(ASSyntax.createLiteral("enabled", tSch, aGoal))) {
            aState = aEnabled;
        }

        // performed by
        ListTerm lAchievedBy = new ListTermImpl();
        ListTerm tail = lAchievedBy;
        for (Literal p: getSchState().getDoneGoals()) {
            if (p.getTerm(1).equals(aGoal))
                tail = tail.append(p.getTerm(2));
        }

        // create the literal
        Literal lGoalSt = ASSyntax.createLiteral(
                piGoalState.getFunctor(),
                tSch,
                lGoal,
                getSchState().getCommittedAgents(g), // lCommittedBy
                lAchievedBy,
                aState);
        all.add(lGoalSt);
    }
    return all;
}