public XMLEventWriter createXMLEventWriter(XMLStreamWriter sw) throws XMLStreamException { XMLStreamWriter2 sw2 = Stax2WriterAdapter.wrapIfNecessary(sw); return new Stax2EventWriterImpl(sw2); }
public NamespaceContext getNamespaceContext() { if (!mNsAware) { return EmptyNamespaceContext.getInstance(); } return mCurrElem; }
public Iterator doGetPrefixes(String nsURI) { return EmptyIterator.getInstance(); } }
public byte[] getElementAsBinary(Base64Variant v) throws XMLStreamException { // note: code here is similar to Base64DecoderBase.aggregateAll(), see comments there Stax2Util.ByteAggregator aggr = _base64Decoder().getByteAggregator(); byte[] buffer = aggr.startAggregation(); while (true) { int offset = 0; int len = buffer.length; do { int readCount = readElementAsBinary(buffer, offset, len, v); if (readCount < 1) { // all done! return aggr.aggregateAll(buffer, offset); } offset += readCount; len -= readCount; } while (len > 0); buffer = aggr.addFullBlock(buffer); } }
public Iterator getNamespaces() { if (mNsList == null) { int firstLocal = mFirstLocalNs; int len = mNsLength - firstLocal; if (len == 0) { // can this happen? return EmptyIterator.getInstance(); } if (len == 2) { // only one NS return new SingletonIterator(NamespaceEventImpl.constructNamespace (mLocation, mNamespaces[firstLocal], mNamespaces[firstLocal+1])); } ArrayList l = new ArrayList(len >> 1); String[] ns = mNamespaces; for (len = mNsLength; firstLocal < len; firstLocal += 2) { l.add(NamespaceEventImpl.constructNamespace(mLocation, ns[firstLocal], ns[firstLocal+1])); } mNsList = l; } return mNsList.iterator(); }
public XMLStreamReader createFilteredReader(XMLStreamReader reader, StreamFilter filter) throws XMLStreamException { Stax2FilteredStreamReader fr = new Stax2FilteredStreamReader(reader, filter); /* [WSTX-111] As per Stax 1.0 TCK, apparently the filtered * reader is expected to be automatically forwarded to the first * acceptable event. This is different from the way RI works, but * since specs don't say anything about filtered readers, let's * consider TCK to be "more formal" for now, and implement that * behavior. */ if (!filter.accept(fr)) { // START_DOCUMENT ok? // Ok, nope, this should do the trick: fr.next(); } return fr; }
return new SingletonIterator(first); return EmptyIterator.getInstance();
public XMLEventWriter createXMLEventWriter(javax.xml.transform.Result result) throws XMLStreamException { return new Stax2EventWriterImpl(createSW(result)); }
public XMLEventReader createXMLEventReader(XMLStreamReader sr) throws XMLStreamException { return new WstxEventReader(createEventAllocator(), Stax2ReaderAdapter.wrapIfNecessary(sr)); }
public final Iterator getPrefixes(String nsURI) { /* First the known offenders; invalid args, 2 predefined xml namespace * prefixes */ if (nsURI == null || nsURI.length() == 0) { throw new IllegalArgumentException("Illegal to pass null/empty prefix as argument."); } if (nsURI.equals(XMLConstants.XML_NS_URI)) { return new SingletonIterator(XMLConstants.XML_NS_PREFIX); } if (nsURI.equals(XMLConstants.XMLNS_ATTRIBUTE_NS_URI)) { return new SingletonIterator(XMLConstants.XMLNS_ATTRIBUTE); } return doGetPrefixes(nsURI); }
public Iterator getAttributes() { if (mAttrList == null) { // List is lazily constructed as needed if (mAttrs == null) { return EmptyIterator.getInstance(); } String[] rawAttrs = mRawAttrs; int rawLen = rawAttrs.length; int defOffset = mAttrs.getFirstDefaultOffset(); if (rawLen == 4) { return new SingletonIterator (constructAttr(rawAttrs, 0, (defOffset == 0))); } ArrayList l = new ArrayList(rawLen >> 2); for (int i = 0; i < rawLen; i += 4) { l.add(constructAttr(rawAttrs, i, (i >= defOffset))); } mAttrList = l; } return mAttrList.iterator(); }
public XMLEventWriter createXMLEventWriter(Writer w, String enc) throws XMLStreamException { return new Stax2EventWriterImpl(createSW(null, w, enc, false)); }
public Iterator getNamespaces() { return EmptyIterator.getInstance(); }
return new SingletonIterator(XMLConstants.XML_NS_PREFIX); return new SingletonIterator(XMLConstants.XMLNS_ATTRIBUTE); return (l == null) ? EmptyIterator.getInstance() : l.iterator();
public XMLEventWriter createXMLEventWriter(OutputStream out, String enc) throws XMLStreamException { if (out == null) { throw new IllegalArgumentException("Null OutputStream is not a valid argument"); } return new Stax2EventWriterImpl(createSW(out, null, enc, false)); }
public Iterator getAttributes() { if (mAttrs == null) { return EmptyIterator.getInstance(); } return mAttrs.values().iterator(); }
public XMLEventWriter createXMLEventWriter(Writer w) throws XMLStreamException { if (w == null) { throw new IllegalArgumentException("Null Writer is not a valid argument"); } return new Stax2EventWriterImpl(createSW(null, w, null, false)); }
public Iterator getNamespaces() { if (mNsCtxt == null) { return EmptyIterator.getInstance(); } /* !!! 28-Sep-2004: Should refactor, since now it's up to ns context * to construct namespace events... which adds unnecessary * up-dependency from stream level to event objects. */ return mNsCtxt.getNamespaces(); }
return (l == null) ? EmptyIterator.getInstance() : l.iterator();
public Iterator doGetPrefixes(String nsURI) { // Note: base class checks for 'known' problems and prefixes: ArrayList l = null; for (int i = 0, len = mNamespaces.size(); i < len; ++i) { Namespace ns = (Namespace) mNamespaces.get(i); String uri = ns.getNamespaceURI(); if (uri == null) { uri = ""; } if (uri.equals(nsURI)) { if (l == null) { l = new ArrayList(); } String prefix = ns.getPrefix(); l.add((prefix == null) ? "" : prefix); } } if (mParentCtxt != null) { Iterator it = mParentCtxt.getPrefixes(nsURI); if (l == null) { return it; } while (it.hasNext()) { l.add(it.next()); } } return (l == null) ? EmptyIterator.getInstance() : l.iterator(); }