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

Showing content from https://www.scala-lang.org/api/2.12.3/scala-swing/scala/swing/TabbedPane$pages$.html below:

 

1. Alphabetic
2. By Inheritance

1. pages
2. BufferWrapper
3. Buffer
4. BufferLike
5. Subtractable
6. Scriptable
7. Shrinkable
8. Growable
9. Clearable
10. Seq
11. SeqLike
12. Cloneable
13. Cloneable
14. Cloneable
15. Seq
16. SeqLike
17. GenSeq
18. GenSeqLike
19. PartialFunction
20. Function1
21. Iterable
22. Iterable
23. IterableLike
24. Equals
25. GenIterable
26. GenIterableLike
27. Traversable
28. Mutable
29. Traversable
30. GenTraversable
31. GenericTraversableTemplate
32. TraversableLike
33. GenTraversableLike
34. Parallelizable
35. TraversableOnce
36. GenTraversableOnce
37. FilterMonadic
38. HasNewBuilder
39. AnyRef
40. Any

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

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

1.  def <<(cmd: Message[Page]): 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