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

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

 

1. Alphabetic
2. By Inheritance

1. NodeBuffer
2. ArrayBuffer
3. Serializable
4. Serializable
5. CustomParallelizable
6. ResizableArray
7. IndexedSeq
8. IndexedSeq
9. Builder
10. IndexedSeqOptimized
11. IndexedSeqOptimized
12. IndexedSeqLike
13. IndexedSeqLike
14. AbstractBuffer
15. Buffer
16. BufferLike
17. Subtractable
18. Scriptable
19. Shrinkable
20. Growable
21. Clearable
22. AbstractSeq
23. Seq
24. SeqLike
25. Cloneable
26. Cloneable
27. Cloneable
28. Iterable
29. Traversable
30. Mutable
31. AbstractSeq
32. Seq
33. SeqLike
34. GenSeq
35. GenSeqLike
36. PartialFunction
37. Function1
38. AbstractIterable
39. Iterable
40. IterableLike
41. Equals
42. GenIterable
43. GenIterableLike
44. AbstractTraversable
45. Traversable
46. GenTraversable
47. GenericTraversableTemplate
48. TraversableLike
49. GenTraversableLike
50. Parallelizable
51. TraversableOnce
52. GenTraversableOnce
53. FilterMonadic
54. HasNewBuilder
55. AnyRef
56. Any

1.  new NodeBuffer()

1.  class Elements extends AbstractIterator[A] with collection.BufferedIterator[A] with Serializable
2.  type Self = ArrayBuffer[Node]
3.  class WithFilter extends FilterMonadic[A, Repr]

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

1.  def <<(cmd: Message[Node]): Unit

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