Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package jason.asSyntax;
  
  
  import java.util.Iterator;
  
Represents a plan body item (achieve, test, action, ...) and its successors. A plan body like a1; ?t; !g is represented by the following structure (a1, (?t, (!g))).

Author(s):
Jomi
Navassoc:
- next - PlanBody
Navassoc:
- type - PlanBody.BodyType
 
 public class PlanBodyImpl extends Structure implements PlanBodyIterable<PlanBody> {
 
     private static final long serialVersionUID = 1L;
     private static final Logger logger = Logger.getLogger(PlanBodyImpl.class.getName());
 
     public static final String BODY_PLAN_FUNCTOR = ";";
 
     private Term        term     = null
     private PlanBody    next     = null;
     private BodyType    formType = .;
     
     private boolean     isTerm = false// it is true when the plan body is used as a term instead of an element of a plan
     
    
constructor for empty plan body
 
     public PlanBodyImpl() {
         super(, 0);
     }
     
     public PlanBodyImpl(BodyType tTerm b) {
         super(, 0);
          = t;
         if (b != null) { 
              = b.getSrcInfo();
             // the atom issue is solved in TS
             //if (b.isAtom())
             //    b = ((Atom)b).forceFullLiteralImpl();
         }
          = b;
     }
 
     public void setBodyNext(PlanBody next) {
         this. = next;
     }
     public PlanBody getBodyNext() {
         return ;
     }
 
     public boolean isEmptyBody() {
         return  == null;
     }
     
     public BodyType getBodyType() {
         return ;
     }
     public void setBodyType(BodyType bt) {
          = bt;
     }
     
     public Term getBodyTerm() {
         return ;
     }
     
     public void setBodyTerm(Term t) {
          = t;
     }
     
     public boolean isBodyTerm() {
         return ;
     }
     
     @Override
     public boolean isAtom() {
         return false;
     }
     
     public void setAsBodyTerm(boolean b) {
         if (b != ) {
              = b;
             if (getBodyNext() != null// goes deep only if changed
                 getBodyNext().setAsBodyTerm(b);
         }
     }
     
     @Override
     public boolean isPlanBody() {
        return true;
    }
    
    public Iterator<PlanBodyiterator() {
        return new Iterator<PlanBody>() {
            PlanBody current = PlanBodyImpl.this;
            public boolean hasNext() {
                return  != null && .getBodyTerm() != null
            }
            public PlanBody next() {
                PlanBody r = ;
                if ( != null)
                     = .getBodyNext();
                return r;
            }
            public void remove() { }
        };
    }
    // Override some structure methods to work with unification/equals
    @Override
    public int getArity() {
        if ( == null)
            return 0;
        else if ( == null)
            return 1;
        else
            return 2;
    }
    @Override
    public Term getTerm(int i) {
        if (i == 0) 
            return ;
        if (i == 1) {
            if ( != null && .getBodyTerm().isVar() && .getBodyNext() == null
                // if next is the last VAR, return that var
                return .getBodyTerm();
            else
                return ;
        }
        return null;
    }
    @Override
    public void setTerm(int iTerm t) {
        if (i == 0)  = t;
        if (i == 1) ..println("Should not setTerm(1) of body literal!");
    }
    
    private boolean applyHead(Unifier u) {
        if ( != null && .apply(u)) {
            if (.isPlanBody()) { // we cannot have "inner" body literals
                PlanBody baknext = ;
                 = ((PlanBody)).getBodyType();
                     = ((PlanBody)).getBodyNext();
                     = ((PlanBody)).getBodyTerm();
                if (baknext != null) {
                    baknext.apply(u);
                    getLastBody().add(baknext);
                }
            }
            return true;
        }        
        return false;
    }
    @Override
    public boolean apply(Unifier u) {
        boolean ok =  != null && .apply(u);
        
        if (applyHead(u))
            ok = true;
        if (ok)
            resetHashCodeCache();
        return ok;
    }
    @Override
    public Iterator<UnifierlogicalConsequence(Agent agUnifier un) {
        .log(."PlanBodyImpl cannot be used for logical consequence!"new Exception());
        return ..iterator();
    }
    
    @Override
    public boolean equals(Object o) {
        if (o == nullreturn false;
        if (o == thisreturn true;
        if (o instanceof PlanBody) {
            PlanBody b = (PlanBody)o;
            return  == b.getBodyType() && super.equals(o);
        }
        return false;
    }
    @Override
    public int calcHashCode() {
        return .hashCode() + super.calcHashCode();
    }

    
clone the plan body and adds it in the end of this plan
    public boolean add(PlanBody bl) {
        if ( == null) {
            bl = bl.clonePB();
            swap(bl);
            this. = bl.getBodyNext();
        } else if ( == null) {
             = bl;
        } else { 
            .add(bl);
        }
        return true;
    }
    public PlanBody getLastBody() {
        if ( == null)
            return this;
        else
            return .getLastBody();
    }
    
    public boolean add(int indexPlanBody bl) {
        if (index == 0) {
            PlanBody newpb = new PlanBodyImpl(this.this.);
            newpb.setBodyNext();
            swap(bl);
            this. = bl.getBodyNext();
            this.getLastBody().setBodyNext(newpb);
        } else if ( != null) { 
            .add(index - 1, bl);
        } else {
             = bl;
        }
        return true;
    }
    public Term removeBody(int index) {
        if (index == 0) {
            Term oldvalue = ;
            if ( == null) {
                 = null// becomes an empty
            } else {
                swap(); // get values of text
                 = .getBodyNext();
            }
            return oldvalue;
        } else { 
            return .removeBody(index - 1);
        }
    }
    public int getPlanSize() {
        if ( == null
            return 0;
        else if ( == null)
            return 1;
        else
            return .getPlanSize() + 1;
    }
    private void swap(PlanBody bl) {
        BodyType bt = this.;
        this. = bl.getBodyType();
        bl.setBodyType(bt);
        Term l = this.;
        this. = bl.getBodyTerm();
        bl.setBodyTerm(l);
    }
    public PlanBody clone() {
        if ( == null// empty
            return new PlanBodyImpl();
        PlanBodyImpl c = new PlanBodyImpl(.clone());
        c.isTerm = ;
        if ( != null)
            c.setBodyNext(getBodyNext().clonePB());
        return c;
    }
    
    public PlanBody clonePB() {
        return clone();
    }
    
    public String toString() {
        if ( == null) {
            return "";
        } else {
            StringBuilder out = new StringBuilder();
            if ()
                out.append("{ ");
            PlanBody pb = this;
            while (pb != null) {
                if (pb.getBodyTerm() != null) {
                    out.append(pb.getBodyType());
                    out.append(pb.getBodyTerm());
                }
                pb = pb.getBodyNext();
                if (pb != null)
                    out.append("; ");
            }
            if (
                out.append(" }"); 
            return out.toString();
        }
    }

    
get as XML
    public Element getAsDOM(Document document) {
        Element eb = (Elementdocument.createElement("body");
        PlanBody bl = this;
        while (bl != null && !bl.isEmptyBody()) {
            Element u = (Elementdocument.createElement("body-literal");
            if (bl.getBodyType().toString().length() > 0) {
                u.setAttribute("type"bl.getBodyType().toString());
            }
            u.appendChild( ((Structure)bl.getBodyTerm()).getAsDOM(document));
            eb.appendChild(u);
            
            bl = bl.getBodyNext();
        }
        return eb;
    }
New to GrepCode? Check out our FAQ X