xml

object <

Creates DslBuilder instances

object ?<

Creates OptionalDslBuilder instances.

object Attr

Allows easy patterns for attribute values

object Attribs

Simple constructor for Attributes

object CData

object Comment

object Elem

def ElemMatcher(name: QName, attributes: AttributeQName*): AnyRef { ... /* 2 definitions in type refinement */ }

Will match if the QNames are the same =:= and if the attributes are present (not requiring that these are the only attributes).

object EmptyNamespace extends UnderlyingNamespace

Special case for empty namespaces

object Namespace

object NoNamespaceQName

object PI

object PrefixedNamespace

object PrefixedQName

object ScalesXml extends ScalesXmlImplicits

object UnprefixedQName

object Xml10 extends XmlVersion with Product with Serializable

object Xml11 extends XmlVersion with Product with Serializable

def XmlBuilder(): XmlBuilder

Default implementation for constructing an instance of XmlBuilder (ImmutableArrayProxyBuilder)

final def addAndFocus(path: XmlPath, elem: Elem, dchildren: XmlChildren = emptyChildren): Path[XmlItem, Elem, XCC]

Adds a subtree to this given path and returns a path focussed on the new subtree.

final def addChild(path: XmlPath, child: XmlItem): Path[XmlItem, Elem, XCC]

Adds a child to the given subpath, however focus remains on the newly modified path

def asStreamSource[T](xml: T)(implicit serf: SerializerFactory, serXml: SerializeableXml[T]): Source

When the user really wants a stream source or there is yet another place that jaxp Source support is not complete.

def asString[T](xml: T)(implicit serf: SerializerFactory, sxml: SerializeableXml[T]): String

Returns a string version of the tree or throws

def attributes(implicit path: XmlPath): Attributes

returns the attributes of a given element

def compare[T](context: ComparisonContext, left: T, right: T)(implicit arg0: XmlComparison[T]): Option[(XmlDifference[_], ComparisonContext)]

Compare the xml object via the available XmlDifference type class

def compare[T](left: T, right: T)(implicit arg0: XmlComparison[T]): Option[(XmlDifference[_], ComparisonContext)]

Compare the xml object via the available XmlDifference type class

def compareTokens(context: ComparisonContext, qnameTokenComparison: Option[(ComparisonContext, String, String) ⇒ Boolean], str: String, str2: String): Boolean

Perform an actual token comparison (Text/CData and Attribute value relevant).

def convertFromScalaXml[Token <: OptimisationToken](elem: scala.xml.Elem, parsers: Loaner[XMLReader] with SaxSupport = DefaultXMLReaderFactoryPool, optimisationStrategy: PathOptimisationStrategy[Token] = defaultPathOptimisation, encoding: String = "UTF-8")(implicit xmlVer: XmlVersion): Doc

Conversion from Scala XML into Scales XML

def convertToStream(tree: XmlTree): Iterator[PullType]

val defaultOptimisation: MemoryOptimisationStrategy[QNameToken]

val defaultPathOptimisation: PathOptimisationStrategy[QNameToken]

def doElement(x: Elem, currentMappings: Map[String, String]): NamespaceContext

package dsl

def eager(xmlPath: XmlPath)(implicit cbf: CanBuildFrom[List[XmlPath], XmlPath, List[XmlPath]]): xml.xpath.XPath[List[XmlPath]]

Same as fromXmlPathToXPath, an eager evaluation of xpath queries

def elem(implicit path: XmlPath): Elem

returns the Elem at this path

val emptyAttributes: Attributes

An empty collection of Attribute

val emptyChildren: XmlChildren

An empty collection of ItemOrElem

val emptyMiscs: Miscs

An empty collection of Misc

val emptyNamespaces: Map[String, String]

An empty Map of String -> String representing prefix -> namespace

package equals

def foldPrint[T](pout: XmlOutput)(it: T)(implicit arg0: SerializeableXml[T]): Option[Throwable]

Placeholder - prefer serialize instead

def hasLocalName[T](localName: String)(implicit name: Names[T]): (T) ⇒ Boolean

curried to allow direct drop in for predicates, if it is an item then it will return false

def hasLocalNameA(local: String): (xml.xpath.AttributePath) ⇒ Boolean

hasLocalName for AttributePaths

def hasLocalNameX(local: String): (XmlPath) ⇒ Boolean

hasLocalName for XmlPaths

def hasNamespace[T](namespaceUri: String)(implicit name: Names[T], d: DIF): (T) ⇒ Boolean

matches only the namespace

def hasNamespace[T](namespace: Namespace)(implicit name: Names[T]): (T) ⇒ Boolean

matches only the namespace

def hasQName[T](t: T)(implicit name: Names[T]): Boolean

Will be true for all values of T except when the resulting QName is "empty".

def hasQName[T](implicit t: T, name: Names[T], d: DIF): Boolean

Will be true for all values of T except when the resulting QName is "empty".

def headerAndFooter(pout: XmlOutput, doc: DocLike)(serializerf: (XmlOutput, Serializer) ⇒ (XmlOutput, Option[Throwable])): (Serializer) ⇒ Option[Throwable]

package impl

This package is not intended for direct usage, however it provides much of the functionality that is used throughout scales.

val isElem: (XmlPath) ⇒ Boolean

def isEmptyTree(tree: XmlTree): Boolean

Returns true if the tree is effectively empty, i.

def isEquivalent[T](qname: QName)(implicit name: Names[T]): (T) ⇒ Boolean

Matches on prefix and namespace only

def isExactly[T](qname: QName)(implicit name: Names[T]): (T) ⇒ Boolean

Does the qname match exactly (prefix included if present)

val isItem: (XmlPath) ⇒ Boolean

def isNil(tree: XmlTree): Boolean

Tests if a given tree is nil, but does not check if children are present.

val isText: (XmlPath) ⇒ Boolean

def itemAsString(xmlItem: XmlItem)(implicit serf: SerializerFactory): String

Just for items, given we don't want to generally serialize them directly but as part of a tree.

def iterate(path: List[QName], xml: Iterator[PullType]): FlatMapIterator[XmlPath]

Provides an optimised version of withIter(onDone(List(onQNames(path))))(enumXml(xml, _)) with default QName equality it unwraps the data providing an Iterator[XPath]

def iterate(path: List[QName], xml: xml.parser.pull.XmlPull): FlatMapIterator[XmlPath]

Wraps XmlPull using default QName equality

def iterateI(path: List[QName], xml: Iterator[PullType])(implicit qe: Equal[QName]): FlatMapIterator[XmlPath]

Provides an optimised version of withIter(onDone(List(onQNames(path))))(enumXml(xml, _)) with an implicit parameter for QName equality it unwraps the data providing an Iterator[XPath]

def iterateI(path: List[QName], xml: xml.parser.pull.XmlPull)(implicit qe: Equal[QName]): FlatMapIterator[XmlPath]

Wraps XmlPull with an implicit parameter for QName equality

package jaxen

This package provides string XPath evaluation based on the Jaxen library, sample use:

def joinTextNodes(children: XmlChildren): XmlChildren

def joinTextNodes(tree: XmlTree): XmlTree

Joins adjacent text nodes for the immediate children only (make a tree more XPath friendly)

def laddNS(entry: (String, String), mappings: Map[String, String], declMap: Map[String, String]): (Map[String, String], Map[String, String])

a) add / replace in mappings b) add to declMap

def lazyRaw[T <: Iterable[XmlPath]](xpath: xml.xpath.XPath[T]): Iterable[XmlPath]

Normally the implicit fromXPathToIterable will provide sorted output, but this can create significant slow down when only the contents are necessary, not their order.

def loadXml[Token <: OptimisationToken](source: InputSource, strategy: PathOptimisationStrategy[Token] = defaultPathOptimisation, parsers: Loaner[SAXParser] with SaxSupport = DefaultSAXParserFactoryPool.parsers)(implicit xmlVer: XmlVersion): Doc

Use a custom parserPool to control the sax factory features

def loadXmlReader[Token <: OptimisationToken](source: InputSource, strategy: PathOptimisationStrategy[Token] = defaultPathOptimisation, parsers: Loaner[XMLReader] with SaxSupport = DefaultXMLReaderFactoryPool)(implicit xmlVer: XmlVersion): Doc

Use a custom parserPool to control the sax factory features

def localName[T](t: T)(implicit name: Names[T]): String

Returns the localName

def localName[T](implicit t: T, name: Names[T], d: DIF): String

Returns the localName

val mergeAdjacentText: ((Option[XmlItem], XmlChildren), ItemOrElem) ⇒ (Option[XmlItem], XmlChildren)

Joins adjacent text nodes for immediate children

def name[T](t: T)(implicit iname: Names[T]): QName

Returns the QName, will throw if the QName is "empty"

def name[T](implicit t: T, name: Names[T], d: DIF): QName

Returns the QName, will throw if the QName is "empty"

def namespace[T](implicit t: T, name: Names[T], d: DIF): UnderlyingNamespace

Returns the underlying namespace object

def namespaceUri[T](t: T)(implicit name: Names[T]): String

XPath namespace-uri function, returns the uri

def namespaceUri[T](implicit t: T, name: Names[T], d: DIF): String

XPath namespace-uri function, returns the uri

def newSchema(source: Source, factory: Loaner[SchemaFactory] = DefaultXSDSchemaFactoryPool): Schema

val noXmlPath: XmlPath

Use to signify a "null object", tree/path shouldn't work like this its a smell

def normalizeSpace[T](t: T)(implicit value: TextValue[T]): String

XPath normalize-space function, replaces all consecutive whitespace with " " and trims.

def normalizeSpace[T](implicit t: T, value: TextValue[T], d: DIF): String

XPath normalize-space function, replaces all consecutive whitespace with " " and trims.

def normalizeSpaceS(str: String): String

XPath normalize-space function, replaces all consecutive whitespace with " " and trims.

def onQNames(qnames: List[QName]): utils.ResumableIter[PullType, (List[QName], Option[XmlPath])]

Collects all data belonging to an element that matches the list.

def onQNamesI(qnames: List[QName])(implicit qe: Equal[QName]): utils.ResumableIter[PullType, (List[QName], Option[XmlPath])]

Collects all data belonging to an element that matches the list.

package parser

def pathAndTreeMatcher[T](pathEval: (XmlTree) ⇒ T)(implicit arg0: (T) ⇒ Boolean): utils.BooleanAndTMatcher[XmlTree, T]

Similar to pathMatcher but also gives the tree back into the pattern match.

def pathMatcher[T](pathEval: (XmlTree) ⇒ T)(implicit arg0: (T) ⇒ Boolean): utils.BooleanMatcher[XmlTree, T]

Creates a booleanMatcher against a Tree based on the @pathEval function.

def pqName[T](t: T)(implicit name: Names[T]): String

Returns either qualifiedName or prefix:{namespace}local when a prefix is present

def pqName[T](implicit t: T, name: Names[T], d: DIF): String

Returns either qualifiedName or prefix:{namespace}local when a prefix is present

def printTree[T](xml: T)(implicit serf: SerializerFactory, sxml: SerializeableXml[T]): Unit

Prints to stdout, useful for testing etc Will dump an error if one is found.

def pullXml[RToken <: OptimisationToken](source: InputSource, optimisationStrategy: MemoryOptimisationStrategy[RToken] = defaultOptimisation, parserFactoryPool: Pool[XMLInputFactory] = impl.DefaultStaxInputFactoryPool, closeAfterUse: Boolean = true): xml.parser.pull.XmlPull with Closeable with IsClosed

Creates a new XmlPull based on source.

def pullXmlCompletely[RToken <: OptimisationToken](source: InputSource, strategy: PathOptimisationStrategy[RToken] = defaultPathOptimisation, parserFactoryPool: Pool[XMLInputFactory] = impl.DefaultStaxInputFactoryPool, closeAfterUse: Boolean = true): Doc

Load xml via pull parsing

def pullXmlReader[RToken <: OptimisationToken](reader: XMLStreamReader, defaultOptimisationStrategy: MemoryOptimisationStrategy[RToken] = defaultOptimisation): xml.parser.pull.XmlPull

Allows plugging in other feeds, non source based, as such not closeable

def pullXmlResource[RToken <: OptimisationToken](source: InputSource, optimisationStrategy: MemoryOptimisationStrategy[RToken] = defaultOptimisation, parserFactoryPool: Pool[XMLInputFactory] = impl.DefaultStaxInputFactoryPool): (CloseOnNeed, xml.parser.pull.XmlPull)

Creates a new XmlPull based on source for direct handling of the stream.

def pushXmlIter(out: Writer, doc: DocLike = EmptyDoc(), version: Option[XmlVersion] = None, encoding: Option[Charset] = None)(implicit serializerFI: SerializerFactory): (CloseOnNeed, SerialIterT)

Returns an Iteratee that can serialize PullTypes to out.

def qName[T](t: T)(implicit name: Names[T]): String

Returns the XPath QName - prefix:local or local

def qName[T](implicit t: T, name: Names[T], d: DIF): String

Returns the XPath QName - prefix:local or local

def qname[T](t: T)(implicit name: Names[T]): String

Returns the XPath QName - prefix:local or local

def qname[T](implicit t: T, name: Names[T], d: DIF): String

Returns the XPath QName - prefix:local or local

def qnamesEqual(context: ComparisonContext, str: String, str2: String): Boolean

Allows comparison of Text nodes or Attribute values that contain QNames, i.

def qualifiedName[T](t: T)(implicit name: Names[T]): String

Returns the qualified name {namespace}local

def qualifiedName[T](implicit t: T, name: Names[T], d: DIF): String

Returns the qualified name {namespace}local

def raw[T <: Iterable[XmlPath]](xpath: xml.xpath.XPath[T]): Iterable[XmlPath]

Normally the implicit fromXPathToIterable will provide sorted output, but this can create significant slow down when only the contents are necessary, not their order.

def readXml[Token <: OptimisationToken](source: InputSource, strategy: PathOptimisationStrategy[Token], reader: XMLReader, saxSupport: SaxSupport)(implicit xmlVer: XmlVersion): Doc

def serialize[T](pout: XmlOutput)(it: T)(implicit arg0: SerializeableXml[T]): Option[Throwable]

Serializes items which can behave like xml.

def serializeIter(output: XmlOutput, serializer: Serializer, closer: () ⇒ Unit, doc: DocLike = EmptyDoc()): SerialIterT

The serializer will be returned automatically to the pool by calling closer

def serializeMisc(pout: XmlOutput, misc: Iterable[Misc], serializer: Serializer): (XmlOutput, Option[Throwable])

package serializers

def skip(downTo: ⇒ List[Int]): IterV[PullType, PeekMatch]

Skips all events until the indexes match downTo, can be seen as \*\*[b]\*[c] skipping until c with skip(List(b,c)).

def skipv(downTo: Int*): IterV[PullType, PeekMatch]

def sourceUser(source: InputSource): SourceUser with Product with Serializable

Provides proxied sources to the pull parsers, the stream provided is the stream used

def streamOr[T](xml: T, f: ⇒ Source)(implicit serf: SerializerFactory, serXml: SerializeableXml[T]): Source

def string[T](t: T)(implicit value: TextValue[T]): String

XPath name for text

def string[T](implicit t: T, value: TextValue[T], d: DIF): String

XPath name for text

def text[T](t: T)(implicit value: TextValue[T]): String

The text value of a given object, .

def text[T](implicit t: T, value: TextValue[T], d: DIF): String

The text value of a given object, .

implicit def toLeft(ev: XmlEvent): Left[XmlEvent, Nothing]

implicit def toRight(ev: EndElem): Right[Nothing, EndElem]

def toTree[RToken <: OptimisationToken](pull: Iterator[PullType], strategy: PathOptimisationStrategy[RToken] = defaultPathOptimisation): XmlTree

Attempts to convert a stream to a tree

package trax

def value[T](t: T)(implicit value: TextValue[T]): String

More readable version for XmlItems and Attributes, same as text

def value[T](implicit t: T, value: TextValue[T], d: DIF): String

More readable version for XmlItems and Attributes, same as text

def viewed(xmlPath: XmlPath)(implicit cbf: CanBuildFrom[List[XmlPath], XmlPath, List[XmlPath]]): xml.xpath.XPath[List[XmlPath]]

Lazy evaluation of XPaths

def withWriter(decl: Declaration, out: Writer): SerializerData

def writeTo[T](it: T, output: Writer, version: Option[XmlVersion] = None, encoding: Option[Charset] = None)(implicit serializerFI: SerializerFactory, sxml: SerializeableXml[T]): Option[Throwable]

Writes the xml to a given Writer with defaults provided for .

package xpath

val xsiNil: AttributeQName

A convenient AttributeQName for xsi:nil attributes

val Functions: AnyRef