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

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

 

1. Alphabetic
2. By Inheritance

1. Node
2. NodeSeq
3. Equality
4. Seq
5. Iterable
6. Traversable
7. Immutable
8. AbstractSeq
9. Seq
10. SeqLike
11. GenSeq
12. GenSeqLike
13. PartialFunction
14. Function1
15. AbstractIterable
16. Iterable
17. IterableLike
18. Equals
19. GenIterable
20. GenIterableLike
21. AbstractTraversable
22. Traversable
23. GenTraversable
24. GenericTraversableTemplate
25. TraversableLike
26. GenTraversableLike
27. Parallelizable
28. TraversableOnce
29. GenTraversableOnce
30. FilterMonadic
31. HasNewBuilder
32. AnyRef
33. Any

1.  new Node()

1.  type Self = NodeSeq
2.  class WithFilter extends FilterMonadic[A, Repr]

1.  abstract def child: Seq[Node]
2.  abstract def label: String

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

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