Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  // ----------------------------------------------------------------------------
  // Copyright (C) 2003 Rafael H. Bordini, Jomi F. Hubner, et al.
  //
  // This library is free software; you can redistribute it and/or
  // modify it under the terms of the GNU Lesser General Public
  // License as published by the Free Software Foundation; either
  // version 2.1 of the License, or (at your option) any later version.
  //
  // This library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 // Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public
 // License along with this library; if not, write to the Free Software
 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 //
 // To contact the authors:
 // http://www.inf.ufrgs.br/~bordini
 // http://www.das.ufsc.br/~jomi
 //
 //----------------------------------------------------------------------------
 
 package jason.asSyntax;
 
 
 
Represents an AgentSpack plan (it extends structure to be used as a term)

Navassoc:
- label - Pred
Navassoc:
- event - Trigger
Navassoc:
- context - LogicalFormula
Navassoc:
- body - PlanBody
Navassoc:
- source - SourceInfo
 
 public class Plan extends Structure implements CloneableSerializable {
     
     private static final long serialVersionUID = 1L;
     private static final Term TAtomic         = ASSyntax.createAtom("atomic");
     private static final Term TBreakPoint     = ASSyntax.createAtom("breakpoint");
     private static final Term TAllUnifs       = ASSyntax.createAtom("all_unifs");
     
     private static Logger     logger          = Logger.getLogger(Plan.class.getName());
     
     private Pred              label  = null;
     private Trigger           tevent = null;
     private LogicalFormula    context;
     private PlanBody          body;
     
     private boolean isAtomic      = false;
     private boolean isAllUnifs    = false;
     private boolean hasBreakpoint = false;
     
     private boolean     isTerm = false// it is true when the plan body is used as a term instead of an element of a plan
 
     // used by clone
     public Plan() {
         super("plan", 0);
     }
     
     // used by parser
     public Plan(Pred labelTrigger teLogicalFormula ctPlanBody bd) {
         super("plan", 0);
          = te;
         .setAsTriggerTerm(false);
         setLabel(label);
         setContext(ct);
         if (bd == null) {
              = new PlanBodyImpl();
         } else {
              = bd;
             .setAsBodyTerm(false);
         }
     }
     
     @Override
     public int getArity() {
         return 4;
     }
     
     private static final Term noLabelAtom = new Atom("nolabel");
     
     @Override
     public Term getTerm(int i) {
         switch (i) {
         case 0: return ( == null) ?  : ;
         case 1: return ;
         case 2: return ( == null) ? . : ;
        case 3: return ;
        defaultreturn null;
        }
    }
    
    @Override
    public void setTerm(int iTerm t) {
        switch (i) {
        case 0:    = (Pred)tbreak;
        case 1:   = (Trigger)tbreak;
        case 2:  = (LogicalFormula)tbreak;
        case 3:     = (PlanBody)tbreak;
        }
    }
    
    public void setLabel(Pred p) {
         = p;
        if (p != null && p.hasAnnot()) {
            for (Term t.getAnnots()) {
                if (t.equals())
                     = true;
                if (t.equals())
                     = true;
                if (t.equals())
                     = true;
                // if change here, also change the clone()!
            }
        }
    }
    
    public Pred getLabel() {
        return ;
    }
    
    public void setContext(LogicalFormula le) {
         = le;
        if (..equals(le))
             = null;
    }
    
    public void setAsPlanTerm(boolean b) {
         = b;
    }

    
prefer using ASSyntax.parsePlan
    public static Plan parse(String sPlan) {
        as2j parser = new as2j(new StringReader(sPlan));
        try {
            return parser.plan();
        } catch (Exception e) {
            .log(."Error parsing plan " + sPlane);
            return null;
        }
    }
    
    

Deprecated:
use getTrigger
    public Trigger getTriggerEvent() {
        return ;
    }
    public Trigger getTrigger() {
        return ;
    }
    
    public LogicalFormula getContext() {
        return ;
    }
    
    public PlanBody getBody() {
        return ;
    }
    
    public boolean isAtomic() {
        return ;
    }
    
    public boolean hasBreakpoint() {
        return ;
    }
    public boolean isAllUnifs() {
        return 
    }
    
    
returns an unifier if this plan is relevant for the event te, returns null otherwise.
    public Unifier isRelevant(Trigger te) {
        // annots in plan's TE must be a subset of the ones in the event!
        // (see definition of Unifier.unifies for 2 Preds)
        Unifier u = new Unifier();
        if (u.unifiesNoUndo(te))
            return u;
        else
            return null;
    }
    
    @Override
    public boolean equals(Object o) {
        if (o == thisreturn true;
        if (o != null && o instanceof Plan) {
            Plan p = (Plano;
            if ( == null && p.context != nullreturn false;
            if ( != null && p.context != null && !.equals(p.context)) return false;
            return .equals(p.tevent) && .equals(p.body);
        }
        return false;
    }
        
    public Term clone() {
        Plan p = new Plan();
        if ( != null) { 
            p.label         = (Pred.clone();
            p.isAtomic      = ;
            p.hasBreakpoint = ;
            p.isAllUnifs    = ;
        }
        
        p.tevent = .clone();        
        if ( != null
            p.context = (LogicalFormula).clone();
        p.body = .clonePB();
        p.setSrcInfo();
        p.isTerm = ;
        return p;
    }

    
used to create a plan clone in a new IM
    public Plan cloneOnlyBody() {
        Plan p = new Plan();
        if ( != null) { 
            p.label         = ;
            p.isAtomic      = ;
            p.hasBreakpoint = ;
            p.isAllUnifs    = ;
        }
        
        p.tevent  = .clone();
        p.context = ;
        p.body    = .clonePB();
        
        p.setSrcInfo();
        p.isTerm = ;
        return p;
    }
    
    public String toString() {
        return toASString();
    }
    
    
returns this plan in a string complaint with AS syntax
    public String toASString() {
        String be;
        if () {
            b = "{ "
            e = " }";
        } else {
            b = ""
            e = ".";
        }
        return b+(( == null) ? "" : "@" +  + " ") + 
                + (( == null) ? "" : " : " + ) +
               (.isEmptyBody() ? "" : " <- " + ) +
               e;
    }
    
    
get as XML
    public Element getAsDOM(Document document) {
        Element u = (Elementdocument.createElement("plan");
        if ( != null) {
            Element l = (Elementdocument.createElement("label");
            l.appendChild(new LiteralImpl().getAsDOM(document));
            u.appendChild(l);
        }
        u.appendChild(.getAsDOM(document));
        
        if ( != null) {
            Element ec = (Elementdocument.createElement("context");
            ec.appendChild(.getAsDOM(document));
            u.appendChild(ec);
        }
        
        if (!.isEmptyBody()) {
            u.appendChild(.getAsDOM(document));
        }
        
        return u;
    }
New to GrepCode? Check out our FAQ X