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.17/scala-xml/scala/xml/Node.html below:

abstract class Node extends NodeSeq

 

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