varint.hpp

Go to the documentation of this file.

#ifndef PROTOZERO_VARINT_HPP
#define PROTOZERO_VARINT_HPP
 
/*****************************************************************************
 
protozero - Minimalistic protocol buffer decoder and encoder in C++.
 
This file is from https://github.com/mapbox/protozero where you can find more
documentation.
 
*****************************************************************************/
 
#include "buffer_tmpl.hpp"
#include "exception.hpp"
 
#include <cstdint>
 
namespace protozero {
 
constexpr const int8_t max_varint_length = (sizeof(uint64_t) * 8 / 7) + 1;
 
namespace detail {
 
    // from https://github.com/facebook/folly/blob/master/folly/Varint.h
    inline uint64_t decode_varint_impl(const char** data, const char* end) {
        const auto* begin = reinterpret_cast<const int8_t*>(*data);
        const auto* iend = reinterpret_cast<const int8_t*>(end);
        const int8_t* p = begin;
        uint64_t val = 0;
 
        if (iend - begin >= max_varint_length) {  // fast path
            do {
                int64_t b = *p++;
                          val  = ((static_cast<uint64_t>(b) & 0x7fU)       ); if (b >= 0) { break; }
                b = *p++; val |= ((static_cast<uint64_t>(b) & 0x7fU) <<  7U); if (b >= 0) { break; }
                b = *p++; val |= ((static_cast<uint64_t>(b) & 0x7fU) << 14U); if (b >= 0) { break; }
                b = *p++; val |= ((static_cast<uint64_t>(b) & 0x7fU) << 21U); if (b >= 0) { break; }
                b = *p++; val |= ((static_cast<uint64_t>(b) & 0x7fU) << 28U); if (b >= 0) { break; }
                b = *p++; val |= ((static_cast<uint64_t>(b) & 0x7fU) << 35U); if (b >= 0) { break; }
                b = *p++; val |= ((static_cast<uint64_t>(b) & 0x7fU) << 42U); if (b >= 0) { break; }
                b = *p++; val |= ((static_cast<uint64_t>(b) & 0x7fU) << 49U); if (b >= 0) { break; }
                b = *p++; val |= ((static_cast<uint64_t>(b) & 0x7fU) << 56U); if (b >= 0) { break; }
                b = *p++; val |= ((static_cast<uint64_t>(b) & 0x01U) << 63U); if (b >= 0) { break; }
                throw varint_too_long_exception{};
            } while (false);
        } else {
            unsigned int shift = 0;
            while (p != iend && *p < 0) {
                val |= (static_cast<uint64_t>(*p++) & 0x7fU) << shift;
                shift += 7;
            }
            if (p == iend) {
                throw end_of_buffer_exception{};
            }
            val |= static_cast<uint64_t>(*p++) << shift;
        }
 
        *data = reinterpret_cast<const char*>(p);
        return val;
    }
 
} // end namespace detail
 
inline uint64_t decode_varint(const char** data, const char* end) {
    // If this is a one-byte varint, decode it here.
    if (end != *data && ((static_cast<uint64_t>(**data) & 0x80U) == 0)) {
        const auto val = static_cast<uint64_t>(**data);
        ++(*data);
        return val;
    }
    // If this varint is more than one byte, defer to complete implementation.
    return detail::decode_varint_impl(data, end);
}
 
inline void skip_varint(const char** data, const char* end) {
    const auto* begin = reinterpret_cast<const int8_t*>(*data);
    const auto* iend = reinterpret_cast<const int8_t*>(end);
    const int8_t* p = begin;
 
    while (p != iend && *p < 0) {
        ++p;
    }
 
    if (p - begin >= max_varint_length) {
        throw varint_too_long_exception{};
    }
 
    if (p == iend) {
        throw end_of_buffer_exception{};
    }
 
    ++p;
 
    *data = reinterpret_cast<const char*>(p);
}
 
template <typename T>
inline int write_varint(T data, uint64_t value) {
    int n = 1;
 
    while (value >= 0x80U) {
        *data++ = static_cast<char>((value & 0x7fU) | 0x80U);
        value >>= 7U;
        ++n;
    }
    *data = static_cast<char>(value);
 
    return n;
}
 
template <typename TBuffer>
inline void add_varint_to_buffer(TBuffer* buffer, uint64_t value) {
    while (value >= 0x80U) {
        buffer_customization<TBuffer>::push_back(buffer, static_cast<char>((value & 0x7fU) | 0x80U));
        value >>= 7U;
    }
    buffer_customization<TBuffer>::push_back(buffer, static_cast<char>(value));
}
 
inline int add_varint_to_buffer(char* data, uint64_t value) noexcept {
    int n = 1;
 
    while (value >= 0x80U) {
        *data++ = static_cast<char>((value & 0x7fU) | 0x80U);
        value >>= 7U;
        ++n;
    }
    *data = static_cast<char>(value);
 
    return n;
}
 
inline int length_of_varint(uint64_t value) noexcept {
    int n = 1;
 
    while (value >= 0x80U) {
        value >>= 7U;
        ++n;
    }
 
    return n;
}
 
constexpr uint32_t encode_zigzag32(int32_t value) noexcept {
    return (static_cast<uint32_t>(value) << 1U) ^ static_cast<uint32_t>(-static_cast<int32_t>(static_cast<uint32_t>(value) >> 31U));
}
 
constexpr uint64_t encode_zigzag64(int64_t value) noexcept {
    return (static_cast<uint64_t>(value) << 1U) ^ static_cast<uint64_t>(-static_cast<int64_t>(static_cast<uint64_t>(value) >> 63U));
}
 
constexpr int32_t decode_zigzag32(uint32_t value) noexcept {
    return static_cast<int32_t>((value >> 1U) ^ static_cast<uint32_t>(-static_cast<int32_t>(value & 1U)));
}
 
constexpr int64_t decode_zigzag64(uint64_t value) noexcept {
    return static_cast<int64_t>((value >> 1U) ^ static_cast<uint64_t>(-static_cast<int64_t>(value & 1U)));
}
 
} // end namespace protozero
 
#endif // PROTOZERO_VARINT_HPP