CRC.h

Go to the documentation of this file.

#pragma once
 
#include <cstring>
#include <type_traits>
#include <vector>
 
 
namespace shlublu
{
 
namespace CRCData
{
    extern "C" const uint32_t crc32Table[]; 
    extern "C" const uint64_t crc64Table[]; 
}
 
 
template <typename T> 
class CRC
{
public:
    CRC()   
    : mHash(0)
    {
        static_assert_valid_base_type();
    }
 
 
    template <typename P> CRC(P param) 
    : CRC()
    { 
        static_assert_valid_base_type();
        accumulate(param); 
    }
 
 
    CRC<T>& accumulate(std::string const & str)
    {
        return accumulate(str.c_str(), 0, str.length());
    }
 
 
    CRC<T>& accumulate(char const * sz)
    {
        return accumulate(sz, 0, ::strlen(sz));
    }
 
 
    template <typename P> 
    CRC<T>& accumulate(std::vector<P> const & v)
    {
        accumulate(v.begin(), v.end());
 
        return *this;
    }
 
 
 
    template <typename P>
    CRC<T>& accumulate(P value)
    {
        static_assert_valid_parameter_type<P>();
        return accumulate(reinterpret_cast<char const *>(&value), 0, sizeof(P));
    }
 
 
    CRC<T>& accumulate(char const* data, size_t offset, size_t length)
    {
        T const * const crcTab(crcTable());
        
        // Compute the CRC
        const size_t afterLastOffset(offset + length);
 
        for (size_t i = offset; i < afterLastOffset; ++i)
        {
            mHash = crcTab[(mHash ^ data[i]) & 0xff] ^ (mHash >> 8);
        }
 
        mHash = mHash & T(-1);
 
        return *this;
    }
 
 
    template <typename Iter>
    CRC<T>& accumulate(const Iter first, const Iter last)
    {
        for (Iter it = first; it != last; ++it)
        {
            accumulate(*it);
        }
 
        return *this;
    }
 
 
    T get() const { return mHash; }
 
 
private:
 
    void static_assert_valid_base_type() const
    {
        static_assert(std::is_same<T, uint32_t>::value || std::is_same<T, uint64_t>::value, "Type should be unsigned 32 or 64.");
    }
 
 
    template<typename P> 
    void static_assert_valid_parameter_type() const
    {
        static_assert(std::is_arithmetic<P>::value, "Type should be arithmetic.");
    }
 
 
    T const * crcTable() const
    {
        return std::is_same<T, uint32_t>::value ?
            reinterpret_cast<T const *>(CRCData::crc32Table) :
            reinterpret_cast<T const *>(CRCData::crc64Table);
    }
 
 
private:
    T mHash;
 
};
 
 
using crc32_t = uint32_t;
 
using crc64_t = uint64_t;
 
using CRC32 = CRC<crc32_t>;
 
using CRC64 = CRC<crc64_t>;
 
}