name: Checksum

synopsis:

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

#include <Checksum.h>

Checksum();
boolean compute();
boolean get();

Checksum cksum;
SysString str(L"Joe");
cksum.compute(str);
ulong result = cksum.get();

static const String CLASS_NAME = L"Checksum";

define algorithm choices:

enum ALGORITHM { CRC_16_CCITT = 0, CRC_16, CRC_12, MD5, DEF_ALGORITHM = CRC_16_CCITT };

define implementations:

enum IMPLEMENTATION { FAST = 0, SLOW, DEF_IMPLEMENTATION = FAST };

define an initial value for CRC:

static const ulong CRC_INITIAL_VALUE = 0;

define CRC polynomials:

static const ulong CRC_12_POLYNOMIAL = 05401;

static const ulong CRC_16_POLYNOMIAL = 0120001;

static const ulong CRC_16_CCITT_POLYNOMIAL = 0102010;

CRC checksums use a 256 length table:

static const long CRC_TABLE_LENGTH = 256;

ALGORITHM algorithm_d;

IMPLEMENTATION implementation_d;

ulong cksum_d;

declare a static debug level for all class instantiations:
```
static Integral::DEBUG debug_level_d;
```
static memory manager:
```
static MemoryManager mgr_d;
```
initialization flag:
```
boolean is_valid_d;
```
these implementations use a table lookup:
```
ulong crc_table_d[CRC_TABLE_LENGTH];
```

static const SysString& name();

static boolean diagnose(Integral::DEBUG debug_level);

debug methods:

static boolean setDebug(Integral::DEBUG level);

boolean debug(const unichar* message) const;

destructor/constructor(s):

~Checksum();

Checksum();

Checksum(const Checksum& arg);

operator= methods:

Checksum& operator=(const Checksum& arg_a);

i/o methods:

i/o methods are omitted because this class can't write itself to an Sof file

memory management methods:

static void* operator new(size_t size);

static void* operator new[](size_t size);

static void operator delete(void* ptr);

static void operator delete[](void* ptr);

static boolean setGrowSize(long grow_size);

boolean clear(Integral::CMODE ctype_a = Integral::DEF_CMODE);

boolean setAlgorithm(ALGORITHM algorithm);

boolean setImplementation(IMPLEMENTATION implementation);

ALGORITHM getAlgorithm() const;

IMPLEMENTATION getImplementation() const;

ulong get() const;

operator ulong() const;

boolean initCrc(ulong poly);

boolean computeCrcFast(const SysString& arg);

boolean computeCrcFast(const byte* input, long nbytes);

Checksum cksum;
String str(L"Joe");
cksum.compute(str);
ulong result = cksum.get();

Only CRC_16_CCITT, CRC_16, and CRC_12 are currently implemented in the FAST mode, since these are the most useful.
The SLOW mode, which calculates the checksums directly using polynomial division, are provided mainly for instructional purposes. They are significantly less efficient than the FAST versions, and are provided mainly for academic purposes.