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.

Interface that represents a namespace with prefix and uri.

A simple namespace context that stores namespaces in a single array Created by pdvrieze on 24/08/15.

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.

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.

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.

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

Simple exception for xml related things.

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.

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.

The default used flags

Flag to indicate that the xml declaration should be omitted, when possible.

Flag to indicate that the namespace usable should be automatically repaired.

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.

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.

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

Determine whether the character is xml whitespace.

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.

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

Convert the string as fqn literal to an actual qname

Convert the string as fqn literal to actual name, but use the namespace parameter to fill in namespace (but not prefix)

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 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.