nobox

ofByte

final class ofByte extends AnyVal

Linear Supertypes
AnyVal, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. ofByte
  2. AnyVal
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new ofByte(self: Array[Byte])

Value Members

  1. final def !=(arg0: Any): Boolean

    Definition Classes
    Any

  2. final def ##(): Int

    Definition Classes
    Any

  3. def ++(that: ofByte): ofByte

  4. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

  5. def ===(that: ofByte): Boolean

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

  7. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  8. def collect[A](f: PartialFunction[Byte, A])(implicit A: ClassTag[A]): Array[A]

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  9. def collectBoolean(f: PartialFunction[Byte, Boolean]): ofBoolean

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  10. def collectByte(f: PartialFunction[Byte, Byte]): ofByte

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  11. def collectChar(f: PartialFunction[Byte, Char]): ofChar

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  12. def collectDouble(f: PartialFunction[Byte, Double]): ofDouble

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  13. def collectFirst[A](f: PartialFunction[Byte, A])(implicit A: ClassTag[A]): Option[A]

  14. def collectFirstBoolean(f: PartialFunction[Byte, Boolean]): Option[Boolean]

  15. def collectFirstByte(f: PartialFunction[Byte, Byte]): Option[Byte]

  16. def collectFirstChar(f: PartialFunction[Byte, Char]): Option[Char]

  17. def collectFirstDouble(f: PartialFunction[Byte, Double]): Option[Double]

  18. def collectFirstFloat(f: PartialFunction[Byte, Float]): Option[Float]

  19. def collectFirstInt(f: PartialFunction[Byte, Int]): Option[Int]

  20. def collectFirstLong(f: PartialFunction[Byte, Long]): Option[Long]

  21. def collectFirstRef[Y <: AnyRef](f: PartialFunction[Byte, Y])(implicit arg0: ClassTag[Y]): Option[Y]

  22. def collectFirstShort(f: PartialFunction[Byte, Short]): Option[Short]

  23. def collectFloat(f: PartialFunction[Byte, Float]): ofFloat

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  24. def collectInt(f: PartialFunction[Byte, Int]): ofInt

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  25. def collectLong(f: PartialFunction[Byte, Long]): ofLong

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  26. def collectRef[Y <: AnyRef](f: PartialFunction[Byte, Y])(implicit arg0: ClassTag[Y]): ofRef[Y]

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  27. def collectShort(f: PartialFunction[Byte, Short]): ofShort

    can not avoid boxing PartialFunction#applyOrElse use .withFilter(predicate).map(f) instead

  28. def contains(elem: Byte): Boolean

  29. def count(f: (Byte) ⇒ Boolean): Int

  30. def deleteFirst(elem: Byte): ofByte

  31. def drop(n: Int): ofByte

  32. def dropRight(n: Int): ofByte

  33. def dropWhile(f: (Byte) ⇒ Boolean): ofByte

  34. def dropWhileR(f: (Byte) ⇒ Boolean): ofByte

  35. def endsWith(that: Array[Byte]): Boolean

  36. def exists(f: (Byte) ⇒ Boolean): Boolean

  37. def filter(f: (Byte) ⇒ Boolean): ofByte

  38. def filterNot(f: (Byte) ⇒ Boolean): ofByte

  39. def find(f: (Byte) ⇒ Boolean): Option[Byte]

  40. def flatMap[A](f: (Byte) ⇒ Array[A])(implicit A: ClassTag[A]): Array[A]

  41. def flatMapBoolean(f: (Byte) ⇒ Array[Boolean]): ofBoolean

  42. def flatMapByte(f: (Byte) ⇒ Array[Byte]): ofByte

  43. def flatMapChar(f: (Byte) ⇒ Array[Char]): ofChar

  44. def flatMapDouble(f: (Byte) ⇒ Array[Double]): ofDouble

  45. def flatMapFloat(f: (Byte) ⇒ Array[Float]): ofFloat

  46. def flatMapInt(f: (Byte) ⇒ Array[Int]): ofInt

  47. def flatMapLong(f: (Byte) ⇒ Array[Long]): ofLong

  48. def flatMapRef[Y <: AnyRef](f: (Byte) ⇒ Array[Y])(implicit arg0: ClassTag[Y]): ofRef[Y]

  49. def flatMapShort(f: (Byte) ⇒ Array[Short]): ofShort

  50. def foldLeft[A](z: A)(f: (A, Byte) ⇒ A)(implicit A: ClassTag[A]): A

  51. def foldLeftBoolean(z: Boolean)(f: (Boolean, Byte) ⇒ Boolean): Boolean

  52. def foldLeftByte(z: Byte)(f: (Byte, Byte) ⇒ Byte): Byte

  53. def foldLeftChar(z: Char)(f: (Char, Byte) ⇒ Char): Char

  54. def foldLeftDouble(z: Double)(f: (Double, Byte) ⇒ Double): Double

  55. def foldLeftFloat(z: Float)(f: (Float, Byte) ⇒ Float): Float

  56. def foldLeftInt(z: Int)(f: (Int, Byte) ⇒ Int): Int

  57. def foldLeftLong(z: Long)(f: (Long, Byte) ⇒ Long): Long

  58. def foldLeftRef[Y](z: Y)(f: (Y, Byte) ⇒ Y): Y

  59. def foldLeftShort(z: Short)(f: (Short, Byte) ⇒ Short): Short

  60. def foldMapLeft1[A](z: (Byte) ⇒ A)(f: (A, Byte) ⇒ A)(implicit A: ClassTag[A]): Option[A]

  61. def foldMapLeft1Boolean(z: (Byte) ⇒ Boolean)(f: (Boolean, Byte) ⇒ Boolean): Option[Boolean]

  62. def foldMapLeft1Byte(z: (Byte) ⇒ Byte)(f: (Byte, Byte) ⇒ Byte): Option[Byte]

  63. def foldMapLeft1Char(z: (Byte) ⇒ Char)(f: (Char, Byte) ⇒ Char): Option[Char]

  64. def foldMapLeft1Double(z: (Byte) ⇒ Double)(f: (Double, Byte) ⇒ Double): Option[Double]

  65. def foldMapLeft1Float(z: (Byte) ⇒ Float)(f: (Float, Byte) ⇒ Float): Option[Float]

  66. def foldMapLeft1Int(z: (Byte) ⇒ Int)(f: (Int, Byte) ⇒ Int): Option[Int]

  67. def foldMapLeft1Long(z: (Byte) ⇒ Long)(f: (Long, Byte) ⇒ Long): Option[Long]

  68. def foldMapLeft1Ref[Y](z: (Byte) ⇒ Y)(f: (Y, Byte) ⇒ Y): Option[Y]

  69. def foldMapLeft1Short(z: (Byte) ⇒ Short)(f: (Short, Byte) ⇒ Short): Option[Short]

  70. def foldMapRight1[A](z: (Byte) ⇒ A)(f: (Byte, A) ⇒ A)(implicit A: ClassTag[A]): Option[A]

  71. def foldMapRight1Boolean(z: (Byte) ⇒ Boolean)(f: (Byte, Boolean) ⇒ Boolean): Option[Boolean]

  72. def foldMapRight1Byte(z: (Byte) ⇒ Byte)(f: (Byte, Byte) ⇒ Byte): Option[Byte]

  73. def foldMapRight1Char(z: (Byte) ⇒ Char)(f: (Byte, Char) ⇒ Char): Option[Char]

  74. def foldMapRight1Double(z: (Byte) ⇒ Double)(f: (Byte, Double) ⇒ Double): Option[Double]

  75. def foldMapRight1Float(z: (Byte) ⇒ Float)(f: (Byte, Float) ⇒ Float): Option[Float]

  76. def foldMapRight1Int(z: (Byte) ⇒ Int)(f: (Byte, Int) ⇒ Int): Option[Int]

  77. def foldMapRight1Long(z: (Byte) ⇒ Long)(f: (Byte, Long) ⇒ Long): Option[Long]

  78. def foldMapRight1Ref[Y](z: (Byte) ⇒ Y)(f: (Byte, Y) ⇒ Y): Option[Y]

  79. def foldMapRight1Short(z: (Byte) ⇒ Short)(f: (Byte, Short) ⇒ Short): Option[Short]

  80. def foldRight[A](z: A)(f: (Byte, A) ⇒ A)(implicit A: ClassTag[A]): A

  81. def foldRightBoolean(z: Boolean)(f: (Byte, Boolean) ⇒ Boolean): Boolean

  82. def foldRightByte(z: Byte)(f: (Byte, Byte) ⇒ Byte): Byte

  83. def foldRightChar(z: Char)(f: (Byte, Char) ⇒ Char): Char

  84. def foldRightDouble(z: Double)(f: (Byte, Double) ⇒ Double): Double

  85. def foldRightFloat(z: Float)(f: (Byte, Float) ⇒ Float): Float

  86. def foldRightInt(z: Int)(f: (Byte, Int) ⇒ Int): Int

  87. def foldRightLong(z: Long)(f: (Byte, Long) ⇒ Long): Long

  88. def foldRightRef[Y](z: Y)(f: (Byte, Y) ⇒ Y): Y

  89. def foldRightShort(z: Short)(f: (Byte, Short) ⇒ Short): Short

  90. def forall(f: (Byte) ⇒ Boolean): Boolean

  91. def foreach[U](f: (Byte) ⇒ U): Unit

  92. def getClass(): Class[_ <: AnyVal]

    Definition Classes
    AnyVal → Any

  93. def groupBy[A](f: (Byte) ⇒ A): Map[A, ofByte]

  94. def grouped(n: Int): Iterator[ofByte]

    Annotations
    @throws( ... )

  95. def indexOf(elem: Byte): Option[Int]

  96. def initOption: Option[ofByte]

  97. def inits: Iterator[ofByte]

  98. def intersperse(a: Byte): ofByte

  99. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  100. def lastIndexOf(elem: Byte): Option[Int]

  101. def length: Int

  102. def map[A](f: (Byte) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  103. def mapBoolean(f: (Byte) ⇒ Boolean): ofBoolean

  104. def mapByte(f: (Byte) ⇒ Byte): ofByte

  105. def mapChar(f: (Byte) ⇒ Char): ofChar

  106. def mapDouble(f: (Byte) ⇒ Double): ofDouble

  107. def mapFloat(f: (Byte) ⇒ Float): ofFloat

  108. def mapInt(f: (Byte) ⇒ Int): ofInt

  109. def mapLong(f: (Byte) ⇒ Long): ofLong

  110. def mapRef[Y <: AnyRef](f: (Byte) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  111. def mapShort(f: (Byte) ⇒ Short): ofShort

  112. def max: Option[Byte]

  113. def maxBy[A](f: (Byte) ⇒ A)(implicit A: Ordering[A]): Option[Byte]

  114. def min: Option[Byte]

  115. def minBy[A](f: (Byte) ⇒ A)(implicit A: Ordering[A]): Option[Byte]

  116. def minmax: Option[(Byte, Byte)]

  117. def mkString: String

  118. def mkString(sep: String): String

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

  120. def partition(f: (Byte) ⇒ Boolean): (ofByte, ofByte)

  121. def product: Int

  122. def productDouble: Double

  123. def productLong: Long

  124. def reduceLeftOption(f: (Byte, Byte) ⇒ Byte): Option[Byte]

  125. def reduceRightOption(f: (Byte, Byte) ⇒ Byte): Option[Byte]

  126. def reverse: ofByte

  127. def reverseMap[A](f: (Byte) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  128. def reverseMapBoolean(f: (Byte) ⇒ Boolean): ofBoolean

  129. def reverseMapByte(f: (Byte) ⇒ Byte): ofByte

  130. def reverseMapChar(f: (Byte) ⇒ Char): ofChar

  131. def reverseMapDouble(f: (Byte) ⇒ Double): ofDouble

  132. def reverseMapFloat(f: (Byte) ⇒ Float): ofFloat

  133. def reverseMapInt(f: (Byte) ⇒ Int): ofInt

  134. def reverseMapLong(f: (Byte) ⇒ Long): ofLong

  135. def reverseMapRef[Y <: AnyRef](f: (Byte) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  136. def reverseMapShort(f: (Byte) ⇒ Short): ofShort

  137. def reverse_:::(prefix: ofByte): ofByte

  138. def scanLeft[A](z: A)(f: (A, Byte) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  139. def scanLeft1(f: (Byte, Byte) ⇒ Byte): ofByte

  140. def scanLeftBoolean(z: Boolean)(f: (Boolean, Byte) ⇒ Boolean): ofBoolean

  141. def scanLeftByte(z: Byte)(f: (Byte, Byte) ⇒ Byte): ofByte

  142. def scanLeftChar(z: Char)(f: (Char, Byte) ⇒ Char): ofChar

  143. def scanLeftDouble(z: Double)(f: (Double, Byte) ⇒ Double): ofDouble

  144. def scanLeftFloat(z: Float)(f: (Float, Byte) ⇒ Float): ofFloat

  145. def scanLeftInt(z: Int)(f: (Int, Byte) ⇒ Int): ofInt

  146. def scanLeftLong(z: Long)(f: (Long, Byte) ⇒ Long): ofLong

  147. def scanLeftRef[Y <: AnyRef](z: Y)(f: (Y, Byte) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  148. def scanLeftShort(z: Short)(f: (Short, Byte) ⇒ Short): ofShort

  149. def scanRight[A](z: A)(f: (Byte, A) ⇒ A)(implicit A: ClassTag[A]): Array[A]

  150. def scanRight1(f: (Byte, Byte) ⇒ Byte): ofByte

  151. def scanRightBoolean(z: Boolean)(f: (Byte, Boolean) ⇒ Boolean): ofBoolean

  152. def scanRightByte(z: Byte)(f: (Byte, Byte) ⇒ Byte): ofByte

  153. def scanRightChar(z: Char)(f: (Byte, Char) ⇒ Char): ofChar

  154. def scanRightDouble(z: Double)(f: (Byte, Double) ⇒ Double): ofDouble

  155. def scanRightFloat(z: Float)(f: (Byte, Float) ⇒ Float): ofFloat

  156. def scanRightInt(z: Int)(f: (Byte, Int) ⇒ Int): ofInt

  157. def scanRightLong(z: Long)(f: (Byte, Long) ⇒ Long): ofLong

  158. def scanRightRef[Y <: AnyRef](z: Y)(f: (Byte, Y) ⇒ Y)(implicit arg0: ClassTag[Y]): ofRef[Y]

  159. def scanRightShort(z: Short)(f: (Byte, Short) ⇒ Short): ofShort

  160. val self: Array[Byte]

  161. def size: Int

  162. def slice(from: Int, until: Int): ofByte

  163. def sliding(_size: Int, step: Int = 1): Iterator[ofByte]

    Annotations
    @throws( ... )

  164. def sorted: ofByte

  165. def span(f: (Byte) ⇒ Boolean): (ofByte, ofByte)

  166. def splitAt(n: Int): (ofByte, ofByte)

  167. def startsWith(that: Array[Byte], offset: Int = 0): Boolean

  168. def sum: Int

  169. def tailOption: Option[ofByte]

  170. def tails: Iterator[ofByte]

  171. def take(n: Int): ofByte

  172. def takeRight(n: Int): ofByte

  173. def takeWhile(f: (Byte) ⇒ Boolean): ofByte

  174. def takeWhileR(f: (Byte) ⇒ Boolean): ofByte

  175. def toString(): String

    Definition Classes
    ofByte → Any

  176. def updated(index: Int, elem: Byte): ofByte

    Annotations
    @throws( ... )

  177. def withFilter(f: (Byte) ⇒ Boolean): WithFilterByte

Inherited from AnyVal

Inherited from Any

Ungrouped