← Back to branch summary

~ubuntu-branches/debian/jessie/armory/jessie

« back to all changes in this revision

Viewing changes to cppForSwig/leveldb/util/coding.cc

  • Committer: Package Import Robot
  • Author(s): Joseph Bisch
  • Date: 2014-10-07 10:22:45 UTC
  • Revision ID: package-import@ubuntu.com-20141007102245-2s3x3rhjxg689hek
Tags: upstream-0.92.3
Import upstream version 0.92.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
cppForSwig/leveldb/util/coding.cc
 
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
void EncodeFixed32(char* buf, uint32_t value) {
 
10
  if (port::kLittleEndian) {
 
11
    memcpy(buf, &value, sizeof(value));
 
12
  } else {
 
13
    buf[0] = value & 0xff;
 
14
    buf[1] = (value >> 8) & 0xff;
 
15
    buf[2] = (value >> 16) & 0xff;
 
16
    buf[3] = (value >> 24) & 0xff;
 
17
  }
 
18
}
 
19
 
 
20
void EncodeFixed64(char* buf, uint64_t value) {
 
21
  if (port::kLittleEndian) {
 
22
    memcpy(buf, &value, sizeof(value));
 
23
  } else {
 
24
    buf[0] = value & 0xff;
 
25
    buf[1] = (value >> 8) & 0xff;
 
26
    buf[2] = (value >> 16) & 0xff;
 
27
    buf[3] = (value >> 24) & 0xff;
 
28
    buf[4] = (value >> 32) & 0xff;
 
29
    buf[5] = (value >> 40) & 0xff;
 
30
    buf[6] = (value >> 48) & 0xff;
 
31
    buf[7] = (value >> 56) & 0xff;
 
32
  }
 
33
}
 
34
 
 
35
void PutFixed32(std::string* dst, uint32_t value) {
 
36
  char buf[sizeof(value)];
 
37
  EncodeFixed32(buf, value);
 
38
  dst->append(buf, sizeof(buf));
 
39
}
 
40
 
 
41
void PutFixed64(std::string* dst, uint64_t value) {
 
42
  char buf[sizeof(value)];
 
43
  EncodeFixed64(buf, value);
 
44
  dst->append(buf, sizeof(buf));
 
45
}
 
46
 
 
47
char* EncodeVarint32(char* dst, uint32_t v) {
 
48
  // Operate on characters as unsigneds
 
49
  unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);
 
50
  static const int B = 128;
 
51
  if (v < (1<<7)) {
 
52
    *(ptr++) = v;
 
53
  } else if (v < (1<<14)) {
 
54
    *(ptr++) = v | B;
 
55
    *(ptr++) = v>>7;
 
56
  } else if (v < (1<<21)) {
 
57
    *(ptr++) = v | B;
 
58
    *(ptr++) = (v>>7) | B;
 
59
    *(ptr++) = v>>14;
 
60
  } else if (v < (1<<28)) {
 
61
    *(ptr++) = v | B;
 
62
    *(ptr++) = (v>>7) | B;
 
63
    *(ptr++) = (v>>14) | B;
 
64
    *(ptr++) = v>>21;
 
65
  } else {
 
66
    *(ptr++) = v | B;
 
67
    *(ptr++) = (v>>7) | B;
 
68
    *(ptr++) = (v>>14) | B;
 
69
    *(ptr++) = (v>>21) | B;
 
70
    *(ptr++) = v>>28;
 
71
  }
 
72
  return reinterpret_cast<char*>(ptr);
 
73
}
 
74
 
 
75
void PutVarint32(std::string* dst, uint32_t v) {
 
76
  char buf[5];
 
77
  char* ptr = EncodeVarint32(buf, v);
 
78
  dst->append(buf, ptr - buf);
 
79
}
 
80
 
 
81
char* EncodeVarint64(char* dst, uint64_t v) {
 
82
  static const int B = 128;
 
83
  unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);
 
84
  while (v >= B) {
 
85
    *(ptr++) = (v & (B-1)) | B;
 
86
    v >>= 7;
 
87
  }
 
88
  *(ptr++) = static_cast<unsigned char>(v);
 
89
  return reinterpret_cast<char*>(ptr);
 
90
}
 
91
 
 
92
void PutVarint64(std::string* dst, uint64_t v) {
 
93
  char buf[10];
 
94
  char* ptr = EncodeVarint64(buf, v);
 
95
  dst->append(buf, ptr - buf);
 
96
}
 
97
 
 
98
void PutLengthPrefixedSlice(std::string* dst, const Slice& value) {
 
99
  PutVarint32(dst, value.size());
 
100
  dst->append(value.data(), value.size());
 
101
}
 
102
 
 
103
int VarintLength(uint64_t v) {
 
104
  int len = 1;
 
105
  while (v >= 128) {
 
106
    v >>= 7;
 
107
    len++;
 
108
  }
 
109
  return len;
 
110
}
 
111
 
 
112
const char* GetVarint32PtrFallback(const char* p,
 
113
                                   const char* limit,
 
114
                                   uint32_t* value) {
 
115
  uint32_t result = 0;
 
116
  for (uint32_t shift = 0; shift <= 28 && p < limit; shift += 7) {
 
117
    uint32_t byte = *(reinterpret_cast<const unsigned char*>(p));
 
118
    p++;
 
119
    if (byte & 128) {
 
120
      // More bytes are present
 
121
      result |= ((byte & 127) << shift);
 
122
    } else {
 
123
      result |= (byte << shift);
 
124
      *value = result;
 
125
      return reinterpret_cast<const char*>(p);
 
126
    }
 
127
  }
 
128
  return NULL;
 
129
}
 
130
 
 
131
bool GetVarint32(Slice* input, uint32_t* value) {
 
132
  const char* p = input->data();
 
133
  const char* limit = p + input->size();
 
134
  const char* q = GetVarint32Ptr(p, limit, value);
 
135
  if (q == NULL) {
 
136
    return false;
 
137
  } else {
 
138
    *input = Slice(q, limit - q);
 
139
    return true;
 
140
  }
 
141
}
 
142
 
 
143
const char* GetVarint64Ptr(const char* p, const char* limit, uint64_t* value) {
 
144
  uint64_t result = 0;
 
145
  for (uint32_t shift = 0; shift <= 63 && p < limit; shift += 7) {
 
146
    uint64_t byte = *(reinterpret_cast<const unsigned char*>(p));
 
147
    p++;
 
148
    if (byte & 128) {
 
149
      // More bytes are present
 
150
      result |= ((byte & 127) << shift);
 
151
    } else {
 
152
      result |= (byte << shift);
 
153
      *value = result;
 
154
      return reinterpret_cast<const char*>(p);
 
155
    }
 
156
  }
 
157
  return NULL;
 
158
}
 
159
 
 
160
bool GetVarint64(Slice* input, uint64_t* value) {
 
161
  const char* p = input->data();
 
162
  const char* limit = p + input->size();
 
163
  const char* q = GetVarint64Ptr(p, limit, value);
 
164
  if (q == NULL) {
 
165
    return false;
 
166
  } else {
 
167
    *input = Slice(q, limit - q);
 
168
    return true;
 
169
  }
 
170
}
 
171
 
 
172
const char* GetLengthPrefixedSlice(const char* p, const char* limit,
 
173
                                   Slice* result) {
 
174
  uint32_t len;
 
175
  p = GetVarint32Ptr(p, limit, &len);
 
176
  if (p == NULL) return NULL;
 
177
  if (p + len > limit) return NULL;
 
178
  *result = Slice(p, len);
 
179
  return p + len;
 
180
}
 
181
 
 
182
bool GetLengthPrefixedSlice(Slice* input, Slice* result) {
 
183
  uint32_t len;
 
184
  if (GetVarint32(input, &len) &&
 
185
      input->size() >= len) {
 
186
    *result = Slice(input->data(), len);
 
187
    input->remove_prefix(len);
 
188
    return true;
 
189
  } else {
 
190
    return false;
 
191
  }
 
192
}
 
193
 
 
194
}  // namespace leveldb