-
Notifications
You must be signed in to change notification settings - Fork 60
/
Character.h
392 lines (347 loc) · 12.4 KB
/
Character.h
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef _DECAF_LANG_CHARACTER_H_
#define _DECAF_LANG_CHARACTER_H_
#include <decaf/util/Config.h>
#include <decaf/lang/Number.h>
#include <decaf/lang/Comparable.h>
#include <string>
namespace decaf{
namespace lang{
class DECAF_API Character : public Number,
public Comparable<Character>,
public Comparable<char> {
private:
// The primitive Char value
char value;
public:
/** The minimum radix available for conversion to and from strings. */
static const int MIN_RADIX;
/** The maximum radix available for conversion to and from strings. */
static const int MAX_RADIX;
/** The minimum value that a signed char can take on. */
static const char MIN_VALUE;
/** The maximum value that a signed char can take on. */
static const char MAX_VALUE;
/** The size of the primitive character in bits. */
static const int SIZE;
public:
/**
* @param value - char to wrap.
*/
Character(char value);
/**
* Compares this Character instance with another.
*
* @param c
* the Character instance to be compared
*
* @return zero if this object represents the same char value as the
* argument; a positive value if this object represents a value greater
* than the passed in value, and -1 if this object represents a value
* less than the passed in value.
*/
virtual int compareTo(const Character& c) const {
return this->value < c.value ? -1 : (this->value > c.value) ? 1 : 0;
}
/**
* Compares equality between this object and the one passed.
*
* @param c
* the value to be compared to this one.
*
* @return true if this object is equal to the one passed.
*/
virtual bool operator==(const Character& c) const {
return this->value == c.value;
}
/**
* Compares this object to another and returns true if this object
* is considered to be less than the one passed.
*
* @param c
* the value to be compared to this one.
*
* @return true if this object is equal to the one passed.
*/
virtual bool operator<(const Character& c) const {
return this->value < c.value;
}
/**
* Compares this Character instance with a char type.
*
* @param c
* the char instance to be compared
*
* @return zero if this object represents the same char value as the
* argument; a positive value if this object represents a value greater
* than the passed in value, and -1 if this object represents a value
* less than the passed in value.
*/
virtual int compareTo(const char& c) const {
return this->value < c ? -1 : (this->value > c) ? 1 : 0;
}
/**
* Compares equality between this object and the one passed.
*
* @param c
* the value to be compared to this one.
*
* @return true if this object is equal to the one passed.
*/
virtual bool operator==(const char& c) const {
return this->value == c;
}
/**
* Compares this object to another and returns true if this object
* is considered to be less than the one passed. This
*
* @param c
* the value to be compared to this one.
*
* @return true if this object is equal to the one passed.
*/
virtual bool operator<(const char& c) const {
return this->value < c;
}
/**
* @returns true if the two Character Objects have the same value.
*/
bool equals(const Character& c) const {
return this->value == c.value;
}
/**
* @returns true if the two Characters have the same value.
*/
bool equals(const char& c) const {
return this->value == c;
}
/**
* @returns this Character Object as a String Representation
*/
std::string toString() const;
/**
* Answers the double value which the receiver represents
*
* @return double the value of the receiver.
*/
virtual double doubleValue() const {
return (double) this->value;
}
/**
* Answers the float value which the receiver represents
*
* @return float the value of the receiver.
*/
virtual float floatValue() const {
return (float) this->value;
}
/**
* Answers the byte value which the receiver represents
*
* @return int the value of the receiver.
*/
virtual unsigned char byteValue() const {
return (unsigned char) this->value;
}
/**
* Answers the short value which the receiver represents
*
* @return int the value of the receiver.
*/
virtual short shortValue() const {
return (short) this->value;
}
/**
* Answers the int value which the receiver represents
*
* @return int the value of the receiver.
*/
virtual int intValue() const {
return (int) this->value;
}
/**
* Answers the long value which the receiver represents
*
* @return long the value of the receiver.
*/
virtual long long longValue() const {
return (long long) this->value;
}
public:
/**
* Returns a Character instance representing the specified char value.
*
* @param value
* the primitive char to wrap.
*
* @returns a new Character instance that wraps this value.
*/
static Character valueOf(char value) {
return Character(value);
}
/**
* Indicates whether or not the given character is considered
* whitespace.
*
* @param c
* The character whose value is being checked.
*
* @returns true if the character is a whitespace value.
*/
static bool isWhitespace(char c) {
switch (c) {
case '\n':
case '\t':
case '\r':
case '\f':
case ' ':
return true;
}
return false;
}
/**
* Indicates whether or not the given character is a digit.
*
* @param c
* The character whose value is being checked.
*
* @returns true if the character is a digit value.
*/
static bool isDigit(char c) {
return c >= '0' && c <= '9';
}
/**
* Indicates whether or not the given character is a lower case character.
*
* @param c
* The character whose value is being checked.
*
* @returns true if the character is a lower case ASCII value.
*/
static bool isLowerCase(char c) {
return c >= 'a' && c <= 'z';
}
/**
* Indicates whether or not the given character is
* a upper case character.
*
* @param c
* The character whose value is being checked.
*
* @returns true if the character is a upper case ASCII value.
*/
static bool isUpperCase(char c) {
return c >= 'A' && c <= 'Z';
}
/**
* Indicates whether or not the given character is a letter.
*
* @param c
* The character whose value is being checked.
*
* @returns true if the character is an ASCII letter value.
*/
static bool isLetter(char c) {
return isUpperCase(c) || isLowerCase(c);
}
/**
* Indicates whether or not the given character is
* either a letter or a digit.
*
* @param c
* The character whose value is being checked.
*
* @returns true if the character is an ASCII letter or numeric value.
*/
static bool isLetterOrDigit(char c) {
return isLetter(c) || isDigit(c);
}
/**
* Answers whether the character is an ISO control character, which
* is a char that lays in the range of 0 to 1f and 7f to 9f
* @param c
* the character, including supplementary characters
*
* @return true if the char is an ISO control character
*/
static bool isISOControl(char c) {
return (c >= 0 && c <= 0x1f) || ((unsigned char) c >= 0x7f && (unsigned char) c <= 0x9f);
}
/**
* Returns the numeric value of the character ch in the specified radix.
*
* If the radix is not in the range MIN_RADIX <= radix <= MAX_RADIX or if
* the value of ch is not a valid digit in the specified radix, -1 is
* returned. A character is a valid digit if at least one of the following
* is true:
*
* * The method isDigit is true of the character and the single-character
* decomposition is less than the specified radix. In this case the
* decimal digit value is returned.
* * The character is one of the uppercase Latin letters 'A' through 'Z'
* and its code is less than radix + 'A' - 10. In this case,
* ch - 'A' + 10 is returned.
* * The character is one of the lowercase Latin letters 'a' through 'z'
* and its code is less than radix + 'a' - 10. In this case,
* ch - 'a' + 10 is returned.
*
* @param c
* the char to be converted
* @param radix
* the radix of the number
*
* @returns the numeric value of the number represented in the given radix
*/
static int digit(char c, int radix);
/**
* Returns the lower case equivalent for the specified character if the
* character is an upper case letter. Otherwise, the specified character is
* returned unchanged.
*
* @param value
* the character to convert if needed.
*
* @return if value is an upper case character then its lower case
* counterpart, otherwise just returns value unchanged.
*/
static char toLowerCase(char value) {
if ('A' <= value && value <= 'Z') {
return (char) (value + ('a' - 'A'));
}
return value;
}
/**
* Returns the upper case equivalent for the specified character if the
* character is a lower case letter. Otherwise, the specified character is
* returned unchanged.
*
* @param value
* the character to convert to upper case if needed.
*
* @return if value is a lower case character then its upper case
* counterpart, otherwise just returns value unchanged.
*/
static char toUpperCase(char value) {
if ('a' <= value && value <= 'z') {
return (char) (value - ('a' - 'A'));
}
return value;
}
};
}}
#endif /*_DECAF_LANG_CHARACTER_H_*/