#include <boost/cstdint.hpp> // for boost::uintmax_t #include <boost/integer.hpp> // for boost::uint_t #include <cstddef> // for std::size_t namespace boost { template < std::size_t Bits, uintmax_t TruncPoly > typename uint_t<Bits>::fast augmented_crc( void const *buffer, std::size_t byte_count, typename uint_t<Bits>::fast initial_remainder = 0u ); }
The boost::augmented_crc
function computes the augmented-style CRC of a data block. Like boost::crc
,
the first two template parameters are the WIDTH and POLY.
However, the INIT has moved to being a function parameter,
after the data block's starting address and byte length, defaulting to zero
if not given.
This function uses modulo-2 division at its most raw, and so forfeits the
REFIN, REFOUT, and XOROUT
attributes, setting them to 0
or
false
. Another difference from
boost::crc
is that a non-zero INIT
has to be skewed when used with this function. (No conversion functions are
currently given.)
The augmented_crc
function
can compute CRCs from distributed data, too:
unsigned combined_acrc_16( int block_count, ... ) {using namespace std; va_list ap; unsigned result = 0u; va_start( ap, block_count ); if ( block_count <= 0 ) goto finish; void const * bs = va_arg( ap, void const * ); size_t bl = va_arg( ap, size_t );
result = boost::augmented_crc<16, 0x1021u>( bs, bl ); while ( --block_count ) { bs = va_arg( ap, void const * ); bl = va_arg( ap, size_t ); result = boost::augmented_crc<16, 0x1021u>( bs, bl, result ); } finish: va_end( ap ); return result; }
No CRC operation throws, so there is no need for extra protection between the varargs macro calls. Feeding the result from the previous run as the initial remainder for the next run works easily because there's no output reflection or XOR mask.
C-style variable-argument routines are or may be macros. |
|
The parameters are based on |
Since augmented_crc
doesn't
know when your data ends, you must supply the augment, either WIDTH
zero bits or the expected checksum. The augment can be either at the end of
last data block or from an extra call. Remember that if an expected checksum
is used as the augment, its bits must be arranged in big-endian order. Because
augmented_crc
reads byte-wise,
while augments assume bit-wise reading, augmentations are valid only when
WIDTH is a multiple of the bits-per-byte ratio (CHAR_BIT
).