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]
-
-
class
WithFilter extends FilterMonadic[A, Repr]
Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
def
+(kv1: (QName, String), kv2: (QName, String), kvs: (QName, String)*): Attributes
-
def
+[B >: String](kv1: (QName, B), kv2: (QName, B), kvs: (QName, B)*): Map[QName, B]
-
-
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
--(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: AnyRef): Boolean
-
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
dropRight(n: Int): Attributes
-
def
dropWhile(p: ((QName, String)) ⇒ Boolean): 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
-
def
hashCode(): Int
-
def
head: (QName, String)
-
def
headOption: Option[(QName, String)]
-
-
def
inits: Iterator[Attributes]
-
def
isDefinedAt(key: QName): Boolean
-
def
isEmpty: Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
final
def
isTraversableAgain: Boolean
-
def
iterator: Iterator[(QName, String)]
-
def
keySet: Set[QName]
-
def
keys: Iterable[QName]
-
def
keysIterator: Iterator[QName]
-
def
last: (QName, String)
-
def
lastOption: Option[(QName, String)]
-
def
lift: (QName) ⇒ Option[String]
-
def
map[B, That](f: ((QName, String)) ⇒ B)(implicit bf: CanBuildFrom[Attributes, B, That]): That
-
def
mapValues[C](f: (String) ⇒ C): Map[QName, C]
-
def
max[B >: (QName, String)](implicit cmp: Ordering[B]): (QName, String)
-
def
maxBy[B](f: ((QName, String)) ⇒ B)(implicit cmp: Ordering[B]): (QName, String)
-
def
min[B >: (QName, String)](implicit cmp: Ordering[B]): (QName, String)
-
def
minBy[B](f: ((QName, String)) ⇒ B)(implicit cmp: Ordering[B]): (QName, String)
-
def
mkString: String
-
def
mkString(sep: String): String
-
def
mkString(start: String, sep: String, end: String): String
-
final
def
ne(arg0: AnyRef): Boolean
-
def
newBuilder: Builder[(QName, String), Attributes]
-
def
nonEmpty: Boolean
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
orElse[A1 <: QName, B1 >: String](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
-
def
par: ParMap[QName, String]
-
def
parCombiner: Combiner[(QName, String), ParMap[QName, String]]
-
-
def
product[B >: (QName, String)](implicit num: Numeric[B]): B
-
def
reduce[A1 >: (QName, String)](op: (A1, A1) ⇒ A1): A1
-
def
reduceLeft[B >: (QName, String)](op: (B, (QName, String)) ⇒ B): B
-
def
reduceLeftOption[B >: (QName, String)](op: (B, (QName, String)) ⇒ B): Option[B]
-
def
reduceOption[A1 >: (QName, String)](op: (A1, A1) ⇒ A1): Option[A1]
-
def
reduceRight[B >: (QName, String)](op: ((QName, String), B) ⇒ B): B
-
def
reduceRightOption[B >: (QName, String)](op: ((QName, String), B) ⇒ B): Option[B]
-
-
def
reversed: List[(QName, String)]
-
def
runWith[U](action: (String) ⇒ U): (QName) ⇒ Boolean
-
def
sameElements[B >: (QName, String)](that: GenIterable[B]): Boolean
-
def
scan[B >: (QName, String), That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Attributes, B, That]): That
-
def
scanLeft[B, That](z: B)(op: (B, (QName, String)) ⇒ B)(implicit bf: CanBuildFrom[Attributes, B, That]): That
-
def
scanRight[B, That](z: B)(op: ((QName, String), B) ⇒ B)(implicit bf: CanBuildFrom[Attributes, B, That]): That
-
def
seq: Map[QName, String]
-
def
size: Int
-
def
slice(from: Int, until: Int): Attributes
-
def
sliding(size: Int, step: Int): Iterator[Attributes]
-
def
sliding(size: Int): Iterator[Attributes]
-
-
-
def
stringPrefix: String
-
def
sum[B >: (QName, String)](implicit num: Numeric[B]): B
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
-
def
tails: Iterator[Attributes]
-
-
def
takeRight(n: Int): Attributes
-
def
takeWhile(p: ((QName, String)) ⇒ Boolean): Attributes
-
def
thisCollection: Iterable[(QName, String)]
-
def
to[Col[_]](implicit cbf: CanBuildFrom[Nothing, (QName, String), Col[(QName, String)]]): Col[(QName, String)]
-
def
toArray[B >: (QName, String)](implicit arg0: ClassTag[B]): Array[B]
-
def
toBuffer[C >: (QName, String)]: Buffer[C]
-
def
toCollection(repr: Attributes): Iterable[(QName, String)]
-
def
toIndexedSeq: IndexedSeq[(QName, String)]
-
def
toIterable: Iterable[(QName, String)]
-
def
toIterator: Iterator[(QName, String)]
-
def
toList: List[(QName, String)]
-
def
toMap[T, U](implicit ev: <:<[(QName, String), (T, U)]): Map[T, U]
-
def
toSeq: Seq[(QName, String)]
-
def
toSet[B >: (QName, String)]: Set[B]
-
def
toStream: Stream[(QName, String)]
-
def
toString(): String
-
def
toTraversable: Traversable[(QName, String)]
-
def
toVector: Vector[(QName, String)]
-
def
transform[C, That](f: (QName, String) ⇒ C)(implicit bf: CanBuildFrom[Attributes, (QName, C), That]): That
-
def
transpose[B](implicit asTraversable: ((QName, String)) ⇒ GenTraversableOnce[B]): Iterable[Iterable[B]]
-
def
unzip[A1, A2](implicit asPair: ((QName, String)) ⇒ (A1, A2)): (Iterable[A1], Iterable[A2])
-
def
unzip3[A1, A2, A3](implicit asTriple: ((QName, String)) ⇒ (A1, A2, A3)): (Iterable[A1], Iterable[A2], Iterable[A3])
-
def
updated(key: QName, value: String): Attributes
-
def
updated[B >: String](key: QName, value: B): Map[QName, B]
-
def
values: Iterable[String]
-
def
valuesIterator: Iterator[String]
-
def
view(from: Int, until: Int): IterableView[(QName, String), Attributes]
-
def
view: IterableView[(QName, String), Attributes]
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
def
withDefault[B1 >: String](d: (QName) ⇒ B1): Map[QName, B1]
-
def
withDefaultValue[B1 >: String](d: B1): Map[QName, B1]
-
def
withFilter(p: ((QName, String)) ⇒ Boolean): FilterMonadic[(QName, String), Attributes]
-
def
zip[A1 >: (QName, String), B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Attributes, (A1, B), That]): That
-
def
zipAll[B, A1 >: (QName, String), That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Attributes, (A1, B), That]): That
-
def
zipWithIndex[A1 >: (QName, String), That](implicit bf: CanBuildFrom[Attributes, (A1, Int), That]): That
Deprecated Value Members
-
def
/:\[A1 >: (QName, String)](z: A1)(op: (A1, A1) ⇒ A1): A1
Inherited from Map[QName, String]
Inherited from Map[QName, String]
Inherited from PartialFunction[QName, String]
Inherited from (QName) ⇒ String
Inherited from GenMap[QName, String]
Inherited from Iterable[(QName, String)]
Inherited from Iterable[(QName, String)]
Inherited from Equals
Inherited from GenIterable[(QName, String)]
Inherited from Traversable[(QName, String)]
Inherited from Immutable
Inherited from Traversable[(QName, String)]
Inherited from GenTraversable[(QName, String)]
Inherited from GenericTraversableTemplate[(QName, String), Iterable]
Inherited from Parallelizable[(QName, String), ParMap[QName, String]]
Inherited from TraversableOnce[(QName, String)]
Inherited from GenTraversableOnce[(QName, String)]
Inherited from AnyRef
Inherited from Any
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: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 conversionString => 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 typeQName
. It will not automatically inject the conversion to satisfy method dispatch onString
. For example: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 ofString
rather than com.codecommit.antixml.QName has been preserved.One implicit space-cluttering that couldn't be avoided is the conversion defined as
. This is required to enable the nice(String, String) => (QName, String)
String
syntax on things like the+
method and the companion objectapply
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 toTuple2
). Thus, it shouldn't cause any scoping problems.com.codecommit.antixml.QName