* Because AGAVE has nested feature and each feature must attached to * some parent feature-holder in biojava, which means we need to generate parents first, * so we have to keep the tree structure of features in memory, which is really bad. * anyway, we still saved a lot of memory compared with DOM tree . Hanning Ni) * @author copied from Thomas Down * @author copied from David Huen * @author Hanning Ni Doubletwist Inc * */ public class StAXFeatureHandler extends StAXContentHandlerBase { // class variables private boolean setOnceFired = false; protected String myLocalName; private boolean hasCallback = false; private List handlers; private boolean startFired=false; private boolean endFired=false; private boolean inFeature=false; // have we been here before? // class variables for use by nested elements protected Feature.Template featureTemplate; protected StAXFeatureHandler staxenv ; protected SeqIOListener featureListener; protected int startLoc; protected int endLoc; // needed because some XML don't give start and stops as attributes. /** * this is the stack of handler objects for the current feature. * The base value is the FeatureHandler itself. * your feature and property handlers place and remove themselves * from this stack. * * the purpose of all this is to implement context sensitivty for * property handlers translucently. Property handlers can pop the * stack for other handlers that implement interfaces that process * that element. This way the context code is within the object that * defines that context rather than in a child property handler. */ protected List callbackStack; protected int stackLevel; //store all the sub features, should be a tree structure with the root is //top level seqeuence protected List subFeatures ; protected SimpleAnnotation annot = new SimpleAnnotation(); StAXFeatureHandler(StAXFeatureHandler staxenv) { // cache environmnet this.staxenv = staxenv; handlers = new ArrayList(); callbackStack = new ArrayList(); subFeatures = new ArrayList(1) ; } StAXFeatureHandler() { handlers = new ArrayList(); callbackStack = new ArrayList(); subFeatures = new ArrayList(1) ; } // there should be a factory method here to make this class /** * Sets the element name that the class responds to. */ public void setHandlerCharacteristics(String localName, boolean hasCallback) { if (!setOnceFired) { myLocalName = localName; this.hasCallback = hasCallback; setOnceFired = true; } } public void setFeatureListener(SeqIOListener siol) { featureListener = siol; } // Class to implement bindings class Binding { final ElementRecognizer recognizer; final StAXHandlerFactory handlerFactory; Binding(ElementRecognizer er, StAXHandlerFactory hf) { recognizer = er; handlerFactory = hf; } } // method to add a handler // we do not distinguish whither it is a feature or property // handler. The factory method creates the right type subclassed // from the correct type of handler protected void addHandler( ElementRecognizer rec, StAXHandlerFactory handler) { handlers.add(new Binding(rec, handler)); } /** * generates a very basic Template for the feature with * SmallAnnotation in the annotation field. *
* Override if you wish a more specialised Template. */ protected Feature.Template createTemplate() { // create Gene Template for this StrandedFeature.Template st = new StrandedFeature.Template(); // assume feature set to describe a transcript st.source = myLocalName; st.type = myLocalName; st.strand = StrandedFeature.UNKNOWN; // set up annotation bundle st.annotation = annot ; st.location = Location.empty; if( staxenv != null ) staxenv. subFeatures .add( this ) ; return st; } /** * recursively attach children features to parent */ protected void realizeSubFeatures(Feature feature) { try{ Iterator it = subFeatures.iterator() ; while( it.hasNext() ) { StAXFeatureHandler handler = (StAXFeatureHandler)it.next() ; if( handler instanceof SequenceHandler ) //already handled continue ; Feature f = feature.createFeature ( handler.featureTemplate ) ; handler.realizeSubFeatures( f ) ; } }catch(BioException e){ e.printStackTrace();} catch(ChangeVetoException e){ e.printStackTrace();} } protected void addFeatureToSequence(Sequence seq) throws Exception { Iterator it = subFeatures.iterator() ; while( it.hasNext() ) { StAXFeatureHandler handler = (StAXFeatureHandler)it.next() ; Feature f = seq.createFeature ( handler.featureTemplate ) ; handler.realizeSubFeatures( f ) ; } } /** * return current stack level. Remember that the * stack level is incremented/decremented AFTER * the push()/pop() calls and superclass * startElement()/StopElement calls. */ protected int getLevel() { return stackLevel; } /** * return iterator to callbackStack */ protected ListIterator getHandlerStackIterator(int level) { return callbackStack.listIterator(level); } /** * Push StAXContentHandler object onto stack */ protected void push(StAXContentHandler handler) { // push handler callbackStack.add(handler); // increment pointer stackLevel++; } /** * pop a StAXContentHandler off the stack. */ protected void pop() { // decrement pointer stackLevel--; // pop handler callbackStack.remove(stackLevel); } /** * Return current feature listener */ public SeqIOListener getFeatureListener() { return featureListener; } /** * Fire the startFeature event. */ private void fireStartFeature() throws ParseException { if (startFired) throw new ParseException("startFeature event has already been fired"); if (featureTemplate == null) featureTemplate = createTemplate(); if (featureTemplate.annotation == null) featureTemplate.annotation = Annotation.EMPTY_ANNOTATION; featureListener.startFeature(featureTemplate); startFired = true; } /** * Fire the endFeature event. */ private void fireEndFeature() throws ParseException { if (!startFired) throw new ParseException("startFeature has not yet been fired!"); if (endFired) throw new ParseException("endFeature event has already been fired!"); featureListener.endFeature(); endFired = true; } protected void setProperty(String name, String value, boolean forFeature) { if ( value != null) { try { annot.setProperty( name, value); if( forFeature ) featureListener.addFeatureProperty(name, value); else featureListener.addSequenceProperty(name, value); } catch (ChangeVetoException cae) { System.err.println(" veto exception caught."); } catch (ParseException cae) { System.err.println("parse exception in addProperty() ."); } } } /** * Element-specific handler. * Subclass this to do something useful! */ public void startElementHandler( String nsURI, String localName, String qName, Attributes attrs) throws SAXException { } /** * Handles basic entry processing for all feature handlers. */ public void startElement( String nsURI, String localName, String qName, Attributes attrs, DelegationManager dm) throws SAXException { // sanity check if (!setOnceFired) throw new SAXException("StAXFeaturehandler not initialised before use!"); // find out if this element is really for me. // perform delegation // if (!(myLocalName.equals(localName)) ) { if( dm.getRecursive() ) for (int i = handlers.size() - 1; i >= 0; --i) { Binding b = (Binding) handlers.get(i); if (b.recognizer.filterStartElement(nsURI, localName, qName, attrs)) { dm.delegate(b.handlerFactory.getHandler(this)); return; } } // } // I don't have a delegate for it but it might be a stray... if (!(myLocalName.equals(localName)) ) { //this one's not for me! return; } // this one's mine. // initialise if this is the first time thru' if (!inFeature) { inFeature = true; if (hasCallback) { if (stackLevel == 0) push(this); } // indicate start of feature to listener try { if (!startFired) fireStartFeature(); } catch (ParseException pe) { throw new SAXException("ParseException thrown in user code"); } } // call the element specific handler now. startElementHandler(nsURI, localName, qName, attrs); } /** * Element specific exit handler * Subclass to do anything useful. */ public void endElementHandler( String nsURI, String localName, String qName, StAXContentHandler handler) throws SAXException { } /** * Handles basic exit processing. */ public void endElement( String nsURI, String localName, String qName, StAXContentHandler handler) throws SAXException { // is this a return after delegation or really mine? if (!(myLocalName.equals(localName)) ) return; // last chance to clear up before exiting //endElementHandler(nsURI, localName, qName, handler); // it's mine, get prepared to leave. if (hasCallback) pop(); // is it time to go beddy-byes? if (stackLevel == 0) { // we need to cope with zero-sized elements try { if (!startFired) fireStartFeature(); if (!endFired) fireEndFeature(); } catch (ParseException pe) { throw new SAXException("ParseException thrown in user code"); } } endElementHandler(nsURI, localName, qName, handler); } }