java.lang.Object
- org.codehaus.stax2.ri.Stax2WriterImpl
- - com.ctc.wstx.sw.BaseStreamWriter

All Implemented Interfaces:

OutputConfigFlags, XMLStreamConstants, XMLStreamWriter, TypedXMLStreamWriter, Validatable, ValidationContext, XMLStreamWriter2

Direct Known Subclasses:

TypedStreamWriter
```
public abstract class BaseStreamWriter
extends Stax2WriterImpl
implements ValidationContext, OutputConfigFlags
```
Base class for XMLStreamWriter implementations Woodstox has. Contains partial stream writer implementation, plus utility methods shared by concrete implementation classes. Main reason for such abstract base class is to allow other parts of Woodstox core to refer to any of stream writer implementations in general way.

Field Summary

Fields
Modifier and Type	Field	Description
`protected static int`	`ATTR_MIN_ARRAYCOPY`
`protected static char`	`CHAR_SPACE`
`protected static int`	`DEFAULT_COPYBUFFER_LEN`
`protected boolean`	`mAnyOutput`	Flag that is set to true first time something has been output.
`protected boolean`	`mCfgAutomaticEmptyElems`
`protected boolean`	`mCfgCDataAsText`
`protected boolean`	`mCfgCopyDefaultAttrs`
`protected boolean`	`mCheckAttrs`
`protected boolean`	`mCheckStructure`
`protected WriterConfig`	`mConfig`
`protected char[]`	`mCopyBuffer`	Intermediate buffer into which characters of a String can be copied, in cases where such a copy followed by array access is faster than calling `String.charAt()` (which perhaps surprisingly is often case, and especially significant for longer buffers).
`protected String`	`mDtdRootElem`	Value passed as the expected root element, when using the multiple argument `writeDTD(java.lang.String)` method.
`protected boolean`	`mEmptyElement`	Flag that indicates that current element is an empty element (one that is explicitly defined as one, by calling a method -- NOT one that just happens to be empty).
`protected String`	`mEncoding`	Encoding to use; may be passed from the factory (when a method that defines encoding is used), updated by a call to `writeStartDocument()`, or null if neither.
`protected static int`	`MIN_ARRAYCOPY`	This constant defines minimum length of a String, for which it is beneficial to do an intermediate copy (using String.getChars()), and iterate over intermediate array, instead of iterating using String.charAt().
`protected boolean`	`mReturnNullForDefaultNamespace`
`protected boolean`	`mStartElementOpen`	Flag that is set during time that a start element is "open", ie.
`protected int`	`mState`
`protected XMLValidator`	`mValidator`	Optional validator to use for validating output against one or more schemas, and/or for safe pretty-printing (indentation).
`protected int`	`mVldContent`	State value used with validation, to track types of content that is allowed at this point in output stream.
`protected ValidationProblemHandler`	`mVldProbHandler`	Custom validation problem handler, if any.
`protected XmlWriter`	`mWriter`	Actual physical writer to output serialized XML content to
`protected boolean`	`mXml11`	Since XML 1.1 has some differences to 1.0, we need to keep a flag to indicate if we were to output XML 1.1 document.
`protected static int`	`STATE_EPILOG`
`protected static int`	`STATE_PROLOG`
`protected static int`	`STATE_TREE`

Fields inherited from interface com.ctc.wstx.cfg.OutputConfigFlags
CFG_ADD_SPACE_AFTER_EMPTY_ELEM, CFG_AUTO_CLOSE_OUTPUT, CFG_AUTOMATIC_EMPTY_ELEMENTS, CFG_AUTOMATIC_END_ELEMENTS, CFG_AUTOMATIC_NS, CFG_COPY_DEFAULT_ATTRS, CFG_ENABLE_NS, CFG_ESCAPE_CR, CFG_FIX_CONTENT, CFG_OUTPUT_CDATA_AS_TEXT, CFG_USE_DOUBLE_QUOTES_IN_XML_DECL, CFG_VALIDATE_ATTR, CFG_VALIDATE_CONTENT, CFG_VALIDATE_NAMES, CFG_VALIDATE_STRUCTURE

Fields inherited from interface javax.xml.stream.XMLStreamConstants
ATTRIBUTE, CDATA, CHARACTERS, COMMENT, DTD, END_DOCUMENT, END_ELEMENT, ENTITY_DECLARATION, ENTITY_REFERENCE, NAMESPACE, NOTATION_DECLARATION, PROCESSING_INSTRUCTION, SPACE, START_DOCUMENT, START_ELEMENT

Constructor Summary

Constructors
Modifier Constructor Description

protected BaseStreamWriter(XmlWriter xw, String enc, WriterConfig cfg)

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`int`	`addDefaultAttribute(String localName, String uri, String prefix, String value)`	Adding default attribute values does not usually make sense on output side, so the implementation is a NOP for now.
`void`	`close()`
`void`	`closeCompletely()`	Method similar to `XMLStreamWriter.close()`, except that this method also does close the underlying output destination (stream) if it has not yet been closed.
`protected abstract void`	`closeStartElement(boolean emptyElem)`	Method called to close an open start element, when another main-level element (not namespace declaration or attribute) is being output; except for end element which is handled differently.
`void`	`copyEventFromReader(XMLStreamReader2 sr, boolean preserveEventData)`	Method that essentially copies event that the specified reader has just read.
`abstract void`	`copyStartElement(InputElementStack elemStack, AttributeCollector attrCollector)`	Implementation-dependant method called to fully copy START_ELEMENT event that the passed-in stream reader points to
`protected void`	`doReportProblem(XMLReporter rep, String probType, String msg, Location loc)`
`protected void`	`doReportProblem(XMLReporter rep, XMLValidationProblem prob)`
`protected void`	`doWriteStartDocument(String version, String encoding, String standAlone)`
`int`	`findAttributeIndex(String nsURI, String localName)`
`void`	`flush()`
`int`	`getAttributeCount()`	This method returns number of attributes accessible from within currently active start element.
`String`	`getAttributeLocalName(int index)`
`String`	`getAttributeNamespace(int index)`
`String`	`getAttributePrefix(int index)`
`String`	`getAttributeType(int index)`
`String`	`getAttributeValue(int index)`
`String`	`getAttributeValue(String nsURI, String localName)`
`String`	`getBaseUri()`	As of now, there is no way to specify the base URI.
`protected char[]`	`getCopyBuffer()`
`protected char[]`	`getCopyBuffer(int minLen)`
`abstract QName`	`getCurrentElementName()`	Method that can be used to access name information of the innermost (top) element in the element stack.
`String`	`getEncoding()`	Method that can be called to get information about encoding that this writer is using (or at least claims is using).
`XMLStreamLocation2`	`getLocation()`	Method that should return current output location, if the writer keeps track of it; null if it does not.
`abstract NamespaceContext`	`getNamespaceContext()`
`abstract String`	`getNamespaceURI(String prefix)`	Method that can be called by the validator to resolve a namespace prefix of the currently active top-level element.
`abstract String`	`getPrefix(String uri)`
`Object`	`getProperty(String name)`
`protected abstract String`	`getTopElementDesc()`	Method needed for error message generation
`Location`	`getValidationLocation()`	Method that will return the location that best represents current location within document to be validated, if such information is available.
`String`	`getXmlVersion()`	Method that validator can call to figure out which xml version document being validated declared (if none, "1.0" is assumed as per xml specifications 1.0 and 1.1).
`protected boolean`	`inPrologOrEpilog()`
`boolean`	`isNotationDeclared(String name)`
`boolean`	`isPropertySupported(String name)`	Method similar to `XMLOutputFactory.isPropertySupported(java.lang.String)`, used to determine whether a property is supported by the Writer instance.
`boolean`	`isUnparsedEntityDeclared(String name)`
`protected boolean`	`isValidating()`	Method that is used by output classes to determine whether we are in validating mode.
`protected static void`	`reportIllegalArg(String msg)`
`protected static void`	`reportIllegalMethod(String msg)`	Method called when an illegal method (namespace-specific method on non-ns writer) is called by the application.
`protected void`	`reportInvalidContent(int evtType)`
`protected static void`	`reportNwfAttr(String msg)`	This is the method called when an output method call violates attribute well-formedness checks (trying to output dup attrs) and `WstxOutputProperties.P_OUTPUT_VALIDATE_NAMES` is is enabled.
`protected static void`	`reportNwfAttr(String msg, Object arg)`
`protected static void`	`reportNwfContent(String msg)`	This is the method called when an output method call violates content well-formedness checks and `WstxOutputProperties.P_OUTPUT_VALIDATE_CONTENT` is is enabled.
`protected static void`	`reportNwfContent(String msg, Object arg)`
`protected static void`	`reportNwfStructure(String msg)`	This is the method called when an output method call violates structural well-formedness checks and `WstxOutputProperties.P_OUTPUT_VALIDATE_STRUCTURE` is is enabled.
`protected static void`	`reportNwfStructure(String msg, Object arg)`
`void`	`reportProblem(XMLValidationProblem prob)`	Method called by the validator, upon encountering a validation problem.
`void`	`reportValidationProblem(String msg)`
`void`	`reportValidationProblem(String msg, int severity)`
`void`	`reportValidationProblem(String format, Object arg)`
`void`	`reportValidationProblem(String format, Object arg, Object arg2)`
`void`	`reportValidationProblem(String msg, Location loc, int severity)`
`void`	`reportValidationProblem(Location loc, String msg)`
`abstract void`	`setDefaultNamespace(String uri)`
`abstract void`	`setNamespaceContext(NamespaceContext context)`
`abstract void`	`setPrefix(String prefix, String uri)`
`boolean`	`setProperty(String name, Object value)`	Method that can be used to set per-writer properties; a subset of properties one can set via matching `XMLOutputFactory2` instance.
`ValidationProblemHandler`	`setValidationProblemHandler(ValidationProblemHandler h)`	Method that application can call to define a custom handler for validation problems encountered during validation process.
`XMLValidator`	`stopValidatingAgainst(XMLValidationSchema schema)`	Method that can be called by application to stop validating output against a schema, for which `Validatable.validateAgainst(org.codehaus.stax2.validation.XMLValidationSchema)` was called earlier.
`XMLValidator`	`stopValidatingAgainst(XMLValidator validator)`	Method that can be called by application to stop validating output using specified validator.
`protected static void`	`throwFromIOE(IOException ioe)`
`protected static void`	`throwOutputError(String msg)`
`protected static void`	`throwOutputError(String format, Object arg)`
`String`	`toString()`
`XMLValidator`	`validateAgainst(XMLValidationSchema schema)`	Method that will construct a `XMLValidator` instance from the given schema (unless a validator for that schema has already been added), initialize it if necessary, and make validatable object (reader, writer) call appropriate validation methods from this point on until the end of the document (that is, it's not scoped with sub-trees), or until validator is removed by an explicit call to `Validatable.stopValidatingAgainst(org.codehaus.stax2.validation.XMLValidationSchema)`.
`abstract String`	`validateQNamePrefix(QName name)`	Method called before writing a QName via Typed Access API.
`protected void`	`verifyRootElement(String localName, String prefix)`
`protected void`	`verifyWriteCData()`
`protected void`	`verifyWriteDTD()`
`Writer`	`wrapAsRawWriter()`	Method that can be called to get a wrapper instance that can be used to essentially call the `writeRaw` method via regular `Writer` interface.
`Writer`	`wrapAsTextWriter()`	Method that can be called to get a wrapper instance that can be used to essentially call the `writeCharacters` method via regular `Writer` interface.
`abstract void`	`writeAttribute(String localName, String value)`
`abstract void`	`writeAttribute(String nsURI, String localName, String value)`
`abstract void`	`writeAttribute(String prefix, String nsURI, String localName, String value)`
`void`	`writeCData(char[] cbuf, int start, int len)`
`void`	`writeCData(String data)`
`void`	`writeCharacters(char[] text, int start, int len)`
`void`	`writeCharacters(String text)`
`void`	`writeCharacters(Characters ch)`	Method called by `XMLEventWriter` (instead of more generic text output methods), so that we can verify (if necessary) that this character output type is legal in this context.
`void`	`writeComment(String data)`
`abstract void`	`writeDefaultNamespace(String nsURI)`
`void`	`writeDTD(String dtd)`
`void`	`writeDTD(String rootName, String systemId, String publicId, String internalSubset)`
`void`	`writeDTD(DTDInfo info)`
`abstract void`	`writeEmptyElement(String localName)`
`abstract void`	`writeEmptyElement(String nsURI, String localName)`
`abstract void`	`writeEmptyElement(String prefix, String localName, String nsURI)`
`void`	`writeEndDocument()`
`abstract void`	`writeEndElement()`
`abstract void`	`writeEndElement(QName name)`	Method called by `XMLEventWriter` (instead of the version that takes no argument), so that we can verify it does match the start element if necessary.
`void`	`writeEntityRef(String name)`
`abstract void`	`writeFullEndElement()`	Method similar to `XMLStreamWriter.writeEndElement()`, but that will always write the full end element, instead of empty element.
`abstract void`	`writeNamespace(String prefix, String nsURI)`
`void`	`writeProcessingInstruction(String target)`
`void`	`writeProcessingInstruction(String target, String data)`
`void`	`writeRaw(char[] text, int start, int offset)`	Method that writes specified content as is, without encoding or deciphering it in any way.
`void`	`writeRaw(String text)`	Method that writes specified content as is, without encoding or deciphering it in any way.
`void`	`writeRaw(String text, int start, int offset)`	Method that writes specified content as is, without encoding or deciphering it in any way.
`void`	`writeSpace(char[] text, int offset, int length)`	Method that can be called to write whitespace-only content.
`void`	`writeSpace(String text)`	Method that can be called to write whitespace-only content.
`void`	`writeStartDocument()`
`void`	`writeStartDocument(String version)`
`void`	`writeStartDocument(String encoding, String version)`
`void`	`writeStartDocument(String version, String encoding, boolean standAlone)`
`abstract void`	`writeStartElement(String localName)`
`abstract void`	`writeStartElement(String nsURI, String localName)`
`abstract void`	`writeStartElement(String prefix, String localName, String nsURI)`
`abstract void`	`writeStartElement(StartElement elem)`	Convenience method needed by `XMLEventWriter` implementation, to use when writing a start element, and possibly its attributes and namespace declarations.

Methods inherited from class org.codehaus.stax2.ri.Stax2WriterImpl
copyStartElement

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - STATE_PROLOG
```
protected static final int STATE_PROLOG
```
    See Also:
    
    Constant Field Values
  - STATE_TREE
```
protected static final int STATE_TREE
```
    See Also:
    
    Constant Field Values
  - STATE_EPILOG
```
protected static final int STATE_EPILOG
```
    See Also:
    
    Constant Field Values
  - CHAR_SPACE
```
protected static final char CHAR_SPACE
```
    See Also:
    
    Constant Field Values
  - MIN_ARRAYCOPY
```
protected static final int MIN_ARRAYCOPY
```
    This constant defines minimum length of a String, for which it is beneficial to do an intermediate copy (using String.getChars()), and iterate over intermediate array, instead of iterating using String.charAt(). Former is generally faster for longer Strings, but has some overhead for shorter Strings. Tests indicate that the threshold is somewhere between 8 and 16 characters, at least on x86 platform.
    
    See Also:
    
    Constant Field Values
  - ATTR_MIN_ARRAYCOPY
```
protected static final int ATTR_MIN_ARRAYCOPY
```
    See Also:
    
    Constant Field Values
  - DEFAULT_COPYBUFFER_LEN
```
protected static final int DEFAULT_COPYBUFFER_LEN
```
    See Also:
    
    Constant Field Values
  - mWriter
```
protected final XmlWriter mWriter
```
    Actual physical writer to output serialized XML content to
  - mCopyBuffer
```
protected char[] mCopyBuffer
```
    Intermediate buffer into which characters of a String can be copied, in cases where such a copy followed by array access is faster than calling String.charAt() (which perhaps surprisingly is often case, and especially significant for longer buffers).
  - mConfig
```
protected final WriterConfig mConfig
```
  - mCfgCDataAsText
```
protected final boolean mCfgCDataAsText
```
  - mCfgCopyDefaultAttrs
```
protected final boolean mCfgCopyDefaultAttrs
```
  - mCfgAutomaticEmptyElems
```
protected final boolean mCfgAutomaticEmptyElems
```
  - mCheckStructure
```
protected boolean mCheckStructure
```
  - mCheckAttrs
```
protected boolean mCheckAttrs
```
  - mEncoding
```
protected String mEncoding
```
    Encoding to use; may be passed from the factory (when a method that defines encoding is used), updated by a call to writeStartDocument(), or null if neither. Is passed to the escaping writer factory to allow escaping writers to do additional escaping if necessary (like encapsulating non-ascii chars in a doc encoded usig ascii).
  - mValidator
```
protected XMLValidator mValidator
```
    Optional validator to use for validating output against one or more schemas, and/or for safe pretty-printing (indentation).
  - mXml11
```
protected boolean mXml11
```
    Since XML 1.1 has some differences to 1.0, we need to keep a flag to indicate if we were to output XML 1.1 document.
  - mVldProbHandler
```
protected ValidationProblemHandler mVldProbHandler
```
    Custom validation problem handler, if any.
  - mState
```
protected int mState
```
  - mAnyOutput
```
protected boolean mAnyOutput
```
    Flag that is set to true first time something has been output. Generally needed to keep track of whether XML declaration (START_DOCUMENT) can be output or not.
  - mStartElementOpen
```
protected boolean mStartElementOpen
```
    Flag that is set during time that a start element is "open", ie. START_ELEMENT has been output (and possibly zero or more name space declarations and attributes), before other main-level constructs have been output.
  - mEmptyElement
```
protected boolean mEmptyElement
```
    Flag that indicates that current element is an empty element (one that is explicitly defined as one, by calling a method -- NOT one that just happens to be empty). This is needed to know what to do when next non-ns/attr node is output; normally a new context is opened, but for empty elements not.
  - mVldContent
```
protected int mVldContent
```
    State value used with validation, to track types of content that is allowed at this point in output stream. Only used if validation is enabled: if so, value is determined via validation callbacks.
  - mDtdRootElem
```
protected String mDtdRootElem
```
    Value passed as the expected root element, when using the multiple argument writeDTD(java.lang.String) method. Will be used in structurally validating mode (and in dtd-validating mode, since that automatically enables structural validation as well, to pre-filter well-formedness errors that validators might have trouble dealing with).
  - mReturnNullForDefaultNamespace
```
protected boolean mReturnNullForDefaultNamespace
```
- Constructor Detail
  - BaseStreamWriter
```
protected BaseStreamWriter(XmlWriter xw,
                           String enc,
                           WriterConfig cfg)
```
- Method Detail
  - close
```
public void close()
           throws XMLStreamException
```
    Specified by:
    
    close in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - flush
```
public void flush()
           throws XMLStreamException
```
    Specified by:
    
    flush in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - getNamespaceContext
```
public abstract NamespaceContext getNamespaceContext()
```
    Specified by:
    
    getNamespaceContext in interface XMLStreamWriter
  - getPrefix
```
public abstract String getPrefix(String uri)
```
    Specified by:
    
    getPrefix in interface XMLStreamWriter
  - getProperty
```
public Object getProperty(String name)
```
    Specified by:
    
    getProperty in interface XMLStreamWriter
  - setDefaultNamespace
```
public abstract void setDefaultNamespace(String uri)
                                  throws XMLStreamException
```
    Specified by:
    
    setDefaultNamespace in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - setNamespaceContext
```
public abstract void setNamespaceContext(NamespaceContext context)
                                  throws XMLStreamException
```
    Specified by:
    
    setNamespaceContext in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - setPrefix
```
public abstract void setPrefix(String prefix,
                               String uri)
                        throws XMLStreamException
```
    Specified by:
    
    setPrefix in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeAttribute
```
public abstract void writeAttribute(String localName,
                                    String value)
                             throws XMLStreamException
```
    Specified by:
    
    writeAttribute in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeAttribute
```
public abstract void writeAttribute(String nsURI,
                                    String localName,
                                    String value)
                             throws XMLStreamException
```
    Specified by:
    
    writeAttribute in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeAttribute
```
public abstract void writeAttribute(String prefix,
                                    String nsURI,
                                    String localName,
                                    String value)
                             throws XMLStreamException
```
    Specified by:
    
    writeAttribute in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeCData
```
public void writeCData(String data)
                throws XMLStreamException
```
    Specified by:
    
    writeCData in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeCharacters
```
public void writeCharacters(char[] text,
                            int start,
                            int len)
                     throws XMLStreamException
```
    Specified by:
    
    writeCharacters in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeCharacters
```
public void writeCharacters(String text)
                     throws XMLStreamException
```
    Specified by:
    
    writeCharacters in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeComment
```
public void writeComment(String data)
                  throws XMLStreamException
```
    Specified by:
    
    writeComment in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeDefaultNamespace
```
public abstract void writeDefaultNamespace(String nsURI)
                                    throws XMLStreamException
```
    Specified by:
    
    writeDefaultNamespace in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeDTD
```
public void writeDTD(String dtd)
              throws XMLStreamException
```
    Specified by:
    
    writeDTD in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeEmptyElement
```
public abstract void writeEmptyElement(String localName)
                                throws XMLStreamException
```
    Specified by:
    
    writeEmptyElement in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeEmptyElement
```
public abstract void writeEmptyElement(String nsURI,
                                       String localName)
                                throws XMLStreamException
```
    Specified by:
    
    writeEmptyElement in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeEmptyElement
```
public abstract void writeEmptyElement(String prefix,
                                       String localName,
                                       String nsURI)
                                throws XMLStreamException
```
    Specified by:
    
    writeEmptyElement in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeEndDocument
```
public void writeEndDocument()
                      throws XMLStreamException
```
    Specified by:
    
    writeEndDocument in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeEndElement
```
public abstract void writeEndElement()
                              throws XMLStreamException
```
    Specified by:
    
    writeEndElement in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeEntityRef
```
public void writeEntityRef(String name)
                    throws XMLStreamException
```
    Specified by:
    
    writeEntityRef in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeNamespace
```
public abstract void writeNamespace(String prefix,
                                    String nsURI)
                             throws XMLStreamException
```
    Specified by:
    
    writeNamespace in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeProcessingInstruction
```
public void writeProcessingInstruction(String target)
                                throws XMLStreamException
```
    Specified by:
    
    writeProcessingInstruction in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeProcessingInstruction
```
public void writeProcessingInstruction(String target,
                                       String data)
                                throws XMLStreamException
```
    Specified by:
    
    writeProcessingInstruction in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeStartDocument
```
public void writeStartDocument()
                        throws XMLStreamException
```
    Specified by:
    
    writeStartDocument in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeStartDocument
```
public void writeStartDocument(String version)
                        throws XMLStreamException
```
    Specified by:
    
    writeStartDocument in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeStartDocument
```
public void writeStartDocument(String encoding,
                               String version)
                        throws XMLStreamException
```
    Specified by:
    
    writeStartDocument in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - doWriteStartDocument
```
protected void doWriteStartDocument(String version,
                                    String encoding,
                                    String standAlone)
                             throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - writeStartElement
```
public abstract void writeStartElement(String localName)
                                throws XMLStreamException
```
    Specified by:
    
    writeStartElement in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeStartElement
```
public abstract void writeStartElement(String nsURI,
                                       String localName)
                                throws XMLStreamException
```
    Specified by:
    
    writeStartElement in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - writeStartElement
```
public abstract void writeStartElement(String prefix,
                                       String localName,
                                       String nsURI)
                                throws XMLStreamException
```
    Specified by:
    
    writeStartElement in interface XMLStreamWriter
    
    Throws:
    
    XMLStreamException
  - copyEventFromReader
```
public void copyEventFromReader(XMLStreamReader2 sr,
                                boolean preserveEventData)
                         throws XMLStreamException
```
    Method that essentially copies event that the specified reader has just read.
    
    Specified by:
    
    copyEventFromReader in interface XMLStreamWriter2
    
    Overrides:
    
    copyEventFromReader in class Stax2WriterImpl
    
    Parameters:
    
    sr - Stream reader to use for accessing event to copy
    
    preserveEventData - If true, writer is not allowed to change the state of the reader (so that all the data associated with the current event has to be preserved); if false, writer is allowed to use methods that may cause some data to be discarded. Setting this to false may improve the performance, since it may allow full no-copy streaming of data, especially textual contents.
    
    Throws:
    
    XMLStreamException
  - closeCompletely
```
public void closeCompletely()
                     throws XMLStreamException
```
    Description copied from interface: XMLStreamWriter2
    
    Method similar to XMLStreamWriter.close(), except that this method also does close the underlying output destination (stream) if it has not yet been closed. It is specifically necessary to call this method if the parsing ends in an exception to ensure that the output destination does get properly closed, even if the stream writer would otherwise close it (as is the case for destinations it manages where calling application has no access)
    
    Specified by:
    
    closeCompletely in interface XMLStreamWriter2
    
    Throws:
    
    XMLStreamException
  - isPropertySupported
```
public boolean isPropertySupported(String name)
```
    Description copied from interface: XMLStreamWriter2
    
    Method similar to XMLOutputFactory.isPropertySupported(java.lang.String), used to determine whether a property is supported by the Writer instance. This means that this method may return false for some properties that the output factory does support: specifically, it should only return true if the value is mutable on per-instance basis. False means that either the property is not recognized, or is not mutable via writer instance.
    
    Specified by:
    
    isPropertySupported in interface XMLStreamWriter2
    
    Overrides:
    
    isPropertySupported in class Stax2WriterImpl
  - setProperty
```
public boolean setProperty(String name,
                           Object value)
```
    Description copied from interface: XMLStreamWriter2
    
    Method that can be used to set per-writer properties; a subset of properties one can set via matching XMLOutputFactory2 instance. Exactly which methods are mutable is implementation specific.
    
    Specified by:
    
    setProperty in interface XMLStreamWriter2
    
    Overrides:
    
    setProperty in class Stax2WriterImpl
    
    Parameters:
    
    name - Name of the property to set
    
    value - Value to set property to.
    
    Returns:
    
    True, if the specified property was succesfully set to specified value; false if its value was not changed
  - validateAgainst
```
public XMLValidator validateAgainst(XMLValidationSchema schema)
                             throws XMLStreamException
```
    Description copied from interface: Validatable
    
    Method that will construct a XMLValidator instance from the given schema (unless a validator for that schema has already been added), initialize it if necessary, and make validatable object (reader, writer) call appropriate validation methods from this point on until the end of the document (that is, it's not scoped with sub-trees), or until validator is removed by an explicit call to Validatable.stopValidatingAgainst(org.codehaus.stax2.validation.XMLValidationSchema).
    Note that while this method can be called at any point in output processing, validator instances are not required to be able to handle addition at other points than right before outputting the root element.
    
    Specified by:
    
    validateAgainst in interface Validatable
    
    Overrides:
    
    validateAgainst in class Stax2WriterImpl
    
    Returns:
    
    Validator instance constructed, if validator was added, or null if a validator for the schema has already been constructed.
    
    Throws:
    
    XMLStreamException
  - stopValidatingAgainst
```
public XMLValidator stopValidatingAgainst(XMLValidationSchema schema)
                                   throws XMLStreamException
```
    Description copied from interface: Validatable
    
    Method that can be called by application to stop validating output against a schema, for which Validatable.validateAgainst(org.codehaus.stax2.validation.XMLValidationSchema) was called earlier.
    
    Specified by:
    
    stopValidatingAgainst in interface Validatable
    
    Overrides:
    
    stopValidatingAgainst in class Stax2WriterImpl
    
    Returns:
    
    Validator instance created from the schema that was removed, if one was in use; null if no such schema in use.
    
    Throws:
    
    XMLStreamException
  - stopValidatingAgainst
```
public XMLValidator stopValidatingAgainst(XMLValidator validator)
                                   throws XMLStreamException
```
    Description copied from interface: Validatable
    
    Method that can be called by application to stop validating output using specified validator. The validator passed should be an earlier return value for a call to Validatable.validateAgainst(org.codehaus.stax2.validation.XMLValidationSchema).
    Note: the specified validator is compared for identity with validators in use, not for equality.
    
    Specified by:
    
    stopValidatingAgainst in interface Validatable
    
    Overrides:
    
    stopValidatingAgainst in class Stax2WriterImpl
    
    Returns:
    
    Validator instance found (ie. argument validator) if it was being used for validating current document; null if not.
    
    Throws:
    
    XMLStreamException
  - setValidationProblemHandler
```
public ValidationProblemHandler setValidationProblemHandler(ValidationProblemHandler h)
```
    Description copied from interface: Validatable
    
    Method that application can call to define a custom handler for validation problems encountered during validation process.
    
    Specified by:
    
    setValidationProblemHandler in interface Validatable
    
    Overrides:
    
    setValidationProblemHandler in class Stax2WriterImpl
    
    Parameters:
    
    h - Handler to install, if non null; if null, indicates that the default (implementation-specific) handling should be used
    
    Returns:
    
    Previously set validation problem handler, if any; null if none was set
  - getLocation
```
public XMLStreamLocation2 getLocation()
```
    Description copied from interface: XMLStreamWriter2
    
    Method that should return current output location, if the writer keeps track of it; null if it does not.
    
    Specified by:
    
    getLocation in interface XMLStreamWriter2
    
    Specified by:
    
    getLocation in class Stax2WriterImpl
  - getEncoding
```
public String getEncoding()
```
    Description copied from interface: XMLStreamWriter2
    Method that can be called to get information about encoding that this writer is using (or at least claims is using). That is, it returns name of encoding specified when (in order of priority):
    
    Passed to one of factory methods of XMLOutputFactory
    
    Passed to writeStartDocument method (explicitly or implicity; latter in cases where defaults are imposed by Stax specification)
    Specified by:
    
    getEncoding in interface XMLStreamWriter2
    
    Specified by:
    
    getEncoding in class Stax2WriterImpl
  - writeCData
```
public void writeCData(char[] cbuf,
                       int start,
                       int len)
                throws XMLStreamException
```
    Specified by:
    
    writeCData in interface XMLStreamWriter2
    
    Overrides:
    
    writeCData in class Stax2WriterImpl
    
    Throws:
    
    XMLStreamException
  - writeDTD
```
public void writeDTD(DTDInfo info)
              throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - writeDTD
```
public void writeDTD(String rootName,
                     String systemId,
                     String publicId,
                     String internalSubset)
              throws XMLStreamException
```
    Specified by:
    
    writeDTD in interface XMLStreamWriter2
    
    Overrides:
    
    writeDTD in class Stax2WriterImpl
    
    Throws:
    
    XMLStreamException
  - writeFullEndElement
```
public abstract void writeFullEndElement()
                                  throws XMLStreamException
```
    Description copied from interface: XMLStreamWriter2
    
    Method similar to XMLStreamWriter.writeEndElement(), but that will always write the full end element, instead of empty element. This only matters for cases where the element itself has no content, and if writer is allowed to write empty elements when it encounters such start/end element write pairs.
    
    Specified by:
    
    writeFullEndElement in interface XMLStreamWriter2
    
    Overrides:
    
    writeFullEndElement in class Stax2WriterImpl
    
    Throws:
    
    XMLStreamException
  - writeStartDocument
```
public void writeStartDocument(String version,
                               String encoding,
                               boolean standAlone)
                        throws XMLStreamException
```
    Specified by:
    
    writeStartDocument in interface XMLStreamWriter2
    
    Specified by:
    
    writeStartDocument in class Stax2WriterImpl
    
    Throws:
    
    XMLStreamException
  - writeRaw
```
public void writeRaw(String text)
              throws XMLStreamException
```
    Description copied from interface: XMLStreamWriter2
    
    Method that writes specified content as is, without encoding or deciphering it in any way. It will not update state of the writer (except by possibly flushing output of previous writes, like finishing a start element), nor be validated in any way. As such, care must be taken, if this method is used.
    Method is usually used when encapsulating output from another writer as a sub-tree, or when passing through XML fragments.
    NOTE: since text to be written may be anything, including markup, it can not be reliably validated. Because of this, validator(s) attached to the writer will NOT be informed about writes.
    
    Specified by:
    
    writeRaw in interface XMLStreamWriter2
    
    Overrides:
    
    writeRaw in class Stax2WriterImpl
    
    Throws:
    
    XMLStreamException
  - writeRaw
```
public void writeRaw(String text,
                     int start,
                     int offset)
              throws XMLStreamException
```
    Description copied from interface: XMLStreamWriter2
    
    Method that writes specified content as is, without encoding or deciphering it in any way. It will not update state of the writer (except by possibly flushing output of previous writes, like finishing a start element), nor be validated in any way. As such, care must be taken, if this method is used.
    Method is usually used when encapsulating output from another writer as a sub-tree, or when passing through XML fragments.
    NOTE: since text to be written may be anything, including markup, it can not be reliably validated. Because of this, validator(s) attached to the writer will NOT be informed about writes.
    
    Specified by:
    
    writeRaw in interface XMLStreamWriter2
    
    Specified by:
    
    writeRaw in class Stax2WriterImpl
    
    Throws:
    
    XMLStreamException
  - writeRaw
```
public void writeRaw(char[] text,
                     int start,
                     int offset)
              throws XMLStreamException
```
    Description copied from interface: XMLStreamWriter2
    
    Method that writes specified content as is, without encoding or deciphering it in any way. It will not update state of the writer (except by possibly flushing output of previous writes, like finishing a start element), nor be validated in any way. As such, care must be taken, if this method is used.
    Method is usually used when encapsulating output from another writer as a sub-tree, or when passing through XML fragments.
    NOTE: since text to be written may be anything, including markup, it can not be reliably validated. Because of this, validator(s) attached to the writer will NOT be informed about writes.
    
    Specified by:
    
    writeRaw in interface XMLStreamWriter2
    
    Specified by:
    
    writeRaw in class Stax2WriterImpl
    
    Throws:
    
    XMLStreamException
  - writeSpace
```
public void writeSpace(String text)
                throws XMLStreamException
```
    Description copied from interface: XMLStreamWriter2
    
    Method that can be called to write whitespace-only content. If so, it is to be written as is (with no escaping), and does not contain non-whitespace characters (writer may validate this, and throw an exception if it does).
    This method is useful for things like outputting indentation.
    
    Specified by:
    
    writeSpace in interface XMLStreamWriter2
    
    Overrides:
    
    writeSpace in class Stax2WriterImpl
    
    Throws:
    
    XMLStreamException
  - writeSpace
```
public void writeSpace(char[] text,
                       int offset,
                       int length)
                throws XMLStreamException
```
    Description copied from interface: XMLStreamWriter2
    
    Method that can be called to write whitespace-only content. If so, it is to be written as is (with no escaping), and does not contain non-whitespace characters (writer may validate this, and throw an exception if it does).
    This method is useful for things like outputting indentation.
    
    Specified by:
    
    writeSpace in interface XMLStreamWriter2
    
    Overrides:
    
    writeSpace in class Stax2WriterImpl
    
    Throws:
    
    XMLStreamException
  - getXmlVersion
```
public String getXmlVersion()
```
    Description copied from interface: ValidationContext
    
    Method that validator can call to figure out which xml version document being validated declared (if none, "1.0" is assumed as per xml specifications 1.0 and 1.1).
    
    Specified by:
    
    getXmlVersion in interface ValidationContext
    
    Returns:
    
    Xml version of the document: currently has to be either "1.0" or "1.1".
  - getCurrentElementName
```
public abstract QName getCurrentElementName()
```
    Description copied from interface: ValidationContext
    
    Method that can be used to access name information of the innermost (top) element in the element stack.
    
    Specified by:
    
    getCurrentElementName in interface ValidationContext
    
    Returns:
    
    Name of the element at the top of the current element stack, if any. During validation calls it refers to the element being processed (start or end tag), or its parent (when processing text nodes), or null (in document prolog and epilog).
  - getNamespaceURI
```
public abstract String getNamespaceURI(String prefix)
```
    Description copied from interface: ValidationContext
    
    Method that can be called by the validator to resolve a namespace prefix of the currently active top-level element. This may be necessary for things like DTD validators (which may need to heuristically guess proper namespace URI of attributes, esp. ones with default values).
    
    Specified by:
    
    getNamespaceURI in interface ValidationContext
  - getBaseUri
```
public String getBaseUri()
```
    As of now, there is no way to specify the base URI. Could be improved in future, if xml:base is supported.
    
    Specified by:
    
    getBaseUri in interface ValidationContext
    
    Returns:
    
    Base URI active in the current location of the document being validated, if known; null to indicate no base URI known.
  - getValidationLocation
```
public Location getValidationLocation()
```
    Description copied from interface: ValidationContext
    
    Method that will return the location that best represents current location within document to be validated, if such information is available.
    Note: it is likely that even when a location is known, it may not be very accurate; for example, when attributes are validated, it is possible that they all would point to a single location that may point to the start of the element that contains attributes.
    
    Specified by:
    
    getValidationLocation in interface ValidationContext
  - reportProblem
```
public void reportProblem(XMLValidationProblem prob)
                   throws XMLStreamException
```
    Description copied from interface: ValidationContext
    
    Method called by the validator, upon encountering a validation problem. Implementations are encouraged to allow an optional ValidationProblemHandler be set by the application, to define handling.
    Note: Stax2 version 2 only allowed throwing instances of XMLValidationProblem; version 3 allows generic base class to be thrown, to support other interfaces such as basic Stax interface XMLReporter.
    
    Specified by:
    
    reportProblem in interface ValidationContext
    
    Throws:
    
    XMLStreamException
  - addDefaultAttribute
```
public int addDefaultAttribute(String localName,
                               String uri,
                               String prefix,
                               String value)
```
    Adding default attribute values does not usually make sense on output side, so the implementation is a NOP for now.
    
    Specified by:
    
    addDefaultAttribute in interface ValidationContext
    
    Returns:
    
    Index of the newly added attribute, if operation was succesful; -1 if not.
  - isNotationDeclared
```
public boolean isNotationDeclared(String name)
```
    Specified by:
    
    isNotationDeclared in interface ValidationContext
    
    Returns:
    
    True, if a notation with specified name has been declared in the document being validated; false if not.
  - isUnparsedEntityDeclared
```
public boolean isUnparsedEntityDeclared(String name)
```
    Specified by:
    
    isUnparsedEntityDeclared in interface ValidationContext
    
    Returns:
    
    True, if an unparsed entity with specified name has been declared in the document being validated; false if not.
  - getAttributeCount
```
public int getAttributeCount()
```
    Description copied from interface: ValidationContext
    
    This method returns number of attributes accessible from within currently active start element.
    Note: this method is only guaranteed to be callable during execution of XMLValidator methods XMLValidator.validateElementStart(java.lang.String, java.lang.String, java.lang.String), XMLValidator.validateAttribute(java.lang.String, java.lang.String, java.lang.String, java.lang.String) and XMLValidator.validateElementAndAttributes(). At other times implementations may choose to allow it to be called (for example, with information regarding last start element processed), to throw a IllegalArgumentException, or to return 0 to indicate no attribute information is available.
    Also note that whether defaulted attributes (attributes for which values are only available via attribute defaulting) are accessible depends on exact time when this method is called, and in general can not be assumed to function reliably.
    
    Specified by:
    
    getAttributeCount in interface ValidationContext
    
    Returns:
    
    Number of attributes accessible for the currently active start element.
  - getAttributeLocalName
```
public String getAttributeLocalName(int index)
```
    Specified by:
    
    getAttributeLocalName in interface ValidationContext
  - getAttributeNamespace
```
public String getAttributeNamespace(int index)
```
    Specified by:
    
    getAttributeNamespace in interface ValidationContext
  - getAttributePrefix
```
public String getAttributePrefix(int index)
```
    Specified by:
    
    getAttributePrefix in interface ValidationContext
  - getAttributeValue
```
public String getAttributeValue(int index)
```
    Specified by:
    
    getAttributeValue in interface ValidationContext
  - getAttributeValue
```
public String getAttributeValue(String nsURI,
                                String localName)
```
    Specified by:
    
    getAttributeValue in interface ValidationContext
  - getAttributeType
```
public String getAttributeType(int index)
```
    Specified by:
    
    getAttributeType in interface ValidationContext
  - findAttributeIndex
```
public int findAttributeIndex(String nsURI,
                              String localName)
```
    Specified by:
    
    findAttributeIndex in interface ValidationContext
    
    Returns:
    
    Index of the specified attribute, if one present; -1 otherwise.
  - wrapAsRawWriter
```
public final Writer wrapAsRawWriter()
```
    Method that can be called to get a wrapper instance that can be used to essentially call the writeRaw method via regular Writer interface.
  - wrapAsTextWriter
```
public final Writer wrapAsTextWriter()
```
    Method that can be called to get a wrapper instance that can be used to essentially call the writeCharacters method via regular Writer interface.
  - isValidating
```
protected boolean isValidating()
```
    Method that is used by output classes to determine whether we are in validating mode.
    Note: current implementation of this method is not perfect; it may be possible it can return true even if we are only using a DTD to get some limited info, without validating?
  - writeStartElement
```
public abstract void writeStartElement(StartElement elem)
                                throws XMLStreamException
```
    Convenience method needed by XMLEventWriter implementation, to use when writing a start element, and possibly its attributes and namespace declarations.
    
    Throws:
    
    XMLStreamException
  - writeEndElement
```
public abstract void writeEndElement(QName name)
                              throws XMLStreamException
```
    Method called by XMLEventWriter (instead of the version that takes no argument), so that we can verify it does match the start element if necessary.
    
    Throws:
    
    XMLStreamException
  - writeCharacters
```
public void writeCharacters(Characters ch)
                     throws XMLStreamException
```
    Method called by XMLEventWriter (instead of more generic text output methods), so that we can verify (if necessary) that this character output type is legal in this context. Specifically, it's not acceptable to add non-whitespace content outside root element (in prolog/epilog).
    Note: cut'n pasted from the main writeCharacters; not good... but done to optimize white-space cases.
    
    Throws:
    
    XMLStreamException
  - closeStartElement
```
protected abstract void closeStartElement(boolean emptyElem)
                                   throws XMLStreamException
```
    Method called to close an open start element, when another main-level element (not namespace declaration or attribute) is being output; except for end element which is handled differently.
    
    Throws:
    
    XMLStreamException
  - inPrologOrEpilog
```
protected final boolean inPrologOrEpilog()
```
  - copyStartElement
```
public abstract void copyStartElement(InputElementStack elemStack,
                                      AttributeCollector attrCollector)
                               throws IOException,
                                      XMLStreamException
```
    Implementation-dependant method called to fully copy START_ELEMENT event that the passed-in stream reader points to
    
    Throws:
    
    IOException
    
    XMLStreamException
  - validateQNamePrefix
```
public abstract String validateQNamePrefix(QName name)
                                    throws XMLStreamException
```
    Method called before writing a QName via Typed Access API. In namespace-repairing mode it should take appropriate actions to ensure that the given namespace URI is bound to a namespace and return whatever it maps to. In non-repairing work no additional work is to be done and methods
    
    Returns:
    
    Prefix to use when writing out given QName as an element or attribute value
    
    Throws:
    
    XMLStreamException
  - verifyWriteCData
```
protected final void verifyWriteCData()
                               throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - verifyWriteDTD
```
protected final void verifyWriteDTD()
                             throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - verifyRootElement
```
protected void verifyRootElement(String localName,
                                 String prefix)
                          throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - throwOutputError
```
protected static void throwOutputError(String msg)
                                throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - throwOutputError
```
protected static void throwOutputError(String format,
                                       Object arg)
                                throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - reportIllegalMethod
```
protected static void reportIllegalMethod(String msg)
                                   throws XMLStreamException
```
    Method called when an illegal method (namespace-specific method on non-ns writer) is called by the application.
    
    Throws:
    
    XMLStreamException
  - reportNwfStructure
```
protected static void reportNwfStructure(String msg)
                                  throws XMLStreamException
```
    This is the method called when an output method call violates structural well-formedness checks and WstxOutputProperties.P_OUTPUT_VALIDATE_STRUCTURE is is enabled.
    
    Throws:
    
    XMLStreamException
  - reportNwfStructure
```
protected static void reportNwfStructure(String msg,
                                         Object arg)
                                  throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - reportNwfContent
```
protected static void reportNwfContent(String msg)
                                throws XMLStreamException
```
    This is the method called when an output method call violates content well-formedness checks and WstxOutputProperties.P_OUTPUT_VALIDATE_CONTENT is is enabled.
    
    Throws:
    
    XMLStreamException
  - reportNwfContent
```
protected static void reportNwfContent(String msg,
                                       Object arg)
                                throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - reportNwfAttr
```
protected static void reportNwfAttr(String msg)
                             throws XMLStreamException
```
    This is the method called when an output method call violates attribute well-formedness checks (trying to output dup attrs) and WstxOutputProperties.P_OUTPUT_VALIDATE_NAMES is is enabled.
    
    Throws:
    
    XMLStreamException
  - reportNwfAttr
```
protected static void reportNwfAttr(String msg,
                                    Object arg)
                             throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - throwFromIOE
```
protected static void throwFromIOE(IOException ioe)
                            throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - reportIllegalArg
```
protected static void reportIllegalArg(String msg)
                                throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - reportInvalidContent
```
protected void reportInvalidContent(int evtType)
                             throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - reportValidationProblem
```
public void reportValidationProblem(String msg,
                                    Location loc,
                                    int severity)
                             throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - reportValidationProblem
```
public void reportValidationProblem(String msg,
                                    int severity)
                             throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - reportValidationProblem
```
public void reportValidationProblem(String msg)
                             throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - reportValidationProblem
```
public void reportValidationProblem(Location loc,
                                    String msg)
                             throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - reportValidationProblem
```
public void reportValidationProblem(String format,
                                    Object arg)
                             throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - reportValidationProblem
```
public void reportValidationProblem(String format,
                                    Object arg,
                                    Object arg2)
                             throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - doReportProblem
```
protected void doReportProblem(XMLReporter rep,
                               String probType,
                               String msg,
                               Location loc)
                        throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - doReportProblem
```
protected void doReportProblem(XMLReporter rep,
                               XMLValidationProblem prob)
                        throws XMLStreamException
```
    Throws:
    
    XMLStreamException
  - getTopElementDesc
```
protected abstract String getTopElementDesc()
```
    Method needed for error message generation
  - getCopyBuffer
```
protected final char[] getCopyBuffer()
```
  - getCopyBuffer
```
protected final char[] getCopyBuffer(int minLen)
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class BaseStreamWriter

Field Summary

Fields inherited from interface com.ctc.wstx.cfg.OutputConfigFlags

Fields inherited from interface javax.xml.stream.XMLStreamConstants

Constructor Summary

Method Summary

Methods inherited from class org.codehaus.stax2.ri.Stax2WriterImpl

Methods inherited from class java.lang.Object

Methods inherited from interface org.codehaus.stax2.typed.TypedXMLStreamWriter

Field Detail

STATE_PROLOG

STATE_TREE

STATE_EPILOG

CHAR_SPACE

MIN_ARRAYCOPY

ATTR_MIN_ARRAYCOPY

DEFAULT_COPYBUFFER_LEN

mWriter

mCopyBuffer

mConfig

mCfgCDataAsText

mCfgCopyDefaultAttrs

mCfgAutomaticEmptyElems

mCheckStructure

mCheckAttrs

mEncoding

mValidator

mXml11

mVldProbHandler

mState

mAnyOutput

mStartElementOpen

mEmptyElement

mVldContent

mDtdRootElem

mReturnNullForDefaultNamespace

Constructor Detail

BaseStreamWriter

Method Detail

close

flush

getNamespaceContext

getPrefix

getProperty

setDefaultNamespace

setNamespaceContext

setPrefix

writeAttribute

writeAttribute

writeAttribute

writeCData

writeCharacters

writeCharacters

writeComment

writeDefaultNamespace

writeDTD

writeEmptyElement

writeEmptyElement

writeEmptyElement

writeEndDocument

writeEndElement

writeEntityRef

writeNamespace

writeProcessingInstruction

writeProcessingInstruction

writeStartDocument

writeStartDocument

writeStartDocument

doWriteStartDocument

writeStartElement

writeStartElement

writeStartElement

copyEventFromReader

closeCompletely

isPropertySupported

setProperty

validateAgainst

stopValidatingAgainst

stopValidatingAgainst

setValidationProblemHandler