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.asSemantics;
 
 
 
Represents and Intention (a stack of IntendedMeans). The comparable sorts the intentions based on the atomic property: atomic intentions comes first.

Author(s):
Jomi & Rafael
 
 public class Intention implements SerializableComparable<Intention>, Iterable<IntendedMeans> {
 
     private static final long serialVersionUID = 1L;
     public  static final Intention EmptyInt = null;
     private static AtomicInteger idCount = new AtomicInteger(0);
 
     private int     id;
     private int     atomicCount    = 0; // how many atomic intended means there are in the intention
     private boolean isSuspended = false;
     
     private Deque<IntendedMeansintendedMeans = new ArrayDeque<IntendedMeans>();
     
     //private Trigger initialTrigger = null; // just for adicional information/debug (not really necessary)
     
     //static private Logger logger = Logger.getLogger(Intention.class.getName());
 
     public Intention() {
          = .incrementAndGet();
     }
 
     public int getId() {
         return ;
     }
 
     public void push(IntendedMeans im) {
         .push(im);
         if (im.isAtomic()) 
             ++;
         //if (initialTrigger == null)
         //    initialTrigger = im.getTrigger();
     }
     
     public IntendedMeans peek() {
         return .peek();
     }
 
     public IntendedMeans pop() {
         IntendedMeans top = .pop();
 
         if (isAtomic() && top.isAtomic()) {
             --;
             /* for (IntendedMeans im : intendedMeans) {
                 if (im.isAtomic()) {
                     isAtomic = true;
                     break;
                 }
             }*/
         }
         return top;
     }
    public boolean isAtomic() {
        return  > 0;
    }
    
    public void setAtomic(int a) { // used for testing
         = a;
    }
    
    public Iterator<IntendedMeansiterator() {
        return .iterator(); 
    }
    public boolean isFinished() {
        return .isEmpty();
    }
    public int size() {
        return .size();
    }
    public void setSuspended(boolean b) {
         = b;
    }
    
    public boolean isSuspended() {
        return ;
    }
    
    
returns the IntendedMeans with TE = g, returns null if there isn't one
    public IntendedMeans getIM(Trigger gUnifier u) {
        for (IntendedMeans im : )
            //System.out.println(g + " = "+ im.getTrigger()+" = "+u.unifies(g, im.getTrigger()));
            if (u.unifies(gim.getTrigger()))
                return im;
        return null;
    }
    
    public IntendedMeans getBottom() {
        return .getLast();
    }
    
    
returns true if the intention has an IM where TE = g, using u to verify equality
    public boolean hasTrigger(Trigger gUnifier u) {
        //return getIM(g,u) != null;
        for (IntendedMeans im : )
            if (u.unifies(gim.getTrigger()))
                return true;
        return false;
    }

    
remove all IMs until the IM with trigger te
    public boolean dropGoal(Trigger teUnifier un) {
        IntendedMeans im = getIM(teun);
        if (im != null) {
            // remove the IMs until im-1
            while (peek() != im) {
                pop();
            }
            pop(); // remove im
            return true;
        }      
        return false;
    }
    
    
implements atomic intentions > not atomic intentions
    public int compareTo(Intention o) {
        if (o.atomicCount > this.return 1;
        if (this. > o.atomicCountreturn -1;
        
        if (o.id > this.return 1;
        if (this. > o.idreturn -1;
        return 0;
    }
    
    public boolean equals(Object o) {
        if (o == nullreturn false;
        if (o == thisreturn true;
        if (o instanceof Intentionreturn ((Intention)o). == this.;
        return false;
    }
    
    public int hashCode() {
        return ;
    }
    
    public Intention clone() {
        Intention i = new Intention();
        i.id = ;
        i.atomicCount = ;
        i.intendedMeans = new ArrayDeque<IntendedMeans>();
        for (IntendedMeans im) {
            i.intendedMeans.add((IntendedMeans)im.clone());
        }
        return i;
    }
        
    public String toString() {
        StringBuilder s = new StringBuilder("intention "++": \n");
        int i = 0;
        for (IntendedMeans im) {
            s.append("    " + im + "\n");
            if (i++ > 40) {
                s.append("... more "+ (size()-40) + " intended means!\n");
                break;
            }
        }
        if (isFinished())
            s.append("<finished intention>");
        return s.toString();
    }
    public Term getAsTerm() {
        Structure intention = new Structure("intention");
        intention.addTerm(new NumberTermImpl(getId()));
        ListTerm lt = new ListTermImpl();
        for (IntendedMeans im)
            lt.add(im.getAsTerm());
        intention.addTerm(lt);
        return intention;        
    }

    
get as XML
    public Element getAsDOM(Document document) {
        Element eint = (Elementdocument.createElement("intention");
        eint.setAttribute("id" + "");
        for (IntendedMeans im)
            eint.appendChild(im.getAsDOM(document));
        //if (intendedMeans.isEmpty())
        //    eint.appendChild( initialTrigger.getAsDOM(document));        
        eint.setAttribute("finished"""+isFinished());
        return eint;
    }
New to GrepCode? Check out our FAQ X