package xml
- Alphabetic
- By Inheritance
- xml
- Functions
- TextFunctions
- NameFunctions
- XmlPaths
- XmlEquals
- SerializingIter
- XmlPrinter
- TraxSourceConversions
- PullIteratees
- XmlPulls
- XmlParser
- XmlUtils
- XmlFactories
- Whitespace
- XmlTypes
- XPathMatcher
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Package Members
Type Members
- case class Attribute(name: xml.AttributeQName, value: String) extends Product with Serializable
Attributes can only work with either a prefixed qname or an empty ns name
- type AttributePath = xml.xpath.AttributePath
AttributePath provides access to the parent XmlPath
- type AttributePaths[PT <: Iterable[XmlPath]] = xml.xpath.AttributePaths[PT]
AttributePaths provides all XPath Axe that are attribute relevant against a given collection of attributes on a colletion of XmlPaths
AttributePaths provides all XPath Axe that are attribute relevant against a given collection of attributes on a colletion of XmlPaths
- See also
[xpath.AttributePaths]
- type AttributeQName = EitherLike[PrefixedQName, NoNamespaceQName]
An AttributeQName is either a PrefixedQName or a NoNamespaceQName
An AttributeQName is either a PrefixedQName or a NoNamespaceQName
- Definition Classes
- XmlTypes
- type Attributes = ListSet[Attribute]
An alias for am immutable ListSet of Attribute
An alias for am immutable ListSet of Attribute
- Definition Classes
- XmlTypes
- trait CData extends XmlItem
Might be tempting to use, but think twice, XOM removes it for a good reason, and I'm sorely tempted to, but I've worked with enough applications that really thought they needed it.
Might be tempting to use, but think twice, XOM removes it for a good reason, and I'm sorely tempted to, but I've worked with enough applications that really thought they needed it. CData serialization is dependent on the encoding, if your CData contains umlauts etc but you choose US-ACSII you will receive a CDataCannotBeEncoded for your efforts. Choose not to use CData in the first place. Note: Will throw if given the CData end sequence
- trait CanHavePrefix extends AnyRef
Mixed in to Prefixed and Unprefixed
- type CloseablePull = XmlPull with Closeable with IsClosed
- Definition Classes
- XmlPrinter
- trait Comment extends XmlItem
Comments aren't escaped and will throw a CommentCannotBeEncoded error if the contents cannot be serialized, xalan just tries to serialize directly which can't work.
Comments aren't escaped and will throw a CommentCannotBeEncoded error if the contents cannot be serialized, xalan just tries to serialize directly which can't work.
Note: Will throw if "--" is found in the value
- case class DTD(name: String, publicId: String, systemId: String) extends Product with Serializable
DTD is not part of the tree, nor a stream, it can only occur once and as such is neither an XmlEvent nor an XmlItem directly
- case class Declaration(version: XmlVersion = defaultVersion, encoding: Charset = scales.utils.defaultCharset, standalone: Boolean = false) extends Product with Serializable
Xml declaration
- case class Doc(rootElem: xml.XmlTree, prolog: Prolog = Prolog(), end: EndMisc = EndMisc()) extends DocLike with Product with Serializable
Tree based document
- trait DocLike extends AnyRef
All documents look similar to this, even when stream
- sealed trait Elem extends XmlEvent
- case class EmptyDoc(prolog: Prolog = Prolog(), end: EndMisc = EndMisc()) extends DocLike with Product with Serializable
Provides a simple empty document for streams etc
- case class EndElem(name: QName, namespaces: Map[String, String] = Map[String, String]()) extends Product with Serializable
Exists purely to satisfy staxs events and indicate to the client code that the xml "stack" should be popped
- case class EndMisc(misc: xml.Miscs = emptyMiscs) extends Product with Serializable
The information after the root elem
- type ItemOrElem = EitherLike[XmlItem, Tree[XmlItem, Elem, XCC]]
Alias for An XML ItemOrTree
Alias for An XML ItemOrTree
- Definition Classes
- XmlTypes
- type Misc = Either[Comment, PI]
Misc is either a Comment or PI, and is used for the Prolog and trailing Misc items in a Doc.
Misc is either a Comment or PI, and is used for the Prolog and trailing Misc items in a Doc.
- Definition Classes
- XmlTypes
- type Miscs = Seq[Misc]
A collection of Misc
A collection of Misc
- Definition Classes
- XmlTypes
- sealed trait Namespace extends UnderlyingNamespace
Represents a XML Namespace spec compliant Namespace.
Represents a XML Namespace spec compliant Namespace.
NOTE Users are recommended to use the prefixed function and work with prefixes directly for qnames.
- trait NoNamespaceQName extends QName with RightLike[PrefixedQName, NoNamespaceQName]
Has neither a prefix nor a namespace (e.g.
Has neither a prefix nor a namespace (e.g. <fred xmlns=""/>)
- trait PI extends XmlItem
- type PeekMatch = Option[XmlPath]
- Definition Classes
- PullIteratees
- sealed trait PrefixedNamespace extends AnyRef
- trait PrefixedQName extends QName with CanHavePrefix with LeftLike[PrefixedQName, NoNamespaceQName]
Has both a namespace and a prefix (e.g.
Has both a namespace and a prefix (e.g. <pre:fred xmlns:pre="uri"/>)
- case class Prolog(decl: Declaration = Declaration(), misc: xml.Miscs = emptyMiscs, dtd: Option[DTD] = None) extends Product with Serializable
Includes all information before the root elem
- type PullType = Either[XmlEvent, EndElem]
- Definition Classes
- XmlPulls
- sealed trait QName extends AnyRef
QNames together with a tree structure form the basis of XML, what type of QName is available depends on Attribute (either no namespace or prefxied - fully qualified) or Elem (attribute's options and non prefixed but still qualified)
- type QNamesMatch = (List[QName], Option[XmlPath])
- Definition Classes
- PullIteratees
- type SerialIterT[F[_]] = IterateeT[PullType, F, (XmlOutput, Option[Throwable])]
- Definition Classes
- SerializingIter
- type SerialStepT[F[_]] = StepT[PullType, F, (XmlOutput, Option[Throwable])]
- Definition Classes
- SerializingIter
- case class Text(value: String) extends XmlItem with Product with Serializable
- sealed trait UnderlyingNamespace extends AnyRef
Seperate the notion of a normal Namespace and that of the "empty namespace" - no default namespace
- trait UnprefixedQName extends QName with CanHavePrefix
Has no prefix but a namespace (e.g.
Has no prefix but a namespace (e.g. <fred xmlns="uri"/>)
- type XCC[T] = ImmutableArrayProxy[T]
XML Collection - an alias for ImmutableArrayProxy
XML Collection - an alias for ImmutableArrayProxy
- Definition Classes
- XmlTypes
- type XPath[PT <: Iterable[XmlPath]] = xml.xpath.XPath[PT]
XPath type, provides all XPath Axe against a given collection of XmlPaths
XPath type, provides all XPath Axe against a given collection of XmlPaths
- See also
[xpath.XPath]
- type XmlBuilder = Builder[ItemOrElem, XmlChildren]
Alias for a mutable builder of XmlChildren
Alias for a mutable builder of XmlChildren
- Definition Classes
- XmlTypes
- type XmlCBF = BuildFrom[XCC[_], utils.ItemOrTree[XmlItem, Elem, XCC], XCC[utils.ItemOrTree[XmlItem, Elem, XCC]]]
Alias for the XmlTree CanBuildFrom
Alias for the XmlTree CanBuildFrom
- Definition Classes
- XmlTypes
- type XmlChildren = ImmutableArrayProxy[ItemOrElem]
An Alias for a collection of ItemOrElem, the children of a given tree node
An Alias for a collection of ItemOrElem, the children of a given tree node
- Definition Classes
- XmlTypes
- sealed trait XmlEvent extends AnyRef
Basis for typed pull api
- sealed trait XmlItem extends LeftLike[XmlItem, Tree[XmlItem, Elem, XCC]] with XmlEvent
- type XmlPath = Path[XmlItem, Elem, XCC]
An alias for a Path over XmlTree
An alias for a Path over XmlTree
- Definition Classes
- XmlTypes
- type XmlPull = xml.parser.pull.XmlPull
Basis for xmlpulls, an Iterator[PullType]
- type XmlTree = Tree[XmlItem, Elem, XCC]
Alias for Trees of Elem and XmlItem
Alias for Trees of Elem and XmlItem
- Definition Classes
- XmlTypes
- sealed trait XmlVersion extends AnyRef
Scales supports many aspects of Xml10 and Xml11, verification of serialization and values takes place with the XmlVersion ADT.
Value Members
- 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).
Will match if the QNames are the same =:= and if the attributes are present (not requiring that these are the only attributes). What is returned is either a Seq of attribute values or a simple boolean
- Definition Classes
- XmlTypes
- def XmlBuilder(): XmlBuilder
Default implementation for constructing an instance of XmlBuilder (ImmutableArrayProxyBuilder)
Default implementation for constructing an instance of XmlBuilder (ImmutableArrayProxyBuilder)
- Definition Classes
- XmlTypes
- final def addAndFocus(path: XmlPath, elem: Elem, dchildren: XmlChildren = emptyChildren): Path[XmlItem, Elem, [T]XCC[T]]
Adds a subtree to this given path and returns a path focussed on the new subtree.
Adds a subtree to this given path and returns a path focussed on the new subtree.
The Tree is constructed from the elem and optional children.
- Definition Classes
- XmlTypes
- final def addChild(path: XmlPath, child: XmlItem): Path[XmlItem, Elem, [T]XCC[T]]
Adds a child to the given subpath, however focus remains on the newly modified path
Adds a child to the given subpath, however focus remains on the newly modified path
- Definition Classes
- XmlTypes
- 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.
When the user really wants a stream source or there is yet another place that jaxp Source support is not complete.
- Definition Classes
- TraxSourceConversions
- def asString[T](xml: T)(implicit serf: SerializerFactory, sxml: SerializeableXml[T]): String
Returns a string version of the tree or throws
Returns a string version of the tree or throws
- Definition Classes
- XmlPrinter
- def attributes(implicit path: XmlPath): Attributes
returns the attributes of a given element
returns the attributes of a given element
- Definition Classes
- XmlPaths
- 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
Compare the xml object via the available XmlDifference type class
- Definition Classes
- XmlEquals
- def compare[T](left: T, right: T)(implicit arg0: XmlComparison[T]): Option[(XmlDifference[_], ComparisonContext)]
Compare the xml object via the available XmlDifference type class
Compare the xml object via the available XmlDifference type class
- Definition Classes
- XmlEquals
- 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).
Perform an actual token comparison (Text/CData and Attribute value relevant).
- Definition Classes
- XmlEquals
- 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
Conversion from Scala XML into Scales XML
- Definition Classes
- XmlUtils
- def convertToStream(tree: XmlTree): Iterator[PullType]
- Definition Classes
- TraxSourceConversions
- val defaultOptimisation: MemoryOptimisationStrategy[QNameToken]
- val defaultPathOptimisation: PathOptimisationStrategy[QNameToken]
- def doElement(x: Elem, currentMappings: Map[String, String]): NamespaceContext
- Definition Classes
- XmlPrinter
- 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
Same as fromXmlPathToXPath, an eager evaluation of xpath queries
- Definition Classes
- XmlPaths
- def elem(implicit path: XmlPath): Elem
returns the Elem at this path
returns the Elem at this path
- Definition Classes
- XmlPaths
- val emptyAttributes: Attributes
An empty collection of Attribute
An empty collection of Attribute
- Definition Classes
- XmlTypes
- val emptyChildren: XmlChildren
An empty collection of ItemOrElem
An empty collection of ItemOrElem
- Definition Classes
- XmlTypes
- val emptyMiscs: Miscs
An empty collection of Misc
An empty collection of Misc
- Definition Classes
- XmlTypes
- val emptyNamespaces: Map[String, String]
An empty Map of String -> String representing prefix -> namespace
An empty Map of String -> String representing prefix -> namespace
- Definition Classes
- XmlTypes
- def foldPrint[T](pout: XmlOutput)(it: T)(implicit arg0: SerializeableXml[T]): Option[Throwable]
Placeholder - prefer serialize instead
Placeholder - prefer serialize instead
- Definition Classes
- XmlPrinter
- 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
curried to allow direct drop in for predicates, if it is an item then it will return false
- Definition Classes
- NameFunctions
- def hasLocalNameA(local: String): (AttributePath) => Boolean
hasLocalName for AttributePaths
hasLocalName for AttributePaths
- Definition Classes
- Functions
- def hasLocalNameX(local: String): (XmlPath) => Boolean
hasLocalName for XmlPaths
hasLocalName for XmlPaths
- Definition Classes
- Functions
- def hasNamespace[T](namespaceUri: String)(implicit name: Names[T], d: DIF): (T) => Boolean
matches only the namespace
matches only the namespace
- Definition Classes
- NameFunctions
- def hasNamespace[T](namespace: Namespace)(implicit name: Names[T]): (T) => Boolean
matches only the namespace
matches only the namespace
- Definition Classes
- NameFunctions
- 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".
Will be true for all values of T except when the resulting QName is "empty".
If hasQName is false then calling name will throw
- Definition Classes
- NameFunctions
- 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".
Will be true for all values of T except when the resulting QName is "empty".
If hasQName is false then calling name will throw
- Definition Classes
- NameFunctions
- def headerAndFooter(pout: XmlOutput, doc: DocLike)(serializerf: (XmlOutput, Serializer) => (XmlOutput, Option[Throwable])): (Serializer) => Option[Throwable]
- Definition Classes
- XmlPrinter
- implicit val idPullIteratees: PullIterateeFunctions[scalaz.Id.Id]
- Definition Classes
- PullIteratees
- implicit val ioPullIteratees: PullIterateeFunctions[IO]
- Definition Classes
- PullIteratees
- val isElem: (XmlPath) => Boolean
- Definition Classes
- XmlPaths
- def isEmptyTree(tree: XmlTree): Boolean
Returns true if the tree is effectively empty, i.e.
Returns true if the tree is effectively empty, i.e. no attributes or children
- Definition Classes
- XmlUtils
- def isEquivalent[T](qname: QName)(implicit name: Names[T]): (T) => Boolean
Matches on prefix and namespace only
Matches on prefix and namespace only
- Definition Classes
- NameFunctions
- def isExactly[T](qname: QName)(implicit name: Names[T]): (T) => Boolean
Does the qname match exactly (prefix included if present)
Does the qname match exactly (prefix included if present)
- Definition Classes
- NameFunctions
- val isItem: (XmlPath) => Boolean
- Definition Classes
- XmlPaths
- def isNil(tree: XmlTree): Boolean
Tests if a given tree is nil, but does not check if children are present.
Tests if a given tree is nil, but does not check if children are present.
- returns
true if there is a xsi:nil="true" value (or 1)
- Definition Classes
- XmlUtils
- val isText: (XmlPath) => Boolean
- Definition Classes
- XmlPaths
- 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.
Just for items, given we don't want to generally serialize them directly but as part of a tree. Useful for debugging only
- Definition Classes
- XmlPrinter
- def iterate(path: List[QName], xml: Iterator[PullType])(implicit qe: Equal[QName]): FlatMapIterator[XmlPath]
A wrapping around withIter(onDone(List(onQNames(path))))(enumXml(xml, _)) it unwraps the data providing an Iterator[XPath]
A wrapping around withIter(onDone(List(onQNames(path))))(enumXml(xml, _)) it unwraps the data providing an Iterator[XPath]
- Definition Classes
- PullIteratees
- def iterate(path: List[QName], xml: xml.parser.pull.XmlPull)(implicit qe: Equal[QName]): FlatMapIterator[XmlPath]
Wraps XmlPull
Wraps XmlPull
- Definition Classes
- PullIteratees
- def joinTextNodes(children: XmlChildren): XmlChildren
- Definition Classes
- Whitespace
- def joinTextNodes(tree: XmlTree): XmlTree
Joins adjacent text nodes for the immediate children only (make a tree more XPath friendly)
Joins adjacent text nodes for the immediate children only (make a tree more XPath friendly)
- Definition Classes
- Whitespace
- 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
a) add / replace in mappings b) add to declMap
- Definition Classes
- XmlPrinter
- 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.
Normally the implicit fromXPathToIterable will provide sorted output, but this can create significant slow down when only the contents are necessary, not their order.
Use lazyRaw to convert without forcing sorting or checking for duplicates, and to evaluate lazily.
Warning, don't use this version of raw unless your XPath usage costs more than the navigation, its based on Stream and terribly slow (huge memory and stack usage etc).
NOTEs Laziness with flatten is achieved by using iterator.toIterable before the flatten (uses Stream internally). Its only useful as a lazy evaluator if viewed was used.
- Definition Classes
- XmlPaths
- 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
Use a custom parserPool to control the sax factory features
- Definition Classes
- XmlParser
- 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
Use a custom parserPool to control the sax factory features
- Definition Classes
- XmlParser
- def localName[T](t: T)(implicit name: Names[T]): String
Returns the localName
Returns the localName
- Definition Classes
- NameFunctions
- def localName[T](implicit t: T, name: Names[T], d: DIF): String
Returns the localName
Returns the localName
- Definition Classes
- NameFunctions
- val mergeAdjacentText: ((Option[XmlItem], XmlChildren), ItemOrElem) => (Option[XmlItem], XmlChildren)
Joins adjacent text nodes for immediate children
Joins adjacent text nodes for immediate children
- Definition Classes
- Whitespace
- def name[T](t: T)(implicit iname: Names[T]): QName
Returns the QName, will throw if the QName is "empty"
Returns the QName, will throw if the QName is "empty"
- Definition Classes
- NameFunctions
- def name[T](implicit t: T, name: Names[T], d: DIF): QName
Returns the QName, will throw if the QName is "empty"
Returns the QName, will throw if the QName is "empty"
- Definition Classes
- NameFunctions
- def namespace[T](implicit t: T, name: Names[T], d: DIF): UnderlyingNamespace
Returns the underlying namespace object
Returns the underlying namespace object
- Definition Classes
- NameFunctions
- def namespaceUri[T](t: T)(implicit name: Names[T]): String
XPath namespace-uri function, returns the uri
XPath namespace-uri function, returns the uri
- Definition Classes
- NameFunctions
- def namespaceUri[T](implicit t: T, name: Names[T], d: DIF): String
XPath namespace-uri function, returns the uri
XPath namespace-uri function, returns the uri
- Definition Classes
- NameFunctions
- def newSchema(source: Source, factory: Loaner[SchemaFactory] = DefaultXSDSchemaFactoryPool): Schema
- Definition Classes
- XmlFactories
- val noXmlPath: XmlPath
Use to signify a "null object", tree/path shouldn't work like this its a smell
Use to signify a "null object", tree/path shouldn't work like this its a smell
- Definition Classes
- XmlTypes
- def normalizeSpace[T](t: T)(implicit value: TextValue[T]): String
XPath normalize-space function, replaces all consecutive whitespace with " " and trims.
XPath normalize-space function, replaces all consecutive whitespace with " " and trims.
- Definition Classes
- TextFunctions
- def normalizeSpace[T](implicit t: T, value: TextValue[T], d: DIF): String
XPath normalize-space function, replaces all consecutive whitespace with " " and trims.
XPath normalize-space function, replaces all consecutive whitespace with " " and trims.
- Definition Classes
- TextFunctions
- def normalizeSpaceS(str: String): String
XPath normalize-space function, replaces all consecutive whitespace with " " and trims.
XPath normalize-space function, replaces all consecutive whitespace with " " and trims.
- Definition Classes
- Whitespace
- def pathAndTreeMatcher[T](pathEval: (XmlTree) => T)(implicit arg0: utils.AsBoolean[T]): utils.BooleanAndTMatcher[XmlTree, T]
Similar to pathMatcher but also gives the tree back into the pattern match.
Similar to pathMatcher but also gives the tree back into the pattern match.
- Definition Classes
- XPathMatcher
- def pathMatcher[T](pathEval: (XmlTree) => T)(implicit arg0: utils.AsBoolean[T]): utils.BooleanMatcher[XmlTree, T]
Creates a booleanMatcher against a Tree based on the @pathEval function.
Creates a booleanMatcher against a Tree based on the @pathEval function.
For XPath evaluations on the tree this typically gives the paths back when the xpath evaluates to a non-empty result. TODO ADD CODE
- Definition Classes
- XPathMatcher
- def pqName[T](t: T)(implicit name: Names[T]): String
Returns either qualifiedName or prefix:{namespace}local when a prefix is present
Returns either qualifiedName or prefix:{namespace}local when a prefix is present
- Definition Classes
- NameFunctions
- def pqName[T](implicit t: T, name: Names[T], d: DIF): String
Returns either qualifiedName or prefix:{namespace}local when a prefix is present
Returns either qualifiedName or prefix:{namespace}local when a prefix is present
- Definition Classes
- NameFunctions
- 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.
Prints to stdout, useful for testing etc Will dump an error if one is found.
Note it outputs to the vmDefaultCharset so it should always be C+P able
- Definition Classes
- XmlPrinter
- def pullIterateesOf[F[_]](implicit F: Monad[F]): PullIterateeFunctions[F]
- Definition Classes
- PullIteratees
- def pullXml[RToken <: OptimisationToken](source: InputSource, optimisationStrategy: MemoryOptimisationStrategy[RToken] = defaultOptimisation, parserFactoryPool: Pool[XMLInputFactory] = impl.DefaultStaxInputFactoryPool, closeAfterUse: Boolean = true, strictPath: List[QName] = Nil): xml.parser.pull.XmlPull with Closeable with IsClosed
Creates a new XmlPull based on source.
Creates a new XmlPull based on source. By default it will close the stream after use.
- Definition Classes
- XmlPulls
- def pullXmlCompletely[RToken <: OptimisationToken](source: InputSource, strategy: PathOptimisationStrategy[RToken] = defaultPathOptimisation, parserFactoryPool: Pool[XMLInputFactory] = impl.DefaultStaxInputFactoryPool, closeAfterUse: Boolean = true): Doc
Load xml via pull parsing
Load xml via pull parsing
- Definition Classes
- XmlPulls
- 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
Allows plugging in other feeds, non source based, as such not closeable
- Definition Classes
- XmlPulls
- 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.
Creates a new XmlPull based on source for direct handling of the stream. Note to close the stream you must bracket. The individual XmlPull will be closed after the document end but the stream will remain open
- Definition Classes
- XmlPulls
- def pushXmlIter[F[_]](out: Writer, doc: DocLike = EmptyDoc(), version: Option[XmlVersion] = None, encoding: Option[Charset] = None)(implicit serializerFI: SerializerFactory, F: Monad[F]): (CloseOnNeed, SerialIterT[F])
Returns an Iteratee that can serialize PullTypes to out.
Returns an Iteratee that can serialize PullTypes to out. The serializer factory management is automatically handled upon calling with eof. This can be triggered earlier by calling closeResource on the returned CloseOnNeed.
- Definition Classes
- SerializingIter
- def qName[T](t: T)(implicit name: Names[T]): String
Returns the XPath QName - prefix:local or local
Returns the XPath QName - prefix:local or local
- Definition Classes
- NameFunctions
- def qName[T](implicit t: T, name: Names[T], d: DIF): String
Returns the XPath QName - prefix:local or local
Returns the XPath QName - prefix:local or local
- Definition Classes
- NameFunctions
- def qname[T](t: T)(implicit name: Names[T]): String
Returns the XPath QName - prefix:local or local
Returns the XPath QName - prefix:local or local
- Definition Classes
- NameFunctions
- def qname[T](implicit t: T, name: Names[T], d: DIF): String
Returns the XPath QName - prefix:local or local
Returns the XPath QName - prefix:local or local
- Definition Classes
- NameFunctions
- def qnamesEqual(context: ComparisonContext, str: String, str2: String): Boolean
Allows comparison of Text nodes or Attribute values that contain QNames, i.e.
Allows comparison of Text nodes or Attribute values that contain QNames, i.e. prefix:value. In order to perform this comparison both the left and right sides must have a NamespaceContext.
- Definition Classes
- XmlEquals
- def qualifiedName[T](t: T)(implicit name: Names[T]): String
Returns the qualified name {namespace}local
Returns the qualified name {namespace}local
- Definition Classes
- NameFunctions
- def qualifiedName[T](implicit t: T, name: Names[T], d: DIF): String
Returns the qualified name {namespace}local
Returns the qualified name {namespace}local
- Definition Classes
- NameFunctions
- 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.
Normally the implicit fromXPathToIterable will provide sorted output, but this can create significant slow down when only the contents are necessary, not their order.
Use raw to convert without forcing sorting or checking for duplicates.
NOTE Any laziness aquired by viewed will also be lost by the flatten
- Definition Classes
- XmlPaths
- def readXml[Token <: OptimisationToken](source: InputSource, strategy: PathOptimisationStrategy[Token], reader: XMLReader, saxSupport: SaxSupport)(implicit xmlVer: XmlVersion): Doc
- Definition Classes
- XmlParser
- def serialize[T](pout: XmlOutput)(it: T)(implicit arg0: SerializeableXml[T]): Option[Throwable]
Serializes items which can behave like xml.
Serializes items which can behave like xml.
- Definition Classes
- XmlPrinter
- def serializeIter[F[_]](output: XmlOutput, serializer: Serializer, closer: () => Unit, doc: DocLike = EmptyDoc())(implicit F: Monad[F]): SerialIterT[F]
The serializer will be returned automatically to the pool by calling closer
The serializer will be returned automatically to the pool by calling closer
doc functions are only evaluated upon the first elem / last elem
- Definition Classes
- SerializingIter
- def serializeMisc(pout: XmlOutput, misc: Iterable[Misc], serializer: Serializer): (XmlOutput, Option[Throwable])
- Definition Classes
- XmlPrinter
- def sourceUser(source: InputSource): SourceUser with Product with Serializable
Provides proxied sources to the pull parsers, the stream provided is the stream used
Provides proxied sources to the pull parsers, the stream provided is the stream used
- Definition Classes
- XmlPulls
- def streamOr[T](xml: T, f: => Source)(implicit serf: SerializerFactory, serXml: SerializeableXml[T]): Source
- Definition Classes
- TraxSourceConversions
- def string[T](t: T)(implicit value: TextValue[T]): String
XPath name for text
XPath name for text
- Definition Classes
- TextFunctions
- def string[T](implicit t: T, value: TextValue[T], d: DIF): String
XPath name for text
XPath name for text
- Definition Classes
- TextFunctions
- def text[T](t: T)(implicit value: TextValue[T]): String
The text value of a given object, .value for attributes & items, the accumalated text if its an elem
The text value of a given object, .value for attributes & items, the accumalated text if its an elem
- Definition Classes
- TextFunctions
- def text[T](implicit t: T, value: TextValue[T], d: DIF): String
The text value of a given object, .value for attributes & items, the accumalated text if its an elem
The text value of a given object, .value for attributes & items, the accumalated text if its an elem
- Definition Classes
- TextFunctions
- implicit def toLeft(ev: XmlEvent): Left[XmlEvent, Nothing]
- Definition Classes
- XmlPulls
- implicit def toRight(ev: EndElem): Right[Nothing, EndElem]
- Definition Classes
- XmlPulls
- def toTree[RToken <: OptimisationToken](pull: Iterator[PullType], strategy: PathOptimisationStrategy[RToken] = defaultPathOptimisation): XmlTree
Attempts to convert a stream to a tree
Attempts to convert a stream to a tree
- Definition Classes
- XmlPulls
- implicit val trampolinePullIteratees: PullIterateeFunctions[Trampoline]
- Definition Classes
- PullIteratees
- def value[T](t: T)(implicit value: TextValue[T]): String
More readable version for XmlItems and Attributes, same as text
More readable version for XmlItems and Attributes, same as text
- Definition Classes
- TextFunctions
- def value[T](implicit t: T, value: TextValue[T], d: DIF): String
More readable version for XmlItems and Attributes, same as text
More readable version for XmlItems and Attributes, same as text
- Definition Classes
- TextFunctions
- def viewed(xmlPath: XmlPath)(implicit cbf: CanBuildFrom[List[XmlPath], XmlPath, List[XmlPath]]): xml.xpath.XPath[List[XmlPath]]
Lazy evaluation of XPaths
Lazy evaluation of XPaths
View called on nested Lists, but not on xlmPath.
- Definition Classes
- XmlPaths
- def withWriter(decl: Declaration, out: Writer): SerializerData
- Definition Classes
- XmlPrinter
- 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 .
Writes the xml to a given Writer with defaults provided for .
- Definition Classes
- XmlPrinter
- val xmlSeqLikeThing: SeqLikeThing[ImmutableArrayProxy[_], ItemOrElem, ImmutableArrayProxy]
The xml typed ImmutableArrayProxy SeqLikeThing
The xml typed ImmutableArrayProxy SeqLikeThing
- Definition Classes
- XmlTypes
- val xsiNil: AttributeQName
A convenient AttributeQName for xsi:nil attributes
A convenient AttributeQName for xsi:nil attributes
- Definition Classes
- XmlUtils
- object <
Creates DslBuilder instances
- object ?<
Creates OptionalDslBuilder instances.
Creates OptionalDslBuilder instances. If none of the end Elems contain data (either attributes or child text nodes) the result of the builder is None.
- object Attr
Allows easy patterns for attribute values
- object Attribs
Simple constructor for Attributes
- object CData
- object Comment
- object Elem
- 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
- case object Xml10 extends XmlVersion with Product with Serializable
- case object Xml11 extends XmlVersion with Product with Serializable