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/Elem.html below:

class Elem extends Node with Serializable

 

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Elem
  2. Node
  3. NodeSeq
  4. Serializable
  5. Serializable
  6. Equality
  7. ScalaVersionSpecificNodeSeq
  8. Seq
  9. Iterable
  10. Traversable
  11. Immutable
  12. AbstractSeq
  13. Seq
  14. SeqLike
  15. GenSeq
  16. GenSeqLike
  17. PartialFunction
  18. Function1
  19. AbstractIterable
  20. Iterable
  21. IterableLike
  22. Equals
  23. GenIterable
  24. GenIterableLike
  25. AbstractTraversable
  26. Traversable
  27. GenTraversable
  28. GenericTraversableTemplate
  29. TraversableLike
  30. GenTraversableLike
  31. Parallelizable
  32. TraversableOnce
  33. GenTraversableOnce
  34. FilterMonadic
  35. HasNewBuilder
  36. AnyRef
  37. Any
Value Members
  1.  final def !=(arg0: Any): Boolean
  2.  final def ##(): Int
  3.  final def %(updates: MetaData): Elem
  4.  def ++[B >: Node, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  5.  def ++:[B >: Node, That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  6.  def ++:[B >: Node, That](that: collection.TraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  7.  def +:[B >: Node, That](elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  8.  def :+[B >: Node, That](elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  9.  final def ==(arg0: Any): Boolean
  10.  def \(that: String): NodeSeq
  11.  def \@(attributeName: String): String
  12.  def \\(that: String): NodeSeq
  13.  def addString(b: StringBuilder): StringBuilder
  14.  def addString(b: StringBuilder, sep: String): StringBuilder
  15.  def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
  16.  def aggregate[B](z: ⇒ B)(seqop: (B, Node) ⇒ B, combop: (B, B) ⇒ B): B
  17.  def andThen[C](k: (Node) ⇒ C): PartialFunction[Int, C]
  18.  def apply(f: (Node) ⇒ Boolean): NodeSeq
  19.  def apply(i: Int): Node
  20.  def applyOrElse[A1 <: Int, B1 >: Node](x: A1, default: (A1) ⇒ B1): B1
  21.  final def asInstanceOf[T0]: T0
  22.  final def attribute(uri: String, key: String): Option[collection.Seq[Node]]
  23.  final def attribute(key: String): Option[collection.Seq[Node]]
  24.  val attributes: MetaData
  25.  def basisForHashCode: collection.Seq[Any]
  26.  def buildString(stripComments: Boolean): String
  27.  def canEqual(other: Any): Boolean
  28.  val child: Node*
  29.  def clone(): AnyRef
  30.  def collect[B, That](pf: PartialFunction[Node, B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  31.  def collectFirst[B](pf: PartialFunction[Node, B]): Option[B]
  32.  def combinations(n: Int): collection.Iterator[NodeSeq]
  33.  def companion: GenericCompanion[collection.immutable.Seq]
  34.  def compose[A](g: (A) ⇒ Int): (A) ⇒ Node
  35.  def contains[A1 >: Node](elem: A1): Boolean
  36.  def containsSlice[B](that: GenSeq[B]): Boolean
  37.  def copy(prefix: String = this.prefix, label: String = this.label, attributes: MetaData = this.attributes, scope: NamespaceBinding = this.scope, minimizeEmpty: Boolean = this.minimizeEmpty, child: collection.Seq[Node] = this.child): Elem
  38.  def copyToArray[B >: Node](xs: Array[B], start: Int, len: Int): Unit
  39.  def copyToArray[B >: Node](xs: Array[B]): Unit
  40.  def copyToArray[B >: Node](xs: Array[B], start: Int): Unit
  41.  def copyToBuffer[B >: Node](dest: Buffer[B]): Unit
  42.  def corresponds[B](that: GenSeq[B])(p: (Node, B) ⇒ Boolean): Boolean
  43.  def count(p: (Node) ⇒ Boolean): Int
  44.  def descendant: List[Node]
  45.  def descendant_or_self: List[Node]
  46.  def diff[B >: Node](that: GenSeq[B]): NodeSeq
  47.  def distinct: NodeSeq
  48.  final def doCollectNamespaces: Boolean
  49.  final def doTransform: Boolean
  50.  def drop(n: Int): NodeSeq
  51.  def dropRight(n: Int): NodeSeq
  52.  def dropWhile(p: (Node) ⇒ Boolean): NodeSeq
  53.  def endsWith[B](that: GenSeq[B]): Boolean
  54.  final def eq(arg0: AnyRef): Boolean
  55.  def equals(other: Any): Boolean
  56.  def exists(p: (Node) ⇒ Boolean): Boolean
  57.  def filter(p: (Node) ⇒ Boolean): NodeSeq
  58.  def filterNot(p: (Node) ⇒ Boolean): NodeSeq
  59.  def finalize(): Unit
  60.  def find(p: (Node) ⇒ Boolean): Option[Node]
  61.  def flatMap[B, That](f: (Node) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  62.  def flatten[B](implicit asTraversable: (Node) ⇒ GenTraversableOnce[B]): collection.immutable.Seq[B]
  63.  def fold[A1 >: Node](z: A1)(op: (A1, A1) ⇒ A1): A1
  64.  def foldLeft[B](z: B)(op: (B, Node) ⇒ B): B
  65.  def foldRight[B](z: B)(op: (Node, B) ⇒ B): B
  66.  def forall(p: (Node) ⇒ Boolean): Boolean
  67.  def foreach[U](f: (Node) ⇒ U): Unit
  68.  def genericBuilder[B]: Builder[B, collection.immutable.Seq[B]]
  69.  final def getClass(): Class[_]
  70.  def getNamespace(pre: String): String
  71.  def groupBy[K](f: (Node) ⇒ K): Map[K, NodeSeq]
  72.  def grouped(size: Int): collection.Iterator[NodeSeq]
  73.  def hasDefiniteSize: Boolean
  74.  def hashCode(): Int
  75.  def head: Node
  76.  def headOption: Option[Node]
  77.  def indexOf[B >: Node](elem: B, from: Int): Int
  78.  def indexOf[B >: Node](elem: B): Int
  79.  def indexOfSlice[B >: Node](that: GenSeq[B], from: Int): Int
  80.  def indexOfSlice[B >: Node](that: GenSeq[B]): Int
  81.  def indexWhere(p: (Node) ⇒ Boolean, from: Int): Int
  82.  def indexWhere(p: (Node) ⇒ Boolean): Int
  83.  def indices: collection.immutable.Range
  84.  def init: NodeSeq
  85.  def inits: collection.Iterator[NodeSeq]
  86.  def intersect[B >: Node](that: GenSeq[B]): NodeSeq
  87.  def isAtom: Boolean
  88.  def isDefinedAt(idx: Int): Boolean
  89.  def isEmpty: Boolean
  90.  final def isInstanceOf[T0]: Boolean
  91.  final def isTraversableAgain: Boolean
  92.  def iterator: Iterator[Node]
  93.  val label: String
  94.  def last: Node
  95.  def lastIndexOf[B >: Node](elem: B, end: Int): Int
  96.  def lastIndexOf[B >: Node](elem: B): Int
  97.  def lastIndexOfSlice[B >: Node](that: GenSeq[B], end: Int): Int
  98.  def lastIndexOfSlice[B >: Node](that: GenSeq[B]): Int
  99.  def lastIndexWhere(p: (Node) ⇒ Boolean, end: Int): Int
  100.  def lastIndexWhere(p: (Node) ⇒ Boolean): Int
  101.  def lastOption: Option[Node]
  102.  def length: Int
  103.  def lengthCompare(len: Int): Int
  104.  def lift: (Int) ⇒ Option[Node]
  105.  def map[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  106.  def max[B >: Node](implicit cmp: Ordering[B]): Node
  107.  def maxBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
  108.  def min[B >: Node](implicit cmp: Ordering[B]): Node
  109.  def minBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
  110.  val minimizeEmpty: Boolean
  111.  def mkString: String
  112.  def mkString(sep: String): String
  113.  def mkString(start: String, sep: String, end: String): String
  114.  def nameToString(sb: StringBuilder): StringBuilder
  115.  def namespace: String
  116.  final def ne(arg0: AnyRef): Boolean
  117.  def newBuilder: Builder[Node, NodeSeq]
  118.  def nonEmpty: Boolean
  119.  def nonEmptyChildren: collection.Seq[Node]
  120.  final def notify(): Unit
  121.  final def notifyAll(): Unit
  122.  def orElse[A1 <: Int, B1 >: Node](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
  123.  def padTo[B >: Node, That](len: Int, elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  124.  def par: ParSeq[Node]
  125.  def parCombiner: Combiner[Node, ParSeq[Node]]
  126.  def partition(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
  127.  def patch[B >: Node, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  128.  def permutations: collection.Iterator[NodeSeq]
  129.  val prefix: String
  130.  def prefixLength(p: (Node) ⇒ Boolean): Int
  131.  def product[B >: Node](implicit num: Numeric[B]): B
  132.  def reduce[A1 >: Node](op: (A1, A1) ⇒ A1): A1
  133.  def reduceLeft[B >: Node](op: (B, Node) ⇒ B): B
  134.  def reduceLeftOption[B >: Node](op: (B, Node) ⇒ B): Option[B]
  135.  def reduceOption[A1 >: Node](op: (A1, A1) ⇒ A1): Option[A1]
  136.  def reduceRight[B >: Node](op: (Node, B) ⇒ B): B
  137.  def reduceRightOption[B >: Node](op: (Node, B) ⇒ B): Option[B]
  138.  def repr: NodeSeq
  139.  def reverse: NodeSeq
  140.  def reverseIterator: collection.Iterator[Node]
  141.  def reverseMap[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  142.  def reversed: List[Node]
  143.  def runWith[U](action: (Node) ⇒ U): (Int) ⇒ Boolean
  144.  def sameElements[B >: Node](that: GenIterable[B]): Boolean
  145.  def scan[B >: Node, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[NodeSeq, B, That]): That
  146.  def scanLeft[B, That](z: B)(op: (B, Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  147.  def scanRight[B, That](z: B)(op: (Node, B) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  148.  val scope: NamespaceBinding
  149.  def segmentLength(p: (Node) ⇒ Boolean, from: Int): Int
  150.  def seq: collection.immutable.Seq[Node]
  151.  def size: Int
  152.  def sizeHintIfCheap: Int
  153.  def slice(from: Int, until: Int): NodeSeq
  154.  def sliding(size: Int, step: Int): collection.Iterator[NodeSeq]
  155.  def sliding(size: Int): collection.Iterator[NodeSeq]
  156.  def sortBy[B](f: (Node) ⇒ B)(implicit ord: math.Ordering[B]): NodeSeq
  157.  def sortWith(lt: (Node, Node) ⇒ Boolean): NodeSeq
  158.  def sorted[B >: Node](implicit ord: math.Ordering[B]): NodeSeq
  159.  def span(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
  160.  def splitAt(n: Int): (NodeSeq, NodeSeq)
  161.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
  162.  def startsWith[B](that: GenSeq[B]): Boolean
  163.  def strict_!=(other: Equality): Boolean
  164.  def strict_==(other: Equality): Boolean
  165.  def stringPrefix: String
  166.  def sum[B >: Node](implicit num: Numeric[B]): B
  167.  final def synchronized[T0](arg0: ⇒ T0): T0
  168.  def tail: NodeSeq
  169.  def tails: collection.Iterator[NodeSeq]
  170.  def take(n: Int): NodeSeq
  171.  def takeRight(n: Int): NodeSeq
  172.  def takeWhile(p: (Node) ⇒ Boolean): NodeSeq
  173.  def text: String
  174.  def theSeq: collection.Seq[Node]
  175.  def thisCollection: collection.Seq[Node]
  176.  def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Node, Col[Node]]): Col[Node]
  177.  def toArray[B >: Node](implicit arg0: ClassTag[B]): Array[B]
  178.  def toBuffer[B >: Node]: Buffer[B]
  179.  def toCollection(repr: NodeSeq): collection.Seq[Node]
  180.  def toIndexedSeq: collection.immutable.IndexedSeq[Node]
  181.  def toIterable: collection.Iterable[Node]
  182.  def toIterator: collection.Iterator[Node]
  183.  def toList: List[Node]
  184.  def toMap[T, U](implicit ev: <:<[Node, (T, U)]): Map[T, U]
  185.  def toSeq: collection.immutable.Seq[Node]
  186.  def toSet[B >: Node]: Set[B]
  187.  def toStream: collection.immutable.Stream[Node]
  188.  def toString(): String
  189.  def toTraversable: collection.Traversable[Node]
  190.  def toVector: Vector[Node]
  191.  def transpose[B](implicit asTraversable: (Node) ⇒ GenTraversableOnce[B]): collection.immutable.Seq[collection.immutable.Seq[B]]
  192.  def union[B >: Node, That](that: GenSeq[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  193.  def unzip[A1, A2](implicit asPair: (Node) ⇒ (A1, A2)): (collection.immutable.Seq[A1], collection.immutable.Seq[A2])
  194.  def unzip3[A1, A2, A3](implicit asTriple: (Node) ⇒ (A1, A2, A3)): (collection.immutable.Seq[A1], collection.immutable.Seq[A2], collection.immutable.Seq[A3])
  195.  def updated[B >: Node, That](index: Int, elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
  196.  def view(from: Int, until: Int): SeqView[Node, NodeSeq]
  197.  def view: SeqView[Node, NodeSeq]
  198.  final def wait(): Unit
  199.  final def wait(arg0: Long, arg1: Int): Unit
  200.  final def wait(arg0: Long): Unit
  201.  def withFilter(p: (Node) ⇒ Boolean): FilterMonadic[Node, NodeSeq]
  202.  def xmlType: TypeSymbol
  203.  final def xml_!=(other: Any): Boolean
  204.  final def xml_==(other: Any): Boolean
  205.  def xml_sameElements[A](that: Iterable[A]): Boolean
  206.  def zip[A1 >: Node, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
  207.  def zipAll[B, A1 >: Node, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
  208.  def zipWithIndex[A1 >: Node, That](implicit bf: CanBuildFrom[NodeSeq, (A1, Int), That]): That
Deprecated Value Members
  1.  def /:[B](z: B)(op: (B, Node) ⇒ B): B
  2.  def :\[B](z: B)(op: (Node, B) ⇒ B): B

Inherited from ScalaVersionSpecificNodeSeq

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