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

 

1. Alphabetic
2. By Inheritance

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

1.  new SpecialNode()

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

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.  final def attributes: Null.type
26.  def basisForHashCode: Seq[Any]
27.  def buildString(stripComments: Boolean): String
28.  def canEqual(other: Any): Boolean
29.  final def child: collection.immutable.Nil.type
30.  def clone(): AnyRef
31.  def collect[B, That](pf: PartialFunction[Node, B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
32.  def collectFirst[B](pf: PartialFunction[Node, B]): Option[B]
33.  def combinations(n: Int): collection.Iterator[NodeSeq]
34.  def companion: GenericCompanion[collection.immutable.Seq]
35.  def compose[A](g: (A) ⇒ Int): (A) ⇒ Node
36.  def contains[A1 >: Node](elem: A1): Boolean
37.  def containsSlice[B](that: GenSeq[B]): Boolean
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.  def doCollectNamespaces: Boolean
49.  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: collection.Iterator[Node]
93.  def last: Node
94.  def lastIndexOf[B >: Node](elem: B, end: Int): Int
95.  def lastIndexOf[B >: Node](elem: B): Int
96.  def lastIndexOfSlice[B >: Node](that: GenSeq[B], end: Int): Int
97.  def lastIndexOfSlice[B >: Node](that: GenSeq[B]): Int
98.  def lastIndexWhere(p: (Node) ⇒ Boolean, end: Int): Int
99.  def lastIndexWhere(p: (Node) ⇒ Boolean): Int
100.  def lastOption: Option[Node]
101.  def length: Int
102.  def lengthCompare(len: Int): Int
103.  def lift: (Int) ⇒ Option[Node]
104.  def map[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
105.  def max[B >: Node](implicit cmp: Ordering[B]): Node
106.  def maxBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
107.  def min[B >: Node](implicit cmp: Ordering[B]): Node
108.  def minBy[B](f: (Node) ⇒ B)(implicit cmp: Ordering[B]): Node
109.  def mkString: String
110.  def mkString(sep: String): String
111.  def mkString(start: String, sep: String, end: String): String
112.  def nameToString(sb: StringBuilder): StringBuilder
113.  final def namespace: Null
114.  final def ne(arg0: AnyRef): Boolean
115.  def newBuilder: Builder[Node, NodeSeq]
116.  def nonEmpty: Boolean
117.  def nonEmptyChildren: Seq[Node]
118.  final def notify(): Unit
119.  final def notifyAll(): Unit
120.  def orElse[A1 <: Int, B1 >: Node](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
121.  def padTo[B >: Node, That](len: Int, elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
122.  def par: ParSeq[Node]
123.  def parCombiner: Combiner[Node, ParSeq[Node]]
124.  def partition(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
125.  def patch[B >: Node, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
126.  def permutations: collection.Iterator[NodeSeq]
127.  def prefix: String
128.  def prefixLength(p: (Node) ⇒ Boolean): Int
129.  def product[B >: Node](implicit num: Numeric[B]): B
130.  def reduce[A1 >: Node](op: (A1, A1) ⇒ A1): A1
131.  def reduceLeft[B >: Node](op: (B, Node) ⇒ B): B
132.  def reduceLeftOption[B >: Node](op: (B, Node) ⇒ B): Option[B]
133.  def reduceOption[A1 >: Node](op: (A1, A1) ⇒ A1): Option[A1]
134.  def reduceRight[B >: Node](op: (Node, B) ⇒ B): B
135.  def reduceRightOption[B >: Node](op: (Node, B) ⇒ B): Option[B]
136.  def repr: NodeSeq
137.  def reverse: NodeSeq
138.  def reverseIterator: collection.Iterator[Node]
139.  def reverseMap[B, That](f: (Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
140.  def reversed: List[Node]
141.  def runWith[U](action: (Node) ⇒ U): (Int) ⇒ Boolean
142.  def sameElements[B >: Node](that: GenIterable[B]): Boolean
143.  def scan[B >: Node, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[NodeSeq, B, That]): That
144.  def scanLeft[B, That](z: B)(op: (B, Node) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
145.  def scanRight[B, That](z: B)(op: (Node, B) ⇒ B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
146.  def scope: NamespaceBinding
147.  def segmentLength(p: (Node) ⇒ Boolean, from: Int): Int
148.  def seq: collection.immutable.Seq[Node]
149.  def size: Int
150.  def sizeHintIfCheap: Int
151.  def slice(from: Int, until: Int): NodeSeq
152.  def sliding(size: Int, step: Int): collection.Iterator[NodeSeq]
153.  def sliding(size: Int): collection.Iterator[NodeSeq]
154.  def sortBy[B](f: (Node) ⇒ B)(implicit ord: math.Ordering[B]): NodeSeq
155.  def sortWith(lt: (Node, Node) ⇒ Boolean): NodeSeq
156.  def sorted[B >: Node](implicit ord: math.Ordering[B]): NodeSeq
157.  def span(p: (Node) ⇒ Boolean): (NodeSeq, NodeSeq)
158.  def splitAt(n: Int): (NodeSeq, NodeSeq)
159.  def startsWith[B](that: GenSeq[B], offset: Int): Boolean
160.  def startsWith[B](that: GenSeq[B]): Boolean
161.  def strict_!=(other: Equality): Boolean
162.  def strict_==(other: Equality): Boolean
163.  def stringPrefix: String
164.  def sum[B >: Node](implicit num: Numeric[B]): B
165.  final def synchronized[T0](arg0: ⇒ T0): T0
166.  def tail: NodeSeq
167.  def tails: collection.Iterator[NodeSeq]
168.  def take(n: Int): NodeSeq
169.  def takeRight(n: Int): NodeSeq
170.  def takeWhile(p: (Node) ⇒ Boolean): NodeSeq
171.  def text: String
172.  def theSeq: Seq[Node]
173.  def thisCollection: collection.Seq[Node]
174.  def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Node, Col[Node]]): Col[Node]
175.  def toArray[B >: Node](implicit arg0: ClassTag[B]): Array[B]
176.  def toBuffer[B >: Node]: Buffer[B]
177.  def toCollection(repr: NodeSeq): collection.Seq[Node]
178.  def toIndexedSeq: collection.immutable.IndexedSeq[Node]
179.  def toIterable: collection.Iterable[Node]
180.  def toIterator: collection.Iterator[Node]
181.  def toList: List[Node]
182.  def toMap[T, U](implicit ev: <:<[Node, (T, U)]): Map[T, U]
183.  def toSeq: collection.immutable.Seq[Node]
184.  def toSet[B >: Node]: Set[B]
185.  def toStream: collection.immutable.Stream[Node]
186.  def toString(): String
187.  def toTraversable: collection.Traversable[Node]
188.  def toVector: Vector[Node]
189.  def transpose[B](implicit asTraversable: (Node) ⇒ GenTraversableOnce[B]): collection.immutable.Seq[collection.immutable.Seq[B]]
190.  def union[B >: Node, That](that: GenSeq[B])(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
191.  def unzip[A1, A2](implicit asPair: (Node) ⇒ (A1, A2)): (collection.immutable.Seq[A1], collection.immutable.Seq[A2])
192.  def unzip3[A1, A2, A3](implicit asTriple: (Node) ⇒ (A1, A2, A3)): (collection.immutable.Seq[A1], collection.immutable.Seq[A2], collection.immutable.Seq[A3])
193.  def updated[B >: Node, That](index: Int, elem: B)(implicit bf: CanBuildFrom[NodeSeq, B, That]): That
194.  def view(from: Int, until: Int): SeqView[Node, NodeSeq]
195.  def view: SeqView[Node, NodeSeq]
196.  final def wait(): Unit
197.  final def wait(arg0: Long, arg1: Int): Unit
198.  final def wait(arg0: Long): Unit
199.  def withFilter(p: (Node) ⇒ Boolean): FilterMonadic[Node, NodeSeq]
200.  def xmlType(): TypeSymbol
201.  final def xml_!=(other: Any): Boolean
202.  final def xml_==(other: Any): Boolean
203.  def xml_sameElements[A](that: Iterable[A]): Boolean
204.  def zip[A1 >: Node, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
205.  def zipAll[B, A1 >: Node, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[NodeSeq, (A1, B), That]): That
206.  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