Package-level declarations

Writer that uses the DOM for the underlying storage (rather than writing to some string).

Enum representing the type of an xml node/event.

Annotation to signify that the annotated code is experimental, with limited compatibility support.

Namespace context that allows iterating over the namespaces.

IXMLStreaming is the interface (accessible through xmlStreaming) that exposes the XML parsing and serialization in a platform independent way.

Interface that represents a namespace with prefix and uri.

Serializer for QNames that allows writing in XML context to be as prefix:localPart where the namespace declaration is added when needed.

Shortcut alias for QName that associates the QNameSerializer with the type. Note that the QNameSerializer has special features for the XML format.

An xml reader that has a buffer that allows peeking events as well as injecting events into the stream. Note that this class does not do any validation of the xml. If injecting/removing elements into/from the buffer you can create invalid XML.

Base class for XML readers that support buffering of the parsing results.

Class that writes xml to a linear buffer of xml events.

A reader that presents a list of events as an xml reader. This is designed to work together with XmlBufferedWriter.

Various namespace constants and their corresponding default prefixes.

Mode to use for writing the XML Declaration.

Simple baseclass for a delating XmlReader. It merely functions as a delegate. With Kotlin it's not really needed, but nice.

Simple delegating writer that passes all calls on to the delegate. This class is abstract for the only reason that any direct instances of this class make little sense.

DeserializationStrategy sub-interface that supports special deserialization for the XML format. The format will call deserializeXML rather than deserialize allowing for special functionality.

Marker (only relevant to custom serializers) that signifies that serialization will contain custom QNames that can be collected when isCollectingNSAttributes is set to true.

A class to represent the events that can occur in XML Documents

Simple exception for xml related things.

XmlReader that supports at least lightweight peeking. This could be full buffering, or being able to "undo" the next function so that calling it again will give the same result. Note that the implementation may not allow for inspecting the event in pushed back state.

Interface that is the entry point to the xml parsing. All implementations implement this interface, generally by delegating to a platform specific parser.

Serial Descriptor delegate that supports special casing by the XML format. This means that the descriptor can be different for non-xml and xml serialization. (Used by the QName serializer).

Marker to signify that the descriptor is an xmlSerialDescriptor and the delegate can be retrieved through getElementDescriptor with negative value.

SerializationStrategy sub-interface that supports special serialization for the XML format. The format will call serializeXML rather than serialize allowing for special functionality.

Combined interface for custom serializers that support special casing by the XML Format.

Annotation to signify that the annotated code is internal to the XmlUtil module, and no API stability is guaranteed.

Annotation to signify that the annotated code is internal to the XmlUtil module, and no API stability is guaranteed.

Interface representing the (wrapper) type that allows generating xml documents.

Get a range for the attributes in the reader

Get an array of all attributes in the current (startTag) event.

Property syntax accessor for QName.getLocalPart

Property syntax accessor for QName.getNamespaceURI

Property syntax accessor for QName.getPrefix

Read a QName text from the reader. This will read prefix:localName values and resolve the namespace.

Consume all text and non-content (comment/processing instruction) to get an uninterrupted text sequence. This will skip over comments but not ignorable whitespace that starts the string, but not tags. Any tags encountered will lead to a return of this function. Any tags encountered with cause an exception to be thrown. It can either be invoked when in a start tag to return all text content, or on a content element to include it (if text or cdata) and all subsequent siblings.

Get the next text sequence in the reader. This will skip over comments and ignorable whitespace (starting the content), but not tags. Any tags encountered with cause an exception to be thrown. It can either be invoked when in a start tag to return all text content, or on a content element to include it (if text or cdata) and all subsequent siblings.

Convert a prefixed element name (CNAME) to a qname. If there is no prefix, the default prefix is used.

Create a new reader that only returns the current element and its descendents. Such sub-reader ensures that the user of the return value does not exceed this stream.

Consume all text and non-content (comment/processing instruction) to get an uninterrupted text sequence. This will skip over comments and ignorable whitespace that starts the string, but not tags. Any tags encountered will lead to a return of this function. Any tags encountered with cause an exception to be thrown. It can either be invoked when in a start tag to return all text content, or on a content element to include it (if text or cdata) and all subsequent siblings.

Differs from .siblingsToFragment in that it skips the current event.

Read the current element (and content) only into a fragment.

Write an end tag event.

Create a writer that wraps a substream ensuring that document level events are ignored.

Determine whether the current event of the XMLReader is an element with the given name. Note that this ignores the prefix of the name.

Check that the current state is a start element for the given name. The mPrefix is ignored.

Determine whether two QNames are equivalent (the prefix is ignored, the others compared textually).

Determine whether the two QNames are fully equal

Determine whether the current event in the reader is ignorable. This ignores: comments, start/end document, processing instructions, document declarations, ignorable whitespace, and text that is effectively xml whitespace.

Determine whether the given prefix is known in the reader (up to this point). This can be used for reading text that could reference a namespace prefix (e.g. when parsing XPath expressions).

Determine whether the character is XML whitespace.

Determine whether all the characters in the array are XML Whitespace.

Determine whether all the characters in the sequence are XML Whitespace.

Create a new XmlWriter that appends to the given Appendable. This writer could be a platform specific writer.

Shorthand function to create a QName.

From a start tag read the text only content of the element. Comments are allowed and handled, but subtags are not allowed. This tag finishes at the end of the element.

Read the current event and all subsequent siblings into a compact fragment.

From a start element, skip all element content until the corresponding end element has been read. After invocation the end element has just been read (and would be returned on relevant state calls).

Skil the preamble events in the stream reader

Enhanced function for writing start tags, that will attempt to reuse prefixes.

Enhanced function for writing start tags, that will attempt to reuse prefixes. Rather than use the passed prefix it will look up the prefix for the given namespace, and if present use that. It will also ensure to write the appropriate namespace attribute if needed. If the namespace is the default/null, xml or the xmlns namespace the implementation will be as expected.

Helper function for writing tags that will automatically write the end tag. Otherwise uses the version that does not take a body parameter.

Helper function for a tag that allows writing the body but closes the tag on completion.

Get the CName part of a QName

Create an XmlEvent for the current event in an XmlReader.

Extract the namespace for the QName (excluding the local name)

Convert the string as fqn literal to an actual qname. The formats handled are:

Write an attribute (must be in tag writing state - no content written yet).

Write the current event to the writer. This will not move the reader.

Write the current event to the writer. Note that for tags/start elements this will write the attributes, but not the children.

Write the entirety of an element content to the writer.

Write the child content of the current element in the reader to the output This does not write the container itself

Helper function for writing a list only if it contains any element.

Helper function that writes a simple element without attributes and a simple value.

Helper function that allows the XML format to use a different descriptor for the given type. This is intended for use with custom serializers implementing XmlSerializer to handle xml serialization specially.

Implementation of the XMLSchema whitespace collapsing algorithm. This involves:

Encode the text such that it escapes the '<', '>', and '&' characters. This does not encode quotation characters (as would be needed in attributes).

Implementation of the XML whitespace trimming algorithm. Unlike xmlCollapseWhitespace this function does not collapse multi-whitespace sequences, but still normalizes to space, and trims start and end.