Branch data Line data Source code
# 1 : : // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
# 2 : : // Use of this source code is governed by a BSD-style license that can be
# 3 : : // found in the LICENSE file. See the AUTHORS file for names of contributors.
# 4 : :
# 5 : : #include "util/coding.h"
# 6 : :
# 7 : : namespace leveldb {
# 8 : :
# 9 : 37790 : void PutFixed32(std::string* dst, uint32_t value) {
# 10 : 37790 : char buf[sizeof(value)];
# 11 : 37790 : EncodeFixed32(buf, value);
# 12 : 37790 : dst->append(buf, sizeof(buf));
# 13 : 37790 : }
# 14 : :
# 15 : 4555 : void PutFixed64(std::string* dst, uint64_t value) {
# 16 : 4555 : char buf[sizeof(value)];
# 17 : 4555 : EncodeFixed64(buf, value);
# 18 : 4555 : dst->append(buf, sizeof(buf));
# 19 : 4555 : }
# 20 : :
# 21 : 12367711 : char* EncodeVarint32(char* dst, uint32_t v) {
# 22 : : // Operate on characters as unsigneds
# 23 : 12367711 : uint8_t* ptr = reinterpret_cast<uint8_t*>(dst);
# 24 : 12367711 : static const int B = 128;
# 25 [ + + ]: 12367711 : if (v < (1 << 7)) {
# 26 : 12364841 : *(ptr++) = v;
# 27 [ + + ]: 12364841 : } else if (v < (1 << 14)) {
# 28 : 2883 : *(ptr++) = v | B;
# 29 : 2883 : *(ptr++) = v >> 7;
# 30 [ - + ]:>1844*10^16 : } else if (v < (1 << 21)) {
# 31 : 0 : *(ptr++) = v | B;
# 32 : 0 : *(ptr++) = (v >> 7) | B;
# 33 : 0 : *(ptr++) = v >> 14;
# 34 [ - + ]:>1844*10^16 : } else if (v < (1 << 28)) {
# 35 : 0 : *(ptr++) = v | B;
# 36 : 0 : *(ptr++) = (v >> 7) | B;
# 37 : 0 : *(ptr++) = (v >> 14) | B;
# 38 : 0 : *(ptr++) = v >> 21;
# 39 :>1844*10^16 : } else {
# 40 :>1844*10^16 : *(ptr++) = v | B;
# 41 :>1844*10^16 : *(ptr++) = (v >> 7) | B;
# 42 :>1844*10^16 : *(ptr++) = (v >> 14) | B;
# 43 :>1844*10^16 : *(ptr++) = (v >> 21) | B;
# 44 :>1844*10^16 : *(ptr++) = v >> 28;
# 45 :>1844*10^16 : }
# 46 : 12367711 : return reinterpret_cast<char*>(ptr);
# 47 : 12367711 : }
# 48 : :
# 49 : 1327169 : void PutVarint32(std::string* dst, uint32_t v) {
# 50 : 1327169 : char buf[5];
# 51 : 1327169 : char* ptr = EncodeVarint32(buf, v);
# 52 : 1327169 : dst->append(buf, ptr - buf);
# 53 : 1327169 : }
# 54 : :
# 55 : 32937 : char* EncodeVarint64(char* dst, uint64_t v) {
# 56 : 32937 : static const int B = 128;
# 57 : 32937 : uint8_t* ptr = reinterpret_cast<uint8_t*>(dst);
# 58 [ + + ]: 50720 : while (v >= B) {
# 59 : 17783 : *(ptr++) = v | B;
# 60 : 17783 : v >>= 7;
# 61 : 17783 : }
# 62 : 32937 : *(ptr++) = static_cast<uint8_t>(v);
# 63 : 32937 : return reinterpret_cast<char*>(ptr);
# 64 : 32937 : }
# 65 : :
# 66 : 32937 : void PutVarint64(std::string* dst, uint64_t v) {
# 67 : 32937 : char buf[10];
# 68 : 32937 : char* ptr = EncodeVarint64(buf, v);
# 69 : 32937 : dst->append(buf, ptr - buf);
# 70 : 32937 : }
# 71 : :
# 72 : 695670 : void PutLengthPrefixedSlice(std::string* dst, const Slice& value) {
# 73 : 695670 : PutVarint32(dst, value.size());
# 74 : 695670 : dst->append(value.data(), value.size());
# 75 : 695670 : }
# 76 : :
# 77 : 957100 : int VarintLength(uint64_t v) {
# 78 : 957100 : int len = 1;
# 79 [ + + ]: 958531 : while (v >= 128) {
# 80 : 1431 : v >>= 7;
# 81 : 1431 : len++;
# 82 : 1431 : }
# 83 : 957100 : return len;
# 84 : 957100 : }
# 85 : :
# 86 : : const char* GetVarint32PtrFallback(const char* p, const char* limit,
# 87 : 7483 : uint32_t* value) {
# 88 : 7483 : uint32_t result = 0;
# 89 [ + + ][ + + ]: 11730 : for (uint32_t shift = 0; shift <= 28 && p < limit; shift += 7) {
# 90 : 8492 : uint32_t byte = *(reinterpret_cast<const uint8_t*>(p));
# 91 : 8492 : p++;
# 92 [ + + ]: 8492 : if (byte & 128) {
# 93 : : // More bytes are present
# 94 : 4247 : result |= ((byte & 127) << shift);
# 95 : 4247 : } else {
# 96 : 4245 : result |= (byte << shift);
# 97 : 4245 : *value = result;
# 98 : 4245 : return reinterpret_cast<const char*>(p);
# 99 : 4245 : }
# 100 : 8492 : }
# 101 : 3238 : return nullptr;
# 102 : 7483 : }
# 103 : :
# 104 : 933043 : bool GetVarint32(Slice* input, uint32_t* value) {
# 105 : 933043 : const char* p = input->data();
# 106 : 933043 : const char* limit = p + input->size();
# 107 : 933043 : const char* q = GetVarint32Ptr(p, limit, value);
# 108 [ + + ]: 933043 : if (q == nullptr) {
# 109 : 3237 : return false;
# 110 : 929806 : } else {
# 111 : 929806 : *input = Slice(q, limit - q);
# 112 : 929806 : return true;
# 113 : 929806 : }
# 114 : 933043 : }
# 115 : :
# 116 : 6999822 : const char* GetVarint64Ptr(const char* p, const char* limit, uint64_t* value) {
# 117 : 6999822 : uint64_t result = 0;
# 118 [ + + ][ + - ]: 17212406 : for (uint32_t shift = 0; shift <= 63 && p < limit; shift += 7) {
# 119 : 17212404 : uint64_t byte = *(reinterpret_cast<const uint8_t*>(p));
# 120 : 17212404 : p++;
# 121 [ + + ]: 17212404 : if (byte & 128) {
# 122 : : // More bytes are present
# 123 : 10212584 : result |= ((byte & 127) << shift);
# 124 : 10212584 : } else {
# 125 : 6999820 : result |= (byte << shift);
# 126 : 6999820 : *value = result;
# 127 : 6999820 : return reinterpret_cast<const char*>(p);
# 128 : 6999820 : }
# 129 : 17212404 : }
# 130 : 2 : return nullptr;
# 131 : 6999822 : }
# 132 : :
# 133 : 6999822 : bool GetVarint64(Slice* input, uint64_t* value) {
# 134 : 6999822 : const char* p = input->data();
# 135 : 6999822 : const char* limit = p + input->size();
# 136 : 6999822 : const char* q = GetVarint64Ptr(p, limit, value);
# 137 [ - + ]: 6999822 : if (q == nullptr) {
# 138 : 0 : return false;
# 139 : 6999822 : } else {
# 140 : 6999822 : *input = Slice(q, limit - q);
# 141 : 6999822 : return true;
# 142 : 6999822 : }
# 143 : 6999822 : }
# 144 : :
# 145 : : const char* GetLengthPrefixedSlice(const char* p, const char* limit,
# 146 : 0 : Slice* result) {
# 147 : 0 : uint32_t len;
# 148 : 0 : p = GetVarint32Ptr(p, limit, &len);
# 149 [ # # ]: 0 : if (p == nullptr) return nullptr;
# 150 [ # # ]: 0 : if (p + len > limit) return nullptr;
# 151 : 0 : *result = Slice(p, len);
# 152 : 0 : return p + len;
# 153 : 0 : }
# 154 : :
# 155 : 916427 : bool GetLengthPrefixedSlice(Slice* input, Slice* result) {
# 156 : 916427 : uint32_t len;
# 157 [ + - ][ + - ]: 916427 : if (GetVarint32(input, &len) && input->size() >= len) {
# 158 : 916427 : *result = Slice(input->data(), len);
# 159 : 916427 : input->remove_prefix(len);
# 160 : 916427 : return true;
# 161 : 916427 : } else {
# 162 : 0 : return false;
# 163 : 0 : }
# 164 : 916427 : }
# 165 : :
# 166 : : } // namespace leveldb
|
