scala.collection.immutable

WrappedString

class WrappedString extends IndexedSeq[Char] with StringLike[WrappedString] with Proxy

Inherits

  1. Proxy
  2. StringLike
  3. Ordered
  4. Comparable
  5. IndexedSeq
  6. IndexedSeq
  7. IndexedSeqLike
  8. Seq
  9. Seq
  10. SeqLike
  11. PartialFunction
  12. Function1
  13. Iterable
  14. Iterable
  15. IterableLike
  16. Equals
  17. Traversable
  18. Immutable
  19. Traversable
  20. GenericTraversableTemplate
  21. TraversableLike
  22. HasNewBuilder
  23. AnyRef
  24. Any

Type Members

  1. class WithFilter extends AnyRef

    A class supporting filtered operations

Value Members

  1. def *(n: Int): String

    return n times the current string

  2. def ++[B >: Char, That](that: Iterator[B])(bf: CanBuildFrom[WrappedString, B, That]): That

    Concatenates this sequence with the elements of an iterator

  3. def ++[B >: Char, That](that: Traversable[B])(bf: CanBuildFrom[WrappedString, B, That]): That

    Concatenates this sequence with the elements of a traversable collection

  4. def +:[B >: Char, That](elem: B)(bf: CanBuildFrom[WrappedString, B, That]): That

    Prepends an element to this sequence

  5. def /:[B](z: B)(op: (B, Char) ⇒ B): B

    Applies a binary operator to a start value and all elements of this sequence, going left to right

  6. def :+[B >: Char, That](elem: B)(bf: CanBuildFrom[WrappedString, B, That]): That

    Appends an element to this sequence

  7. def :\[B](z: B)(op: (Char, B) ⇒ B): B

    Applies a binary operator to all elements of this sequence and a start value, going right to left

  8. def <(that: String): Boolean

  9. def <=(that: String): Boolean

  10. def >(that: String): Boolean

  11. def >=(that: String): Boolean

  12. def addString(b: StringBuilder): StringBuilder

    Appends all elements of this sequence to a string builder

  13. def addString(b: StringBuilder, sep: String): StringBuilder

    Appends all elements of this sequence to a string builder using a separator string

  14. def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

    Appends all elements of this sequence to a string builder using start, end, and separator strings

  15. def andThen[C](k: (Char) ⇒ C): PartialFunction[Int, C]

    Composes this partial function with a transformation function that gets applied to results of this partial function

  16. def apply(n: Int): Char

    Return element at index n

  17. def canEqual(that: Any): Boolean

    Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind

  18. def capitalize: String

    Returns this string with first character converted to upper case

  19. def companion: GenericCompanion[IndexedSeq[A][A]]

    The factory companion object that builds instances of class Seq

  20. def compare(other: String): Int

    Result of comparing this with operand that

  21. def compareTo(that: String): Int

  22. def compose[A](g: (A) ⇒ Int): (A) ⇒ Char

    (f compose g)(x) == f(g(x))

  23. def contains(elem: Any): Boolean

    Tests whether this sequence contains a given value as an element

  24. def containsSlice[B](that: Seq[B]): Boolean

    Tests whether this sequence contains a given sequence as a slice

  25. def copyToArray[B >: Char](xs: Array[B], start: Int, len: Int): Unit

    Copies elements of this sequence to an array

  26. def copyToArray[B >: Char](xs: Array[B]): Unit

    Copies elements of this sequence to an array

  27. def copyToArray[B >: Char](xs: Array[B], start: Int): Unit

    Copies elements of this sequence to an array

  28. def copyToBuffer[B >: Char](dest: Buffer[B]): Unit

    Copies all elements of this sequence to a buffer

  29. def corresponds[B](that: Seq[B])(p: (Char, B) ⇒ Boolean): Boolean

    Tests whether every element of this sequence relates to the corresponding element of another sequence by satisfying a test predicate

  30. def count(p: (Char) ⇒ Boolean): Int

    Counts the number of elements in the sequence which satisfy a predicate

  31. def diff[B >: Char, That](that: Seq[B]): WrappedString

    Computes the multiset difference between this sequence and another sequence

  32. def drop(n: Int): WrappedString

    Selects all elements except first n ones

  33. def dropRight(n: Int): WrappedString

    Selects all elements except first n ones

  34. def dropWhile(p: (Char) ⇒ Boolean): WrappedString

    Drops longest prefix of elements that satisfy a predicate

  35. def elements: Iterator[Char]

  36. def endsWith[B](that: Seq[B]): Boolean

    Tests whether this sequence ends with the given sequence

  37. def equals(that: Any): Boolean

    This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence

  38. def equalsWith[B](that: Seq[B])(f: (Char, B) ⇒ Boolean): Boolean

    Tests whether every element of this sequence relates to the corresponding element of another sequence by satisfying a test predicate

  39. def exists(p: (Char) ⇒ Boolean): Boolean

    Tests whether a predicate holds for some of the elements of this sequence

  40. def filter(p: (Char) ⇒ Boolean): WrappedString

    Selects all elements of this sequence which satisfy a predicate

  41. def filterNot(p: (Char) ⇒ Boolean): WrappedString

    Selects all elements of this sequence which do not satisfy a predicate

  42. def find(p: (Char) ⇒ Boolean): Option[Char]

    Finds the first element of the sequence satisfying a predicate, if any

  43. def findIndexOf(p: (Char) ⇒ Boolean): Int

    Returns index of the first element satisying a predicate, or -1

  44. def findLastIndexOf(p: (Char) ⇒ Boolean): Int

    Returns index of the last element satisying a predicate, or -1

  45. def first: Char

  46. def firstOption: Option[Char]

    None if iterable is empty

  47. def flatMap[B, That](f: (Char) ⇒ Traversable[B])(bf: CanBuildFrom[WrappedString, B, That]): That

    Builds a new collection by applying a function to all elements of this sequence and concatenating the results

  48. def flatten[B](asTraversable: (Char) ⇒ Traversable[B]): IndexedSeq[B]

    Converts this sequence of traversable collections into a sequence in which all element collections are concatenated

  49. def foldLeft[B](z: B)(op: (B, Char) ⇒ B): B

    Applies a binary operator to a start value and all elements of this sequence, going left to right

  50. def foldRight[B](z: B)(op: (Char, B) ⇒ B): B

    Applies a binary operator to all elements of this sequence and a start value, going right to left

  51. def forall(p: (Char) ⇒ Boolean): Boolean

    Tests whether a predicate holds for all elements of this sequence

  52. def foreach[U](f: (Char) ⇒ U): Unit

    Applies a function f to all elements of this sequence

  53. def format(l: Locale, args: Any*): String

    Like format(args*) but takes an initial Locale parameter which influences formatting as in java

  54. def format(args: Any*): String

    Uses the underlying string as a pattern (in a fashion similar to printf in C), and uses the supplied arguments to fill in the holes

  55. def genericBuilder[B]: Builder[B, IndexedSeq[B]]

    The generic builder that builds instances of Seq at arbitrary element types

  56. def groupBy[K](f: (Char) ⇒ K): Map[K, WrappedString]

    Partitions this sequence into a map of sequences according to some discriminator function

  57. def hasDefiniteSize: Boolean

    Tests whether this sequence is known to have a finite size

  58. def hashCode(): Int

    Returns a hash code value for the object

  59. def head: Char

    Selects the first element of this sequence

  60. def headOption: Option[Char]

    Optionally selects the first element

  61. def indexOf[B >: Char](elem: B, from: Int): Int

    Finds index of first occurrence of some value in this sequence after or at some start index

  62. def indexOf[B >: Char](elem: B): Int

    Finds index of first occurrence of some value in this sequence

  63. def indexOfSlice[B >: Char](that: Seq[B], from: Int): Int

    Finds first index after or at a start index where this sequence contains a given sequence as a slice

  64. def indexOfSlice[B >: Char](that: Seq[B]): Int

    Finds first index where this sequence contains a given sequence as a slice

  65. def indexWhere(p: (Char) ⇒ Boolean, from: Int): Int

    Finds index of the first element satisfying some predicate after or at some start index

  66. def indexWhere(p: (Char) ⇒ Boolean): Int

    Finds index of first element satisfying some predicate

  67. def indices: Range

    Produces the range of all indices of this sequence

  68. def init: WrappedString

    Selects all elements except the last

  69. def intersect[B >: Char, That](that: Seq[B]): WrappedString

    Computes the multiset intersection between this sequence and another sequence

  70. def isDefinedAt(idx: Int): Boolean

    Tests whether this sequence contains given index

  71. def isEmpty: Boolean

    Tests whether this sequence is empty

  72. def iterator: Iterator[Char]

    Creates a new iterator over all elements contained in this iterable object

  73. def last: Char

    Selects the last element

  74. def lastIndexOf[B >: Char](elem: B, end: Int): Int

    Finds index of last occurrence of some value in this sequence before or at a given end index

  75. def lastIndexOf[B >: Char](elem: B): Int

    Finds index of last occurrence of some value in this sequence

  76. def lastIndexOfSlice[B >: Char](that: Seq[B], end: Int): Int

    Finds last index before or at a given end index where this sequence contains a given sequence as a slice

  77. def lastIndexOfSlice[B >: Char](that: Seq[B]): Int

    Finds last index where this sequence contains a given sequence as a slice

  78. def lastIndexWhere(p: (Char) ⇒ Boolean, end: Int): Int

    Finds index of last element satisfying some predicate before or at given end index

  79. def lastIndexWhere(p: (Char) ⇒ Boolean): Int

    Finds index of last element satisfying some predicate

  80. def lastOption: Option[Char]

    Optionally selects the last element

  81. def length: Int

    The length of the sequence

  82. def lengthCompare(len: Int): Int

    Compares the length of this sequence to a test value

  83. def lift: (Int) ⇒ Option[Char]

    Turns this partial function into an plain function returning an Option result

  84. def lines: Iterator[String]

    Return all lines in this string in an iterator, excluding trailing line end characters, i

  85. def linesIterator: Iterator[String]

    Return all lines in this string in an iterator, excluding trailing line end characters, i

  86. def linesWithSeparators: Iterator[String]

    Return all lines in this string in an iterator, including trailing line end characters

  87. def map[B, That](f: (Char) ⇒ B)(bf: CanBuildFrom[WrappedString, B, That]): That

    Builds a new collection by applying a function to all elements of this sequence

  88. def max[B >: Char](cmp: Ordering[B]): Char

    Finds the largest element

  89. def min[B >: Char](cmp: Ordering[B]): Char

    Finds the smallest element

  90. def mkString: String

    Displays all elements of this sequence in a string

  91. def mkString(sep: String): String

    Displays all elements of this sequence in a string using a separator string

  92. def mkString(start: String, sep: String, end: String): String

    Displays all elements of this sequence in a string using start, end, and separator strings

  93. def nonEmpty: Boolean

    Tests whether the sequence is not empty

  94. def orElse[A1 <: Int, B1 >: Char](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

    Composes this partial function with a fallback partial function which gets applied where this partial function is not defined

  95. def padTo[B >: Char, That](len: Int, elem: B)(bf: CanBuildFrom[WrappedString, B, That]): That

    Appends an element value to this sequence until a given target length is reached

  96. def partialMap[B, That](pf: PartialFunction[Char, B])(bf: CanBuildFrom[WrappedString, B, That]): That

    Builds a new collection by applying a partial function to all elements of this sequence on which the function is defined

  97. def partition(p: (Char) ⇒ Boolean): (WrappedString, WrappedString)

    Partitions this sequence in two sequences according to a predicate

  98. def patch[B >: Char, That](from: Int, patch: Seq[B], replaced: Int)(bf: CanBuildFrom[WrappedString, B, That]): That

    Produces a new sequence where a slice of elements in this sequence is replaced by another sequence

  99. def prefixLength(p: (Char) ⇒ Boolean): Int

    Returns the length of the longest prefix whose elements all satisfy some preficate

  100. def product[B >: Char](num: Numeric[B]): B

    Multiplies up the elements of this collection

  101. def projection: SeqView[Char, WrappedString]

    returns a projection that can be used to call non-strict filter, map, and flatMap methods that build projections of the collection

  102. def r: Regex

    You can follow a string with

  103. def reduceLeft[B >: Char](op: (B, Char) ⇒ B): B

    Applies a binary operator to all elements of this sequence, going left to right

  104. def reduceLeftOption[B >: Char](op: (B, Char) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this sequence, going left to right

  105. def reduceRight[B >: Char](op: (Char, B) ⇒ B): B

    Applies a binary operator to all elements of this sequence, going right to left

  106. def reduceRightOption[B >: Char](op: (Char, B) ⇒ B): Option[B]

    Optionally applies a binary operator to all elements of this sequence, going right to left

  107. def removeDuplicates: WrappedString

    Builds a new sequence from this sequence without any duplicate elements

  108. def repr: WrappedString

    The collection of type sequence underlying this TraversableLike object

  109. def reverse: WrappedString

    Returns new sequence wih elements in reversed order

  110. def reverseIterator: Iterator[Char]

    An iterator yielding elements in reversed order

  111. def reverseMap[B, That](f: (Char) ⇒ B)(bf: CanBuildFrom[WrappedString, B, That]): That

    Builds a new collection by applying a function to all elements of this sequence and collecting the results in reversed order

  112. def reversedElements: Iterator[Char]

  113. def sameElements[B >: Char](that: Iterable[B]): Boolean

    Checks if the other iterable collection contains the same elements in the same order as this sequence

  114. def segmentLength(p: (Char) ⇒ Boolean, from: Int): Int

    Computes length of longest segment whose elements all satisfy some preficate

  115. val self: String

  116. def size: Int

    The size of this sequence, equivalent to length

  117. def slice(from: Int, until: Int): WrappedString

    Selects an interval of elements

  118. def sortBy[B](f: (Char) ⇒ B)(ord: Ordering[B]): WrappedString

    Sorts this Seq according to the Ordering which results from transforming an implicitly given Ordering with a transformation function

  119. def sortWith[B >: Char](ord: Ordering[B]): WrappedString

    Sorts this sequence according to an Ordering

  120. def sortWith(lt: (Char, Char) ⇒ Boolean): WrappedString

    Sorts this sequence according to a comparison function

  121. def span(p: (Char) ⇒ Boolean): (WrappedString, WrappedString)

    Spits this sequence into a prefix/suffix pair according to a predicate

  122. def split(separators: Array[Char]): Array[String]

  123. def split(separator: Char): Array[String]

  124. def splitAt(n: Int): (WrappedString, WrappedString)

    Splits this sequence into two at a given position

  125. def startsWith[B](that: Seq[B], offset: Int): Boolean

    Tests whether this sequence contains the given sequence at a given index

  126. def startsWith[B](that: Seq[B]): Boolean

    Tests whether this sequence starts with the given sequence

  127. def stringPrefix: String

    Defines the prefix of this object's toString representation

  128. def stripLineEnd: String

    Strip trailing line end character from this string if it has one

  129. def stripMargin: String

    For every line in this string:

  130. def stripMargin(marginChar: Char): String

    For every line in this string:

  131. def stripPrefix(prefix: String): String

    Returns this string with the given prefix stripped

  132. def stripSuffix(suffix: String): String

    Returns this string with the given suffix stripped

  133. def sum[B >: Char](num: Numeric[B]): B

    Sums up the elements of this collection

  134. def tail: WrappedString

    Selects all elements except the first

  135. def take(n: Int): WrappedString

    Selects first n elements

  136. def takeRight(n: Int): WrappedString

    Selects last n elements

  137. def takeWhile(p: (Char) ⇒ Boolean): WrappedString

    Takes longest prefix of elements that satisfy a predicate

  138. def toArray[B >: Char](arg0: ClassManifest[B]): Array[B]

    Converts this sequence to an array

  139. def toBoolean: Boolean

  140. def toByte: Byte

  141. def toDouble: Double

  142. def toFloat: Float

  143. def toIndexedSeq[B >: Char]: IndexedSeq[B]

    Converts this sequence to an indexed sequence

  144. def toInt: Int

  145. def toIterable: Iterable[Char]

    Converts this sequence to an iterable collection

  146. def toList: List[Char]

    Converts this sequence to a list

  147. def toLong: Long

  148. def toSeq: Seq[Char]

    Converts this sequence to a sequence

  149. def toSet[B >: Char]: Set[B]

    Converts this sequence to a set

  150. def toShort: Short

  151. def toStream: Stream[Char]

    Converts this sequence to a stream

  152. def toString(): String

    Returns a string representation of the object

  153. def transpose[B](asTraversable: (Char) ⇒ Traversable[B]): IndexedSeq[IndexedSeq[B]]

    Transposes this sequence of traversable collections into

  154. def union[B >: Char, That](that: Seq[B])(bf: CanBuildFrom[WrappedString, B, That]): That

    Produces a new sequence which contains all elements of this sequence and also all elements of a given sequence

  155. def unzip[A1, A2](asPair: (Char) ⇒ (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])

    Converts this sequence of pairs into two collections of the first and second halfs of each pair

  156. def updated[B >: Char, That](index: Int, elem: B)(bf: CanBuildFrom[WrappedString, B, That]): That

    A copy of this sequence with one single replaced element

  157. def view(from: Int, until: Int): IndexedSeqView[Char, WrappedString]

    Creates a non-strict view of a slice of this sequence

  158. def view: IndexedSeqView[Char, WrappedString]

    Creates a non-strict view of this sequence

  159. def withFilter(p: (Char) ⇒ Boolean): WithFilter

    Creates a non-strict filter of this sequence

  160. def zip[A1 >: Char, B, That](that: Iterable[B])(bf: CanBuildFrom[WrappedString, (A1, B), That]): That

    Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs

  161. def zipAll[B, A1 >: Char, That](that: Iterable[B], thisElem: A1, thatElem: B)(bf: CanBuildFrom[WrappedString, (A1, B), That]): That

    Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs

  162. def zipWithIndex[A1 >: Char, That](bf: CanBuildFrom[WrappedString, (A1, Int), That]): That

    Zips this sequence with its indices

Instance constructors

  1. new WrappedString(self: String)

  2. new WrappedString()