vint.h

Go to the documentation of this file.

#ifndef EBML_NG_VINT_H
#define EBML_NG_VINT_H

#include "exceptions.h"
#include "io.h"
#include "ebmlID_t.h"
#include "struct.h"
#include "struct/ull.h"
#include <array>
#include <stdexcept>
#include <string>

namespace ebml {

    extern const size_t UNKNOWN;

    inline unsigned char vintWidth(char b) {
        static const std::array<unsigned char, 8> masks = {{
            0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01
        }};
        unsigned char k;
        for (k = 0; k < 8; ++k) {
            if (b & masks[k]) {
                return k + 1;
            }
        }
        throw ebmlInvalidVint("Variable-length integer cannot start with null byte.");
    }

    inline unsigned char widthAsVint(unsigned long long n) {
        unsigned char k = 0;
        if (n == 0xffffffffffffffffULL) {
            return 8;
        }
        while (k <= 8) {
            if (n < ((1ULL << (7 * k)) - 1ULL)) {
                return k;
            }
            k++;
        }
        throw std::overflow_error(
            std::string("int too big to convert (") + std::to_string(__LINE__)
            + std::string(":") + std::string(__FILE__) + std::string(")")
        );
    }

    inline unsigned long long unpackVint(const char* data, unsigned char size) {
        unsigned long long val = unpack<unsigned long long>(data, size);
        val &= ~(1ULL << (7 * size)); // remove the marker bit
        if (val == ((1ULL << (7 * size)) - 1ULL)) {
            return 0xffffffffffffffffULL;
        }
        return val;
    }

    inline unsigned long long unpackVint(const char* data) {
        unsigned char size = vintWidth(data[0]);
        return unpackVint(data, size);
    }

    inline void packVint(unsigned long long n, unsigned char size, char* dest) {
        if ((size == 0) || (size > 8)) {
            throw std::invalid_argument(
                std::string("packVint: invalid value for size (") + std::to_string(__LINE__)
                + std::string(":") + std::string(__FILE__) + std::string(")")
            );
        }

        if (n == 0xffffffffffffffffULL) {
            pack((1ULL << (7 * size + 1)) - 1ULL, size, dest);
            return;
        }

        if (((1ULL << (7 * size)) - 1ULL) <= n) {
            throw std::overflow_error(
                std::string("int too big to convert (") + std::to_string(__LINE__)
                + std::string(":") + std::string(__FILE__) + std::string(")")
            );
        }

        pack((1ULL << (7 * size)) | n, size, dest);
    }

    inline unsigned char packVint(unsigned long long n, char* dest) {
        unsigned char size = widthAsVint(n);
        packVint(n, size, dest);
        return size;
    }

    unsigned long long unpackVint(const char* data, size_t dataSize, unsigned char& vintw);

    unsigned long long unpackVint(ioBase& file, unsigned char& vintw);

    unsigned long long unpackVint(ioBase& file, off_t offset, unsigned char& vintw);

} // namespace ebml

#endif