EIC code displayed by LXR master/​include/​boost/​crc.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-07-09 08:28:41

 //  Boost CRC library crc.hpp header file  -----------------------------------//
 
 //  Copyright 2001, 2004, 2011 Daryle Walker.
 //  Distributed under the Boost Software License, Version 1.0.  (See the
 //  accompanying file LICENSE_1_0.txt or a copy at
 //  <http://www.boost.org/LICENSE_1_0.txt>.)
 
 //  See <http://www.boost.org/libs/crc/> for the library's home page.
 
 /** \file
     \brief  A collection of function templates and class templates that compute
       various forms of Cyclic Redundancy Codes (CRCs).
 
     \author  Daryle Walker
 
     \version  1.5
 
     \copyright  Boost Software License, version 1.0
 
     Contains the declarations (and definitions) of various kinds of CRC
     computation functions, function object types, and encapsulated policy types.
 
     \warning  The sample CRC-computer types were just checked against the
       <a href="http://regregex.bbcmicro.net/crc-catalogue.htm">Catalogue of
       parametrised CRC algorithms</a>.  New type aliases were added where I got
       a standard wrong.  However, the mistaken <code>typedef</code>s are still
       there for backwards compatibility.
     \note  There are references to the <i>Rocksoft&trade; Model CRC
       Algorithm</i>, as described within \"A Painless Guide to CRC Error
       Detection Algorithms,\" linked from \"<a
       href="http://www.ross.net/crc/crcpaper.html">CRC: A Paper On CRCs</a>\" by
       Ross Williams.  It will be abbreviated \"RMCA\" in other documentation
       blocks.
  */
 
 #ifndef BOOST_CRC_HPP
 #define BOOST_CRC_HPP
 
 #include <array>        // for std::array
 #include <climits>      // for CHAR_BIT, etc.
 #include <cstddef>      // for std::size_t
 #include <cstdint>      // for UINTMAX_C, std::uintmax_t
 #include <limits>       // for std::numeric_limits
 #include <type_traits>  // for std::conditional, std::integral_constant
 
 // Local reimplementation of boost::uint_t, to avoid dependency on Integer
 
 namespace boost {
 namespace crc_detail {
 
 struct uint_t_8
 {
     typedef std::uint_least8_t least;
     typedef std::uint_fast8_t fast;
 };
 
 struct uint_t_16
 {
     typedef std::uint_least16_t least;
     typedef std::uint_fast16_t fast;
 };
 
 struct uint_t_32
 {
     typedef std::uint_least32_t least;
     typedef std::uint_fast32_t fast;
 };
 
 struct uint_t_64
 {
     typedef std::uint_least64_t least;
     typedef std::uint_fast64_t fast;
 };
 
 struct uint_t_none
 {
 };
 
 template<int Bits> struct uint_t:
     std::conditional< (Bits <=  8), uint_t_8,
     typename std::conditional< (Bits <= 16), uint_t_16,
     typename std::conditional< (Bits <= 32), uint_t_32,
     typename std::conditional< (Bits <= 64), uint_t_64,
     uint_t_none>::type>::type>::type>::type
 {
 };
 
 } // namespace crc_detail
 } // namespace boost
 
 // The type of CRC parameters that can go in a template should be related
 // on the CRC's bit count.  This macro expresses that type in a compact
 // form.
 #define BOOST_CRC_PARM_TYPE  typename ::boost::crc_detail::uint_t<Bits>::fast
 
 namespace boost
 {
 
 
 //  Forward declarations  ----------------------------------------------------//
 
 //! Bit-wise CRC computer
 template < std::size_t Bits >
     class crc_basic;
 
 //! Table-driven CRC computer, usable as a function object
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly = 0u,
            BOOST_CRC_PARM_TYPE InitRem = 0u,
            BOOST_CRC_PARM_TYPE FinalXor = 0u, bool ReflectIn = false,
            bool ReflectRem = false >
     class crc_optimal;
 
 //! Compute the (unaugmented) CRC of a memory block
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
     typename crc_detail::uint_t<Bits>::fast  crc( void const *buffer,
      std::size_t byte_count);
 
 //! Compute the CRC of a memory block, with any augmentation provided by user
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly >
     typename crc_detail::uint_t<Bits>::fast  augmented_crc( void const *buffer,
      std::size_t byte_count,
      typename crc_detail::uint_t<Bits>::fast initial_remainder = 0u);
 
 //! Computation type for ARC|CRC-16|CRC-IBM|CRC-16/ARC|CRC-16/LHA standard
 typedef crc_optimal<16, 0x8005, 0, 0, true, true>         crc_16_type;
 //! Computation type for CRC-16/CCITT-FALSE standard
 typedef crc_optimal<16, 0x1021, 0xFFFF, 0, false, false>  crc_ccitt_false_t;
 //! Computation type for the CRC mistakenly called the CCITT standard
 typedef crc_ccitt_false_t                                 crc_ccitt_type;
 //! Computation type for the actual
 //! KERMIT|CRC-16/CCITT|CRC-16/CCITT-TRUE|CRC-CCITT standard
 typedef crc_optimal<16, 0x1021, 0, 0, true, true>         crc_ccitt_true_t;
 //! Computation type that I mistakenly called the XMODEM standard; it inverts
 //! both reflection parameters and reflects the truncated divisor (Don't use?!)
 typedef crc_optimal<16, 0x8408, 0, 0, true, true>         crc_xmodem_type;
 //! Computation type for the actual XMODEM|ZMODEM|CRC-16/ACORN standard
 typedef crc_optimal<16, 0x1021, 0, 0, false, false>       crc_xmodem_t;
 
 //! Computation type for CRC-32|CRC-32/ADCCP|PKZIP standard
 typedef crc_optimal<32, 0x04C11DB7, 0xFFFFFFFF, 0xFFFFFFFF, true, true>
   crc_32_type;
 
 
 //  Forward declarations for implementation detail stuff  --------------------//
 //  (Just for the stuff that will be needed for the next two sections)
 
 //! \cond
 namespace detail
 {
     //! Mix-in class to add a possibly-reflecting member function
     template < int BitLength, bool DoIt, int Id = 0 >
         class possible_reflector;
 
     //! Mix-in class for byte-fed, table-driven CRC algorithms
     template < int Order, std::uintmax_t TruncatedPolynomial, bool Reflect,
      int Id = 0 >
     class crc_driver;
 
 }  // namespace detail
 //! \endcond
 
 
 //  Simple cyclic redundancy code (CRC) class declaration  -------------------//
 
 /** Objects of this type compute the CRC checksum of submitted data, where said
     data can be entered piecemeal through several different kinds of groupings.
     Modulo-2 polynomial division steps are always performed bit-wise, without
     the use of pre-computation tables.  Said division uses the altered
     algorithm, so any data has to be unaugmented.
 
     \pre  0 \< \a Bits \<= \c std\::numeric_limits\<uintmax_t\>\::digits
 
     \tparam Bits  The order of the modulo-2 polynomial divisor.  (\e Width from
       the RMCA)
  */
 template < std::size_t Bits >
 class crc_basic
 {
 public:
     // Type
     /** \brief  The register type used for computations
 
         This type is used for CRC calculations and is the type for any returned
         checksums and returned or submitted remainders, (truncated) divisors, or
         XOR masks.  It is a built-in unsigned integer type.
      */
     typedef typename boost::crc_detail::uint_t<Bits>::fast  value_type;
 
     // Constant for the template parameter
     //! A copy of \a Bits provided for meta-programming purposes
     static const std::size_t bit_count = Bits;
 
     // Constructor (use the automatic copy-ctr, move-ctr, and dtr)
     //! Create a computer, separately listing each needed parameter
     explicit  crc_basic( value_type truncated_polynomial,
                value_type initial_remainder = 0, value_type final_xor_value = 0,
                bool reflect_input = false, bool reflect_remainder = false );
 
     // Internal Operations
     //! Return the (truncated) polynomial divisor
     value_type  get_truncated_polynominal() const;
     //! Return what the polynomial remainder was set to during construction
     value_type  get_initial_remainder() const;
     //! Return the XOR-mask used during output processing
     value_type  get_final_xor_value() const;
     //! Check if input-bytes will be reflected before processing
     bool        get_reflect_input() const;
     //! Check if the remainder will be reflected during output processing
     bool        get_reflect_remainder() const;
 
     //! Return the remainder based from already-processed bits
     value_type  get_interim_remainder() const;
     //! Change the interim remainder to a new value
     void        reset( value_type new_rem );
     //! Change the interim remainder back to the initial value
     void        reset();
 
     // External Operations
     //! Submit a single bit for input processing
     void  process_bit( bool bit );
     //! Submit the lowest \a bit_length bits of a byte for input processing
     void  process_bits( unsigned char bits, std::size_t bit_length );
     //! Submit a single byte for input processing
     void  process_byte( unsigned char byte );
     //! Submit a memory block for input processing, iterator-pair style
     void  process_block( void const *bytes_begin, void const *bytes_end );
     //! Submit a memory block for input processing, pointer-and-size style
     void  process_bytes( void const *buffer, std::size_t byte_count );
 
     //! Return the checksum of the already-processed bits
     value_type  checksum() const;
 
 private:
     // Member data
     value_type  rem_;
     value_type  poly_, init_, final_;  // non-const to allow assignability
     bool        rft_in_, rft_out_;     // non-const to allow assignability
 
 };  // boost::crc_basic
 
 
 //  Optimized cyclic redundancy code (CRC) class declaration  ----------------//
 
 /** Objects of this type compute the CRC checksum of submitted data, where said
     data can be entered piecemeal through several different kinds of groupings.
     Modulo-2 polynomial division steps are performed byte-wise, aided by the use
     of pre-computation tables.  Said division uses the altered algorithm, so any
     data has to be unaugmented.
 
     \pre  0 \< \a Bits \<= \c std\::numeric_limits\<uintmax_t\>\::digits
 
     \tparam Bits  The order of the modulo-2 polynomial divisor.  (\e Width from
       the RMCA)
     \tparam TruncPoly  The lowest coefficients of the divisor polynomial.  The
       highest-order coefficient is omitted and always assumed to be 1.  Defaults
       to \c 0, i.e. the only non-zero term is the implicit one for
       x<sup><var>Bits</var></sup>.  (\e Poly from the RMCA)
     \tparam InitRem  The (unaugmented) initial state of the polynomial
       remainder.  Defaults to \c 0 if omitted.  (\e Init from the RMCA)
     \tparam FinalXor  The (XOR) bit-mask to be applied to the output remainder,
       after possible reflection but before returning.  Defaults to \c 0 (i.e. no
       bit changes) if omitted.  (\e XorOut from the RMCA)
     \tparam ReflectIn  If \c true, input bytes are read lowest-order bit first,
       otherwise highest-order bit first.  Defaults to \c false if omitted.
       (\e RefIn from the RMCA)
     \tparam ReflectRem  If \c true, the output remainder is reflected before the
       XOR-mask.  Defaults to \c false if omitted.  (\e RefOut from the RMCA)
 
     \todo  Get rid of the default value for \a TruncPoly.  Choosing a divisor is
       an important decision with many factors, so a default is never useful,
       especially a bad one.
  */
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 class crc_optimal
 {
 public:
     // Type
     //! \copydoc  boost::crc_basic::value_type
     typedef typename boost::crc_detail::uint_t<Bits>::fast  value_type;
 
     // Constants for the template parameters
     //! \copydoc  boost::crc_basic::bit_count
     static const std::size_t bit_count = Bits;
     //! A copy of \a TruncPoly provided for meta-programming purposes
     static const value_type truncated_polynominal = TruncPoly;
     //! A copy of \a InitRem provided for meta-programming purposes
     static const value_type initial_remainder = InitRem;
     //! A copy of \a FinalXor provided for meta-programming purposes
     static const value_type final_xor_value = FinalXor;
     //! A copy of \a ReflectIn provided for meta-programming purposes
     static const bool reflect_input = ReflectIn;
     //! A copy of \a ReflectRem provided for meta-programming purposes
     static const bool reflect_remainder = ReflectRem;
 
     // Constructor (use the automatic copy-ctr, move-ctr, and dtr)
     //! Create a computer, giving an initial remainder if desired
     explicit  crc_optimal( value_type init_rem = initial_remainder );
 
     // Internal Operations
     //! \copybrief  boost::crc_basic::get_truncated_polynominal
     value_type  get_truncated_polynominal() const;
     //! \copybrief  boost::crc_basic::get_initial_remainder
     value_type  get_initial_remainder() const;
     //! \copybrief  boost::crc_basic::get_final_xor_value
     value_type  get_final_xor_value() const;
     //! \copybrief  boost::crc_basic::get_reflect_input
     bool        get_reflect_input() const;
     //! \copybrief  boost::crc_basic::get_reflect_remainder
     bool        get_reflect_remainder() const;
 
     //! \copybrief  boost::crc_basic::get_interim_remainder
     value_type  get_interim_remainder() const;
     //! Change the interim remainder to either a given value or the initial one
     void        reset( value_type new_rem = initial_remainder );
 
     // External Operations
     //! \copybrief  boost::crc_basic::process_byte
     void  process_byte( unsigned char byte );
     //! \copybrief  boost::crc_basic::process_block
     void  process_block( void const *bytes_begin, void const *bytes_end );
     //! \copybrief  boost::crc_basic::process_bytes
     void  process_bytes( void const *buffer, std::size_t byte_count );
 
     //! \copybrief  boost::crc_basic::checksum
     value_type  checksum() const;
 
     // Operators
     //! Submit a single byte for input processing, suitable for the STL
     void        operator ()( unsigned char byte );
     //! Return the checksum of the already-processed bits, suitable for the STL
     value_type  operator ()() const;
 
 private:
     // Implementation types
     // (Processing for reflected input gives reflected remainders, so you only
     // have to apply output-reflection if Reflect-Remainder doesn't match
     // Reflect-Input.)
     typedef detail::possible_reflector<Bits, ReflectIn>     reflect_i_type;
     typedef detail::crc_driver<Bits, TruncPoly, ReflectIn>  crc_table_type;
     typedef detail::possible_reflector<Bits, ReflectRem != ReflectIn>
       reflect_o_type;
 
     // Member data
     value_type  rem_;
 
 };  // boost::crc_optimal
 
 
 //  Implementation detail stuff  ---------------------------------------------//
 
 //! \cond
 namespace detail
 {
     /** \brief  Meta-programming integral constant for a single-bit bit-mask
 
         Generates a compile-time constant for a bit-mask that affects a single
         bit.  The \c value will be 2<sup><var>BitIndex</var></sup>.  The \c type
         will be the smallest built-in unsigned integer type that can contain the
         value, unless there's a built-in type that the system can handle easier,
         then the \c type will be smallest fast-handled unsigned integer type.
 
         \pre  0 \<= BitIndex \< \c std\::numeric_limits\<uintmax_t\>\::digits
 
         \tparam BitIndex  The place of the sole set bit.
      */
     template < int BitIndex >
     struct high_bit_mask_c
         : std::integral_constant<typename boost::crc_detail::uint_t< BitIndex + 1 >::fast,
            ( UINTMAX_C(1) << BitIndex )>
     {};
 
     /** \brief  Meta-programming integral constant for a lowest-bits bit-mask
 
         Generates a compile-time constant for a bit-mask that affects the lowest
         bits.  The \c value will be 2<sup><var>BitCount</var></sup> - 1.  The
         \c type will be the smallest built-in unsigned integer type that can
         contain the value, unless there's a built-in type that the system can
         handle easier, then the \c type will be smallest fast-handled unsigned
         integer type.
 
         \pre  0 \<= BitCount \<= \c std\::numeric_limits\<uintmax_t\>\::digits
 
         \tparam BitCount  The number of lowest-placed bits set.
      */
     template < int BitCount >
     struct low_bits_mask_c
         : std::integral_constant<typename boost::crc_detail::uint_t< BitCount >::fast, (
            BitCount ? (( (( UINTMAX_C(1) << (BitCount - 1) ) - 1u) << 1 ) |
            UINTMAX_C( 1 )) : 0u )>
     {};
 
     /** \brief  Reflects the bits of a number
 
         Reverses the order of the given number of bits within a value.  For
         instance, if the given reflect count is 5, then the bit values for the
         16- and 1-place will switch and the 8- and 2-place will switch, leaving
         the other bits alone.  (The 4-place bit is in the middle, so it wouldn't
         change.)
 
         \pre  \a Unsigned is a built-in unsigned integer type
         \pre  0 \< word_length \<= \c std\::numeric_limits\<Unsigned\>\::digits
 
         \tparam Unsigned  The type of \a x.
 
         \param x  The value to be (partially) reflected.
         \param word_length  The number of low-order bits to reflect.  Defaults
           to the total number of value bits in \a Unsigned.
 
         \return  The (partially) reflected value.
 
         \todo  Check if this is the fastest way.
      */
     template < typename Unsigned >
     Unsigned  reflect_unsigned( Unsigned x, int word_length
      = std::numeric_limits<Unsigned>::digits )
     {
         for ( Unsigned  l = 1u, h = static_cast<Unsigned>(l << (word_length - 1)) ; h > l ; h >>= 1, l
          <<= 1 )
         {
             Unsigned const  m = h | l, t = x & m;
 
             if ( (t == h) || (t == l) )
                 x ^= m;
         }
 
         return x;
     }
 
     /** \brief  Make a byte-to-byte-reflection map
 
         Creates a mapping array so the results can be cached.  Uses
         #reflect_unsigned to generate the element values.
 
         \return  An array <var>a</var> such that, for a given byte value
           <var>i</var>, <code><var>a</var>[ <var>i</var> ]</code> resolves to
           the reflected value of <var>i</var>.
      */
     std::array< unsigned char, (UINTMAX_C( 1 ) << CHAR_BIT) >
     inline make_byte_reflection_table()
     {
         std::array<unsigned char, ( UINTMAX_C(1) << CHAR_BIT )>  result;
         unsigned char                                              i = 0u;
 
         do
             result[ i ] = reflect_unsigned( i );
         while ( ++i );
         return result;
     }
 
     /** \brief  Reflects the bits of a single byte
 
         Reverses the order of all the bits within a value.  For instance, the
         bit values for the 2<sup><code>CHAR_BIT</code> - 1</sup>- and 1-place
         will switch and the 2<sup><code>CHAR_BIT</code> - 2</sup>- and 2-place
         will switch, etc.
 
         \param x  The byte value to be reflected.
 
         \return  The reflected value.
 
         \note  Since this could be the most common type of reflection, and the
           number of states is relatively small, the implementation pre-computes
           and uses a table of all the results.
      */
     inline unsigned char  reflect_byte( unsigned char x )
     {
         static  std::array<unsigned char, ( UINTMAX_C(1) << CHAR_BIT )> const
           table = make_byte_reflection_table();
 
         return table[ x ];
     }
 
     /** \brief  Reflects some bits within a single byte
 
         Like #reflect_unsigned, except it takes advantage of any (long-term)
         speed gains #reflect_byte may bring.
 
         \pre  0 \< \a word_length \<= \c CHAR_BIT
 
         \param x  The value to be (partially) reflected.
         \param word_length  The number of low-order bits to reflect.
 
         \return  The (partially) reflected value.
      */
     inline  unsigned char  reflect_sub_byte( unsigned char x, int word_length )
     { return reflect_byte(x) >> (CHAR_BIT - word_length); }
 
     /** \brief  Possibly reflects the bits of a number
 
         Reverses the order of the given number of bits within a value.  For
         instance, if the given reflect count is 5, then the bit values for the
         16- and 1-place will switch and the 8- and 2-place will switch, leaving
         the other bits alone.  (The 4-place bit is in the middle, so it wouldn't
         change.)  This variant function allows the reflection be controlled by
         an extra parameter, in case the decision to use reflection is made at
         run-time.
 
         \pre  \a Unsigned is a built-in unsigned integer type
         \pre  0 \< word_length \<= \c std\::numeric_limits\<Unsigned\>\::digits
 
         \tparam Unsigned  The type of \a x.
 
         \param x  The value to be (partially) reflected.
         \param reflect  Controls whether \a x is actually reflected (\c true) or
           left alone (\c false).
         \param word_length  The number of low-order bits to reflect.  Defaults
           to the total number of value bits in \a Unsigned.
 
         \return  The possibly (partially) reflected value.
      */
     template < typename Unsigned >
     inline
     Unsigned  reflect_optionally( Unsigned x, bool reflect, int word_length
      = std::numeric_limits<Unsigned>::digits )
     { return reflect ? reflect_unsigned(x, word_length) : x; }
 
     /** \brief  Possibly reflects the bits of a single byte
 
         Uses #reflect_byte (if \a reflect is \c true).
 
         \param x  The byte value to be (possibly) reflected.
         \param reflect  Whether (\c true) or not (\c false) \a x is reflected.
 
         \return  <code><var>reflect</var> ? reflect_byte(<var>x</var>) :
           <var>x</var></code>
      */
     inline
     unsigned char  reflect_byte_optionally( unsigned char x, bool reflect )
     { return reflect ? reflect_byte(x) : x; }
 
     /** \brief  Update a CRC remainder by several bits, assuming a non-augmented
           message
 
         Performs several steps of division required by the CRC algorithm, giving
         a new remainder polynomial based on the divisor polynomial and the
         synthesized dividend polynomial (from the old remainder and the
         newly-provided input).  The computations assume that the CRC is directly
         exposed from the remainder, without any zero-valued bits augmented to
         the message bits.
 
         \pre  \a Register and \a Word are both built-in unsigned integer types
         \pre  0 \< \a register_length \<= std\::numeric_limits\<\a Register\>
           \::digits
         \pre  0 \< \a word_length \<= std\::numeric_limits\<\a Word\>\::digits
 
         \tparam Register  The type used for representing the remainder and
           divisor modulo-2 polynomials.  The bit at <code>2<sup>i</sup></code>
           is used as the coefficient of <i>x<sup>i</sup></i>.
         \tparam Word  The type used for storing the incoming terms of the
           dividend modulo-2 polynomial.  The bit at <code>2<sup>i</sup></code>
           is used as the coefficient of <i>x<sup>i</sup></i> when \a reflect is
           \c false, and the coefficient of <i>x<sup><var>word_length</var> - 1 -
           i</sup></i> otherwise.
 
         \param[in]     register_length  The number of significant low-order bits
           to be used from \a Register values.  It is the order of the modulo-2
           polynomial remainder and one less than the divisor's order.
         \param[in,out] remainder  The upper part of the dividend polynomial
           before division, and the remainder polynomial after.
         \param[in]     new_dividend_bits  The coefficients for the next
           \a word_length lowest terms of the dividend polynomial.
         \param[in]     truncated_divisor  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
         \param[in]     word_length  The number of lowest-order bits to read from
           \a new_dividend_bits.
         \param[in]     reflect  If \c false, read from the highest-order marked
           bit from \a new_dividend_bits and go down, as normal.  Otherwise,
           proceed from the lowest-order bit and go up.
 
         \note  This routine performs a modulo-2 polynomial division variant.
           The exclusive-or operations are applied in a different order, since
           that kind of operation is commutative and associative.  It also
           assumes that the zero-valued augment string was applied before this
           step, which means that the updated remainder can be directly used as
           the final CRC.
      */
     template < typename Register, typename Word >
     void  crc_modulo_word_update( int register_length, Register &remainder, Word
      new_dividend_bits, Register truncated_divisor, int word_length, bool
      reflect )
     {
         // Create this masking constant outside the loop.
         Register const  high_bit_mask = UINTMAX_C(1) << (register_length - 1);
 
         // The natural reading order for division is highest digit/bit first.
         // The "reflect" parameter switches this.  However, building a bit mask
         // for the lowest bit is the easiest....
         new_dividend_bits = reflect_optionally( new_dividend_bits, !reflect,
          word_length );
 
         // Perform modulo-2 division for each new dividend input bit
         for ( int  i = word_length ; i ; --i, new_dividend_bits >>= 1 )
         {
             // compare the new bit with the remainder's highest
             remainder ^= ( new_dividend_bits & 1u ) ? high_bit_mask : 0u;
 
             // perform modulo-2 division
             bool const  quotient = (remainder & high_bit_mask) != 0;
 
             remainder <<= 1;
             remainder ^= quotient ? truncated_divisor : 0u;
 
             // The quotient isn't used for anything, so don't keep it.
         }
 
         // Clear overflowed bits
         remainder &= (std::numeric_limits<Register>::max)() >> (std::numeric_limits<Register>::digits - register_length);
     }
 
     /** \brief  Update a CRC remainder by a single bit, assuming a non-augmented
           message
 
         Performs the next step of division required by the CRC algorithm, giving
         a new remainder polynomial based on the divisor polynomial and the
         synthesized dividend polynomial (from the old remainder and the
         newly-provided input).  The computations assume that the CRC is directly
         exposed from the remainder, without any zero-valued bits augmented to
         the message bits.
 
         \pre  \a Register is a built-in unsigned integer type
         \pre  0 \< \a register_length \<= std\::numeric_limits\<\a Register\>
           \::digits
 
         \tparam Register  The type used for representing the remainder and
           divisor modulo-2 polynomials.  The bit at <code>2<sup>i</sup></code>
           is used as the coefficient of <i>x<sup>i</sup></i>.
 
         \param[in]     register_length  The number of significant low-order bits
           to be used from \a Register values.  It is the order of the modulo-2
           polynomial remainder and one less than the divisor's order.
         \param[in,out] remainder  The upper part of the dividend polynomial
           before division, and the remainder polynomial after.
         \param[in]     new_dividend_bit  The coefficient for the constant term
           of the dividend polynomial.
         \param[in]     truncated_divisor  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
 
         \note  This routine performs a modulo-2 polynomial division variant.
           The exclusive-or operations are applied in a different order, since
           that kind of operation is commutative and associative.  It also
           assumes that the zero-valued augment string was applied before this
           step, which means that the updated remainder can be directly used as
           the final CRC.
      */
     template < typename Register >
     inline  void  crc_modulo_update( int register_length, Register &remainder,
      bool new_dividend_bit, Register truncated_divisor )
     {
         crc_modulo_word_update( register_length, remainder,
          static_cast<unsigned>(new_dividend_bit), truncated_divisor, 1, false );
     }
 
     /** \brief  Update a CRC remainder by several bits, assuming an augmented
           message
 
         Performs several steps of division required by the CRC algorithm, giving
         a new remainder polynomial based on the divisor polynomial and the
         synthesized dividend polynomial (from the old remainder and the
         newly-provided input).  The computations assume that a zero-valued
         string of bits will be appended to the message before extracting the
         CRC.
 
         \pre  \a Register and \a Word are both built-in unsigned integer types
         \pre  0 \< \a register_length \<= std\::numeric_limits\<\a Register\>
           \::digits
         \pre  0 \< \a word_length \<= std\::numeric_limits\<\a Word\>\::digits
 
         \tparam Register  The type used for representing the remainder and
           divisor modulo-2 polynomials.  The bit at <code>2<sup>i</sup></code>
           is used as the coefficient of <i>x<sup>i</sup></i>.
         \tparam Word  The type used for storing the incoming terms of the
           dividend modulo-2 polynomial.  The bit at <code>2<sup>i</sup></code>
           is used as the coefficient of <i>x<sup>i</sup></i> when \a reflect is
           \c false, and the coefficient of <i>x<sup><var>word_length</var> - 1 -
           i</sup></i> otherwise.
 
         \param[in]     register_length  The number of significant low-order bits
           to be used from \a Register values.  It is the order of the modulo-2
           polynomial remainder and one less than the divisor's order.
         \param[in,out] remainder  The upper part of the dividend polynomial
           before division, and the remainder polynomial after.
         \param[in]     new_dividend_bits  The coefficients for the next
           \a word_length lowest terms of the dividend polynomial.
         \param[in]     truncated_divisor  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
         \param[in]     word_length  The number of lowest-order bits to read from
           \a new_dividend_bits.
         \param[in]     reflect  If \c false, read from the highest-order marked
           bit from \a new_dividend_bits and go down, as normal.  Otherwise,
           proceed from the lowest-order bit and go up.
 
         \note  This routine performs straight-forward modulo-2 polynomial
           division.  It assumes that an augment string will be processed at the
           end of the message bits before doing CRC analysis.
         \todo  Use this function somewhere so I can test it.
      */
     template < typename Register, typename Word >
     void  augmented_crc_modulo_word_update( int register_length, Register
      &remainder, Word new_dividend_bits, Register truncated_divisor, int
      word_length, bool reflect )
     {
         // Create this masking constant outside the loop.
         Register const  high_bit_mask = UINTMAX_C(1) << (register_length - 1);
 
         // The natural reading order for division is highest digit/bit first.
         // The "reflect" parameter switches this.  However, building a bit mask
         // for the lowest bit is the easiest....
         new_dividend_bits = reflect_optionally( new_dividend_bits, !reflect,
          word_length );
 
         // Perform modulo-2 division for each new dividend input bit
         for ( int  i = word_length ; i ; --i, new_dividend_bits >>= 1 )
         {
             bool const  quotient = (remainder & high_bit_mask) != 0;
 
             remainder <<= 1;
             remainder |= new_dividend_bits & 1u;
             remainder ^= quotient ? truncated_divisor : 0u;
 
             // The quotient isn't used for anything, so don't keep it.
         }
     }
 
     /** \brief  Update a CRC remainder by a single bit, assuming an augmented
           message
 
         Performs the next step of division required by the CRC algorithm, giving
         a new remainder polynomial based on the divisor polynomial and the
         synthesized dividend polynomial (from the old remainder and the
         newly-provided input).  The computations assume that a zero-valued
         string of bits will be appended to the message before extracting the
         CRC.
 
         \pre  \a Register is a built-in unsigned integer type
         \pre  0 \< \a register_length \<= std\::numeric_limits\<\a Register\>
           \::digits
 
         \tparam Register  The type used for representing the remainder and
           divisor modulo-2 polynomials.  The bit at <code>2<sup>i</sup></code>
           is used as the coefficient of <i>x<sup>i</sup></i>.
 
         \param[in]     register_length  The number of significant low-order bits
           to be used from \a Register values.  It is the order of the modulo-2
           polynomial remainder and one less than the divisor's order.
         \param[in,out] remainder  The upper part of the dividend polynomial
           before division, and the remainder polynomial after.
         \param[in]     new_dividend_bit  The coefficient for the constant term
           of the dividend polynomial.
         \param[in]     truncated_divisor  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
 
         \note  This routine performs straight-forward modulo-2 polynomial
           division.  It assumes that an augment string will be processed at the
           end of the message bits before doing CRC analysis.
         \todo  Use this function somewhere so I can test it.
      */
     template < typename Register >
     inline  void  augmented_crc_modulo_update( int register_length, Register
      &remainder, bool new_dividend_bit, Register truncated_divisor )
     {
         augmented_crc_modulo_word_update( register_length, remainder,
          static_cast<unsigned>(new_dividend_bit), truncated_divisor, 1, false );
     }
 
     /** \brief  A mix-in class that returns its argument
 
         This class template makes a function object that returns its argument
         as-is.  It's one case for #possible_reflector.
 
         \pre  0 \< \a BitLength \<= \c std\::numeric_limits\<uintmax_t\>
           \::digits
 
         \tparam BitLength  How many significant bits arguments have.
      */
     template < int BitLength >
     class non_reflector
     {
     public:
         /** \brief  The type to check for specialization
 
             This is a Boost integral constant indicating that this class
             does not reflect its input values.
          */
         typedef std::false_type                 is_reflecting_type;
         /** \brief  The type to check for register bit length
 
             This is a Boost integral constant indicating how many
             significant bits won't actually be reflected.
          */
         typedef std::integral_constant< int, BitLength >      width_c;
         /** \brief  The type of (not-)reflected values
 
             This type is the input and output type for the (possible-)
             reflection function, which does nothing here.
          */
         typedef typename boost::crc_detail::uint_t< BitLength >::fast  value_type;
 
         /** \brief  Does nothing
 
             Returns the given value, not reflecting any part of it.
 
             \param x  The value to not be reflected.
 
             \return  \a x
          */
         inline  static  value_type  reflect_q( value_type x )
         { return x; }
     };
 
     /** \brief  A mix-in class that reflects (the lower part of) its argument,
           generally for types larger than a byte
 
         This class template makes a function object that returns its argument
         after reflecting its lower-order bits.  It's one sub-case for
         #possible_reflector.
 
         \pre  \c CHAR_BIT \< \a BitLength \<= \c std\::numeric_limits\<uintmax_t
           \>\::digits
 
         \tparam BitLength  How many significant bits arguments have.
      */
     template < int BitLength >
     class super_byte_reflector
     {
     public:
         /** \brief  The type to check for specialization
 
             This is a Boost integral constant indicating that this class
             does reflect its input values.
          */
         typedef std::true_type                  is_reflecting_type;
         /** \brief  The type to check for register bit length
 
             This is a Boost integral constant indicating how many
             significant bits will be reflected.
          */
         typedef std::integral_constant< int, BitLength >      width_c;
         /** \brief  The type of reflected values
 
             This is both the input and output type for the reflection function.
          */
         typedef typename boost::crc_detail::uint_t< BitLength >::fast  value_type;
 
         /** \brief  Reflect (part of) the given value
 
             Reverses the order of the given number of bits within a value,
             using #reflect_unsigned.
 
             \param x  The value to be (partially) reflected.
 
             \return  ( <var>x</var> &amp;
               ~(2<sup><var>width_c</var>\::value</sup> - 1) ) | REFLECT(
               <var>x</var> &amp; (2<sup><var>width_c</var>\::value</sup> -
               1) )
          */
         inline  static  value_type  reflect_q( value_type x )
         { return reflect_unsigned(x, width_c::value); }
     };
 
     /** \brief  A mix-in class that reflects (the lower part of) its argument,
           generally for bytes
 
         This class template makes a function object that returns its argument
         after reflecting its lower-order bits.  It's one sub-case for
         #possible_reflector.
 
         \pre  0 \< \a BitLength \<= \c CHAR_BIT
 
         \tparam BitLength  How many significant bits arguments have.
      */
     template < int BitLength >
     class sub_type_reflector
     {
     public:
         /** \brief  The type to check for specialization
 
             This is a Boost integral constant indicating that this class
             does reflect its input values.
          */
         typedef std::true_type              is_reflecting_type;
         /** \brief  The type to check for register bit length
 
             This is a Boost integral constant indicating how many
             significant bits will be reflected.
          */
         typedef std::integral_constant< int, BitLength >  width_c;
         /** \brief  The type of reflected values
 
             This is both the input and output type for the reflection function.
          */
         typedef unsigned char                          value_type;
 
         /** \brief  Reflect (part of) the given value
 
             Reverses the order of the given number of bits within a value,
             using #reflect_sub_byte.
 
             \param x  The value to be (partially) reflected.
 
             \return  ( <var>x</var> &amp;
               ~(2<sup><var>width_c</var>\::value</sup> - 1) ) | REFLECT(
               <var>x</var> &amp; (2<sup><var>width_c</var>\::value</sup> -
               1) )
          */
         inline  static  value_type  reflect_q( value_type x )
         { return reflect_sub_byte(x, width_c::value); }
     };
 
     /** \brief  A mix-in class that reflects (the lower part of) its argument
 
         This class template makes a function object that returns its argument
         after reflecting its lower-order bits.  It's one case for
         #possible_reflector.
 
         \pre  0 \< \a BitLength \<= \c std\::numeric_limits\<uintmax_t\>
           \::digits
 
         \tparam BitLength  How many significant bits arguments have.
      */
     template < int BitLength >
     class reflector
         : public std::conditional< (BitLength > CHAR_BIT),
           super_byte_reflector<BitLength>, sub_type_reflector<BitLength> >::type
     { };
 
     /** This class template adds a member function #reflect_q that will
         conditionally reflect its first argument, controlled by a compile-time
         parameter.
 
         \pre  0 \< \a BitLength \<= \c std\::numeric_limits\<uintmax_t\>
           \::digits
 
         \tparam BitLength  How many significant bits arguments have.
         \tparam DoIt  \c true if #reflect_q will reflect, \c false if it should
           return its argument unchanged.
         \tparam Id  An extra differentiator if multiple copies of this class
           template are mixed-in as base classes.  Defaults to 0 if omitted.
      */
     template < int BitLength, bool DoIt, int Id >
     class possible_reflector
         : public std::conditional< DoIt, reflector<BitLength>,
           non_reflector<BitLength> >::type
     {
     public:
         /** \brief  The type to check for ID
 
             This is a Boost integral constant indicating what ID number this
             instantiation used.
          */
         typedef std::integral_constant<int, Id>  id_type;
     };
 
     /** \brief  Find the composite remainder update effect from a fixed bit
           sequence, for each potential sequence combination.
 
         For each value between 0 and 2<sup><var>SubOrder</var></sup> - 1,
         computes the XOR mask corresponding to the composite effect they update
         the incoming remainder, which is the upper part of the dividend that
         gets (partially) pushed out of its register by the incoming value's
         bits.  The composite value merges the \"partial products\" from each bit
         of the value being updated individually.
 
         \pre  \a Register is a built-in unsigned integer type
         \pre  0 \< \a SubOrder \<= \a register_length \<=
           std\::numeric_limits\<\a Register\>\::digits
 
         \tparam SubOrder  The number of low-order significant bits of the trial
           new dividends.
         \tparam Register  The type used for representing the remainder and
           divisor modulo-2 polynomials.  The bit at <code>2<sup>i</sup></code>
           is used as the coefficient of <i>x<sup>i</sup></i>.
 
         \param[in] register_length  The number of significant low-order bits
           to be used from \a Register values.  It is the order of the modulo-2
           polynomial remainder and one less than the divisor's order.
         \param[in] truncated_divisor  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
         \param[in] reflect  If \c false, read from the highest-order marked
           bit from a new dividend's bits and go down, as normal.  Otherwise,
           proceed from the lowest-order bit and go up.
 
         \return  An array such that the element at index <var>i</var> is the
           composite effect XOR mask for value <var>i</var>.
 
         \note  This routine performs a modulo-2 polynomial division variant.
           The exclusive-or operations are applied in a different order, since
           that kind of operation is commutative and associative.  It also
           assumes that the zero-valued augment string was applied before this
           step, which means that the updated remainder can be directly used as
           the final CRC.
         \todo  Check that using the unaugmented-CRC division routines give the
           same composite mask table as using augmented-CRC routines.
      */
     template < int SubOrder, typename Register >
     std::array< Register, (UINTMAX_C( 1 ) << SubOrder) >
     make_partial_xor_products_table( int register_length, Register
      truncated_divisor, bool reflect )
     {
         std::array<Register, ( UINTMAX_C(1) << SubOrder )>  result = { 0 };
 
         // Loop over every possible dividend value
         for ( typename boost::crc_detail::uint_t<SubOrder + 1>::fast  dividend = 0u;
          dividend < result.size() ; ++dividend )
         {
             Register  remainder = 0u;
 
             crc_modulo_word_update( register_length, remainder, dividend,
              truncated_divisor, SubOrder, false );
             result[ reflect_optionally(dividend, reflect, SubOrder) ] =
              reflect_optionally( remainder, reflect, register_length );
         }
         return result;
     }
 
     /** \brief  A mix-in class for the table of table-driven CRC algorithms
 
         Encapsulates the parameters need to make a global (technically,
         class-static) table usuable in CRC algorithms, and generates said
         table.
 
         \pre  0 \< \a SubOrder \<= Order \<=
           std\::numeric_limits\<uintmax_t\>\::digits
 
         \tparam Order  The order of the modulo-2 polynomial remainder and one
           less than the divisor's order.
         \tparam SubOrder  The number of low-order significant bits of the trial
           new dividends.
         \tparam TruncatedPolynomial  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
         \tparam Reflect  If \c false, read from the highest-order marked
           bit from a new dividend's bits and go down, as normal.  Otherwise,
           proceed from the lowest-order bit and go up.
      */
     template < int Order, int SubOrder, std::uintmax_t TruncatedPolynomial,
      bool Reflect >
     class crc_table_t
     {
     public:
         /** \brief  The type to check for register bit length
 
             This is a Boost integral constant indicating how many
             significant bits are in the remainder and (truncated) divisor.
          */
         typedef std::integral_constant< int, Order >              width_c;
         /** \brief  The type to check for index-unit bit length
 
             This is a Boost integral constant indicating how many
             significant bits are in the trial new dividends.
          */
         typedef std::integral_constant< int, SubOrder >      unit_width_c;
         /** \brief  The type of registers
 
             This is the output type for the partial-product map.
          */
         typedef typename boost::crc_detail::uint_t< Order >::fast          value_type;
         /** \brief  The type to check the divisor
 
             This is a Boost integral constant representing the (truncated)
             divisor.
          */
         typedef std::integral_constant< value_type, TruncatedPolynomial >
           poly_c;
         /** \brief  The type to check for reflection
 
             This is a Boost integral constant representing whether input
             units should be read in reverse order.
          */
         typedef std::integral_constant< bool, Reflect >           refin_c;
         /** \brief  The type to check for map size
 
             This is a Boost integral constant representing the number of
             elements in the partial-product map, based on the unit size.
          */
         typedef high_bit_mask_c< SubOrder >                  table_size_c;
         /** \brief  The type of the unit TO partial-product map
 
             This is the array type that takes units as the index and said unit's
             composite partial-product mask as the element.
          */
         typedef std::array<value_type, table_size_c::value>  array_type;
         /** \brief  Create a global array for the mapping table
 
             Creates an instance of a partial-product array with this class's
             parameters.
 
             \return  A reference to a immutable array giving the partial-product
               update XOR map for each potential sub-unit value.
          */
         static  array_type const &  get_table()
         {
             static  array_type const  table =
              make_partial_xor_products_table<unit_width_c::value>(
              width_c::value, poly_c::value, refin_c::value );
 
             return table;
         }
     };
 
     /** \brief  A mix-in class that handles direct (i.e. non-reflected) byte-fed
           table-driven CRC algorithms
 
         This class template adds member functions #augmented_crc_update and
         #crc_update to update remainders from new input bytes.  The bytes aren't
         reflected before processing.
 
         \pre  \c CHAR_BIT \<= \a Order \<= \c std\::numeric_limits\<uintmax_t\>
           \::digits
 
         \tparam Order  The order of the modulo-2 polynomial remainder and one
           less than the divisor's order.
         \tparam TruncatedPolynomial  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
      */
     template < int Order, std::uintmax_t TruncatedPolynomial >
     class direct_byte_table_driven_crcs
         : public crc_table_t<Order, CHAR_BIT, TruncatedPolynomial, false>
     {
         typedef crc_table_t<Order, CHAR_BIT, TruncatedPolynomial, false>
           base_type;
 
     public:
         typedef typename base_type::value_type  value_type;
         typedef typename base_type::array_type  array_type;
 
         /** \brief  Compute the updated remainder after reading some bytes
 
             The implementation reads from a table to speed-up applying
             augmented-CRC updates byte-wise.
 
             \param remainder  The pre-update remainder
             \param new_dividend_bytes  The address where the new bytes start
             \param new_dividend_byte_count  The number of new bytes to read
 
             \return  The updated remainder
          */
         static  value_type  augmented_crc_update( value_type remainder, unsigned
          char const *new_dividend_bytes, std::size_t new_dividend_byte_count)
         {
             static  array_type const &  table = base_type::get_table();
 
             while ( new_dividend_byte_count-- )
             {
                 // Locates the merged partial product based on the leading byte
                 unsigned char const  index = ( remainder >> (Order - CHAR_BIT) )
                  & UCHAR_MAX;
 
                 // Complete the multi-bit modulo-2 polynomial division
                 remainder <<= CHAR_BIT;
                 remainder |= *new_dividend_bytes++;
                 remainder ^= table[ index ];
             }
 
             return remainder;
         }
 
         /** \brief  Compute the updated remainder after reading some bytes
 
             The implementation reads from a table to speed-up applying
             unaugmented-CRC updates byte-wise.
 
             \param remainder  The pre-update remainder
             \param new_dividend_bytes  The address where the new bytes start
             \param new_dividend_byte_count  The number of new bytes to read
 
             \return  The updated remainder
          */
         static  value_type  crc_update( value_type remainder, unsigned char
          const *new_dividend_bytes, std::size_t new_dividend_byte_count)
         {
             static  array_type const &  table = base_type::get_table();
 
             while ( new_dividend_byte_count-- )
             {
                 // Locates the merged partial product based on comparing the
                 // leading and incoming bytes
                 unsigned char const  index = ( (remainder >> ( Order - CHAR_BIT
                  )) & UCHAR_MAX ) ^ *new_dividend_bytes++;
 
                 // Complete the multi-bit altered modulo-2 polynomial division
                 remainder <<= CHAR_BIT;
                 remainder ^= table[ index ];
             }
 
             return remainder;
         }
     };
 
     /** \brief  A mix-in class that handles reflected byte-fed, table-driven CRC
           algorithms
 
         This class template adds member functions #augmented_crc_update and
         #crc_update to update remainders from new input bytes.  The bytes are
         reflected before processing.
 
         \pre  \c CHAR_BIT \<= \a Order \<= \c std\::numeric_limits\<uintmax_t\>
           \::digits
 
         \tparam Order  The order of the modulo-2 polynomial remainder and one
           less than the divisor's order.
         \tparam TruncatedPolynomial  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
      */
     template < int Order, std::uintmax_t TruncatedPolynomial >
     class reflected_byte_table_driven_crcs
         : public crc_table_t<Order, CHAR_BIT, TruncatedPolynomial, true>
     {
         typedef crc_table_t<Order, CHAR_BIT, TruncatedPolynomial, true>
           base_type;
 
     public:
         typedef typename base_type::value_type  value_type;
         typedef typename base_type::array_type  array_type;
 
         /** \brief  Compute the updated remainder after reading some bytes
 
             The implementation reads from a table to speed-up applying
             reflecting augmented-CRC updates byte-wise.
 
             \param remainder  The pre-update remainder; since the bytes are
               being reflected, this remainder also has to be reflected
             \param new_dividend_bytes  The address where the new bytes start
             \param new_dividend_byte_count  The number of new bytes to read
 
             \return  The updated, reflected remainder
          */
         static  value_type  augmented_crc_update( value_type remainder, unsigned
          char const *new_dividend_bytes, std::size_t new_dividend_byte_count)
         {
             static  array_type const &  table = base_type::get_table();
 
             while ( new_dividend_byte_count-- )
             {
                 // Locates the merged partial product based on the leading byte
                 // (which is at the low-order end for reflected remainders)
                 unsigned char const  index = remainder & UCHAR_MAX;
 
                 // Complete the multi-bit reflected modulo-2 polynomial division
                 remainder >>= CHAR_BIT;
                 remainder |= static_cast<value_type>( *new_dividend_bytes++ )
                  << ( Order - CHAR_BIT );
                 remainder ^= table[ index ];
             }
 
             return remainder;
         }
 
         /** \brief  Compute the updated remainder after reading some bytes
 
             The implementation reads from a table to speed-up applying
             reflected unaugmented-CRC updates byte-wise.
 
             \param remainder  The pre-update remainder; since the bytes are
               being reflected, this remainder also has to be reflected
             \param new_dividend_bytes  The address where the new bytes start
             \param new_dividend_byte_count  The number of new bytes to read
 
             \return  The updated, reflected remainder
          */
         static  value_type  crc_update( value_type remainder, unsigned char
          const *new_dividend_bytes, std::size_t new_dividend_byte_count)
         {
             static  array_type const &  table = base_type::get_table();
 
             while ( new_dividend_byte_count-- )
             {
                 // Locates the merged partial product based on comparing the
                 // leading and incoming bytes
                 unsigned char const  index = ( remainder & UCHAR_MAX ) ^
                  *new_dividend_bytes++;
 
                 // Complete the multi-bit reflected altered modulo-2 polynomial
                 // division
                 remainder >>= CHAR_BIT;
                 remainder ^= table[ index ];
             }
 
             return remainder;
         }
     };
 
     /** \brief  Mix-in class for byte-fed, table-driven CRC algorithms with
           parameter values at least a byte in width
 
         This class template adds member functions #augmented_crc_update and
         #crc_update to update remainders from new input bytes.  The bytes may be
         reflected before processing, controlled by a compile-time parameter.
 
         \pre  \c CHAR_BIT \<= \a Order \<= \c std\::numeric_limits\<uintmax_t\>
           \::digits
 
         \tparam Order  The order of the modulo-2 polynomial remainder and one
           less than the divisor's order.
         \tparam TruncatedPolynomial  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
         \tparam Reflect  If \c false, read from the highest-order bit from a new
           input byte and go down, as normal.  Otherwise, proceed from the
           lowest-order bit and go up.
      */
     template < int Order, std::uintmax_t TruncatedPolynomial, bool Reflect >
     class byte_table_driven_crcs
         : public std::conditional< Reflect,
           reflected_byte_table_driven_crcs<Order, TruncatedPolynomial>,
           direct_byte_table_driven_crcs<Order, TruncatedPolynomial> >::type
     { };
 
     /** \brief  A mix-in class that handles direct (i.e. non-reflected) byte-fed
           CRC algorithms for sub-byte parameters
 
         This class template adds member functions #augmented_crc_update and
         #crc_update to update remainders from new input bytes.  The bytes aren't
         reflected before processing.
 
         \pre  0 \< \a Order \< \c CHAR_BIT
 
         \tparam Order  The order of the modulo-2 polynomial remainder and one
           less than the divisor's order.
         \tparam TruncatedPolynomial  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
      */
     template < int Order, std::uintmax_t TruncatedPolynomial >
     class direct_sub_byte_crcs
         : public crc_table_t<Order, Order, TruncatedPolynomial, false>
     {
         typedef crc_table_t<Order, Order, TruncatedPolynomial, false>
           base_type;
 
     public:
         typedef typename base_type::width_c     width_c;
         typedef typename base_type::value_type  value_type;
         typedef typename base_type::poly_c       poly_c;
         typedef typename base_type::array_type  array_type;
 
         /** \brief  Compute the updated remainder after reading some bytes
 
             The implementation reads from a table to speed-up applying
             augmented-CRC updates byte-wise.
 
             \param remainder  The pre-update remainder
             \param new_dividend_bytes  The address where the new bytes start
             \param new_dividend_byte_count  The number of new bytes to read
 
             \return  The updated remainder
 
             \todo  Use this function somewhere so I can test it.
          */
         static  value_type  augmented_crc_update( value_type remainder, unsigned
          char const *new_dividend_bytes, std::size_t new_dividend_byte_count)
         {
             //static  array_type const &  table = base_type::get_table();
 
             while ( new_dividend_byte_count-- )
             {
                 // Without a table, process each byte explicitly
                 augmented_crc_modulo_word_update( width_c::value, remainder,
                  *new_dividend_bytes++, poly_c::value, CHAR_BIT, false );
             }
 
             return remainder;
         }
 
         /** \brief  Compute the updated remainder after reading some bytes
 
             The implementation reads from a table to speed-up applying
             unaugmented-CRC updates byte-wise.
 
             \param remainder  The pre-update remainder
             \param new_dividend_bytes  The address where the new bytes start
             \param new_dividend_byte_count  The number of new bytes to read
 
             \return  The updated remainder
          */
         static  value_type  crc_update( value_type remainder, unsigned char
          const *new_dividend_bytes, std::size_t new_dividend_byte_count)
         {
             //static  array_type const &  table = base_type::get_table();
 
             while ( new_dividend_byte_count-- )
             {
                 // Without a table, process each byte explicitly
                 crc_modulo_word_update( width_c::value, remainder,
                  *new_dividend_bytes++, poly_c::value, CHAR_BIT, false );
             }
 
             return remainder;
         }
     };
 
     /** \brief  A mix-in class that handles reflected byte-fed, CRC algorithms
           for sub-byte parameters
 
         This class template adds member functions #augmented_crc_update and
         #crc_update to update remainders from new input bytes.  The bytes are
         reflected before processing.
 
         \pre  0 \< \a Order \< \c CHAR_BIT
 
         \tparam Order  The order of the modulo-2 polynomial remainder and one
           less than the divisor's order.
         \tparam TruncatedPolynomial  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
      */
     template < int Order, std::uintmax_t TruncatedPolynomial >
     class reflected_sub_byte_crcs
         : public crc_table_t<Order, Order, TruncatedPolynomial, true>
     {
         typedef crc_table_t<Order, Order, TruncatedPolynomial, true>
           base_type;
 
     public:
         typedef typename base_type::width_c     width_c;
         typedef typename base_type::value_type  value_type;
         typedef typename base_type::poly_c       poly_c;
         typedef typename base_type::array_type  array_type;
 
         /** \brief  Compute the updated remainder after reading some bytes
 
             The implementation reads from a table to speed-up applying
             reflecting augmented-CRC updates byte-wise.
 
             \param remainder  The pre-update remainder; since the bytes are
               being reflected, this remainder also has to be reflected
             \param new_dividend_bytes  The address where the new bytes start
             \param new_dividend_byte_count  The number of new bytes to read
 
             \return  The updated, reflected remainder
 
             \todo  Use this function somewhere so I can test it.
          */
         static  value_type  augmented_crc_update( value_type remainder, unsigned
          char const *new_dividend_bytes, std::size_t new_dividend_byte_count)
         {
             //static  array_type const &  table = base_type::get_table();
 
             remainder = reflect_sub_byte( remainder, width_c::value );
             while ( new_dividend_byte_count-- )
             {
                 // Without a table, process each byte explicitly
                 augmented_crc_modulo_word_update( width_c::value, remainder,
                  *new_dividend_bytes++, poly_c::value, CHAR_BIT, true );
             }
             remainder = reflect_sub_byte( remainder, width_c::value );
 
             return remainder;
         }
 
         /** \brief  Compute the updated remainder after reading some bytes
 
             The implementation reads from a table to speed-up applying
             reflected unaugmented-CRC updates byte-wise.
 
             \param remainder  The pre-update remainder; since the bytes are
               being reflected, this remainder also has to be reflected
             \param new_dividend_bytes  The address where the new bytes start
             \param new_dividend_byte_count  The number of new bytes to read
 
             \return  The updated, reflected remainder
          */
         static  value_type  crc_update( value_type remainder, unsigned char
          const *new_dividend_bytes, std::size_t new_dividend_byte_count)
         {
             //static  array_type const &  table = base_type::get_table();
 
             remainder = reflect_sub_byte( remainder, width_c::value );
             while ( new_dividend_byte_count-- )
             {
                 // Without a table, process each byte explicitly
                 crc_modulo_word_update( width_c::value, remainder,
                  *new_dividend_bytes++, poly_c::value, CHAR_BIT, true );
             }
             remainder = reflect_sub_byte( remainder, width_c::value );
 
             return remainder;
         }
     };
 
     /** \brief  Mix-in class for byte-fed, table-driven CRC algorithms with
           sub-byte parameters
 
         This class template adds member functions #augmented_crc_update and
         #crc_update to update remainders from new input bytes.  The bytes may be
         reflected before processing, controlled by a compile-time parameter.
 
         \pre  0 \< \a Order \< \c CHAR_BIT
 
         \tparam Order  The order of the modulo-2 polynomial remainder and one
           less than the divisor's order.
         \tparam TruncatedPolynomial  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
         \tparam Reflect  If \c false, read from the highest-order bit from a new
           input byte and go down, as normal.  Otherwise, proceed from the
           lowest-order bit and go up.
      */
     template < int Order, std::uintmax_t TruncatedPolynomial, bool Reflect >
     class sub_byte_crcs
         : public std::conditional< Reflect,
           reflected_sub_byte_crcs<Order, TruncatedPolynomial>,
           direct_sub_byte_crcs<Order, TruncatedPolynomial> >::type
     { };
 
     /** This class template adds member functions #augmented_crc_update and
         #crc_update to update remainders from new input bytes.  The bytes may be
         reflected before processing, controlled by a compile-time parameter.
 
         \pre  0 \< \a Order \<= \c std\::numeric_limits\<uintmax_t\>\::digits
 
         \tparam Order  The order of the modulo-2 polynomial remainder and one
           less than the divisor's order.
         \tparam TruncatedPolynomial  The lowest coefficients of the divisor
           polynomial.  The highest-order coefficient is omitted and always
           assumed to be 1.
         \tparam Reflect  If \c false, read from the highest-order bit from a new
           input byte and go down, as normal.  Otherwise, proceed from the
           lowest-order bit and go up.
         \tparam Id  An extra differentiator if multiple copies of this class
           template are mixed-in as base classes.  Defaults to 0 if omitted.
      */
     template < int Order, std::uintmax_t TruncatedPolynomial, bool Reflect,
      int Id >
     class crc_driver
         : public std::conditional< (Order < CHAR_BIT), sub_byte_crcs<Order,
           TruncatedPolynomial, Reflect>, byte_table_driven_crcs<Order,
           TruncatedPolynomial, Reflect> >::type
     {
     public:
         /** \brief  The type to check for ID
 
             This is a Boost integral constant indicating what ID number this
             instantiation used.
          */
         typedef std::integral_constant<int, Id>  id_type;
     };
 
 
 }  // namespace detail
 //! \endcond
 
 
 //  Simple CRC class function definitions  -----------------------------------//
 
 /** Constructs a \c crc_basic object with at least the required parameters to a
     particular CRC formula to be processed upon receiving input.
 
     \param[in] truncated_polynomial  The lowest coefficients of the divisor
       polynomial.  The highest-order coefficient is omitted and always assumed
       to be 1.  (\e Poly from the RMCA)
     \param[in] initial_remainder  The (unaugmented) initial state of the
       polynomial remainder.  Defaults to \c 0 if omitted.  (\e Init from the
       RMCA)
     \param[in] final_xor_value  The (XOR) bit-mask to be applied to the output
       remainder, after possible reflection but before returning.  Defaults to
       \c 0 (i.e. no bit changes) if omitted.  (\e XorOut from the RMCA)
     \param[in] reflect_input  If \c true, input bytes are read lowest-order bit
       first, otherwise highest-order bit first.  Defaults to \c false if
       omitted.  (\e RefIn from the RMCA)
     \param[in] reflect_remainder  If \c true, the output remainder is reflected
       before the XOR-mask.  Defaults to \c false if omitted.  (\e RefOut from
       the RMCA)
 
     \post  <code><var>truncated_polynomial</var> ==
       this-&gt;get_truncated_polynominal()</code>
     \post  <code><var>initial_remainder</var> ==
       this-&gt;get_initial_remainder()</code>
     \post  <code><var>final_xor_value</var> ==
       this-&gt;get_final_xor_value()</code>
     \post  <code><var>reflect_input</var> ==
       this-&gt;get_reflect_input()</code>
     \post  <code><var>reflect_remainder</var> ==
       this-&gt;get_reflect_remainder()</code>
     \post  <code><var>initial_remainder</var> ==
       this-&gt;get_interim_remainder()</code>
     \post  <code>(<var>reflect_remainder</var> ?
       REFLECT(<var>initial_remainder</var>) : <var>initial_remainder</var>) ^
       <var>final_xor_value</var> == this-&gt;checksum()</code>
  */
 template < std::size_t Bits >
 inline
 crc_basic<Bits>::crc_basic
 (
     value_type  truncated_polynomial,
     value_type  initial_remainder,      // = 0
     value_type  final_xor_value,        // = 0
     bool        reflect_input,          // = false
     bool        reflect_remainder       // = false
 )
     : rem_( initial_remainder ), poly_( truncated_polynomial )
     , init_( initial_remainder ), final_( final_xor_value )
     , rft_in_( reflect_input ), rft_out_( reflect_remainder )
 {
 }
 
 /** Returns a representation of the polynomial divisor.  The value of the
     2<sup>i</sup> bit is the value of the coefficient of the polynomial's
     x<sup>i</sup> term.  The omitted bit for x<sup>(#bit_count)</sup> term is
     always 1.
 
     \return  The bit-packed list of coefficients.  If the bit-length of
       #value_type exceeds #bit_count, the values of higher-placed bits should be
       ignored (even any for x<sup>(#bit_count)</sup>) since they're unregulated.
  */
 template < std::size_t Bits >
 inline
 typename crc_basic<Bits>::value_type
 crc_basic<Bits>::get_truncated_polynominal
 (
 ) const
 {
     return poly_;
 }
 
 /** Returns a representation of the polynomial remainder before any input has
     been submitted.  The value of the 2<sup>i</sup> bit is the value of the
     coefficient of the polynomial's x<sup>i</sup> term.
 
     \return  The bit-packed list of coefficients.  If the bit-length of
       #value_type exceeds #bit_count, the values of higher-placed bits should be
       ignored since they're unregulated.
  */
 template < std::size_t Bits >
 inline
 typename crc_basic<Bits>::value_type
 crc_basic<Bits>::get_initial_remainder
 (
 ) const
 {
     return init_;
 }
 
 /** Returns the mask to be used during creation of a checksum.  The mask is used
     for an exclusive-or (XOR) operation applied bit-wise to the interim
     remainder representation (after any reflection, if #get_reflect_remainder()
     returns \c true).
 
     \return  The bit-mask.  If the bit-length of #value_type exceeds #bit_count,
       the values of higher-placed bits should be ignored since they're
       unregulated.
  */
 template < std::size_t Bits >
 inline
 typename crc_basic<Bits>::value_type
 crc_basic<Bits>::get_final_xor_value
 (
 ) const
 {
     return final_;
 }
 
 /** Returns a whether or not a submitted byte will be \"reflected\" before it is
     used to update the interim remainder.  Only the byte-wise operations
     #process_byte, #process_block, and #process_bytes are affected.
 
     \retval true  Input bytes will be read starting from the lowest-order bit.
     \retval false  Input bytes will be read starting from the highest-order bit.
  */
 template < std::size_t Bits >
 inline
 bool
 crc_basic<Bits>::get_reflect_input
 (
 ) const
 {
     return rft_in_;
 }
 
 /** Indicates if the interim remainder will be \"reflected\" before it is passed
     to the XOR-mask stage when returning a checksum.
 
     \retval true  The interim remainder is reflected before further work.
     \retval false  The interim remainder is applied to the XOR-mask as-is.
  */
 template < std::size_t Bits >
 inline
 bool
 crc_basic<Bits>::get_reflect_remainder
 (
 ) const
 {
     return rft_out_;
 }
 
 /** Returns a representation of the polynomial remainder after all the input
     submissions since construction or the last #reset call.  The value of the
     2<sup>i</sup> bit is the value of the coefficient of the polynomial's
     x<sup>i</sup> term.  If CRC processing gets interrupted here, retain the
     value returned, and use it to start up the next CRC computer where you left
     off (with #reset(value_type) or construction).  The next computer has to
     have its other parameters compatible with this computer.
 
     \return  The bit-packed list of coefficients.  If the bit-length of
       #value_type exceeds #bit_count, the values of higher-placed bits should be
       ignored since they're unregulated.  No output processing (reflection or
       XOR mask) has been applied to the value.
  */
 template < std::size_t Bits >
 inline
 typename crc_basic<Bits>::value_type
 crc_basic<Bits>::get_interim_remainder
 (
 ) const
 {
     return rem_ & detail::low_bits_mask_c<bit_count>::value;
 }
 
 /** Changes the interim polynomial remainder to \a new_rem, purging any
     influence previously submitted input has had.  The value of the
     2<sup>i</sup> bit is the value of the coefficient of the polynomial's
     x<sup>i</sup> term.
 
     \param[in] new_rem  The (unaugmented) state of the polynomial remainder
       starting from this point, with no output processing applied.
 
     \post  <code><var>new_rem</var> == this-&gt;get_interim_remainder()</code>
     \post  <code>((this-&gt;get_reflect_remainder() ?
       REFLECT(<var>new_rem</var>) : <var>new_rem</var>) ^
       this-&gt;get_final_xor_value()) == this-&gt;checksum()</code>
  */
 template < std::size_t Bits >
 inline
 void
 crc_basic<Bits>::reset
 (
     value_type  new_rem
 )
 {
     rem_ = new_rem;
 }
 
 /** Changes the interim polynomial remainder to the initial remainder given
     during construction, purging any influence previously submitted input has
     had.  The value of the 2<sup>i</sup> bit is the value of the coefficient of
     the polynomial's x<sup>i</sup> term.
 
     \post  <code>this-&gt;get_initial_remainder() ==
       this-&gt;get_interim_remainder()</code>
     \post  <code>((this-&gt;get_reflect_remainder() ?
       REFLECT(this-&gt;get_initial_remainder()) :
       this-&gt;get_initial_remainder()) ^ this-&gt;get_final_xor_value())
       == this-&gt;checksum()</code>
  */
 template < std::size_t Bits >
 inline
 void
 crc_basic<Bits>::reset
 (
 )
 {
     this->reset( this->get_initial_remainder() );
 }
 
 /** Updates the interim remainder with a single altered-CRC-division step.
 
     \param[in] bit  The new input bit.
 
     \post  The interim remainder is updated though a modulo-2 polynomial
       division, where the division steps are altered for unaugmented CRCs.
  */
 template < std::size_t Bits >
 inline
 void
 crc_basic<Bits>::process_bit
 (
     bool  bit
 )
 {
     detail::crc_modulo_update( bit_count, rem_, bit, poly_ );
 }
 
 /** Updates the interim remainder with several altered-CRC-division steps.  Each
     bit is processed separately, starting from the one at the
     2<sup><var>bit_length</var> - 1</sup> place, then proceeding down to the
     lowest-placed bit.  Any order imposed by
     <code>this-&gt;get_reflect_input()</code> is ignored.
 
     \pre  0 \< \a bit_length \<= \c CHAR_BIT
 
     \param[in] bits  The byte containing the new input bits.
     \param[in] bit_length  The number of bits in the byte to be read.
 
     \post  The interim remainder is updated though \a bit_length modulo-2
       polynomial divisions, where the division steps are altered for unaugmented
       CRCs.
  */
 template < std::size_t Bits >
 void
 crc_basic<Bits>::process_bits
 (
     unsigned char  bits,
     std::size_t    bit_length
 )
 {
     // ignore the bits above the ones we want
     bits <<= CHAR_BIT - bit_length;
 
     // compute the CRC for each bit, starting with the upper ones
     unsigned char const  high_bit_mask = 1u << ( CHAR_BIT - 1u );
     for ( std::size_t i = bit_length ; i > 0u ; --i, bits <<= 1u )
     {
         process_bit( (bits & high_bit_mask) != 0 );
     }
 }
 
 /** Updates the interim remainder with a byte's worth of altered-CRC-division
     steps.  The bits within the byte are processed from the highest place down
     if <code>this-&gt;get_reflect_input()</code> is \c false, and lowest place
     up otherwise.
 
     \param[in] byte  The new input byte.
 
     \post  The interim remainder is updated though \c CHAR_BIT modulo-2
       polynomial divisions, where the division steps are altered for unaugmented
       CRCs.
  */
 template < std::size_t Bits >
 inline
 void
 crc_basic<Bits>::process_byte
 (
     unsigned char  byte
 )
 {
     process_bits( (rft_in_ ? detail::reflect_byte( byte ) : byte), CHAR_BIT );
 }
 
 /** Updates the interim remainder with several bytes' worth of
     altered-CRC-division steps.  The bits within each byte are processed from
     the highest place down if <code>this-&gt;get_reflect_input()</code> is
     \c false, and lowest place up otherwise.  The bytes themselves are processed
     starting from the one pointed by \a bytes_begin until \a bytes_end is
     reached through forward iteration, treating the two pointers as if they
     point to <code>unsigned char</code> objects.
 
     \pre  \a bytes_end has to equal \a bytes_begin if the latter is \c NULL or
       otherwise doesn't point to a valid buffer.
     \pre  \a bytes_end, if not equal to \a bytes_begin, has to point within or
       one-byte-past the same buffer \a bytes_begin points into.
     \pre  \a bytes_end has to be reachable from \a bytes_begin through a finite
       number of forward byte-pointer increments.
 
     \param[in] bytes_begin  The address where the memory block begins.
     \param[in] bytes_end  Points to one-byte past the address of the memory
       block's last byte, or \a bytes_begin if no bytes are to be read.
 
     \post  The interim remainder is updated though <code>CHAR_BIT * (((unsigned
       char const *) bytes_end) - ((unsigned char const *) bytes_begin))</code>
       modulo-2 polynomial divisions, where the division steps are altered for
       unaugmented CRCs.
  */
 template < std::size_t Bits >
 void
 crc_basic<Bits>::process_block
 (
     void const *  bytes_begin,
     void const *  bytes_end
 )
 {
     for ( unsigned char const * p
      = static_cast<unsigned char const *>(bytes_begin) ; p < bytes_end ; ++p )
     {
         process_byte( *p );
     }
 }
 
 /** Updates the interim remainder with several bytes' worth of
     altered-CRC-division steps.  The bits within each byte are processed from
     the highest place down if <code>this-&gt;get_reflect_input()</code> is
     \c false, and lowest place up otherwise.  The bytes themselves are processed
     starting from the one pointed by \a buffer, forward-iterated (as if the
     pointed-to objects were of <code>unsigned char</code>) until \a byte_count
     bytes are read.
 
     \pre  \a byte_count has to equal 0 if \a buffer is \c NULL or otherwise
       doesn't point to valid memory.
     \pre  If \a buffer points within valid memory, then that block has to have
       at least \a byte_count more valid bytes allocated from that point.
 
     \param[in] buffer  The address where the memory block begins.
     \param[in] byte_count  The number of bytes in the memory block.
 
     \post  The interim remainder is updated though <code>CHAR_BIT *
       <var>byte_count</var></code> modulo-2 polynomial divisions, where the
       division steps are altered for unaugmented CRCs.
  */
 template < std::size_t Bits >
 inline
 void
 crc_basic<Bits>::process_bytes
 (
     void const *  buffer,
     std::size_t   byte_count
 )
 {
     unsigned char const * const  b = static_cast<unsigned char const *>(
      buffer );
 
     process_block( b, b + byte_count );
 }
 
 /** Computes the checksum of all the submitted bits since construction or the
     last call to #reset.  The checksum will be the raw checksum, i.e. the
     (interim) remainder after all the modulo-2 polynomial division, plus any
     output processing.
 
     \return  <code>(this-&gt;get_reflect_remainder() ?
       REFLECT(this-&gt;get_interim_remainder()) :
       this-&gt;get_interim_remainder()) ^ this-&gt;get_final_xor_value()</code>
 
     \note  Since checksums are meant to be compared, any higher-placed bits
       (when the bit-length of #value_type exceeds #bit_count) will be set to 0.
  */
 template < std::size_t Bits >
 inline
 typename crc_basic<Bits>::value_type
 crc_basic<Bits>::checksum
 (
 ) const
 {
     return ( (rft_out_ ? detail::reflect_unsigned( rem_, bit_count ) :
      rem_) ^ final_ ) & detail::low_bits_mask_c<bit_count>::value;
 }
 
 
 //  Optimized CRC class function definitions  --------------------------------//
 
 // Macro to compact code
 #define BOOST_CRC_OPTIMAL_NAME  crc_optimal<Bits, TruncPoly, InitRem, \
  FinalXor, ReflectIn, ReflectRem>
 
 /** Constructs a \c crc_optimal object with a particular CRC formula to be
     processed upon receiving input.  The initial remainder may be overridden.
 
     \param[in] init_rem  The (unaugmented) initial state of the polynomial
       remainder.  Defaults to #initial_remainder if omitted.
 
     \post  <code>#truncated_polynominal ==
       this-&gt;get_truncated_polynominal()</code>
     \post  <code>#initial_remainder == this-&gt;get_initial_remainder()</code>
     \post  <code>#final_xor_value == this-&gt;get_final_xor_value()</code>
     \post  <code>#reflect_input == this-&gt;get_reflect_input()</code>
     \post  <code>#reflect_remainder == this-&gt;get_reflect_remainder()</code>
     \post  <code><var>init_rem</var> == this-&gt;get_interim_remainder()</code>
     \post  <code>(#reflect_remainder ? REFLECT(<var>init_rem</var>) :
       <var>init_rem</var>) ^ #final_xor_value == this-&gt;checksum()</code>
  */
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 BOOST_CRC_OPTIMAL_NAME::crc_optimal
 (
     value_type  init_rem  // = initial_remainder
 )
     : rem_( reflect_i_type::reflect_q(init_rem) )
 {
 }
 
 //! \copydetails  boost::crc_basic::get_truncated_polynominal
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 typename BOOST_CRC_OPTIMAL_NAME::value_type
 BOOST_CRC_OPTIMAL_NAME::get_truncated_polynominal
 (
 ) const
 {
     return truncated_polynominal;
 }
 
 //! \copydetails  boost::crc_basic::get_initial_remainder
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 typename BOOST_CRC_OPTIMAL_NAME::value_type
 BOOST_CRC_OPTIMAL_NAME::get_initial_remainder
 (
 ) const
 {
     return initial_remainder;
 }
 
 //! \copydetails  boost::crc_basic::get_final_xor_value
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 typename BOOST_CRC_OPTIMAL_NAME::value_type
 BOOST_CRC_OPTIMAL_NAME::get_final_xor_value
 (
 ) const
 {
     return final_xor_value;
 }
 
 //! \copydetails  boost::crc_basic::get_reflect_input
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 bool
 BOOST_CRC_OPTIMAL_NAME::get_reflect_input
 (
 ) const
 {
     return reflect_input;
 }
 
 //! \copydetails  boost::crc_basic::get_reflect_remainder
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 bool
 BOOST_CRC_OPTIMAL_NAME::get_reflect_remainder
 (
 ) const
 {
     return reflect_remainder;
 }
 
 //! \copydetails  boost::crc_basic::get_interim_remainder
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 typename BOOST_CRC_OPTIMAL_NAME::value_type
 BOOST_CRC_OPTIMAL_NAME::get_interim_remainder
 (
 ) const
 {
     // Interim remainder should be _un_-reflected, so we have to undo it.
     return reflect_i_type::reflect_q( rem_ ) &
      detail::low_bits_mask_c<bit_count>::value;
 }
 
 /** Changes the interim polynomial remainder to \a new_rem, purging any
     influence previously submitted input has had.  The value of the
     2<sup>i</sup> bit is the value of the coefficient of the polynomial's
     x<sup>i</sup> term.
 
     \param[in] new_rem  The (unaugmented) state of the polynomial remainder
       starting from this point, with no output processing applied.  Defaults to
       <code>this-&gt;get_initial_remainder()</code> if omitted.
 
     \post  <code><var>new_rem</var> == this-&gt;get_interim_remainder()</code>
     \post  <code>((this-&gt;get_reflect_remainder() ?
       REFLECT(<var>new_rem</var>) : <var>new_rem</var>) ^
       this-&gt;get_final_xor_value()) == this-&gt;checksum()</code>
  */
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 void
 BOOST_CRC_OPTIMAL_NAME::reset
 (
     value_type  new_rem  // = initial_remainder
 )
 {
     rem_ = reflect_i_type::reflect_q( new_rem );
 }
 
 /** \copydetails  boost::crc_basic::process_byte
 
     \note  Any modulo-2 polynomial divisions may use a table of pre-computed
       remainder changes (as XOR masks) to speed computation when reading data
       byte-wise.
  */
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 void
 BOOST_CRC_OPTIMAL_NAME::process_byte
 (
     unsigned char  byte
 )
 {
     process_bytes( &byte, sizeof(byte) );
 }
 
 /** \copydetails  boost::crc_basic::process_block
 
     \note  Any modulo-2 polynomial divisions may use a table of pre-computed
       remainder changes (as XOR masks) to speed computation when reading data
       byte-wise.
  */
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 void
 BOOST_CRC_OPTIMAL_NAME::process_block
 (
     void const *  bytes_begin,
     void const *  bytes_end
 )
 {
     process_bytes( bytes_begin, static_cast<unsigned char const *>(bytes_end) -
      static_cast<unsigned char const *>(bytes_begin) );
 }
 
 /** \copydetails  boost::crc_basic::process_bytes
 
     \note  Any modulo-2 polynomial divisions may use a table of pre-computed
       remainder changes (as XOR masks) to speed computation when reading data
       byte-wise.
  */
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 void
 BOOST_CRC_OPTIMAL_NAME::process_bytes
 (
     void const *   buffer,
     std::size_t  byte_count
 )
 {
     rem_ = crc_table_type::crc_update( rem_, static_cast<unsigned char const
      *>(buffer), byte_count );
 }
 
 //! \copydetails  boost::crc_basic::checksum
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 typename BOOST_CRC_OPTIMAL_NAME::value_type
 BOOST_CRC_OPTIMAL_NAME::checksum
 (
 ) const
 {
     return ( reflect_o_type::reflect_q(rem_) ^ get_final_xor_value() )
      & detail::low_bits_mask_c<bit_count>::value;
 }
 
 /** Updates the interim remainder with a byte's worth of altered-CRC-division
     steps.  The bits within the byte are processed from the highest place down
     if <code>this-&gt;get_reflect_input()</code> is \c false, and lowest place
     up otherwise.  This function is meant to present a function-object interface
     to code that wants to process a stream of bytes with
     <code>std::for_each</code> or similar range-processing algorithms.  Since
     some of these algorithms takes their function object by value, make sure to
     copy back the result to this object so the updates can be remembered.
 
     \param[in] byte  The new input byte.
 
     \post  The interim remainder is updated though \c CHAR_BIT modulo-2
       polynomial divisions, where the division steps are altered for unaugmented
       CRCs.
 
     \note  Any modulo-2 polynomial divisions may use a table of pre-computed
       remainder changes (as XOR masks) to speed computation when reading data
       byte-wise.
  */
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 void
 BOOST_CRC_OPTIMAL_NAME::operator ()
 (
     unsigned char  byte
 )
 {
     process_byte( byte );
 }
 
 /** Computes the checksum of all the submitted bits since construction or the
     last call to #reset.  The checksum will be the raw checksum, i.e. the
     (interim) remainder after all the modulo-2 polynomial division, plus any
     output processing.  This function is meant to present a function-object
     interface to code that wants to receive data like
     <code>std::generate_n</code> or similar data-processing algorithms.  Note
     that if this object is used as a generator multiple times without an
     intervening mutating operation, the same value will always be returned.
 
     \return  <code>(this-&gt;get_reflect_remainder() ?
       REFLECT(this-&gt;get_interim_remainder()) :
       this-&gt;get_interim_remainder()) ^ this-&gt;get_final_xor_value()</code>
 
     \note  Since checksums are meant to be compared, any higher-placed bits
       (when the bit-length of #value_type exceeds #bit_count) will be set to 0.
  */
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 typename BOOST_CRC_OPTIMAL_NAME::value_type
 BOOST_CRC_OPTIMAL_NAME::operator ()
 (
 ) const
 {
     return checksum();
 }
 
 
 //  CRC computation function definition  -------------------------------------//
 
 /** Computes the polynomial remainder of a CRC run, assuming that \a buffer and
     \a byte_count describe a memory block representing the polynomial dividend.
     The division steps are altered so the result directly gives a checksum,
     without need to augment the memory block with scratch-space bytes.  The
     first byte is considered the highest order, going down for subsequent bytes.
 
     \pre  0 \< \a Bits \<= \c std\::numeric_limits\<uintmax_t\>\::digits
 
     \tparam Bits  The order of the modulo-2 polynomial divisor.  (\e Width from
       the RMCA)
     \tparam TruncPoly  The lowest coefficients of the divisor polynomial.  The
       highest-order coefficient is omitted and always assumed to be 1.
       (\e Poly from the RMCA)
     \tparam InitRem  The (unaugmented) initial state of the polynomial
       remainder.  (\e Init from the RMCA)
     \tparam FinalXor  The (XOR) bit-mask to be applied to the output remainder,
       after possible reflection but before returning.  (\e XorOut from the RMCA)
     \tparam ReflectIn  If \c True, input bytes are read lowest-order bit first,
       otherwise highest-order bit first.  (\e RefIn from the RMCA)
     \tparam ReflectRem  If \c True, the output remainder is reflected before the
       XOR-mask.  (\e RefOut from the RMCA)
 
     \param[in] buffer  The address where the memory block begins.
     \param[in] byte_count  The number of bytes in the memory block.
 
     \return  The checksum, which is the last (interim) remainder plus any output
       processing.
 
     \note  Unaugmented-style CRC runs perform modulo-2 polynomial division in
       an altered order.  The trailing \a Bits number of zero-valued bits needed
       to extracted an (unprocessed) checksum is virtually moved to near the
       beginning of the message.  This is OK since the XOR operation is
       commutative and associative.  It also means that you can get a checksum
       anytime.  Since data is being read byte-wise, a table of pre-computed
       remainder changes (as XOR masks) can be used to speed computation.
 
  */
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly,
            BOOST_CRC_PARM_TYPE InitRem, BOOST_CRC_PARM_TYPE FinalXor,
            bool ReflectIn, bool ReflectRem >
 inline
 typename crc_detail::uint_t<Bits>::fast
 crc
 (
     void const *  buffer,
     std::size_t   byte_count
 )
 {
     BOOST_CRC_OPTIMAL_NAME  computer;
     computer.process_bytes( buffer, byte_count );
     return computer.checksum();
 }
 
 
 //  Augmented-message CRC computation function definition  -------------------//
 
 /** Computes the polynomial remainder of a CRC run, assuming that \a buffer and
     \a byte_count describe a memory block representing the polynomial dividend.
     The first byte is considered the highest order, going down for subsequent
     bytes.  Within a byte, the highest-order bit is read first (corresponding to
     \e RefIn = \c False in the RMCA).  Check the other parts of this function's
     documentation to see how a checksum can be gained and/or used.
 
     \pre  0 \< \a Bits \<= \c std\::numeric_limit\<uintmax_t\>\::digits
 
     \tparam Bits  The order of the modulo-2 polynomial divisor.  (\e Width from
       the RMCA)
     \tparam TruncPoly  The lowest coefficients of the divisor polynomial.  The
       highest-order coefficient is omitted and always assumed to be 1.
       (\e Poly from the RMCA)
 
     \param[in] buffer  The address where the memory block begins.
     \param[in] byte_count  The number of bytes in the memory block.
     \param[in] initial_remainder  The initial state of the polynomial
       remainder, defaulting to zero if omitted.  If you are reading a memory
       block in multiple runs, put the return value of the previous run here.
       (Note that initial-remainders given by RMCA parameter lists, as
       \e Init, assume that the initial remainder is in its \b unaugmented state,
       so you would need to convert the value to make it suitable for this
       function.  I currently don't provide a conversion routine.)
 
     \return  The interim remainder, if no augmentation is used.  A special value
       if augmentation is used (see the notes).  No output processing is done on
       the value.  (In RMCA terms, \e RefOut is \c False and \e XorOut is \c 0.)
 
     \note  Augmented-style CRC runs use straight-up modulo-2 polynomial
       division.  Since data is being read byte-wise, a table of pre-computed
       remainder changes (as XOR masks) can be used to speed computation.
     \note  Reading just a memory block will yield an interim remainder, and not
       the final checksum.  To get that checksum, allocate \a Bits / \c CHAR_BIT
       bytes directly after the block and fill them with zero values, then extend
       \a byte_count to include those extra bytes.  A data block is corrupt if
       the return value doesn't equal your separately given checksum.
     \note  Another way to perform a check is use the zero-byte extension method,
       but replace the zero values with your separately-given checksum.  The
       checksum must be loaded in big-endian order.  Here corruption, in either
       the data block or the given checksum, is confirmed if the return value is
       not zero.
     \note  The two checksum techniques assume the CRC-run is performed bit-wise,
       while this function works byte-wise.  That means that the techniques can
       be used only if \c CHAR_BIT divides \a Bits evenly!
  */
 template < std::size_t Bits, BOOST_CRC_PARM_TYPE TruncPoly >
 typename crc_detail::uint_t<Bits>::fast
 augmented_crc
 (
     void const *                 buffer,
     std::size_t                  byte_count,
     typename crc_detail::uint_t<Bits>::fast  initial_remainder  // = 0u
 )
 {
     return detail::low_bits_mask_c<Bits>::value &
      detail::byte_table_driven_crcs<Bits, TruncPoly, false>::
      augmented_crc_update( initial_remainder, static_cast<unsigned char const
      *>(buffer), byte_count );
 }
 
 
 }  // namespace boost
 
 
 // Undo header-private macros
 #undef BOOST_CRC_OPTIMAL_NAME
 #undef BOOST_CRC_PARM_TYPE
 
 
 #endif  // BOOST_CRC_HPP
 

This page was automatically generated by the 2.3.7 LXR engine. The LXR team