name: SysChar

synopsis:

g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_system.a

#include <SysChar.h>

SysChar();
SysChar(const SysChar& arg);
SysChar(byte* data, ENCODE encoding = DEF_ENCODE);

boolean assign(byte arg);

boolean isAlnum() const;
boolean isAlpha() const;
boolean isDigit() const;

quick start:

SysChar c0;
SysChar c1(c0);

c0.assign(L't');
c1.assign((byte)'e');

if ((!c0.isAlnum()) ||
   (!c1.isAlnum())) {
  Console::put(L"Error in isAlnum");
}

if ((!c0.isAlpha()) ||
   (!c1.isAlpha())) {
  Console::put(L"Error in isAlpha");
}

if ((c0.isDigit()) ||
    (c1.isDigit())) {
  Console::put(L"Error in isDigit");
}

description:

The SysChar class manages unicode characters. The SysChar class is implemented as an index into the Unicode standard list of characters. The class supports automatic conversion to and from UTF8 (which includes standard 7-bit ASCII) and UTF16 encoded byte streams. In the future this class will also support other character encoding formats, such as shift JIS and UEC.

The SysChar object may be assigned a value in many different ways. It can be directly passed a unicode index (in the form of a SysChar integral type), it can be passed a single byte, or it can be passed a byte-stream. When passed a single byte it assumes ASCII encoding. When passed a byte stream the default encoding is ASCII for byte streams as well as single bytes, but the user may specify any other coding for automatic conversion.

dependencies:

public constants:

define the class name:

static const SysString CLASS_NAME = L"SysChar";

define encoding constants:

static const byte UTF8_FIXED = 0x80;

static const unsigned short UTF16_FIXED = 0x0000;

define encoding flags & the default encoding:

enum ENCODE { ENCODE_ASCII = 0, ENCODE_UTF8, ENCODE_UTF16,DEF_ENCODE = ENCODE_ASCII };

define special characters:

static const SysChar NULLC = (SysChar)0;

static const SysChar SPACEC = L' ';

static const SysChar TILDE = L'~';

static const SysChar DOLLAR = L'$';

static const SysChar NEWLINE = L'\n';

define the default value(s) of the class data:
```
static const unichar DEF_VALUE = (unichar)0;
```

error codes:

error code indicating SysChar class general error:
```
static const long ERR = 1100;
```
error code indicating characters are not ascii:
```
static const long ERR_NOTASC = 1101;
```
error code indicating multi-bit UTF8 character encountered:
```
static const long ERR_UNUTF8 = 1102;
```
error code indicating multi-bit UTF16 character encountered:
```
static const long ERR_UNUTF16 = 1103;
```
error code indicating unknown encoding:
```
static const long ERR_UNKENC = 1104;
```

protected data:

define unichar character:

unichar value_d;

define debug level:
```
static Integral::DEBUG debug_level_d;
```

required public methods:

static methods:

static const SysString& name();

static boolean diagnose(Integral::DEBUG debug_level);

debug methods:

boolean debug(const unichar* message) const;

static boolean setDebug(Integral::DEBUG debug_level);

destructor/constructor(s):

~SysChar();

SysChar(unichar arg = DEF_VALUE);

SysChar(const SysChar& arg);

assign methods:
```
boolean assign(const SysChar& arg);
```
operator= methods:
```
SysChar& operator=(const SysChar& arg);
```

i/o methods:

these methods are omitted because this class can't write itself to an Sof file

equality methods:
```
boolean eq(const SysChar& arg) const;
```
memory management methods: the new and delete methods are omitted because only classes at the math library level and above are required to override new and delete
```
boolean clear(Integral::CMODE ctype);
```

class-specific public methods:

constructors:

SysChar(byte* data, ENCODE encoding = DEF_ENCODE);

assign methods:

boolean assign(byte arg);

boolean assign(unichar arg);

boolean assign(long& len, const byte* arg, ENCODE encoding = DEF_ENCODE);

boolean assign(const SysString& arg);

equality methods:

boolean eq(const unichar arg) const;

boolean ne(const SysChar& arg) const;

boolean ne(const unichar arg) const;

size methods:
```
long memSize() const;
```
casting methods:
```
operator unichar() const;
```

type conversion methods:

boolean get(byte& arg) const;

boolean get(unichar& arg) const;

boolean get(long& len, byte* arg, ENCODE encoding = DEF_ENCODE) const;

case conversion methods:
```
boolean toUpper();
```
```
boolean toLower();
```

character classification methods:

boolean isAlnum() const;

boolean isAlpha() const;

boolean isDigit() const;

boolean isLower() const;

boolean isPrint() const;

boolean isPunct() const;

boolean isSpace() const;

boolean isUpper() const;

relational methods:

boolean gt(const SysChar& arg) const;

boolean gt(unichar arg) const;

boolean lt(const SysChar& arg) const;

boolean lt(unichar arg) const;

boolean ge(const SysChar& arg) const;

boolean ge(unichar arg) const;

boolean le(const SysChar& arg) const;

boolean le(unichar arg) const;

private methods:

none

examples:

This is a simple example to check whether the declared Syschar data are alpha characters or digits:

SysChar c0;
SysChar c1(c0);
SysChar c2(L'e');
SysChar c3((byte*)"h");
SysChar c4(L'.');
SysChar c5(L'\n');
SysChar c6(L'9');
       
if ((c0.isAlnum()) ||
   (c1.isAlnum()) ||
   (!c2.isAlnum()) ||
   (!c3.isAlnum()) ||
   (c4.isAlnum()) ||
   (c5.isAlnum()) ||
   (!c6.isAlnum())) {
     Console::put(L"Error in isAlnum");
}

notes:

The SysChar class can turn the encoding into the actual bits based on the given format. SysChar uses wchar_t as its data member. Unicode is the universal character encoding standard used for representation of text for computer processing. This class provides methods for case conversion and comparison in relational and logical operations.