← Back to branch summary

~ubuntu-branches/debian/sid/scala/sid

« back to all changes in this revision

Viewing changes to src/library/scala/Char.scala

  • Committer: Package Import Robot
  • Author(s): Emmanuel Bourg, Mehdi Dogguy, Lucas Satabin, Frank S. Thomas, Emmanuel Bourg
  • Date: 2015-06-05 23:52:59 UTC
  • mfrom: (1.2.11)
  • Revision ID: package-import@ubuntu.com-20150605235259-wk00vgk83dh8o19g
Tags: 2.10.5-1
http://bugs.debian.org/744278
http://bugs.debian.org/754935
http://bugs.debian.org/724704
* Team upload.

[ Mehdi Dogguy ]
* New upstream release (Closes: #744278).

[ Lucas Satabin ]
* Update patches
* Update the clean target
* Update paths of elements to install
* Update watch file

[ Frank S. Thomas ]
* Remove myself from Uploaders.

[ Emmanuel Bourg ]
* The package has been adopted by the Java Team (Closes: #754935)
* Patched the build to avoid downloading libraries from the Internet
* Replaced the minified JavaScript files with unobfuscated ones
* No longer build scala-partest.jar until diffutils is packaged or replaced
* debian/watch: Fixed the versions matched (x.y.z instead of x.y.z..z)
* debian/rules:
  - Added the missing get-orig-source target (Closes: #724704)
  - Improved the clean target
* debian/control:
  - Build depend on scala (>= 2.10) and bnd
  - Use canonical URLs for the Vcs-* fields
  - Standards-Version updated to 3.9.6 (no changes)
* Switch to debhelper level 9

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/library/scala/Char.scala
10
10
 
11
11
package scala
12
12
 
13
 
/** `Char` is a member of the value classes, those whose instances are
14
 
 *  not represented as objects by the underlying host system.
 
13
import scala.language.implicitConversions
 
14
 
 
15
/** `Char`, a 16-bit unsigned integer (equivalent to Java's `char` primitive type) is a
 
16
 *  subtype of [[scala.AnyVal]]. Instances of `Char` are not
 
17
 *  represented by an object in the underlying runtime system.
15
18
 *
16
19
 *  There is an implicit conversion from [[scala.Char]] => [[scala.runtime.RichChar]]
17
20
 *  which provides useful non-primitive operations.
18
21
 */
19
 
final class Char extends AnyVal {
20
 
  def toByte: Byte = sys.error("stub")
21
 
  def toShort: Short = sys.error("stub")
22
 
  def toChar: Char = sys.error("stub")
23
 
  def toInt: Int = sys.error("stub")
24
 
  def toLong: Long = sys.error("stub")
25
 
  def toFloat: Float = sys.error("stub")
26
 
  def toDouble: Double = sys.error("stub")
27
 
 
28
 
  def unary_+ : Int = sys.error("stub")
29
 
  def unary_- : Int = sys.error("stub")
30
 
  def unary_~ : Int = sys.error("stub")
31
 
 
32
 
  def +(x: String): String = sys.error("stub")
33
 
 
34
 
  def <<(x: Int): Int = sys.error("stub")
35
 
  def <<(x: Long): Int = sys.error("stub")
36
 
  def >>>(x: Int): Int = sys.error("stub")
37
 
  def >>>(x: Long): Int = sys.error("stub")
38
 
  def >>(x: Int): Int = sys.error("stub")
39
 
  def >>(x: Long): Int = sys.error("stub")
40
 
 
41
 
  def ==(x: Byte): Boolean = sys.error("stub")
42
 
  def ==(x: Short): Boolean = sys.error("stub")
43
 
  def ==(x: Char): Boolean = sys.error("stub")
44
 
  def ==(x: Int): Boolean = sys.error("stub")
45
 
  def ==(x: Long): Boolean = sys.error("stub")
46
 
  def ==(x: Float): Boolean = sys.error("stub")
47
 
  def ==(x: Double): Boolean = sys.error("stub")
48
 
 
49
 
  def !=(x: Byte): Boolean = sys.error("stub")
50
 
  def !=(x: Short): Boolean = sys.error("stub")
51
 
  def !=(x: Char): Boolean = sys.error("stub")
52
 
  def !=(x: Int): Boolean = sys.error("stub")
53
 
  def !=(x: Long): Boolean = sys.error("stub")
54
 
  def !=(x: Float): Boolean = sys.error("stub")
55
 
  def !=(x: Double): Boolean = sys.error("stub")
56
 
 
57
 
  def <(x: Byte): Boolean = sys.error("stub")
58
 
  def <(x: Short): Boolean = sys.error("stub")
59
 
  def <(x: Char): Boolean = sys.error("stub")
60
 
  def <(x: Int): Boolean = sys.error("stub")
61
 
  def <(x: Long): Boolean = sys.error("stub")
62
 
  def <(x: Float): Boolean = sys.error("stub")
63
 
  def <(x: Double): Boolean = sys.error("stub")
64
 
 
65
 
  def <=(x: Byte): Boolean = sys.error("stub")
66
 
  def <=(x: Short): Boolean = sys.error("stub")
67
 
  def <=(x: Char): Boolean = sys.error("stub")
68
 
  def <=(x: Int): Boolean = sys.error("stub")
69
 
  def <=(x: Long): Boolean = sys.error("stub")
70
 
  def <=(x: Float): Boolean = sys.error("stub")
71
 
  def <=(x: Double): Boolean = sys.error("stub")
72
 
 
73
 
  def >(x: Byte): Boolean = sys.error("stub")
74
 
  def >(x: Short): Boolean = sys.error("stub")
75
 
  def >(x: Char): Boolean = sys.error("stub")
76
 
  def >(x: Int): Boolean = sys.error("stub")
77
 
  def >(x: Long): Boolean = sys.error("stub")
78
 
  def >(x: Float): Boolean = sys.error("stub")
79
 
  def >(x: Double): Boolean = sys.error("stub")
80
 
 
81
 
  def >=(x: Byte): Boolean = sys.error("stub")
82
 
  def >=(x: Short): Boolean = sys.error("stub")
83
 
  def >=(x: Char): Boolean = sys.error("stub")
84
 
  def >=(x: Int): Boolean = sys.error("stub")
85
 
  def >=(x: Long): Boolean = sys.error("stub")
86
 
  def >=(x: Float): Boolean = sys.error("stub")
87
 
  def >=(x: Double): Boolean = sys.error("stub")
88
 
 
89
 
  def |(x: Byte): Int = sys.error("stub")
90
 
  def |(x: Short): Int = sys.error("stub")
91
 
  def |(x: Char): Int = sys.error("stub")
92
 
  def |(x: Int): Int = sys.error("stub")
93
 
  def |(x: Long): Long = sys.error("stub")
94
 
 
95
 
  def &(x: Byte): Int = sys.error("stub")
96
 
  def &(x: Short): Int = sys.error("stub")
97
 
  def &(x: Char): Int = sys.error("stub")
98
 
  def &(x: Int): Int = sys.error("stub")
99
 
  def &(x: Long): Long = sys.error("stub")
100
 
 
101
 
  def ^(x: Byte): Int = sys.error("stub")
102
 
  def ^(x: Short): Int = sys.error("stub")
103
 
  def ^(x: Char): Int = sys.error("stub")
104
 
  def ^(x: Int): Int = sys.error("stub")
105
 
  def ^(x: Long): Long = sys.error("stub")
106
 
 
107
 
  def +(x: Byte): Int = sys.error("stub")
108
 
  def +(x: Short): Int = sys.error("stub")
109
 
  def +(x: Char): Int = sys.error("stub")
110
 
  def +(x: Int): Int = sys.error("stub")
111
 
  def +(x: Long): Long = sys.error("stub")
112
 
  def +(x: Float): Float = sys.error("stub")
113
 
  def +(x: Double): Double = sys.error("stub")
114
 
 
115
 
  def -(x: Byte): Int = sys.error("stub")
116
 
  def -(x: Short): Int = sys.error("stub")
117
 
  def -(x: Char): Int = sys.error("stub")
118
 
  def -(x: Int): Int = sys.error("stub")
119
 
  def -(x: Long): Long = sys.error("stub")
120
 
  def -(x: Float): Float = sys.error("stub")
121
 
  def -(x: Double): Double = sys.error("stub")
122
 
 
123
 
  def *(x: Byte): Int = sys.error("stub")
124
 
  def *(x: Short): Int = sys.error("stub")
125
 
  def *(x: Char): Int = sys.error("stub")
126
 
  def *(x: Int): Int = sys.error("stub")
127
 
  def *(x: Long): Long = sys.error("stub")
128
 
  def *(x: Float): Float = sys.error("stub")
129
 
  def *(x: Double): Double = sys.error("stub")
130
 
 
131
 
  def /(x: Byte): Int = sys.error("stub")
132
 
  def /(x: Short): Int = sys.error("stub")
133
 
  def /(x: Char): Int = sys.error("stub")
134
 
  def /(x: Int): Int = sys.error("stub")
135
 
  def /(x: Long): Long = sys.error("stub")
136
 
  def /(x: Float): Float = sys.error("stub")
137
 
  def /(x: Double): Double = sys.error("stub")
138
 
 
139
 
  def %(x: Byte): Int = sys.error("stub")
140
 
  def %(x: Short): Int = sys.error("stub")
141
 
  def %(x: Char): Int = sys.error("stub")
142
 
  def %(x: Int): Int = sys.error("stub")
143
 
  def %(x: Long): Long = sys.error("stub")
144
 
  def %(x: Float): Float = sys.error("stub")
145
 
  def %(x: Double): Double = sys.error("stub")
146
 
 
147
 
  def getClass(): Class[Char] = sys.error("stub")
 
22
final abstract class Char private extends AnyVal {
 
23
  def toByte: Byte
 
24
  def toShort: Short
 
25
  def toChar: Char
 
26
  def toInt: Int
 
27
  def toLong: Long
 
28
  def toFloat: Float
 
29
  def toDouble: Double
 
30
 
 
31
  /**
 
32
 * Returns the bitwise negation of this value.
 
33
 * @example {{{
 
34
 * ~5 == -6
 
35
 * // in binary: ~00000101 ==
 
36
 * //             11111010
 
37
 * }}}
 
38
 */
 
39
  def unary_~ : Int
 
40
  /**
 
41
 * Returns this value, unmodified.
 
42
 */
 
43
  def unary_+ : Int
 
44
  /**
 
45
 * Returns the negation of this value.
 
46
 */
 
47
  def unary_- : Int
 
48
 
 
49
  def +(x: String): String
 
50
 
 
51
  /**
 
52
  * Returns this value bit-shifted left by the specified number of bits,
 
53
  *         filling in the new right bits with zeroes.
 
54
  * @example {{{ 6 << 3 == 48 // in binary: 0110 << 3 == 0110000 }}}
 
55
  */
 
56
  def <<(x: Int): Int
 
57
  /**
 
58
  * Returns this value bit-shifted left by the specified number of bits,
 
59
  *         filling in the new right bits with zeroes.
 
60
  * @example {{{ 6 << 3 == 48 // in binary: 0110 << 3 == 0110000 }}}
 
61
  */
 
62
  def <<(x: Long): Int
 
63
  /**
 
64
  * Returns this value bit-shifted right by the specified number of bits,
 
65
  *         filling the new left bits with zeroes.
 
66
  * @example {{{ 21 >>> 3 == 2 // in binary: 010101 >>> 3 == 010 }}}
 
67
  * @example {{{
 
68
  * -21 >>> 3 == 536870909
 
69
  * // in binary: 11111111 11111111 11111111 11101011 >>> 3 ==
 
70
  * //            00011111 11111111 11111111 11111101
 
71
  * }}}
 
72
  */
 
73
  def >>>(x: Int): Int
 
74
  /**
 
75
  * Returns this value bit-shifted right by the specified number of bits,
 
76
  *         filling the new left bits with zeroes.
 
77
  * @example {{{ 21 >>> 3 == 2 // in binary: 010101 >>> 3 == 010 }}}
 
78
  * @example {{{
 
79
  * -21 >>> 3 == 536870909
 
80
  * // in binary: 11111111 11111111 11111111 11101011 >>> 3 ==
 
81
  * //            00011111 11111111 11111111 11111101
 
82
  * }}}
 
83
  */
 
84
  def >>>(x: Long): Int
 
85
  /**
 
86
  * Returns this value bit-shifted left by the specified number of bits,
 
87
  *         filling in the right bits with the same value as the left-most bit of this.
 
88
  *         The effect of this is to retain the sign of the value.
 
89
  * @example {{{
 
90
  * -21 >> 3 == -3
 
91
  * // in binary: 11111111 11111111 11111111 11101011 >> 3 ==
 
92
  * //            11111111 11111111 11111111 11111101
 
93
  * }}}
 
94
  */
 
95
  def >>(x: Int): Int
 
96
  /**
 
97
  * Returns this value bit-shifted left by the specified number of bits,
 
98
  *         filling in the right bits with the same value as the left-most bit of this.
 
99
  *         The effect of this is to retain the sign of the value.
 
100
  * @example {{{
 
101
  * -21 >> 3 == -3
 
102
  * // in binary: 11111111 11111111 11111111 11101011 >> 3 ==
 
103
  * //            11111111 11111111 11111111 11111101
 
104
  * }}}
 
105
  */
 
106
  def >>(x: Long): Int
 
107
 
 
108
  /**
 
109
  * Returns `true` if this value is equal to x, `false` otherwise.
 
110
  */
 
111
  def ==(x: Byte): Boolean
 
112
  /**
 
113
  * Returns `true` if this value is equal to x, `false` otherwise.
 
114
  */
 
115
  def ==(x: Short): Boolean
 
116
  /**
 
117
  * Returns `true` if this value is equal to x, `false` otherwise.
 
118
  */
 
119
  def ==(x: Char): Boolean
 
120
  /**
 
121
  * Returns `true` if this value is equal to x, `false` otherwise.
 
122
  */
 
123
  def ==(x: Int): Boolean
 
124
  /**
 
125
  * Returns `true` if this value is equal to x, `false` otherwise.
 
126
  */
 
127
  def ==(x: Long): Boolean
 
128
  /**
 
129
  * Returns `true` if this value is equal to x, `false` otherwise.
 
130
  */
 
131
  def ==(x: Float): Boolean
 
132
  /**
 
133
  * Returns `true` if this value is equal to x, `false` otherwise.
 
134
  */
 
135
  def ==(x: Double): Boolean
 
136
 
 
137
  /**
 
138
  * Returns `true` if this value is not equal to x, `false` otherwise.
 
139
  */
 
140
  def !=(x: Byte): Boolean
 
141
  /**
 
142
  * Returns `true` if this value is not equal to x, `false` otherwise.
 
143
  */
 
144
  def !=(x: Short): Boolean
 
145
  /**
 
146
  * Returns `true` if this value is not equal to x, `false` otherwise.
 
147
  */
 
148
  def !=(x: Char): Boolean
 
149
  /**
 
150
  * Returns `true` if this value is not equal to x, `false` otherwise.
 
151
  */
 
152
  def !=(x: Int): Boolean
 
153
  /**
 
154
  * Returns `true` if this value is not equal to x, `false` otherwise.
 
155
  */
 
156
  def !=(x: Long): Boolean
 
157
  /**
 
158
  * Returns `true` if this value is not equal to x, `false` otherwise.
 
159
  */
 
160
  def !=(x: Float): Boolean
 
161
  /**
 
162
  * Returns `true` if this value is not equal to x, `false` otherwise.
 
163
  */
 
164
  def !=(x: Double): Boolean
 
165
 
 
166
  /**
 
167
  * Returns `true` if this value is less than x, `false` otherwise.
 
168
  */
 
169
  def <(x: Byte): Boolean
 
170
  /**
 
171
  * Returns `true` if this value is less than x, `false` otherwise.
 
172
  */
 
173
  def <(x: Short): Boolean
 
174
  /**
 
175
  * Returns `true` if this value is less than x, `false` otherwise.
 
176
  */
 
177
  def <(x: Char): Boolean
 
178
  /**
 
179
  * Returns `true` if this value is less than x, `false` otherwise.
 
180
  */
 
181
  def <(x: Int): Boolean
 
182
  /**
 
183
  * Returns `true` if this value is less than x, `false` otherwise.
 
184
  */
 
185
  def <(x: Long): Boolean
 
186
  /**
 
187
  * Returns `true` if this value is less than x, `false` otherwise.
 
188
  */
 
189
  def <(x: Float): Boolean
 
190
  /**
 
191
  * Returns `true` if this value is less than x, `false` otherwise.
 
192
  */
 
193
  def <(x: Double): Boolean
 
194
 
 
195
  /**
 
196
  * Returns `true` if this value is less than or equal to x, `false` otherwise.
 
197
  */
 
198
  def <=(x: Byte): Boolean
 
199
  /**
 
200
  * Returns `true` if this value is less than or equal to x, `false` otherwise.
 
201
  */
 
202
  def <=(x: Short): Boolean
 
203
  /**
 
204
  * Returns `true` if this value is less than or equal to x, `false` otherwise.
 
205
  */
 
206
  def <=(x: Char): Boolean
 
207
  /**
 
208
  * Returns `true` if this value is less than or equal to x, `false` otherwise.
 
209
  */
 
210
  def <=(x: Int): Boolean
 
211
  /**
 
212
  * Returns `true` if this value is less than or equal to x, `false` otherwise.
 
213
  */
 
214
  def <=(x: Long): Boolean
 
215
  /**
 
216
  * Returns `true` if this value is less than or equal to x, `false` otherwise.
 
217
  */
 
218
  def <=(x: Float): Boolean
 
219
  /**
 
220
  * Returns `true` if this value is less than or equal to x, `false` otherwise.
 
221
  */
 
222
  def <=(x: Double): Boolean
 
223
 
 
224
  /**
 
225
  * Returns `true` if this value is greater than x, `false` otherwise.
 
226
  */
 
227
  def >(x: Byte): Boolean
 
228
  /**
 
229
  * Returns `true` if this value is greater than x, `false` otherwise.
 
230
  */
 
231
  def >(x: Short): Boolean
 
232
  /**
 
233
  * Returns `true` if this value is greater than x, `false` otherwise.
 
234
  */
 
235
  def >(x: Char): Boolean
 
236
  /**
 
237
  * Returns `true` if this value is greater than x, `false` otherwise.
 
238
  */
 
239
  def >(x: Int): Boolean
 
240
  /**
 
241
  * Returns `true` if this value is greater than x, `false` otherwise.
 
242
  */
 
243
  def >(x: Long): Boolean
 
244
  /**
 
245
  * Returns `true` if this value is greater than x, `false` otherwise.
 
246
  */
 
247
  def >(x: Float): Boolean
 
248
  /**
 
249
  * Returns `true` if this value is greater than x, `false` otherwise.
 
250
  */
 
251
  def >(x: Double): Boolean
 
252
 
 
253
  /**
 
254
  * Returns `true` if this value is greater than or equal to x, `false` otherwise.
 
255
  */
 
256
  def >=(x: Byte): Boolean
 
257
  /**
 
258
  * Returns `true` if this value is greater than or equal to x, `false` otherwise.
 
259
  */
 
260
  def >=(x: Short): Boolean
 
261
  /**
 
262
  * Returns `true` if this value is greater than or equal to x, `false` otherwise.
 
263
  */
 
264
  def >=(x: Char): Boolean
 
265
  /**
 
266
  * Returns `true` if this value is greater than or equal to x, `false` otherwise.
 
267
  */
 
268
  def >=(x: Int): Boolean
 
269
  /**
 
270
  * Returns `true` if this value is greater than or equal to x, `false` otherwise.
 
271
  */
 
272
  def >=(x: Long): Boolean
 
273
  /**
 
274
  * Returns `true` if this value is greater than or equal to x, `false` otherwise.
 
275
  */
 
276
  def >=(x: Float): Boolean
 
277
  /**
 
278
  * Returns `true` if this value is greater than or equal to x, `false` otherwise.
 
279
  */
 
280
  def >=(x: Double): Boolean
 
281
 
 
282
  /**
 
283
  * Returns the bitwise OR of this value and `x`.
 
284
  * @example {{{
 
285
  * (0xf0 | 0xaa) == 0xfa
 
286
  * // in binary:   11110000
 
287
  * //            | 10101010
 
288
  * //              --------
 
289
  * //              11111010
 
290
  * }}}
 
291
  */
 
292
  def |(x: Byte): Int
 
293
  /**
 
294
  * Returns the bitwise OR of this value and `x`.
 
295
  * @example {{{
 
296
  * (0xf0 | 0xaa) == 0xfa
 
297
  * // in binary:   11110000
 
298
  * //            | 10101010
 
299
  * //              --------
 
300
  * //              11111010
 
301
  * }}}
 
302
  */
 
303
  def |(x: Short): Int
 
304
  /**
 
305
  * Returns the bitwise OR of this value and `x`.
 
306
  * @example {{{
 
307
  * (0xf0 | 0xaa) == 0xfa
 
308
  * // in binary:   11110000
 
309
  * //            | 10101010
 
310
  * //              --------
 
311
  * //              11111010
 
312
  * }}}
 
313
  */
 
314
  def |(x: Char): Int
 
315
  /**
 
316
  * Returns the bitwise OR of this value and `x`.
 
317
  * @example {{{
 
318
  * (0xf0 | 0xaa) == 0xfa
 
319
  * // in binary:   11110000
 
320
  * //            | 10101010
 
321
  * //              --------
 
322
  * //              11111010
 
323
  * }}}
 
324
  */
 
325
  def |(x: Int): Int
 
326
  /**
 
327
  * Returns the bitwise OR of this value and `x`.
 
328
  * @example {{{
 
329
  * (0xf0 | 0xaa) == 0xfa
 
330
  * // in binary:   11110000
 
331
  * //            | 10101010
 
332
  * //              --------
 
333
  * //              11111010
 
334
  * }}}
 
335
  */
 
336
  def |(x: Long): Long
 
337
 
 
338
  /**
 
339
  * Returns the bitwise AND of this value and `x`.
 
340
  * @example {{{
 
341
  * (0xf0 & 0xaa) == 0xa0
 
342
  * // in binary:   11110000
 
343
  * //            & 10101010
 
344
  * //              --------
 
345
  * //              10100000
 
346
  * }}}
 
347
  */
 
348
  def &(x: Byte): Int
 
349
  /**
 
350
  * Returns the bitwise AND of this value and `x`.
 
351
  * @example {{{
 
352
  * (0xf0 & 0xaa) == 0xa0
 
353
  * // in binary:   11110000
 
354
  * //            & 10101010
 
355
  * //              --------
 
356
  * //              10100000
 
357
  * }}}
 
358
  */
 
359
  def &(x: Short): Int
 
360
  /**
 
361
  * Returns the bitwise AND of this value and `x`.
 
362
  * @example {{{
 
363
  * (0xf0 & 0xaa) == 0xa0
 
364
  * // in binary:   11110000
 
365
  * //            & 10101010
 
366
  * //              --------
 
367
  * //              10100000
 
368
  * }}}
 
369
  */
 
370
  def &(x: Char): Int
 
371
  /**
 
372
  * Returns the bitwise AND of this value and `x`.
 
373
  * @example {{{
 
374
  * (0xf0 & 0xaa) == 0xa0
 
375
  * // in binary:   11110000
 
376
  * //            & 10101010
 
377
  * //              --------
 
378
  * //              10100000
 
379
  * }}}
 
380
  */
 
381
  def &(x: Int): Int
 
382
  /**
 
383
  * Returns the bitwise AND of this value and `x`.
 
384
  * @example {{{
 
385
  * (0xf0 & 0xaa) == 0xa0
 
386
  * // in binary:   11110000
 
387
  * //            & 10101010
 
388
  * //              --------
 
389
  * //              10100000
 
390
  * }}}
 
391
  */
 
392
  def &(x: Long): Long
 
393
 
 
394
  /**
 
395
  * Returns the bitwise XOR of this value and `x`.
 
396
  * @example {{{
 
397
  * (0xf0 ^ 0xaa) == 0x5a
 
398
  * // in binary:   11110000
 
399
  * //            ^ 10101010
 
400
  * //              --------
 
401
  * //              01011010
 
402
  * }}}
 
403
  */
 
404
  def ^(x: Byte): Int
 
405
  /**
 
406
  * Returns the bitwise XOR of this value and `x`.
 
407
  * @example {{{
 
408
  * (0xf0 ^ 0xaa) == 0x5a
 
409
  * // in binary:   11110000
 
410
  * //            ^ 10101010
 
411
  * //              --------
 
412
  * //              01011010
 
413
  * }}}
 
414
  */
 
415
  def ^(x: Short): Int
 
416
  /**
 
417
  * Returns the bitwise XOR of this value and `x`.
 
418
  * @example {{{
 
419
  * (0xf0 ^ 0xaa) == 0x5a
 
420
  * // in binary:   11110000
 
421
  * //            ^ 10101010
 
422
  * //              --------
 
423
  * //              01011010
 
424
  * }}}
 
425
  */
 
426
  def ^(x: Char): Int
 
427
  /**
 
428
  * Returns the bitwise XOR of this value and `x`.
 
429
  * @example {{{
 
430
  * (0xf0 ^ 0xaa) == 0x5a
 
431
  * // in binary:   11110000
 
432
  * //            ^ 10101010
 
433
  * //              --------
 
434
  * //              01011010
 
435
  * }}}
 
436
  */
 
437
  def ^(x: Int): Int
 
438
  /**
 
439
  * Returns the bitwise XOR of this value and `x`.
 
440
  * @example {{{
 
441
  * (0xf0 ^ 0xaa) == 0x5a
 
442
  * // in binary:   11110000
 
443
  * //            ^ 10101010
 
444
  * //              --------
 
445
  * //              01011010
 
446
  * }}}
 
447
  */
 
448
  def ^(x: Long): Long
 
449
 
 
450
  /**
 
451
  * Returns the sum of this value and `x`.
 
452
  */
 
453
  def +(x: Byte): Int
 
454
  /**
 
455
  * Returns the sum of this value and `x`.
 
456
  */
 
457
  def +(x: Short): Int
 
458
  /**
 
459
  * Returns the sum of this value and `x`.
 
460
  */
 
461
  def +(x: Char): Int
 
462
  /**
 
463
  * Returns the sum of this value and `x`.
 
464
  */
 
465
  def +(x: Int): Int
 
466
  /**
 
467
  * Returns the sum of this value and `x`.
 
468
  */
 
469
  def +(x: Long): Long
 
470
  /**
 
471
  * Returns the sum of this value and `x`.
 
472
  */
 
473
  def +(x: Float): Float
 
474
  /**
 
475
  * Returns the sum of this value and `x`.
 
476
  */
 
477
  def +(x: Double): Double
 
478
 
 
479
  /**
 
480
  * Returns the difference of this value and `x`.
 
481
  */
 
482
  def -(x: Byte): Int
 
483
  /**
 
484
  * Returns the difference of this value and `x`.
 
485
  */
 
486
  def -(x: Short): Int
 
487
  /**
 
488
  * Returns the difference of this value and `x`.
 
489
  */
 
490
  def -(x: Char): Int
 
491
  /**
 
492
  * Returns the difference of this value and `x`.
 
493
  */
 
494
  def -(x: Int): Int
 
495
  /**
 
496
  * Returns the difference of this value and `x`.
 
497
  */
 
498
  def -(x: Long): Long
 
499
  /**
 
500
  * Returns the difference of this value and `x`.
 
501
  */
 
502
  def -(x: Float): Float
 
503
  /**
 
504
  * Returns the difference of this value and `x`.
 
505
  */
 
506
  def -(x: Double): Double
 
507
 
 
508
  /**
 
509
  * Returns the product of this value and `x`.
 
510
  */
 
511
  def *(x: Byte): Int
 
512
  /**
 
513
  * Returns the product of this value and `x`.
 
514
  */
 
515
  def *(x: Short): Int
 
516
  /**
 
517
  * Returns the product of this value and `x`.
 
518
  */
 
519
  def *(x: Char): Int
 
520
  /**
 
521
  * Returns the product of this value and `x`.
 
522
  */
 
523
  def *(x: Int): Int
 
524
  /**
 
525
  * Returns the product of this value and `x`.
 
526
  */
 
527
  def *(x: Long): Long
 
528
  /**
 
529
  * Returns the product of this value and `x`.
 
530
  */
 
531
  def *(x: Float): Float
 
532
  /**
 
533
  * Returns the product of this value and `x`.
 
534
  */
 
535
  def *(x: Double): Double
 
536
 
 
537
  /**
 
538
  * Returns the quotient of this value and `x`.
 
539
  */
 
540
  def /(x: Byte): Int
 
541
  /**
 
542
  * Returns the quotient of this value and `x`.
 
543
  */
 
544
  def /(x: Short): Int
 
545
  /**
 
546
  * Returns the quotient of this value and `x`.
 
547
  */
 
548
  def /(x: Char): Int
 
549
  /**
 
550
  * Returns the quotient of this value and `x`.
 
551
  */
 
552
  def /(x: Int): Int
 
553
  /**
 
554
  * Returns the quotient of this value and `x`.
 
555
  */
 
556
  def /(x: Long): Long
 
557
  /**
 
558
  * Returns the quotient of this value and `x`.
 
559
  */
 
560
  def /(x: Float): Float
 
561
  /**
 
562
  * Returns the quotient of this value and `x`.
 
563
  */
 
564
  def /(x: Double): Double
 
565
 
 
566
  /**
 
567
  * Returns the remainder of the division of this value by `x`.
 
568
  */
 
569
  def %(x: Byte): Int
 
570
  /**
 
571
  * Returns the remainder of the division of this value by `x`.
 
572
  */
 
573
  def %(x: Short): Int
 
574
  /**
 
575
  * Returns the remainder of the division of this value by `x`.
 
576
  */
 
577
  def %(x: Char): Int
 
578
  /**
 
579
  * Returns the remainder of the division of this value by `x`.
 
580
  */
 
581
  def %(x: Int): Int
 
582
  /**
 
583
  * Returns the remainder of the division of this value by `x`.
 
584
  */
 
585
  def %(x: Long): Long
 
586
  /**
 
587
  * Returns the remainder of the division of this value by `x`.
 
588
  */
 
589
  def %(x: Float): Float
 
590
  /**
 
591
  * Returns the remainder of the division of this value by `x`.
 
592
  */
 
593
  def %(x: Double): Double
 
594
 
 
595
  override def getClass(): Class[Char] = null
148
596
}
149
597
 
150
598
object Char extends AnyValCompanion {
176
624
  /** The String representation of the scala.Char companion object.
177
625
   */
178
626
  override def toString = "object scala.Char"
 
627
 
 
628
  /** Language mandated coercions from Char to "wider" types.
 
629
   */
 
630
  implicit def char2int(x: Char): Int = x.toInt
 
631
  implicit def char2long(x: Char): Long = x.toLong
 
632
  implicit def char2float(x: Char): Float = x.toFloat
 
633
  implicit def char2double(x: Char): Double = x.toDouble
179
634
}
180
635