srecord: srecord::fletcher32 Class Reference

srecord 1.65.0

Loading...
Searching...
No Matches
srecord::fletcher32 Class Reference

The fletcher32 class is used to represent the running value of a 32-bit Fletcher's Checksum of a series of bytes. More...

`#include <fletcher32.h>`

## Public Member Functions
virtual | ~fletcher32 ()
| The destructor.
| fletcher32 ()
| The default constructor.
| fletcher32 (const fletcher32 &)
| The copy constructor.
fletcher32 & | operator= (const fletcher32 &)
| The assignment operator.
unsigned long | get () const
| The get method is used to obtain the running value of the cyclic redundancy check.
void | next (unsigned char)
| The next method is used to advance the state by one byte.
void | nextbuf (const void *, size_t)
| The nextbuf method is used to advance the state by a series of bytes.

## Detailed Description

The fletcher32 class is used to represent the running value of a 32-bit Fletcher's Checksum of a series of bytes.

http://en.wikipedia.org/wiki/Fletcher%27s_checksum

Fletcher's checksum is one of several types of checksum algorithms, which are relatively simple processes used by computers to check the integrity of data.

The implementation of the Fletcher-32 is very similar to the Adler-32 algorithm but several differences should be noted. Fletcher wraps around at modulo 65535 while Adler wraps at the prime 65521. In other words, Fletcher adds overflow bits (16-31) into its sum; while Adler multiplies those bits by 15, then adds the product into its sum. Fletcher-32 works on 16 bit data while Adler works on 8 bit data.

It is designed to overcome some of the inadequacies of simply summing all the bytes as in the original checksum. Fletcher's checksum, unlike the original checksum, can detect the inserting/deleting of zero value bytes, the reordering of bytes, and the incrementing and decrementing of bytes in opposite directions.

Fletcher's checksum is described in RFC 1146. You can also find information about generating (as well as verifying) such a checksum in Annex B of RFC 905.

Fletcher-32 is slightly more reliable than Adler-32.[1]

Definition at line 56 of file fletcher32.h.

## Constructor & Destructor Documentation

## ◆ ~fletcher32()

virtual srecord::fletcher32::~fletcher32 | ( |  | ) |
| virtual

The destructor.

## ◆ fletcher32() [1/2]

srecord::fletcher32::fletcher32 | ( |  | ) |

The default constructor.

Referenced by fletcher32(), and operator=().

## ◆ fletcher32() [2/2]

srecord::fletcher32::fletcher32 | ( | const fletcher32 & |  | ) |

The copy constructor.

References fletcher32().

## Member Function Documentation

## ◆ operator=()

fletcher32 & srecord::fletcher32::operator= | ( | const fletcher32 & |  | ) |

The assignment operator.

References fletcher32().

## ◆ get()

unsigned long srecord::fletcher32::get | ( |  | ) | const

The get method is used to obtain the running value of the cyclic redundancy check.

## ◆ next()

void srecord::fletcher32::next | ( | unsigned char |  | ) |

The next method is used to advance the state by one byte.

## ◆ nextbuf()

void srecord::fletcher32::nextbuf | ( | const void * | ,
|  | size_t | )

The nextbuf method is used to advance the state by a series of bytes.

The documentation for this class was generated from the following file:

- fletcher32.h