A RetroSearch Logo

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Search Query:

Showing content from https://www.scala-lang.org/api/2.12.6/scala-xml/scala/xml/Attribute.html below:

trait Attribute extends MetaData

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Attribute
  2. MetaData
  3. Serializable
  4. Serializable
  5. Equality
  6. AbstractIterable
  7. Iterable
  8. IterableLike
  9. Equals
  10. GenIterable
  11. GenIterableLike
  12. AbstractTraversable
  13. Traversable
  14. GenTraversable
  15. GenericTraversableTemplate
  16. TraversableLike
  17. GenTraversableLike
  18. Parallelizable
  19. TraversableOnce
  20. GenTraversableOnce
  21. FilterMonadic
  22. HasNewBuilder
  23. AnyRef
  24. Any
Type Members
  1. type Self = collection.Iterable[MetaData]
  2. class WithFilter extends FilterMonadic[A, Repr]
Concrete Value Members
  1. final def !=(arg0: Any): Boolean
  2. final def ##(): Int
  3. def ++[B >: MetaData, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[collection.Iterable[MetaData], B, That]): That
  4. def ++:[B >: MetaData, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[collection.Iterable[MetaData], B, That]): That
  5. def ++:[B >: MetaData, That](that: collection.TraversableOnce[B])(implicit bf: CanBuildFrom[collection.Iterable[MetaData], B, That]): That
  6. def /:[B](z: B)(op: (B, MetaData) ⇒ B): B
  7. def :\[B](z: B)(op: (MetaData, B) ⇒ B): B
  8. final def ==(arg0: Any): Boolean
  9. def addString(b: StringBuilder): StringBuilder
  10. def addString(b: StringBuilder, sep: String): StringBuilder
  11. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
  12. def aggregate[B](z: ⇒ B)(seqop: (B, MetaData) ⇒ B, combop: (B, B) ⇒ B): B
  13. def append(updates: MetaData, scope: NamespaceBinding = TopScope): MetaData
  14. final def apply(namespace_uri: String, owner: Node, key: String): Seq[Node]
  15. def asAttrMap: Map[String, String]
  16. final def asInstanceOf[T0]: T0
  17. def basisForHashCode: Seq[Any]
  18. def buildString(sb: StringBuilder): StringBuilder
  19. def canEqual(other: Any): Boolean
  20. def clone(): AnyRef
  21. def collect[B, That](pf: PartialFunction[MetaData, B])(implicit bf: CanBuildFrom[collection.Iterable[MetaData], B, That]): That
  22. def collectFirst[B](pf: PartialFunction[MetaData, B]): Option[B]
  23. def companion: GenericCompanion[collection.Iterable]
  24. def copyToArray[B >: MetaData](xs: Array[B], start: Int, len: Int): Unit
  25. def copyToArray[B >: MetaData](xs: Array[B]): Unit
  26. def copyToArray[B >: MetaData](xs: Array[B], start: Int): Unit
  27. def copyToBuffer[B >: MetaData](dest: Buffer[B]): Unit
  28. def count(p: (MetaData) ⇒ Boolean): Int
  29. def drop(n: Int): collection.Iterable[MetaData]
  30. def dropRight(n: Int): collection.Iterable[MetaData]
  31. def dropWhile(p: (MetaData) ⇒ Boolean): collection.Iterable[MetaData]
  32. final def eq(arg0: AnyRef): Boolean
  33. def equals(other: Any): Boolean
  34. def exists(p: (MetaData) ⇒ Boolean): Boolean
  35. def filter(f: (MetaData) ⇒ Boolean): MetaData
  36. def filterNot(p: (MetaData) ⇒ Boolean): collection.Iterable[MetaData]
  37. def finalize(): Unit
  38. def find(p: (MetaData) ⇒ Boolean): Option[MetaData]
  39. def flatMap[B, That](f: (MetaData) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[collection.Iterable[MetaData], B, That]): That
  40. def flatten[B](implicit asTraversable: (MetaData) ⇒ GenTraversableOnce[B]): collection.Iterable[B]
  41. def fold[A1 >: MetaData](z: A1)(op: (A1, A1) ⇒ A1): A1
  42. def foldLeft[B](z: B)(op: (B, MetaData) ⇒ B): B
  43. def foldRight[B](z: B)(op: (MetaData, B) ⇒ B): B
  44. def forall(p: (MetaData) ⇒ Boolean): Boolean
  45. def foreach[U](f: (MetaData) ⇒ U): Unit
  46. def genericBuilder[B]: Builder[B, collection.Iterable[B]]
  47. final def get(uri: String, scope: NamespaceBinding, key: String): Option[Seq[Node]]
  48. final def get(uri: String, owner: Node, key: String): Option[Seq[Node]]
  49. final def get(key: String): Option[Seq[Node]]
  50. final def getClass(): Class[_]
  51. def groupBy[K](f: (MetaData) ⇒ K): Map[K, collection.Iterable[MetaData]]
  52. def grouped(size: Int): collection.Iterator[collection.Iterable[MetaData]]
  53. def hasDefiniteSize: Boolean
  54. def hasNext: Boolean
  55. def hashCode(): Int
  56. def head: MetaData
  57. def headOption: Option[MetaData]
  58. def init: collection.Iterable[MetaData]
  59. def inits: collection.Iterator[collection.Iterable[MetaData]]
  60. def isEmpty: Boolean
  61. final def isInstanceOf[T0]: Boolean
  62. def isPrefixed: Boolean
  63. final def isTraversableAgain: Boolean
  64. def iterator: Iterator[MetaData]
  65. def last: MetaData
  66. def lastOption: Option[MetaData]
  67. def length(i: Int): Int
  68. def length: Int
  69. def map[B, That](f: (MetaData) ⇒ B)(implicit bf: CanBuildFrom[collection.Iterable[MetaData], B, That]): That
  70. def max[B >: MetaData](implicit cmp: Ordering[B]): MetaData
  71. def maxBy[B](f: (MetaData) ⇒ B)(implicit cmp: Ordering[B]): MetaData
  72. def min[B >: MetaData](implicit cmp: Ordering[B]): MetaData
  73. def minBy[B](f: (MetaData) ⇒ B)(implicit cmp: Ordering[B]): MetaData
  74. def mkString: String
  75. def mkString(sep: String): String
  76. def mkString(start: String, sep: String, end: String): String
  77. final def ne(arg0: AnyRef): Boolean
  78. def newBuilder: Builder[MetaData, collection.Iterable[MetaData]]
  79. def nonEmpty: Boolean
  80. final def notify(): Unit
  81. final def notifyAll(): Unit
  82. def par: ParIterable[MetaData]
  83. def parCombiner: Combiner[MetaData, ParIterable[MetaData]]
  84. def partition(p: (MetaData) ⇒ Boolean): (collection.Iterable[MetaData], collection.Iterable[MetaData])
  85. def prefixedKey: String
  86. def product[B >: MetaData](implicit num: Numeric[B]): B
  87. def reduce[A1 >: MetaData](op: (A1, A1) ⇒ A1): A1
  88. def reduceLeft[B >: MetaData](op: (B, MetaData) ⇒ B): B
  89. def reduceLeftOption[B >: MetaData](op: (B, MetaData) ⇒ B): Option[B]
  90. def reduceOption[A1 >: MetaData](op: (A1, A1) ⇒ A1): Option[A1]
  91. def reduceRight[B >: MetaData](op: (MetaData, B) ⇒ B): B
  92. def reduceRightOption[B >: MetaData](op: (MetaData, B) ⇒ B): Option[B]
  93. def remove(namespace: String, scope: NamespaceBinding, key: String): MetaData
  94. def remove(key: String): MetaData
  95. final def remove(namespace: String, owner: Node, key: String): MetaData
  96. def repr: collection.Iterable[MetaData]
  97. def reversed: List[MetaData]
  98. def sameElements[B >: MetaData](that: GenIterable[B]): Boolean
  99. def scan[B >: MetaData, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[collection.Iterable[MetaData], B, That]): That
  100. def scanLeft[B, That](z: B)(op: (B, MetaData) ⇒ B)(implicit bf: CanBuildFrom[collection.Iterable[MetaData], B, That]): That
  101. def scanRight[B, That](z: B)(op: (MetaData, B) ⇒ B)(implicit bf: CanBuildFrom[collection.Iterable[MetaData], B, That]): That
  102. def seq: collection.Iterable[MetaData]
  103. def size: Int
  104. def sizeHintIfCheap: Int
  105. def slice(from: Int, until: Int): collection.Iterable[MetaData]
  106. def sliding(size: Int, step: Int): collection.Iterator[collection.Iterable[MetaData]]
  107. def sliding(size: Int): collection.Iterator[collection.Iterable[MetaData]]
  108. def span(p: (MetaData) ⇒ Boolean): (collection.Iterable[MetaData], collection.Iterable[MetaData])
  109. def splitAt(n: Int): (collection.Iterable[MetaData], collection.Iterable[MetaData])
  110. def strict_!=(other: Equality): Boolean
  111. def strict_==(other: Equality): Boolean
  112. def stringPrefix: String
  113. def sum[B >: MetaData](implicit num: Numeric[B]): B
  114. final def synchronized[T0](arg0: ⇒ T0): T0
  115. def tail: collection.Iterable[MetaData]
  116. def tails: collection.Iterator[collection.Iterable[MetaData]]
  117. def take(n: Int): collection.Iterable[MetaData]
  118. def takeRight(n: Int): collection.Iterable[MetaData]
  119. def takeWhile(p: (MetaData) ⇒ Boolean): collection.Iterable[MetaData]
  120. def thisCollection: collection.Iterable[MetaData]
  121. def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, MetaData, Col[MetaData]]): Col[MetaData]
  122. def toArray[B >: MetaData](implicit arg0: ClassTag[B]): Array[B]
  123. def toBuffer[B >: MetaData]: Buffer[B]
  124. def toCollection(repr: collection.Iterable[MetaData]): collection.Iterable[MetaData]
  125. def toIndexedSeq: collection.immutable.IndexedSeq[MetaData]
  126. def toIterable: collection.Iterable[MetaData]
  127. def toIterator: collection.Iterator[MetaData]
  128. def toList: List[MetaData]
  129. def toMap[T, U](implicit ev: <:<[MetaData, (T, U)]): Map[T, U]
  130. def toSeq: collection.Seq[MetaData]
  131. def toSet[B >: MetaData]: Set[B]
  132. def toStream: collection.immutable.Stream[MetaData]
  133. def toString(): String
  134. def toString1(sb: StringBuilder): Unit
  135. def toString1(): String
  136. def toTraversable: collection.Traversable[MetaData]
  137. def toVector: Vector[MetaData]
  138. def transpose[B](implicit asTraversable: (MetaData) ⇒ GenTraversableOnce[B]): collection.Iterable[collection.Iterable[B]]
  139. def unzip[A1, A2](implicit asPair: (MetaData) ⇒ (A1, A2)): (collection.Iterable[A1], collection.Iterable[A2])
  140. def unzip3[A1, A2, A3](implicit asTriple: (MetaData) ⇒ (A1, A2, A3)): (collection.Iterable[A1], collection.Iterable[A2], collection.Iterable[A3])
  141. def view(from: Int, until: Int): IterableView[MetaData, collection.Iterable[MetaData]]
  142. def view: IterableView[MetaData, collection.Iterable[MetaData]]
  143. final def wait(): Unit
  144. final def wait(arg0: Long, arg1: Int): Unit
  145. final def wait(arg0: Long): Unit
  146. def wellformed(scope: NamespaceBinding): Boolean
  147. def withFilter(p: (MetaData) ⇒ Boolean): FilterMonadic[MetaData, collection.Iterable[MetaData]]
  148. final def xml_!=(other: Any): Boolean
  149. final def xml_==(other: Any): Boolean
  150. def zip[A1 >: MetaData, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[collection.Iterable[MetaData], (A1, B), That]): That
  151. def zipAll[B, A1 >: MetaData, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[collection.Iterable[MetaData], (A1, B), That]): That
  152. def zipWithIndex[A1 >: MetaData, That](implicit bf: CanBuildFrom[collection.Iterable[MetaData], (A1, Int), That]): That

Inherited from Serializable

Inherited from java.io.Serializable

Inherited from AbstractIterable[MetaData] Inherited from collection.Iterable[MetaData]

Inherited from Equals

Inherited from AbstractTraversable[MetaData] Inherited from collection.Traversable[MetaData] Inherited from GenericTraversableTemplate[MetaData, collection.Iterable] Inherited from collection.TraversableOnce[MetaData] Inherited from GenTraversableOnce[MetaData] Inherited from HasNewBuilder[MetaData, Iterable[scala.xml.MetaData] @scala.annotation.unchecked.uncheckedVariance]

Inherited from Any

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4