core/nl.adaptivity.xmlutil

Package-level declarations

Core package for a wrapper that provides XML pull parsing access. Note that the implementations may do some adjustments beyond what is provided by the underlying implementation to improve compatibility across platforms. The access point to the package/module is (XmlStreaming)nl.adaptivity.xml.XmlStreaming.

Types

AndroidStreamingFactory

class AndroidStreamingFactory : XmlStreamingFactory

Android version of the streaming factory.

AndroidXmlReader

class AndroidXmlReader(val parser: XmlPullParser)

And XMLReader implementation that works on Android

DomReader

class DomReader(val delegate: Node) : XmlReader

Created by pdvrieze on 22/03/17.

DomWriter

class DomWriter(current: Node?, val isAppend: Boolean = false, val xmlDeclMode: XmlDeclMode = XmlDeclMode.None) : PlatformXmlWriterBase, XmlWriter

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

EventType

enum EventType : Enum<EventType>

Enum representing the type of an xml node/event.

ExperimentalXmlUtilApi

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FUNCTION, AnnotationTarget.TYPEALIAS, AnnotationTarget.CONSTRUCTOR])

annotation class ExperimentalXmlUtilApi

FreezableNamespaceContext

typealias FreezableNamespaceContext = IterableNamespaceContext

IterableNamespaceContext

interface IterableNamespaceContext : NamespaceContextImpl, Iterable<Namespace>

Namespace context that allows iterating over the namespaces.

IXmlStreaming

interface IXmlStreaming

Namespace

interface Namespace

Interface that represents a namespace with prefix and uri.

NamespaceContext

expect interface NamespaceContext

Interface that provides access to namespace queries

actual typealias NamespaceContext = javax.xml.namespace.NamespaceContext

actual interface NamespaceContext

PlatformXmlReader

actual typealias PlatformXmlReader = AndroidXmlReader

Type alias that allows cross-platform reference to the platform reader.

actual typealias PlatformXmlReader = KtXmlReader

This class provides access to the XmlReader implementation for the platform. using an independent name.

expect class PlatformXmlReader : XmlReader

This class provides access to the XmlReader implementation for the platform. using an independent name.

actual typealias PlatformXmlReader = DomReader

actual typealias PlatformXmlReader = StAXReader

PlatformXmlWriter

actual typealias PlatformXmlWriter = <Error class: unknown class>

actual typealias PlatformXmlWriter = KtXmlWriter

This class provides access to the XmlWriter implementation for the platform. using an independent name.

expect class PlatformXmlWriter : XmlWriter

This class provides access to the XmlWriter implementation for the platform. using an independent name.

actual typealias PlatformXmlWriter = DomWriter

actual typealias PlatformXmlWriter = StAXWriter

QName

expect class QName(namespaceURI: String, localPart: String, prefix: String)

actual typealias QName = javax.xml.namespace.QName

actual class QName(namespaceURI: String, localPart: String, prefix: String)

QNameSerializer

object QNameSerializer : KSerializer<QName>

SerializableQName

typealias SerializableQName = @Serializable(with = QNameSerializer::class) QName

SimpleNamespaceContext

@Serializable(with = SimpleNamespaceContext.Companion::class)

open class SimpleNamespaceContext : IterableNamespaceContext

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

StAXReader

class StAXReader(delegate: XMLStreamReader)

An implementation of XmlReader based upon the JDK StAX implementation.

StAXStreamingFactory

class StAXStreamingFactory

StAXWriter

class StAXWriter(val delegate: XMLStreamWriter, val xmlDeclMode: <Error class: unknown class> = XmlDeclMode.None, val autoCloseEmpty: Boolean = true)

An implementation of XmlWriter that uses an underlying stax writer. Created by pdvrieze on 16/11/15.

XmlBufferedReader

open class XmlBufferedReader(delegate: XmlReader) : XmlBufferedReaderBase

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.

XmlBufferedReaderBase

abstract class XmlBufferedReaderBase(delegate: XmlReader) : XmlReader

XmlBufferedWriter

class XmlBufferedWriter constructor(buffer: MutableList<XmlEvent> = mutableListOf(), delegateNamespaceContext: FreezableNamespaceContext?) : XmlWriter

XmlBufferReader

class XmlBufferReader(buffer: List<XmlEvent>) : XmlReader

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

XMLConstants

object XMLConstants

XmlDeclMode

enum XmlDeclMode : Enum<XmlDeclMode>

XmlDelegatingReader

open class XmlDelegatingReader : XmlReader

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

XmlDelegatingWriter

abstract class XmlDelegatingWriter(delegate: XmlWriter) : XmlWriter

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.

XmlEvent

sealed class XmlEvent

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

XmlException

open class XmlException : IOException

Simple exception for xml related things. Created by pdvrieze on 15/11/15.

XmlReader

interface XmlReader : Closeable, Iterator<EventType>

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

XmlSerializable

interface XmlSerializable

XmlStreamingFactory

expect interface XmlStreamingFactory

actual interface XmlStreamingFactory

XmlUtilInternal

@Target(allowedTargets = [AnnotationTarget.CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FUNCTION, AnnotationTarget.TYPEALIAS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.PROPERTY_GETTER])

annotation class XmlUtilInternal

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

XmlWriter

interface XmlWriter : Closeable

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

Properties

attributeIndices

val XmlReader.attributeIndices: IntRange

attributes

val XmlReader.attributes: Array<out XmlEvent.Attribute>

DEFAULT_FLAGS

const val DEFAULT_FLAGS: Int

The default used flags

FLAG_OMIT_XMLDECL

const val FLAG_OMIT_XMLDECL: Int = 1

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

FLAG_REPAIR_NS

const val FLAG_REPAIR_NS: Int = 2

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

localPart

val QName.localPart: String

namespaceURI

val QName.namespaceURI: String

prefix

val QName.prefix: String

qname

val XmlReader.qname: QName

xmlStreaming

expect val xmlStreaming: IXmlStreaming

actual val xmlStreaming: IXmlStreaming

Functions

allConsecutiveTextContent

fun XmlBufferedReader.allConsecutiveTextContent(): String

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.

allText

fun XmlReader.allText(): String

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.

asQName

fun NamespaceContext.asQName(name: String): QName

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

asSubstream

fun XmlReader.asSubstream(): XmlReader

consecutiveTextContent

fun XmlBufferedReader.consecutiveTextContent(): String

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.

deserialize

inline fun <T : Any> deserialize(input: InputStream): T

inline fun <T : Any> deserialize(input: Reader): T

inline fun <T : Any> deserialize(input: String): T

elementContentToFragment

fun XmlReader.elementContentToFragment(): ICompactFragment

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

elementToFragment

fun XmlReader.elementToFragment(): CompactFragment

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

endTag

fun XmlWriter.endTag(predelemname: QName)

filterSubstream

fun XmlWriter.filterSubstream(): XmlWriter

isElement

fun XmlReader.isElement(elementname: QName): Boolean

fun XmlReader.isElement(type: EventType, elementname: QName): Boolean

@JvmOverloads

fun XmlReader.isElement(elementNamespace: String?, elementName: String, elementPrefix: String? = null): Boolean

fun XmlReader.isElement(type: EventType, elementNamespace: String?, elementName: String, elementPrefix: String? = null): Boolean

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

isEquivalent

infix fun QName.isEquivalent(other: QName): Boolean

isIgnorable

fun XmlReader.isIgnorable(): Boolean

isPrefixDeclaredInElement

fun XmlReader.isPrefixDeclaredInElement(prefix: String): Boolean

isXml

fun XmlReader.isXml(): Boolean

isXmlWhitespace

fun isXmlWhitespace(char: Char): Boolean

Determine whether the character is xml whitespace.

fun isXmlWhitespace(data: CharArray): Boolean

fun isXmlWhitespace(data: CharSequence): Boolean

newGenericWriter

fun IXmlStreaming.newGenericWriter(output: Appendable, isRepairNamespaces: Boolean = false, xmlDeclMode: XmlDeclMode = XmlDeclMode.None): KtXmlWriter

newReader

fun IXmlStreaming.newReader(delegate: Node): DomReader

newWriter

fun <Error class: unknown class>.newWriter(writer: Writer, repairNamespaces: Boolean = false, xmlDeclMode: <Error class: unknown class> = XmlDeclMode.None): <Error class: unknown class>

expect fun IXmlStreaming.newWriter(output: Appendable, repairNamespaces: Boolean = false, xmlDeclMode: XmlDeclMode = XmlDeclMode.None): XmlWriter

expect fun IXmlStreaming.newWriter(writer: Writer, repairNamespaces: Boolean = false, xmlDeclMode: XmlDeclMode = XmlDeclMode.None): XmlWriter

fun IXmlStreaming.newWriter(): DomWriter

fun IXmlStreaming.newWriter(dest: ParentNode): DomWriter

actual fun IXmlStreaming.newWriter(output: Appendable, repairNamespaces: Boolean, xmlDeclMode: XmlDeclMode): XmlWriter

actual fun IXmlStreaming.newWriter(writer: Writer, repairNamespaces: Boolean, xmlDeclMode: XmlDeclMode): XmlWriter

fun <Error class: unknown class>.newWriter(writer: Writer, repairNamespaces: Boolean = false, xmlDeclMode: <Error class: unknown class> = XmlDeclMode.None): <Error class: unknown class>

qname

fun qname(namespaceUri: String?, localname: String, prefix: String? = DEFAULT_NS_PREFIX): QName

readSimpleElement

fun XmlReader.readSimpleElement(): String

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.

serialize

fun <Error class: unknown class>.serialize(node: Node)

fun XmlWriter.serialize(reader: XmlReader)

fun <Error class: unknown class>.serialize(node: Node)

serializeAll

inline fun <T : XmlSerializable> XmlWriter.serializeAll(iterable: Iterable<T>)

inline fun <T : XmlSerializable> XmlWriter.serializeAll(sequence: Sequence<T>)

siblingsToFragment

expect fun XmlReader.siblingsToFragment(): CompactFragment

actual fun XmlReader.siblingsToFragment(): CompactFragment

Read the current element (and content) and all its siblings into a fragment.

actual fun XmlReader.siblingsToFragment(): CompactFragment

Read the current element (and content) and all its siblings into a fragment.

skipElement

fun XmlReader.skipElement()

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

skipPreamble

fun XmlReader.skipPreamble()

Skil the preamble events in the stream reader

smartStartTag

fun XmlWriter.smartStartTag(qName: QName)

inline fun XmlWriter.smartStartTag(qName: QName, body: XmlWriter.() -> Unit)

@JvmOverloads

fun XmlWriter.smartStartTag(nsUri: String?, localName: String, prefix: String? = null)

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

@JvmOverloads

inline fun XmlWriter.smartStartTag(nsUri: String?, localName: String, prefix: String? = null, body: XmlWriter.() -> Unit)

startTag

inline fun XmlWriter.startTag(nsUri: String?, localName: String, prefix: String? = null, body: XmlWriter.() -> Unit)

toCharArrayWriter

fun XmlReader.toCharArrayWriter(): CharArrayWriter

toCName

fun QName.toCName(): String

toEvent

fun XmlReader.toEvent(): XmlEvent

toNamespace

fun QName.toNamespace(): Namespace

toQname

fun CharSequence.toQname(): QName

Convert the string as fqn literal to an actual qname

fun CharSequence.toQname(namespace: Namespace): QName

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

writeAttribute

fun XmlWriter.writeAttribute(name: String, value: Any?)

fun XmlWriter.writeAttribute(name: String, value: Double)

fun XmlWriter.writeAttribute(name: String, value: Long)

fun XmlWriter.writeAttribute(name: String, value: String?)

fun XmlWriter.writeAttribute(name: String, value: QName?)

fun XmlWriter.writeAttribute(name: QName, value: String?)

writeChild

fun <Error class: unknown class>.writeChild(node: Node)

writeCurrent

fun XmlReader.writeCurrent(writer: XmlWriter)

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

writeCurrentEvent

fun XmlWriter.writeCurrentEvent(reader: XmlReader)

writeElement

fun XmlWriter.writeElement(missingNamespaces: MutableMap<String, String>?, reader: XmlReader)

Write

writeElementContent

fun XmlWriter.writeElementContent(missingNamespaces: MutableMap<String, String>?, reader: XmlReader)

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

writeListIfNotEmpty

inline fun <T> XmlWriter.writeListIfNotEmpty(iterable: Iterable<T>, nsUri: String?, localName: String, prefix: String? = null, body: XmlWriter.(T) -> Unit)

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

writeSimpleElement

fun XmlWriter.writeSimpleElement(qName: QName, value: String?)

fun XmlWriter.writeSimpleElement(nsUri: String?, localName: String, prefix: String?, value: String?)

xmlCollapseWhitespace

fun xmlCollapseWhitespace(original: String): String

xmlEncode

fun CharSequence.xmlEncode(): String