blob: dc0c82fc0b771cf5525ba487ee1529746087fa65 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
package java.lang
import scala.scalajs.js
/* This is a hijacked class. Its instances are primitive numbers.
* Constructors are not emitted.
*/
final class Byte private () extends Number with Comparable[Byte] {
def this(value: scala.Byte) = this()
def this(s: String) = this()
@inline override def byteValue(): scala.Byte =
this.asInstanceOf[scala.Byte]
@inline override def shortValue(): scala.Short = byteValue.toShort
@inline def intValue(): scala.Int = byteValue.toInt
@inline def longValue(): scala.Long = byteValue.toLong
@inline def floatValue(): scala.Float = byteValue.toFloat
@inline def doubleValue(): scala.Double = byteValue.toDouble
@inline override def equals(that: Any): scala.Boolean =
this eq that.asInstanceOf[AnyRef]
@inline override def hashCode(): Int =
byteValue
@inline override def compareTo(that: Byte): Int =
Byte.compare(byteValue, that.byteValue)
@inline override def toString(): String =
Byte.toString(byteValue)
}
object Byte {
final val TYPE = classOf[scala.Byte]
final val SIZE = 8
/* MIN_VALUE and MAX_VALUE should be 'final val's. But it is impossible to
* write a proper Byte literal in Scala, that would both considered a Byte
* and a constant expression (optimized as final val).
* Since vals and defs are binary-compatible (although they're not strictly
* speaking source-compatible, because of stability), we implement them as
* defs. Source-compatibility is not an issue because user code is compiled
* against the JDK .class files anyway.
*/
def MIN_VALUE: scala.Byte = -128
def MAX_VALUE: scala.Byte = 127
@inline def valueOf(byteValue: scala.Byte): Byte = new Byte(byteValue)
@inline def valueOf(s: String): Byte = valueOf(parseByte(s))
@inline def valueOf(s: String, radix: Int): Byte =
valueOf(parseByte(s, radix))
@inline def parseByte(s: String): scala.Byte = parseByte(s, 10)
def parseByte(s: String, radix: Int): scala.Byte = {
val r = Integer.parseInt(s, radix)
if (r < MIN_VALUE || r > MAX_VALUE)
throw new NumberFormatException(s"""For input string: "$s"""")
else
r.toByte
}
@inline def toString(b: scala.Byte): String =
"" + b
@inline def compare(x: scala.Byte, y: scala.Byte): scala.Int =
x - y
}
|
