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.20/scala-xml/scala/xml/MetaData.html below:

abstract class MetaData extends AbstractIterable[MetaData] with Iterable[MetaData] with Equality with Serializable

 

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

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