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.9/scala-swing/scala/swing/Container$$Wrapper$Content.html below:

class Content extends BufferWrapper[Component]

 

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

Inherited from Clearable

Inherited from collection.mutable.Seq[Component] Inherited from collection.mutable.Cloneable[Buffer[Component]]

Inherited from Cloneable

Inherited from java.lang.Cloneable

Inherited from PartialFunction[Int, Component] Inherited from collection.mutable.Iterable[Component] Inherited from collection.Iterable[Component]

Inherited from Equals

Inherited from collection.mutable.Traversable[Component]

Inherited from Mutable

Inherited from collection.Traversable[Component] Inherited from GenericTraversableTemplate[Component, Buffer] Inherited from collection.TraversableOnce[Component] Inherited from HasNewBuilder[Component, scala.collection.mutable.Buffer[scala.swing.Component] @scala.annotation.unchecked.uncheckedVariance]

Inherited from Any

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