Type Members

1.  class AttributeComparison extends XmlComparison[Attribute]

   Comparison between attributes, requires an Equal type class for QNames

2.  sealed trait AttributeDifference extends XmlDifference[Attribute]
3.  case class AttributeNameDifference(left: Attribute, right: Attribute) extends AttributeDifference with Product with Serializable
4.  case class AttributeValueDifference(left: Attribute, right: Attribute) extends AttributeDifference with Product with Serializable
5.  class AttributesComparison extends XmlComparison[xml.Attributes]

   Comparison for attributes, requires a comparison for individual attributes, allowing flexible definitions of equality

6.  sealed trait AttributesDifference extends XmlDifference[xml.Attributes]
7.  class ComparisonContext extends AnyRef

   ComparisonContext represents both the path to a given comparison and the namespace declarations which are relevant for it.

8.  trait ComparisonContextImplicits extends AnyRef

   Provides an immplicit to easily access the head QName in a path

9.  trait DefaultAttributeEquals extends AnyRef
10.  trait DefaultAttributesEquals extends AnyRef
11.  trait DefaultDocLikeEquals extends AnyRef
12.  trait DefaultElemEquals extends AnyRef
13.  trait DefaultItemEquals extends AnyRef
14.  trait DefaultQNameEquals extends AnyRef
15.  trait DefaultQNameToken extends AnyRef
16.  trait DefaultStreamEquals extends StreamEquals

    Streams compared after transforming via joinTextAndCData

17.  trait DefaultXmlEquals extends DefaultItemEquals with DefaultAttributeEquals with DefaultAttributesEquals with DefaultElemEquals with DefaultStreamEquals with QNameEquals with DefaultQNameToken with DefaultDocLikeEquals

    All CData nodes are converted to text nodes, adjoining Text nodes (including CData) are joined.

18.  case class DifferentNumberOfAttributes(left: xml.Attributes, right: xml.Attributes) extends AttributesDifference with Product with Serializable

    Their size is different

19.  case class DifferentNumberOfMiscs(left: xml.Miscs, right: xml.Miscs, isProlog: Boolean) extends XmlDifference[xml.Miscs] with Product with Serializable
20.  case class DifferentTypes(left: xml.PullType, right: xml.PullType) extends XmlDifference[xml.PullType] with Product with Serializable

    When types are different, or an end element vs XmlEvent

21.  case class DifferentValueAttributes(left: xml.Attributes, right: xml.Attributes, differentValue: Attribute) extends AttributesDifference with Product with Serializable

    Re-packs the AttributeValueDifference, but will only occur when the attributes QName is present

22.  class DocLikeComparison[T, B] extends XmlComparison[T]

    Compares neither of the version, DTD nor encoding of a document, but prolog and end misc.

    Compares neither of the version, DTD nor encoding of a document, but prolog and end misc. Requires a @T that can be converted to a DocLike and a body @B. B must have an XmlComparison available and there must exist conversions from T to DocLike and T to B.

23.  abstract class DocLikeWrapper[T] extends AnyRef

    Wrap the creation of doclike things

24.  class DocLikeWrapperBase[T, B] extends DocLikeWrapper[T]

    Base wrapper for most usecases, extra type is here to keep lookup working

25.  case class ElemAttributeDifference(left: Elem, right: Elem, attributesDifference: AttributesDifference) extends ElemDifference with Product with Serializable

    If the difference is due to an attribute thats included as well

26.  class ElemComparison extends XmlComparison[Elem]

    Namespaces by default are not compared.

    Namespaces by default are not compared. They aren't marked as implicit as you really have to be explicitly wanting to compare them.

    An Attributes comparison and a QName Equal instance are required. This also allows, for example, specification of equality using prefixes for the Elem, but not on the Attributes.

27.  sealed trait ElemDifference extends XmlDifference[Elem]
28.  case class ElemNameDifference(left: Elem, right: Elem) extends ElemDifference with Product with Serializable
29.  case class ElemNamespacesDifference(left: Elem, right: Elem) extends ElemDifference with Product with Serializable

    This can only be returned when an ElemComparisom has been suplied with a custom namespaces implementation.

30.  case class EndElemNameDifference(left: EndElem, right: EndElem) extends XmlDifference[EndElem] with Product with Serializable
31.  trait ExactQName extends AnyRef
32.  trait ExactStreamEquals extends StreamEquals
33.  trait ExactXmlEquals extends DefaultItemEquals with DefaultAttributeEquals with DefaultAttributesEquals with DefaultElemEquals with ExactStreamEquals with QNameEquals with DefaultQNameToken

    All default exact Xml Equal and XmlComparison trait instances.

    All default exact Xml Equal and XmlComparison trait instances.

    CData, Comments, PI are all kept as is, DTD, encoding and prolog etc are not. Text nodes are not joined. Use LogicalXmlEquals to focus more on content only.

34.  trait FromEqualsImplicit extends AnyRef
35.  case class ItemDifference(left: XmlItem, right: XmlItem) extends XmlDifference[XmlItem] with Product with Serializable
36.  class JoinTextAndCData extends Iterator[xml.PullType]

    Modifies the stream to turn CData nodes into Text nodes and join all adjacent Text nodes togeter i.e.

    Modifies the stream to turn CData nodes into Text nodes and join all adjacent Text nodes togeter i.e. a "tree" with children (Text, CData, Text, CData) will become a single Text child.

    CData can be kept if keepCData is set to true

37.  case class MiscDifference(left: xml.Misc, right: xml.Misc, isProlog: Boolean) extends XmlDifference[xml.Misc] with Product with Serializable
38.  case class MiscDifferentTypes(left: xml.Misc, right: xml.Misc, isProlog: Boolean) extends XmlDifference[xml.Misc] with Product with Serializable
39.  case class MissingAttributes(left: xml.Attributes, right: xml.Attributes, missing: Attribute) extends AttributesDifference with Product with Serializable

    The size is the same but one of lefts qnames is not present in right

40.  class PathAsPullTypeIterable extends AbstractPathIterator[XmlItem, Elem, xml.XCC, xml.PullType]

    Makes the given path the top path

41.  class QNameComparison extends XmlComparison[QName]

    Only added to provide a complete compare set

42.  case class QNameDifference(left: QName, right: QName) extends XmlDifference[QName] with Product with Serializable
43.  trait QNameEquals extends AnyRef
44.  class StreamComparable[T] extends AnyRef

    This interface allows for non xml matching, for example a forward Iterator from a Text child.

    This interface allows for non xml matching, for example a forward Iterator from a Text child. This would be impossible to model as an xml document, but could be useful for comparison.

    This trait boxes a given conversion, stopping accidental serialize calls on the resulting streams.

45.  trait StreamComparableImplicits extends TheyReallyAreIterators

    Collection of all implicit conversions to StreamComparables.

    Collection of all implicit conversions to StreamComparables.

    NOTE: The results are only usable with compare / ===, and should not be used to serialize

46.  class StreamComparison extends XmlComparison[StreamComparable[_]]

    Compares based on streams.

    Compares based on streams. Requires comparisons for XmlItem, Elem and a QName Equal instance for testing EndElems.

47.  class StreamComparisonWrapper[T] extends XmlComparison[T]

    Wraps a given T with a conversion from T to an xml stream

48.  trait StreamEquals extends AnyRef
49.  trait TheyReallyAreIterators extends AnyRef

    For Iterator[PullType]s that actually are, lets help the inference and implicit lookup out

50.  trait XmlComparison[-T] extends AnyRef

    Like Equals but also gives a path in addition to the fun reason

51.  sealed trait XmlDifference[X] extends AnyRef

    Why did equality fail, pattern match fun

52.  trait XmlEquals extends AnyRef

    Base functions for equality

53.  class XmlItemComparison extends XmlComparison[XmlItem]

    Compares XmlItems, providing Some qnameTokenComparison will force that to be used to decide if qname comparison should be used or not