Attributes

A special implementation of scala.collection.Map[com.codecommit.antixml.QName, String] with nice overloading and some implicit magic designed for use containing element attributes in com.codecommit.antixml.Elem. The actual stored keys are of type com.codecommit.antixml.QName. This is how (optional) namespace information for attributes is stored in Anti-XML trees. However, there are some syntactic tricks which allow you to ignore the com.codecommit.antixml.QName boiler-plate when you don't actually need namespace support. For example:

val attrs = Attributes("foo" -> "bar", "baz" -> "bin")
attrs("foo")                  // => "bar"
attrs(QName(None, "foo"))     // => "bar"

val attrs2 = attrs + ("even" -> "more")                       // => Attributes(...)
val attrs3 = attrs + (QName(Some("pre"), "even" -> "less")    // => Attributes(...)

With very, very few exceptions, String and com.codecommit.antixml.QName are interchangable. Of course, this is being done with implicit conversions. However, you don't need to worry about the conversion String => QName poluting the implicit dispatch space! The conversion is defined on the companion object for com.codecommit.antixml.QName, meaning that the compiler will only select it when the result of an expression is explicitly of type QName. It will not automatically inject the conversion to satisfy method dispatch on String. For example:

val str = "fubar"

val qn: QName = str      // works!
str.ns                   // won't compile!

In this example, it is important to note that ns is a method on com.codecommit.antixml.QName. Thus, if the implicit conversion were pimp-enabling, the compiler would have accepted the last line of the example. However, as you can see, the implicit dispatch space has not been cluttered while the convenience of String rather than com.codecommit.antixml.QName has been preserved.

One implicit space-cluttering that couldn't be avoided is the conversion defined as (String, String) => (QName, String). This is required to enable the nice String syntax on things like the + method and the companion object apply factory. Unfortunately, this conversion had to be defined in the com.codecommit.antixml companion object. Fortunately, it is a conversion within the same type (simply different parameters passed to Tuple2). Thus, it shouldn't cause any scoping problems.

Source: Attributes.scala
See also: com.codecommit.antixml.QName

Linear Supertypes

Map[QName, String], MapLike[QName, String, Attributes], Map[QName, String], MapLike[QName, String, Attributes], Subtractable[QName, Attributes], PartialFunction[QName, String], (QName) ⇒ String, GenMap[QName, String], GenMapLike[QName, String, Attributes], Iterable[(QName, String)], Iterable[(QName, String)], IterableLike[(QName, String), Attributes], Equals, GenIterable[(QName, String)], GenIterableLike[(QName, String), Attributes], Traversable[(QName, String)], Immutable, Traversable[(QName, String)], GenTraversable[(QName, String)], GenericTraversableTemplate[(QName, String), Iterable], TraversableLike[(QName, String), Attributes], GenTraversableLike[(QName, String), Attributes], Parallelizable[(QName, String), ParMap[QName, String]], TraversableOnce[(QName, String)], GenTraversableOnce[(QName, String)], FilterMonadic[(QName, String), Attributes], HasNewBuilder[(QName, String), Attributes], AnyRef, Any

Instance Constructors

new Attributes(entries: Map[QName, String])

Annotations
@deprecated
Deprecated
(Since version 0.4) Use the factory methods on the Attributes companion instead

Type Members

class DefaultKeySet extends AbstractSet[A] with Set[A] with Serializable

Attributes
protected
Definition Classes
MapLike
class DefaultValuesIterable extends AbstractIterable[B] with Iterable[B] with Serializable

Attributes
protected
Definition Classes
MapLike
class FilteredKeys extends AbstractMap[A, B] with DefaultMap[A, B]

Attributes
protected
Definition Classes
MapLike
class ImmutableDefaultKeySet extends scala.collection.immutable.MapLike.DefaultKeySet with Set[A]

Attributes
protected
Definition Classes
MapLike
class MappedValues[C] extends AbstractMap[A, C] with DefaultMap[A, C]

Attributes
protected
Definition Classes
MapLike
type Self = Attributes

Attributes
protected[this]
Definition Classes
TraversableLike
class WithFilter extends FilterMonadic[A, Repr]

Definition Classes
TraversableLike

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(kv1: (QName, String), kv2: (QName, String), kvs: (QName, String)*): Attributes

[use case]
[use case]

Full Signature
def +(kv1: (QName, String), kv2: (QName, String), kvs: (QName, String)*)(implicit d: DummyImplicit): Attributes
def +[B >: String](kv1: (QName, B), kv2: (QName, B), kvs: (QName, B)*): Map[QName, B]

Definition Classes
Attributes → MapLike → MapLike
def +(kv: (QName, String)): Attributes

[use case]
[use case]

Full Signature
def +(kv: (QName, String))(implicit d: DummyImplicit): Attributes
def +[B >: String](kv: (QName, B)): Map[QName, B]

Definition Classes
Attributes → Map → MapLike → MapLike → GenMapLike
def ++(xs: GenTraversableOnce[(QName, String)])(implicit d: DummyImplicit): Attributes

Special overload of the ++ method to return Attributes rather than Map[QName, String].
Special overload of the ++ method to return Attributes rather than Map[QName, String].
See the corresponding override of single-argument ++ for more details.
def ++[B1 >: String](xs: GenTraversableOnce[(QName, B1)]): OrderPreservingMap[QName, B1]

Definition Classes
Attributes → MapLike → MapLike
def ++[B >: (QName, String), That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Attributes, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def ++:[B >: (QName, String), That](that: Traversable[B])(implicit bf: CanBuildFrom[Attributes, B, That]): That

Definition Classes
TraversableLike
def ++:[B >: (QName, String), That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Attributes, B, That]): That

Definition Classes
TraversableLike
def -(key: QName): Attributes

Definition Classes
Attributes → MapLike → Subtractable → GenMapLike
def -(elem1: QName, elem2: QName, elems: QName*): Attributes

Definition Classes
Subtractable
def --(xs: GenTraversableOnce[QName]): Attributes

Definition Classes
Subtractable
def /:[B](z: B)(op: (B, (QName, String)) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def :\[B](z: B)(op: ((QName, String), B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Definition Classes
MapLike → TraversableOnce
def addString(b: StringBuilder): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, sep: String): StringBuilder

Definition Classes
TraversableOnce
def aggregate[B](z: ⇒ B)(seqop: (B, (QName, String)) ⇒ B, combop: (B, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def andThen[C](k: (String) ⇒ C): PartialFunction[QName, C]

Definition Classes
PartialFunction → Function1
def apply(key: QName): String

Definition Classes
MapLike → GenMapLike → Function1
def applyOrElse[A1 <: QName, B1 >: String](x: A1, default: (A1) ⇒ B1): B1

Definition Classes
PartialFunction
final def asInstanceOf[T0]: T0

Definition Classes
Any
def canEqual(that: Any): Boolean

Definition Classes
IterableLike → Equals
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B, That](pf: PartialFunction[(QName, String), B])(implicit bf: CanBuildFrom[Attributes, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def collectFirst[B](pf: PartialFunction[(QName, String), B]): Option[B]

Definition Classes
TraversableOnce
def companion: GenericCompanion[Iterable]

Definition Classes
Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → GenericTraversableTemplate
def compose[A](g: (A) ⇒ QName): (A) ⇒ String

Definition Classes
Function1
Annotations
@unspecialized()
def contains(key: QName): Boolean

Definition Classes
MapLike → GenMapLike
def copyToArray[B >: (QName, String)](xs: Array[B], start: Int, len: Int): Unit

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def copyToArray[B >: (QName, String)](xs: Array[B]): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToArray[B >: (QName, String)](xs: Array[B], start: Int): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToBuffer[B >: (QName, String)](dest: Buffer[B]): Unit

Definition Classes
TraversableOnce
def count(p: ((QName, String)) ⇒ Boolean): Int

Definition Classes
TraversableOnce → GenTraversableOnce
def default(key: QName): String

Definition Classes
MapLike → GenMapLike
def drop(n: Int): Attributes

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def dropRight(n: Int): Attributes

Definition Classes
IterableLike
def dropWhile(p: ((QName, String)) ⇒ Boolean): Attributes

Definition Classes
TraversableLike → GenTraversableLike
def empty: Attributes

Definition Classes
Attributes → Map → Map → MapLike
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(that: Any): Boolean

Definition Classes
GenMapLike → Equals → AnyRef → Any
def exists(p: ((QName, String)) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def filter(p: ((QName, String)) ⇒ Boolean): Attributes

Definition Classes
TraversableLike → GenTraversableLike
def filterKeys(p: (QName) ⇒ Boolean): Map[QName, String]

Definition Classes
MapLike → MapLike → GenMapLike
def filterNot(p: ((QName, String)) ⇒ Boolean): Attributes

Definition Classes
MapLike → TraversableLike → GenTraversableLike
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(p: ((QName, String)) ⇒ Boolean): Option[(QName, String)]

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def flatMap[B, That](f: ((QName, String)) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Attributes, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def flatten[B](implicit asTraversable: ((QName, String)) ⇒ GenTraversableOnce[B]): Iterable[B]

Definition Classes
GenericTraversableTemplate
def fold[A1 >: (QName, String)](z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def foldLeft[B](z: B)(op: (B, (QName, String)) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def foldRight[B](z: B)(op: ((QName, String), B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def forall(p: ((QName, String)) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def foreach[U](f: ((QName, String)) ⇒ U): Unit

Definition Classes
Attributes → IterableLike → GenericTraversableTemplate → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
def genericBuilder[B]: Builder[B, Iterable[B]]

Definition Classes
GenericTraversableTemplate
def get(key: QName): Option[String]

Definition Classes
Attributes → MapLike → GenMapLike
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getOrElse[B1 >: String](key: QName, default: ⇒ B1): B1

Definition Classes
MapLike → GenMapLike
def groupBy[K](f: ((QName, String)) ⇒ K): Map[K, Attributes]

Definition Classes
TraversableLike → GenTraversableLike
def grouped(size: Int): Iterator[Attributes]

Definition Classes
IterableLike
def hasDefiniteSize: Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def hashCode(): Int

Definition Classes
GenMapLike → AnyRef → Any
def head: (QName, String)

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def headOption: Option[(QName, String)]

Definition Classes
TraversableLike → GenTraversableLike
def init: Attributes

Definition Classes
TraversableLike → GenTraversableLike
def inits: Iterator[Attributes]

Definition Classes
TraversableLike
def isDefinedAt(key: QName): Boolean

Definition Classes
MapLike → GenMapLike → PartialFunction
def isEmpty: Boolean

Definition Classes
MapLike → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isTraversableAgain: Boolean

Definition Classes
TraversableLike → GenTraversableLike → GenTraversableOnce
def iterator: Iterator[(QName, String)]

Definition Classes
Attributes → MapLike → IterableLike → GenIterableLike
def keySet: Set[QName]

Definition Classes
MapLike → MapLike → GenMapLike
def keys: Iterable[QName]

Definition Classes
MapLike → GenMapLike
Annotations
@migration
Migration
(Changed in version 2.8.0) keys returns Iterable[A] rather than Iterator[A].
def keysIterator: Iterator[QName]

Definition Classes
MapLike → GenMapLike
def last: (QName, String)

Definition Classes
TraversableLike → GenTraversableLike
def lastOption: Option[(QName, String)]

Definition Classes
TraversableLike → GenTraversableLike
def lift: (QName) ⇒ Option[String]

Definition Classes
PartialFunction
def map[B, That](f: ((QName, String)) ⇒ B)(implicit bf: CanBuildFrom[Attributes, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def mapValues[C](f: (String) ⇒ C): Map[QName, C]

Definition Classes
MapLike → MapLike → GenMapLike
def max[B >: (QName, String)](implicit cmp: Ordering[B]): (QName, String)

Definition Classes
TraversableOnce → GenTraversableOnce
def maxBy[B](f: ((QName, String)) ⇒ B)(implicit cmp: Ordering[B]): (QName, String)

Definition Classes
TraversableOnce → GenTraversableOnce
def min[B >: (QName, String)](implicit cmp: Ordering[B]): (QName, String)

Definition Classes
TraversableOnce → GenTraversableOnce
def minBy[B](f: ((QName, String)) ⇒ B)(implicit cmp: Ordering[B]): (QName, String)

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString: String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(sep: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(start: String, sep: String, end: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newBuilder: Builder[(QName, String), Attributes]

Attributes
protected[this]
Definition Classes
MapLike → TraversableLike → HasNewBuilder
def nonEmpty: Boolean

Definition Classes
TraversableOnce → GenTraversableOnce
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def orElse[A1 <: QName, B1 >: String](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

Definition Classes
PartialFunction
def par: ParMap[QName, String]

Definition Classes
Parallelizable
def parCombiner: Combiner[(QName, String), ParMap[QName, String]]

Attributes
protected[this]
Definition Classes
MapLike → MapLike → TraversableLike → Parallelizable
def partition(p: ((QName, String)) ⇒ Boolean): (Attributes, Attributes)

Definition Classes
TraversableLike → GenTraversableLike
def product[B >: (QName, String)](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduce[A1 >: (QName, String)](op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceLeft[B >: (QName, String)](op: (B, (QName, String)) ⇒ B): B

Definition Classes
TraversableOnce
def reduceLeftOption[B >: (QName, String)](op: (B, (QName, String)) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceOption[A1 >: (QName, String)](op: (A1, A1) ⇒ A1): Option[A1]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRight[B >: (QName, String)](op: ((QName, String), B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def reduceRightOption[B >: (QName, String)](op: ((QName, String), B) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def repr: Attributes

Definition Classes
TraversableLike → GenTraversableLike
def reversed: List[(QName, String)]

Attributes
protected[this]
Definition Classes
TraversableOnce
def runWith[U](action: (String) ⇒ U): (QName) ⇒ Boolean

Definition Classes
PartialFunction
def sameElements[B >: (QName, String)](that: GenIterable[B]): Boolean

Definition Classes
IterableLike → GenIterableLike
def scan[B >: (QName, String), That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Attributes, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanLeft[B, That](z: B)(op: (B, (QName, String)) ⇒ B)(implicit bf: CanBuildFrom[Attributes, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanRight[B, That](z: B)(op: ((QName, String), B) ⇒ B)(implicit bf: CanBuildFrom[Attributes, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
Annotations
@migration
Migration
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
def seq: Map[QName, String]

Definition Classes
Map → Map → GenMap → GenMapLike → Iterable → Iterable → GenIterable → Traversable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce
def size: Int

Definition Classes
Attributes → GenTraversableLike → TraversableOnce → GenTraversableOnce
def slice(from: Int, until: Int): Attributes

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def sliding(size: Int, step: Int): Iterator[Attributes]

Definition Classes
IterableLike
def sliding(size: Int): Iterator[Attributes]

Definition Classes
IterableLike
def span(p: ((QName, String)) ⇒ Boolean): (Attributes, Attributes)

Definition Classes
TraversableLike → GenTraversableLike
def splitAt(n: Int): (Attributes, Attributes)

Definition Classes
TraversableLike → GenTraversableLike
def stringPrefix: String

Definition Classes
MapLike → TraversableLike → GenTraversableLike
def sum[B >: (QName, String)](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: Attributes

Definition Classes
TraversableLike → GenTraversableLike
def tails: Iterator[Attributes]

Definition Classes
TraversableLike
def take(n: Int): Attributes

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def takeRight(n: Int): Attributes

Definition Classes
IterableLike
def takeWhile(p: ((QName, String)) ⇒ Boolean): Attributes

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def thisCollection: Iterable[(QName, String)]

Attributes
protected[this]
Definition Classes
IterableLike → TraversableLike
def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, (QName, String), Col[(QName, String)]]): Col[(QName, String)]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def toArray[B >: (QName, String)](implicit arg0: ClassTag[B]): Array[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toBuffer[C >: (QName, String)]: Buffer[C]

Definition Classes
MapLike → TraversableOnce → GenTraversableOnce
def toCollection(repr: Attributes): Iterable[(QName, String)]

Attributes
protected[this]
Definition Classes
IterableLike → TraversableLike
def toIndexedSeq: IndexedSeq[(QName, String)]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterable: Iterable[(QName, String)]

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def toIterator: Iterator[(QName, String)]

Definition Classes
IterableLike → TraversableLike → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toList: List[(QName, String)]

Definition Classes
TraversableOnce → GenTraversableOnce
def toMap[T, U](implicit ev: <:<[(QName, String), (T, U)]): Map[T, U]

Definition Classes
Map → TraversableOnce → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toSeq: Seq[(QName, String)]

Definition Classes
MapLike → TraversableOnce → GenTraversableOnce
def toSet[B >: (QName, String)]: Set[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toStream: Stream[(QName, String)]

Definition Classes
IterableLike → TraversableLike → GenTraversableOnce
def toString(): String

Definition Classes
MapLike → TraversableLike → Function1 → AnyRef → Any
def toTraversable: Traversable[(QName, String)]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toVector: Vector[(QName, String)]

Definition Classes
TraversableOnce → GenTraversableOnce
def transform[C, That](f: (QName, String) ⇒ C)(implicit bf: CanBuildFrom[Attributes, (QName, C), That]): That

Definition Classes
MapLike
def transpose[B](implicit asTraversable: ((QName, String)) ⇒ GenTraversableOnce[B]): Iterable[Iterable[B]]

Definition Classes
GenericTraversableTemplate
Annotations
@migration
Migration
(Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.
def unzip[A1, A2](implicit asPair: ((QName, String)) ⇒ (A1, A2)): (Iterable[A1], Iterable[A2])

Definition Classes
GenericTraversableTemplate
def unzip3[A1, A2, A3](implicit asTriple: ((QName, String)) ⇒ (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])

Definition Classes
GenericTraversableTemplate
def updated(key: QName, value: String): Attributes

[use case]
[use case]

Full Signature
def updated(key: QName, value: String)(implicit d: DummyImplicit): Attributes
def updated[B >: String](key: QName, value: B): Map[QName, B]

Definition Classes
Attributes → Map → MapLike → MapLike → GenMap
def values: Iterable[String]

Definition Classes
MapLike → GenMapLike
Annotations
@migration
Migration
(Changed in version 2.8.0) values returns Iterable[B] rather than Iterator[B].
def valuesIterator: Iterator[String]

Definition Classes
MapLike → GenMapLike
def view(from: Int, until: Int): IterableView[(QName, String), Attributes]

Definition Classes
IterableLike → TraversableLike
def view: IterableView[(QName, String), Attributes]

Definition Classes
IterableLike → TraversableLike
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withDefault[B1 >: String](d: (QName) ⇒ B1): Map[QName, B1]

Definition Classes
Map
def withDefaultValue[B1 >: String](d: B1): Map[QName, B1]

Definition Classes
Map
def withFilter(p: ((QName, String)) ⇒ Boolean): FilterMonadic[(QName, String), Attributes]

Definition Classes
TraversableLike → FilterMonadic
def zip[A1 >: (QName, String), B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Attributes, (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipAll[B, A1 >: (QName, String), That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Attributes, (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipWithIndex[A1 >: (QName, String), That](implicit bf: CanBuildFrom[Attributes, (A1, Int), That]): That

Definition Classes
IterableLike → GenIterableLike

Related Docs: object Attributes | package antixml

class Attributes extends Map[QName, String] with MapLike[QName, String, Attributes]

Instance Constructors

new Attributes(entries: Map[QName, String])

Type Members

class DefaultKeySet extends AbstractSet[A] with Set[A] with Serializable

class DefaultValuesIterable extends AbstractIterable[B] with Iterable[B] with Serializable

class FilteredKeys extends AbstractMap[A, B] with DefaultMap[A, B]

class ImmutableDefaultKeySet extends scala.collection.immutable.MapLike.DefaultKeySet with Set[A]

class MappedValues[C] extends AbstractMap[A, C] with DefaultMap[A, C]

type Self = Attributes

class WithFilter extends FilterMonadic[A, Repr]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(kv1: (QName, String), kv2: (QName, String), kvs: (QName, String)*): Attributes

def +(kv1: (QName, String), kv2: (QName, String), kvs: (QName, String)*)(implicit d: DummyImplicit): Attributes

def +[B >: String](kv1: (QName, B), kv2: (QName, B), kvs: (QName, B)*): Map[QName, B]

def +(kv: (QName, String)): Attributes

def +(kv: (QName, String))(implicit d: DummyImplicit): Attributes

def +[B >: String](kv: (QName, B)): Map[QName, B]

def ++(xs: GenTraversableOnce[(QName, String)])(implicit d: DummyImplicit): Attributes

def ++[B1 >: String](xs: GenTraversableOnce[(QName, B1)]): OrderPreservingMap[QName, B1]

def ++[B >: (QName, String), That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Attributes, B, That]): That

def ++:[B >: (QName, String), That](that: Traversable[B])(implicit bf: CanBuildFrom[Attributes, B, That]): That

def ++:[B >: (QName, String), That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Attributes, B, That]): That

def -(key: QName): Attributes

def -(elem1: QName, elem2: QName, elems: QName*): Attributes

def --(xs: GenTraversableOnce[QName]): Attributes

def /:[B](z: B)(op: (B, (QName, String)) ⇒ B): B

def :\[B](z: B)(op: ((QName, String), B) ⇒ B): B

final def ==(arg0: Any): Boolean

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def aggregate[B](z: ⇒ B)(seqop: (B, (QName, String)) ⇒ B, combop: (B, B) ⇒ B): B

def andThen[C](k: (String) ⇒ C): PartialFunction[QName, C]

def apply(key: QName): String

def applyOrElse[A1 <: QName, B1 >: String](x: A1, default: (A1) ⇒ B1): B1

final def asInstanceOf[T0]: T0

def canEqual(that: Any): Boolean

def clone(): AnyRef

def collect[B, That](pf: PartialFunction[(QName, String), B])(implicit bf: CanBuildFrom[Attributes, B, That]): That

def collectFirst[B](pf: PartialFunction[(QName, String), B]): Option[B]

def companion: GenericCompanion[Iterable]

def compose[A](g: (A) ⇒ QName): (A) ⇒ String

def contains(key: QName): Boolean

def copyToArray[B >: (QName, String)](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: (QName, String)](xs: Array[B]): Unit

def copyToArray[B >: (QName, String)](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: (QName, String)](dest: Buffer[B]): Unit

def count(p: ((QName, String)) ⇒ Boolean): Int

def default(key: QName): String

def drop(n: Int): Attributes

def dropRight(n: Int): Attributes

def dropWhile(p: ((QName, String)) ⇒ Boolean): Attributes

def empty: Attributes

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def exists(p: ((QName, String)) ⇒ Boolean): Boolean

def filter(p: ((QName, String)) ⇒ Boolean): Attributes

def filterKeys(p: (QName) ⇒ Boolean): Map[QName, String]

def filterNot(p: ((QName, String)) ⇒ Boolean): Attributes

def finalize(): Unit

def find(p: ((QName, String)) ⇒ Boolean): Option[(QName, String)]

def flatMap[B, That](f: ((QName, String)) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Attributes, B, That]): That

def flatten[B](implicit asTraversable: ((QName, String)) ⇒ GenTraversableOnce[B]): Iterable[B]

def fold[A1 >: (QName, String)](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, (QName, String)) ⇒ B): B

def foldRight[B](z: B)(op: ((QName, String), B) ⇒ B): B

def forall(p: ((QName, String)) ⇒ Boolean): Boolean

def foreach[U](f: ((QName, String)) ⇒ U): Unit

def genericBuilder[B]: Builder[B, Iterable[B]]

def get(key: QName): Option[String]

final def getClass(): Class[_]

def getOrElse[B1 >: String](key: QName, default: ⇒ B1): B1

def groupBy[K](f: ((QName, String)) ⇒ K): Map[K, Attributes]

def grouped(size: Int): Iterator[Attributes]

def hasDefiniteSize: Boolean