adler32.cpp

Go to the documentation of this file.

#include "adler32.h"
#include "block.h"
#include <iomanip>
#include <iostream>
#include <sstream>
#include <vector>
#include <zlib.h>
 
namespace checksum {
    decltype(adler32::factory) adler32::factory("adler32");
    adler32::adler32(const std::string& aName): base(aName) {
        adler = ::adler32(0, Z_NULL, 0);
    }
    void  adler32::update(void *data, size_t size) {
        adler = ::adler32(adler, reinterpret_cast<const unsigned char*>(data), size);
    }
 
    void  adler32::update(size_t size) { // case for block of zeroes
        auto A = adler & 0x0000ffff;
        auto B = adler >> 16;
        B = (B + A * size ) % 65521;
        adler = A | (B << 16);
    }
 
    void adler32::finish() {
        std::ostringstream hashBuffer;
        hashBuffer << std::hex << std::setw(2 * 4) << std::setfill('0') << adler;
        result = hashBuffer.str();
    }
 
 
    bool adler32::parallelizable() const {
        return true;
    }
    void adler32::update(void *data, size_t size, size_t offset) {
        auto part = ::adler32(adler,
                              reinterpret_cast<const unsigned char*>(data),
                              size);
        std::lock_guard<decltype(partialSumsMutex)> lock(partialSumsMutex);
        partialSums.emplace(offset, std::pair<uint32_t, size_t>(part, size));
    }
    void adler32::update(size_t size, size_t offset) {
        auto A = adler & 0x0000ffff;
        auto B = adler >> 16;
        B = (B + A * size ) % 65521;
        std::lock_guard<decltype(partialSumsMutex)> lock(partialSumsMutex);
        partialSums.emplace(offset, std::pair<uint32_t, size_t>( A | (B << 16), size));
    }
    void adler32::parallelFinish() {
        std::lock_guard<decltype(partialSumsMutex)> lock(partialSumsMutex);
        for (auto& item : partialSums) {
            adler = ::adler32_combine(adler, item.second.first, item.second.second);
        }
        finish();
    }
 
 
 
    decltype(adler32noOpt::factory) adler32noOpt::factory("adler32noOpt");
    adler32noOpt::adler32noOpt(const std::string& aName): adler32(aName) {}
 
    void  adler32noOpt::update(void *data, size_t size) {
        adler = ::adler32(adler, reinterpret_cast<const unsigned char*>(data), size);
    }
    void  adler32noOpt::update(size_t size) { // case for block of zeroes
        for (size_t bytes_done = 0; bytes_done < size;) {
            auto missing = size - bytes_done;
            size_t bytes = std::min(missing, block::nullBufferSize());
 
            adler = ::adler32(adler, static_cast<const unsigned char*>(block::nullBuffer()), bytes);
            bytes_done += bytes;
        }
    }
 
    void adler32noOpt::update(void *data, size_t size, size_t offset) {
        auto part = ::adler32(adler,
                              reinterpret_cast<const unsigned char*>(data),
                              size);
        std::lock_guard<decltype(partialSumsMutex)> lock(partialSumsMutex);
        partialSums.emplace(offset, std::pair<uint32_t, size_t>(part, size));
    }
    void adler32noOpt::update(size_t size, size_t offset) {
        auto part = adler;
        for (size_t bytes_done = 0; bytes_done < size;) {
            auto missing = size - bytes_done;
            size_t bytes = std::min(missing, block::nullBufferSize());
 
            part = ::adler32(part, static_cast<const unsigned char*>(block::nullBuffer()), bytes);
            bytes_done += bytes;
        }
        std::lock_guard<decltype(partialSumsMutex)> lock(partialSumsMutex);
        partialSums.emplace(offset, std::pair<uint32_t, size_t>(part, size));
    }
 
 
 
    decltype(crc32::factory) crc32::factory("crc32");
    crc32::crc32(const std::string& aName): base(aName) {
        crc = ::crc32(0, Z_NULL, 0);
    }
    void  crc32::update(void *data, size_t size) {
        crc = ::crc32(crc, reinterpret_cast<const unsigned char*>(data), size);
    }
 
    void  crc32::update(size_t size) { // case for block of zeroes
        for (size_t bytes_done = 0; bytes_done < size;) {
            auto missing = size - bytes_done;
            size_t bytes = std::min(missing, block::nullBufferSize());
 
            crc = ::crc32(crc, static_cast<const unsigned char*>(block::nullBuffer()), bytes);
            bytes_done += bytes;
        }
    }
 
    void crc32::finish() {
        std::ostringstream hashBuffer;
        hashBuffer << std::hex << std::setw(2 * 4) << std::setfill('0') << crc;
        result = hashBuffer.str();
    }
 
    bool crc32::parallelizable() const {
        return true;
    }
    void  crc32::update(void *data, size_t size, size_t offset) {
        auto part =::crc32(crc,
                           reinterpret_cast<const unsigned char*>(data),
                           size);
        std::lock_guard<decltype(partialSumsMutex)> lock(partialSumsMutex);
        partialSums.emplace(offset, std::pair<uint32_t, size_t>(part, size));
    }
 
    void  crc32::update(size_t size, size_t offset) { // case for block of zeroes
        auto part = crc;
        for (size_t bytes_done = 0; bytes_done < size;) {
            auto missing = size - bytes_done;
            size_t bytes = std::min(missing, block::nullBufferSize());
 
            part = ::crc32(part, static_cast<const unsigned char*>(block::nullBuffer()), bytes);
            bytes_done += bytes;
        }
        std::lock_guard<decltype(partialSumsMutex)> lock(partialSumsMutex);
        partialSums.emplace(offset, std::pair<uint32_t, size_t>(part, size));
    }
    void crc32::parallelFinish() {
        std::lock_guard<decltype(partialSumsMutex)> lock(partialSumsMutex);
        for (auto& item : partialSums) {
            crc = ::crc32_combine(crc, item.second.first, item.second.second);
        }
        finish();
    }
 
}; // end namespace checksum