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;
 
 
 import java.util.List;
 import java.util.Map;
 
A Pred extends a Structure with annotations, e.g.: a(1)[an1,an2].
 
 public class Pred extends Structure {
 
     private static final long serialVersionUID = 1L;
     private static Logger logger = Logger.getLogger(Pred.class.getName());
 
     private ListTerm      annots;
 
     public Pred(String functor) {
         super(functor);
     }
 
     public Pred(Literal l) {
         super(l);
 
         if (l.hasAnnot()) {
              = l.getAnnots().cloneLT();
         } else {
              = null;
         }
     }
 
     // used by capply
     protected Pred(Literal lUnifier u) {
         super(l,u);
         if (l.hasAnnot()) {
             setAnnots( (ListTerm)l.getAnnots().capply(u) );
         } else {
              = null;
         }
     }
 
     public Pred(String functorint termsSize) {
         super(functortermsSize);
     }
     
     public static Pred parsePred(String sPred) {
         as2j parser = new as2j(new StringReader(sPred));
         try {
             return parser.pred();
         } catch (Exception e) {
             .log(."Error parsing predicate " + sPrede);
             return null;
         }
     }
 
     @Override
     public boolean isPred() {
         return true;
     }
 
     @Override
     public boolean isAtom() {
         return super.isAtom() && !hasAnnot();
     }
     
     @Override
     public boolean isGround() {
         if ( == null) {
            return super.isGround();
        } else {
            return super.isGround() && .isGround();
        }
    }
    /*
    @Override       
    public boolean apply(Unifier u) {
        boolean r1 = super.apply(u);
        boolean r2 = applyAnnots(u);
        return r1 || r2;
    }
    */
    /*
    private final boolean applyAnnots(Unifier u) {
        boolean r  = false;
        if (annots != null) {
            // if some annotation has variables that become ground, they need to be replaced in the list to maintain the order
            List<Term> toAdd = null;
            Iterator<ListTerm> i = annots.listTermIterator();
            while (i.hasNext()) {
                ListTerm lt = i.next();
                if (lt.isTail() && lt.getTail().apply(u)) { // have to test tail before term, since term test may lead to i.remove that remove also the tail
                    r = true;
                    lt.getTerm().apply(u); // apply for the term
                    setAnnots(annots); // sort all annots given from tail ground
                    break; // the iterator is inconsistent
                } else if (lt.getTerm() != null && lt.getTerm().apply(u)) {
                    r = true;
                    if (toAdd == null) 
                        toAdd = new ArrayList<Term>();
                    toAdd.add( lt.getTerm() );
                    i.remove();
                }
            }            
            if (toAdd != null)
                for (Term t: toAdd)
                    addAnnot(t);
        }
        return r;        
    }
    */
    
    @Override       
    public Literal setAnnots(ListTerm l) {
         = null;
        if (l == null)
            return this;
        Iterator<ListTermi = l.listTermIterator();
        while (i.hasNext()) {
            ListTerm lt = i.next();
            if (lt.getTerm() == null)
                return this;
            addAnnot(lt.getTerm()); // use addAnnot to sort them
            if (lt.isTail()) {
                .setTail(lt.getTail());
                return this;
            }
        }
        return this;
    }
    @Override       
    public boolean addAnnot(Term t) {
        if ( == null
             = new ListTermImpl();
        Iterator<ListTermi = .listTermIterator();
        while (i.hasNext()) {
            ListTerm lt = i.next();
            int c = t.compareTo(lt.getTerm());
            if (c == 0) { // equals
                return false;
            } else if (c < 0) {
                lt.insert(t);
                return true;
            }
        }
        return false;
    }
    @Override       
    public Literal addAnnots(List<Terml) {
        if (l != null
            for (Term t : l
                addAnnot(t);
        return this;
    }
    @Override       
    public Literal addAnnots(Term ... l) {
        for (Term t : l)
            addAnnot(t);
        return this;
    }
    @Override       
    public boolean delAnnot(Term t) {
        if ( == null)
            return false;
        else
            return .remove(t); // TODO: use the sorted annots to reduce search (as in addAnnot)
    }
    @Override       
    public void clearAnnots() {
         = null;
    }
    @Override       
    public ListTerm getAnnots() {
        return ;
    }
    @Override       
    public boolean hasAnnot(Term t) {
        if ( == null
            return false;
        // annots are ordered
        Iterator<ListTermi = .listTermIterator();
        while (i.hasNext()) {
            ListTerm lt = i.next();
            int c = t.compareTo(lt.getTerm());
            if (c == 0) { // equals
                return true;
            } else if (c < 0) {
                return false;
            }
        }
        return false//annots.contains(t);
    }
    
    @Override       
    public Literal getAnnot(String functor) {
        if ( == null
            return null;
        // annots are ordered
        for (Term t) {
            if (t.isLiteral()) {
                Literal l = (Literal)t;
                int c = functor.compareTo(l.getFunctor());
                if (c == 0) { // equals
                    return l;
                } else if (c < 0) {
                    return null;
                }
            }
        }
        return null;
    }
    @Override       
    public boolean hasAnnot() {
        return  != null && !.isEmpty();
    }
    @Override
    public boolean hasVar(VarTerm tUnifier u) {
        if (super.hasVar(tu)) 
            return true;
        if ( != null)
            for (Term v)
                if (v.hasVar(tu)) 
                    return true;
        return false;
    }
    
    @Override
    public void countVars(Map<VarTermIntegerc) {
        super.countVars(c);
        if ( != null)
            for (Term t) {
                t.countVars(c);
            }
    }
    @Override       
    public boolean importAnnots(Literal p) {
        boolean imported = false;
        if (p.hasAnnot()) {
            Iterator<Termi = p.getAnnots().iterator();
            while (i.hasNext()) {
                Term t = i.next();
                // p will only contain the annots actually added (for Event)
                if (addAnnot(t.clone())) {
                    imported = true;
                } else {
                    i.remove(); // Remove what is not new from p
                }
            }
        }
        return imported;
    }
    @Override
    public boolean delAnnots(List<Terml) {
        boolean removed = false;
        if (l != null && this.hasAnnot()) {
            for (Term tl) { 
                boolean r = delAnnot(t);
                removed = removed || r;
            }
        }
        return removed;
    }
    @Override
    public ListTerm getAnnots(String functor) {
        ListTerm ls = new ListTermImpl();
        if ( != null) {
            ListTerm tail = ls;
            for (Term ta : ) {
                if (ta.isLiteral()) {
                    if (((Literal)ta).getFunctor().equals(functor)) {
                        tail = tail.append(ta);
                    }
                }
            }
        }
        return ls;
    }
    @Override
    public boolean hasSubsetAnnot(Literal p) {
        if ( == null
            return true;
        if (hasAnnot() && !p.hasAnnot()) 
            return false;
        
        // both has annots (annots are ordered)
        Iterator<Termi2 = p.getAnnots().iterator();
        int c = -1;
        for (Term myAnnot : ) { // all my annots should be member of p annots
            // move i2 until it is >= myAnnot
            if (!i2.hasNext())
                return false;
            while (i2.hasNext()) {
                Term t = i2.next();
                c = myAnnot.compareTo(t);
                if (c <= 0)
                    break// found my annot in p's annots OR my annot is not in p's annots, stop searching 
            }
            if (c != 0)
                return false;            
        }
        return true;
    }
    @Override
    public boolean hasSubsetAnnot(Literal pUnifier u) {
        if ( == null
            return true;
        if (!p.hasAnnot()) 
            return false;
        Term thisTail    = null;
        // since p's annots will be changed, clone the list (but not the terms)
        ListTerm pAnnots     = p.getAnnots().cloneLTShallow();
        VarTerm  pTail       = pAnnots.getTail();
        Term pAnnot          = null;
        ListTerm pAnnotsTail = null;
        Iterator<Termi2 = pAnnots.iterator();
        boolean i2Reset   = false;
        
        Iterator<ListTermi1 = .listTermIterator(); // use this iterator to get the tail of the list
        while (i1.hasNext()) {
            ListTerm lt = i1.next();
            Term annot = lt.getTerm();
            if (annot == null)
                break;
            if (lt.isTail())
                thisTail = lt.getTail();
            if (annot.isVar() && !i2Reset) { // when we arrive to the vars in the annots of this, we need to start searching from the begin again
                i2Reset = true;
                i2 = pAnnots.iterator();
                pAnnot = null;
            }
            
            // search annot in p's annots
            boolean ok = false;
            while (true) {
                if (pAnnot != null && u.unifiesNoUndo(annotpAnnot)) {
                    ok = true;
                    i2.remove();
                    pAnnot = i2.next();
                    break;
                } else if (pAnnot != null && pAnnot.compareTo(annot) > 0) {
                    break// quite the loop, the current p annot is greater than this annot, so annot is not in p's annots
                } else if (i2.hasNext()) {
                    pAnnot = i2.next();
                } else {
                    break;
                }
            }
            
            // if p has a tail, add annot in p's tail
            if (!ok && pTail != null) {
                if (pAnnotsTail == null) { 
                    pAnnotsTail = (ListTerm)u.get(pTail);
                    if (pAnnotsTail == null) {
                        pAnnotsTail = new ListTermImpl();
                        u.unifies(pTailpAnnotsTail);
                        pAnnotsTail = (ListTerm)u.get(pTail);
                    }
                }
                pAnnotsTail.add(annot.clone());
                ok = true;
            }
            if (!ok
                return false;
        }
        // if this Pred has a Tail, unify it with p remaining annots
        if (thisTail != null)  
            u.unifies(thisTailpAnnots);
        
        return true;
    }
    
    @Override
    public void addSource(Term agName) {
        if (agName != null)
            addAnnot(createSource(agName));
    }
    @Override
    public boolean delSource(Term agName) {
        if ( != null)
            return delAnnot(createSource(agName));
        else
            return false;
    }
    public static Pred createSource(Term source) {
        Pred s;
        if (source.isGround()) {
            s = new Pred("source",1) {
                @Override
                public Term clone() {
                    return this;
                }
                @Override
                public Term capply(Unifier u) {
                    return this;
                }
                @Override
                public boolean isGround() {
                    return true;
                }
                @Override
                public Literal makeVarsAnnon() {
                    return this;
                }
                @Override
                public Literal makeVarsAnnon(Unifier un) {
                    return this;
                }
            };
        } else { // source is a var, so cannot be optimised
            s = new Pred("source",1);
        }
        s.addTerm(source);
        return s;
    }
    
    @Override
    public ListTerm getSources() {
        ListTerm ls = new ListTermImpl();
        if ( != null) {
            ListTerm tail = ls;
            for (Term ta : ) {
                if (ta.isStructure()) {
                    Structure tas = (Structure)ta;
                    if (tas.getFunctor().equals("source")) {
                        tail = tail.append(tas.getTerm(0));
                    }
                }
            }
        }
        return ls;
    }
    @Override
    public void delSources() {
        if ( != null) {
            Iterator<Termi = .iterator();
            while (i.hasNext()) {
                Term t = i.next();
                if (t.isStructure()) {
                    if (((Structure)t).getFunctor().equals("source")) {
                        i.remove();
                    }
                }
            }
        }
    }
    @Override
    public boolean hasSource() {
        if ( != null) {
            for (Term ta : ) {
                if (ta.isStructure()) {
                    if (((Structure)ta).getFunctor().equals("source")) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    @Override
    public boolean hasSource(Term agName) {
        if ( != null) {
            return hasAnnot(createSource(agName));
        }
        return false;
    }
    
    @Override
    public Literal makeVarsAnnon(Unifier un) {
        if ( != null) {
            ListTerm lt = ;
            while (!lt.isEmpty()) {
                Term ta = lt.getTerm();
                if (ta.isVar())
                    lt.setTerm(varToReplace(taun));
                else if (ta instanceof Structure)
                    ((Structure)ta).makeVarsAnnon(un);
                if (lt.isTail() && lt.getNext().isVar()) {
                    lt.setNext(varToReplace(lt.getNext(), un));
                    break;
                }
                lt = lt.getNext();
            }
        }
        return super.makeVarsAnnon(un);
    }
    
    @Override
    public boolean equals(Object o) {
        if (o == nullreturn false;
        if (o == thisreturn true;
        if (o instanceof Pred) {
            final Pred p = (Predo;
            return super.equals(o) && this.hasSubsetAnnot(p) && p.hasSubsetAnnot(this);
        } else if (o instanceof Atom && !hasAnnot() ) { // if o is some object that extends Atom (e.g. structure), goes to super equals
            return super.equals(o);                     // consider super equals only when this has no annots
        }
        return false;
    }
    
    public boolean equalsAsStructure(Object p) { // this method must be in this class, do not move (I do not remember why!)
        return super.equals((Termp);
    }
    @Override
    public int compareTo(Term t) {
        int c = super.compareTo(t);
        if (c != 0) 
            return c;
        
        if (t.isPred()) {
            Pred tAsPred = (Pred)t;
            if (getAnnots() == null && tAsPred.getAnnots() == nullreturn 0;
            if (getAnnots() == nullreturn -1;
            if (tAsPred.getAnnots() == nullreturn 1;
    
            Iterator<Termpai = tAsPred.getAnnots().iterator();
            for (Term a : getAnnots()) {
                c = a.compareTo(pai.next());
                if (c != 0) 
                    return c;
            }
            final int ats = getAnnots().size();
            final int ots = tAsPred.getAnnots().size(); 
            if (ats < otsreturn -1;
            if (ats > otsreturn 1;
        }
        return 0;
    }
    @Override
    public Term capply(Unifier u) {
        return new Pred(this,u);
    }
    public Term clone() {
        return new Pred(this);
    }
    public String toStringAsTerm() {
        return super.toString();
    }
    public String toString() {
        String s = super.toString();
        if (hasAnnot())  s += .toString();
        return s;
    }

    
get as XML
    @Override
    public Element getAsDOM(Document document) {
        Element u = super.getAsDOM(document);
        if (hasAnnot()) {
            Element ea = document.createElement("annotations");
            ea.appendChild(getAnnots().getAsDOM(document));
            u.appendChild(ea);
        }
        return u;
    }
New to GrepCode? Check out our FAQ X