leveldb 0.0.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (128) hide show
  1. checksums.yaml +7 -0
  2. data/LICENSE.txt +22 -0
  3. data/README.md +95 -0
  4. data/ext/Rakefile +11 -0
  5. data/ext/leveldb/LICENSE +27 -0
  6. data/ext/leveldb/Makefile +206 -0
  7. data/ext/leveldb/build_config.mk +13 -0
  8. data/ext/leveldb/db/builder.cc +88 -0
  9. data/ext/leveldb/db/builder.h +34 -0
  10. data/ext/leveldb/db/c.cc +595 -0
  11. data/ext/leveldb/db/c_test.c +390 -0
  12. data/ext/leveldb/db/corruption_test.cc +359 -0
  13. data/ext/leveldb/db/db_bench.cc +979 -0
  14. data/ext/leveldb/db/db_impl.cc +1485 -0
  15. data/ext/leveldb/db/db_impl.h +203 -0
  16. data/ext/leveldb/db/db_iter.cc +299 -0
  17. data/ext/leveldb/db/db_iter.h +26 -0
  18. data/ext/leveldb/db/db_test.cc +2092 -0
  19. data/ext/leveldb/db/dbformat.cc +140 -0
  20. data/ext/leveldb/db/dbformat.h +227 -0
  21. data/ext/leveldb/db/dbformat_test.cc +112 -0
  22. data/ext/leveldb/db/filename.cc +139 -0
  23. data/ext/leveldb/db/filename.h +80 -0
  24. data/ext/leveldb/db/filename_test.cc +122 -0
  25. data/ext/leveldb/db/leveldb_main.cc +238 -0
  26. data/ext/leveldb/db/log_format.h +35 -0
  27. data/ext/leveldb/db/log_reader.cc +259 -0
  28. data/ext/leveldb/db/log_reader.h +108 -0
  29. data/ext/leveldb/db/log_test.cc +500 -0
  30. data/ext/leveldb/db/log_writer.cc +103 -0
  31. data/ext/leveldb/db/log_writer.h +48 -0
  32. data/ext/leveldb/db/memtable.cc +145 -0
  33. data/ext/leveldb/db/memtable.h +91 -0
  34. data/ext/leveldb/db/repair.cc +389 -0
  35. data/ext/leveldb/db/skiplist.h +379 -0
  36. data/ext/leveldb/db/skiplist_test.cc +378 -0
  37. data/ext/leveldb/db/snapshot.h +66 -0
  38. data/ext/leveldb/db/table_cache.cc +121 -0
  39. data/ext/leveldb/db/table_cache.h +61 -0
  40. data/ext/leveldb/db/version_edit.cc +266 -0
  41. data/ext/leveldb/db/version_edit.h +107 -0
  42. data/ext/leveldb/db/version_edit_test.cc +46 -0
  43. data/ext/leveldb/db/version_set.cc +1443 -0
  44. data/ext/leveldb/db/version_set.h +383 -0
  45. data/ext/leveldb/db/version_set_test.cc +179 -0
  46. data/ext/leveldb/db/write_batch.cc +147 -0
  47. data/ext/leveldb/db/write_batch_internal.h +49 -0
  48. data/ext/leveldb/db/write_batch_test.cc +120 -0
  49. data/ext/leveldb/doc/bench/db_bench_sqlite3.cc +718 -0
  50. data/ext/leveldb/doc/bench/db_bench_tree_db.cc +528 -0
  51. data/ext/leveldb/helpers/memenv/memenv.cc +384 -0
  52. data/ext/leveldb/helpers/memenv/memenv.h +20 -0
  53. data/ext/leveldb/helpers/memenv/memenv_test.cc +232 -0
  54. data/ext/leveldb/include/leveldb/c.h +291 -0
  55. data/ext/leveldb/include/leveldb/cache.h +99 -0
  56. data/ext/leveldb/include/leveldb/comparator.h +63 -0
  57. data/ext/leveldb/include/leveldb/db.h +161 -0
  58. data/ext/leveldb/include/leveldb/env.h +333 -0
  59. data/ext/leveldb/include/leveldb/filter_policy.h +70 -0
  60. data/ext/leveldb/include/leveldb/iterator.h +100 -0
  61. data/ext/leveldb/include/leveldb/options.h +195 -0
  62. data/ext/leveldb/include/leveldb/slice.h +109 -0
  63. data/ext/leveldb/include/leveldb/status.h +106 -0
  64. data/ext/leveldb/include/leveldb/table.h +85 -0
  65. data/ext/leveldb/include/leveldb/table_builder.h +92 -0
  66. data/ext/leveldb/include/leveldb/write_batch.h +64 -0
  67. data/ext/leveldb/issues/issue178_test.cc +92 -0
  68. data/ext/leveldb/port/atomic_pointer.h +224 -0
  69. data/ext/leveldb/port/port.h +19 -0
  70. data/ext/leveldb/port/port_example.h +135 -0
  71. data/ext/leveldb/port/port_posix.cc +54 -0
  72. data/ext/leveldb/port/port_posix.h +157 -0
  73. data/ext/leveldb/port/thread_annotations.h +59 -0
  74. data/ext/leveldb/port/win/stdint.h +24 -0
  75. data/ext/leveldb/table/block.cc +268 -0
  76. data/ext/leveldb/table/block.h +44 -0
  77. data/ext/leveldb/table/block_builder.cc +109 -0
  78. data/ext/leveldb/table/block_builder.h +57 -0
  79. data/ext/leveldb/table/filter_block.cc +111 -0
  80. data/ext/leveldb/table/filter_block.h +68 -0
  81. data/ext/leveldb/table/filter_block_test.cc +128 -0
  82. data/ext/leveldb/table/format.cc +145 -0
  83. data/ext/leveldb/table/format.h +108 -0
  84. data/ext/leveldb/table/iterator.cc +67 -0
  85. data/ext/leveldb/table/iterator_wrapper.h +63 -0
  86. data/ext/leveldb/table/merger.cc +197 -0
  87. data/ext/leveldb/table/merger.h +26 -0
  88. data/ext/leveldb/table/table.cc +275 -0
  89. data/ext/leveldb/table/table_builder.cc +270 -0
  90. data/ext/leveldb/table/table_test.cc +868 -0
  91. data/ext/leveldb/table/two_level_iterator.cc +182 -0
  92. data/ext/leveldb/table/two_level_iterator.h +34 -0
  93. data/ext/leveldb/util/arena.cc +68 -0
  94. data/ext/leveldb/util/arena.h +68 -0
  95. data/ext/leveldb/util/arena_test.cc +68 -0
  96. data/ext/leveldb/util/bloom.cc +95 -0
  97. data/ext/leveldb/util/bloom_test.cc +160 -0
  98. data/ext/leveldb/util/cache.cc +325 -0
  99. data/ext/leveldb/util/cache_test.cc +186 -0
  100. data/ext/leveldb/util/coding.cc +194 -0
  101. data/ext/leveldb/util/coding.h +104 -0
  102. data/ext/leveldb/util/coding_test.cc +196 -0
  103. data/ext/leveldb/util/comparator.cc +81 -0
  104. data/ext/leveldb/util/crc32c.cc +332 -0
  105. data/ext/leveldb/util/crc32c.h +45 -0
  106. data/ext/leveldb/util/crc32c_test.cc +72 -0
  107. data/ext/leveldb/util/env.cc +96 -0
  108. data/ext/leveldb/util/env_posix.cc +698 -0
  109. data/ext/leveldb/util/env_test.cc +104 -0
  110. data/ext/leveldb/util/filter_policy.cc +11 -0
  111. data/ext/leveldb/util/hash.cc +52 -0
  112. data/ext/leveldb/util/hash.h +19 -0
  113. data/ext/leveldb/util/histogram.cc +139 -0
  114. data/ext/leveldb/util/histogram.h +42 -0
  115. data/ext/leveldb/util/logging.cc +81 -0
  116. data/ext/leveldb/util/logging.h +47 -0
  117. data/ext/leveldb/util/mutexlock.h +41 -0
  118. data/ext/leveldb/util/options.cc +29 -0
  119. data/ext/leveldb/util/posix_logger.h +98 -0
  120. data/ext/leveldb/util/random.h +59 -0
  121. data/ext/leveldb/util/status.cc +75 -0
  122. data/ext/leveldb/util/testharness.cc +77 -0
  123. data/ext/leveldb/util/testharness.h +138 -0
  124. data/ext/leveldb/util/testutil.cc +51 -0
  125. data/ext/leveldb/util/testutil.h +53 -0
  126. data/lib/leveldb/version.rb +3 -0
  127. data/lib/leveldb.rb +1006 -0
  128. metadata +228 -0
@@ -0,0 +1,595 @@
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 "leveldb/c.h"
6
+
7
+ #include <stdlib.h>
8
+ #include <unistd.h>
9
+ #include "leveldb/cache.h"
10
+ #include "leveldb/comparator.h"
11
+ #include "leveldb/db.h"
12
+ #include "leveldb/env.h"
13
+ #include "leveldb/filter_policy.h"
14
+ #include "leveldb/iterator.h"
15
+ #include "leveldb/options.h"
16
+ #include "leveldb/status.h"
17
+ #include "leveldb/write_batch.h"
18
+
19
+ using leveldb::Cache;
20
+ using leveldb::Comparator;
21
+ using leveldb::CompressionType;
22
+ using leveldb::DB;
23
+ using leveldb::Env;
24
+ using leveldb::FileLock;
25
+ using leveldb::FilterPolicy;
26
+ using leveldb::Iterator;
27
+ using leveldb::kMajorVersion;
28
+ using leveldb::kMinorVersion;
29
+ using leveldb::Logger;
30
+ using leveldb::NewBloomFilterPolicy;
31
+ using leveldb::NewLRUCache;
32
+ using leveldb::Options;
33
+ using leveldb::RandomAccessFile;
34
+ using leveldb::Range;
35
+ using leveldb::ReadOptions;
36
+ using leveldb::SequentialFile;
37
+ using leveldb::Slice;
38
+ using leveldb::Snapshot;
39
+ using leveldb::Status;
40
+ using leveldb::WritableFile;
41
+ using leveldb::WriteBatch;
42
+ using leveldb::WriteOptions;
43
+
44
+ extern "C" {
45
+
46
+ struct leveldb_t { DB* rep; };
47
+ struct leveldb_iterator_t { Iterator* rep; };
48
+ struct leveldb_writebatch_t { WriteBatch rep; };
49
+ struct leveldb_snapshot_t { const Snapshot* rep; };
50
+ struct leveldb_readoptions_t { ReadOptions rep; };
51
+ struct leveldb_writeoptions_t { WriteOptions rep; };
52
+ struct leveldb_options_t { Options rep; };
53
+ struct leveldb_cache_t { Cache* rep; };
54
+ struct leveldb_seqfile_t { SequentialFile* rep; };
55
+ struct leveldb_randomfile_t { RandomAccessFile* rep; };
56
+ struct leveldb_writablefile_t { WritableFile* rep; };
57
+ struct leveldb_logger_t { Logger* rep; };
58
+ struct leveldb_filelock_t { FileLock* rep; };
59
+
60
+ struct leveldb_comparator_t : public Comparator {
61
+ void* state_;
62
+ void (*destructor_)(void*);
63
+ int (*compare_)(
64
+ void*,
65
+ const char* a, size_t alen,
66
+ const char* b, size_t blen);
67
+ const char* (*name_)(void*);
68
+
69
+ virtual ~leveldb_comparator_t() {
70
+ (*destructor_)(state_);
71
+ }
72
+
73
+ virtual int Compare(const Slice& a, const Slice& b) const {
74
+ return (*compare_)(state_, a.data(), a.size(), b.data(), b.size());
75
+ }
76
+
77
+ virtual const char* Name() const {
78
+ return (*name_)(state_);
79
+ }
80
+
81
+ // No-ops since the C binding does not support key shortening methods.
82
+ virtual void FindShortestSeparator(std::string*, const Slice&) const { }
83
+ virtual void FindShortSuccessor(std::string* key) const { }
84
+ };
85
+
86
+ struct leveldb_filterpolicy_t : public FilterPolicy {
87
+ void* state_;
88
+ void (*destructor_)(void*);
89
+ const char* (*name_)(void*);
90
+ char* (*create_)(
91
+ void*,
92
+ const char* const* key_array, const size_t* key_length_array,
93
+ int num_keys,
94
+ size_t* filter_length);
95
+ unsigned char (*key_match_)(
96
+ void*,
97
+ const char* key, size_t length,
98
+ const char* filter, size_t filter_length);
99
+
100
+ virtual ~leveldb_filterpolicy_t() {
101
+ (*destructor_)(state_);
102
+ }
103
+
104
+ virtual const char* Name() const {
105
+ return (*name_)(state_);
106
+ }
107
+
108
+ virtual void CreateFilter(const Slice* keys, int n, std::string* dst) const {
109
+ std::vector<const char*> key_pointers(n);
110
+ std::vector<size_t> key_sizes(n);
111
+ for (int i = 0; i < n; i++) {
112
+ key_pointers[i] = keys[i].data();
113
+ key_sizes[i] = keys[i].size();
114
+ }
115
+ size_t len;
116
+ char* filter = (*create_)(state_, &key_pointers[0], &key_sizes[0], n, &len);
117
+ dst->append(filter, len);
118
+ free(filter);
119
+ }
120
+
121
+ virtual bool KeyMayMatch(const Slice& key, const Slice& filter) const {
122
+ return (*key_match_)(state_, key.data(), key.size(),
123
+ filter.data(), filter.size());
124
+ }
125
+ };
126
+
127
+ struct leveldb_env_t {
128
+ Env* rep;
129
+ bool is_default;
130
+ };
131
+
132
+ static bool SaveError(char** errptr, const Status& s) {
133
+ assert(errptr != NULL);
134
+ if (s.ok()) {
135
+ return false;
136
+ } else if (*errptr == NULL) {
137
+ *errptr = strdup(s.ToString().c_str());
138
+ } else {
139
+ // TODO(sanjay): Merge with existing error?
140
+ free(*errptr);
141
+ *errptr = strdup(s.ToString().c_str());
142
+ }
143
+ return true;
144
+ }
145
+
146
+ static char* CopyString(const std::string& str) {
147
+ char* result = reinterpret_cast<char*>(malloc(sizeof(char) * str.size()));
148
+ memcpy(result, str.data(), sizeof(char) * str.size());
149
+ return result;
150
+ }
151
+
152
+ leveldb_t* leveldb_open(
153
+ const leveldb_options_t* options,
154
+ const char* name,
155
+ char** errptr) {
156
+ DB* db;
157
+ if (SaveError(errptr, DB::Open(options->rep, std::string(name), &db))) {
158
+ return NULL;
159
+ }
160
+ leveldb_t* result = new leveldb_t;
161
+ result->rep = db;
162
+ return result;
163
+ }
164
+
165
+ void leveldb_close(leveldb_t* db) {
166
+ delete db->rep;
167
+ delete db;
168
+ }
169
+
170
+ void leveldb_put(
171
+ leveldb_t* db,
172
+ const leveldb_writeoptions_t* options,
173
+ const char* key, size_t keylen,
174
+ const char* val, size_t vallen,
175
+ char** errptr) {
176
+ SaveError(errptr,
177
+ db->rep->Put(options->rep, Slice(key, keylen), Slice(val, vallen)));
178
+ }
179
+
180
+ void leveldb_delete(
181
+ leveldb_t* db,
182
+ const leveldb_writeoptions_t* options,
183
+ const char* key, size_t keylen,
184
+ char** errptr) {
185
+ SaveError(errptr, db->rep->Delete(options->rep, Slice(key, keylen)));
186
+ }
187
+
188
+
189
+ void leveldb_write(
190
+ leveldb_t* db,
191
+ const leveldb_writeoptions_t* options,
192
+ leveldb_writebatch_t* batch,
193
+ char** errptr) {
194
+ SaveError(errptr, db->rep->Write(options->rep, &batch->rep));
195
+ }
196
+
197
+ char* leveldb_get(
198
+ leveldb_t* db,
199
+ const leveldb_readoptions_t* options,
200
+ const char* key, size_t keylen,
201
+ size_t* vallen,
202
+ char** errptr) {
203
+ char* result = NULL;
204
+ std::string tmp;
205
+ Status s = db->rep->Get(options->rep, Slice(key, keylen), &tmp);
206
+ if (s.ok()) {
207
+ *vallen = tmp.size();
208
+ result = CopyString(tmp);
209
+ } else {
210
+ *vallen = 0;
211
+ if (!s.IsNotFound()) {
212
+ SaveError(errptr, s);
213
+ }
214
+ }
215
+ return result;
216
+ }
217
+
218
+ leveldb_iterator_t* leveldb_create_iterator(
219
+ leveldb_t* db,
220
+ const leveldb_readoptions_t* options) {
221
+ leveldb_iterator_t* result = new leveldb_iterator_t;
222
+ result->rep = db->rep->NewIterator(options->rep);
223
+ return result;
224
+ }
225
+
226
+ const leveldb_snapshot_t* leveldb_create_snapshot(
227
+ leveldb_t* db) {
228
+ leveldb_snapshot_t* result = new leveldb_snapshot_t;
229
+ result->rep = db->rep->GetSnapshot();
230
+ return result;
231
+ }
232
+
233
+ void leveldb_release_snapshot(
234
+ leveldb_t* db,
235
+ const leveldb_snapshot_t* snapshot) {
236
+ db->rep->ReleaseSnapshot(snapshot->rep);
237
+ delete snapshot;
238
+ }
239
+
240
+ char* leveldb_property_value(
241
+ leveldb_t* db,
242
+ const char* propname) {
243
+ std::string tmp;
244
+ if (db->rep->GetProperty(Slice(propname), &tmp)) {
245
+ // We use strdup() since we expect human readable output.
246
+ return strdup(tmp.c_str());
247
+ } else {
248
+ return NULL;
249
+ }
250
+ }
251
+
252
+ void leveldb_approximate_sizes(
253
+ leveldb_t* db,
254
+ int num_ranges,
255
+ const char* const* range_start_key, const size_t* range_start_key_len,
256
+ const char* const* range_limit_key, const size_t* range_limit_key_len,
257
+ uint64_t* sizes) {
258
+ Range* ranges = new Range[num_ranges];
259
+ for (int i = 0; i < num_ranges; i++) {
260
+ ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]);
261
+ ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]);
262
+ }
263
+ db->rep->GetApproximateSizes(ranges, num_ranges, sizes);
264
+ delete[] ranges;
265
+ }
266
+
267
+ void leveldb_compact_range(
268
+ leveldb_t* db,
269
+ const char* start_key, size_t start_key_len,
270
+ const char* limit_key, size_t limit_key_len) {
271
+ Slice a, b;
272
+ db->rep->CompactRange(
273
+ // Pass NULL Slice if corresponding "const char*" is NULL
274
+ (start_key ? (a = Slice(start_key, start_key_len), &a) : NULL),
275
+ (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : NULL));
276
+ }
277
+
278
+ void leveldb_destroy_db(
279
+ const leveldb_options_t* options,
280
+ const char* name,
281
+ char** errptr) {
282
+ SaveError(errptr, DestroyDB(name, options->rep));
283
+ }
284
+
285
+ void leveldb_repair_db(
286
+ const leveldb_options_t* options,
287
+ const char* name,
288
+ char** errptr) {
289
+ SaveError(errptr, RepairDB(name, options->rep));
290
+ }
291
+
292
+ void leveldb_iter_destroy(leveldb_iterator_t* iter) {
293
+ delete iter->rep;
294
+ delete iter;
295
+ }
296
+
297
+ unsigned char leveldb_iter_valid(const leveldb_iterator_t* iter) {
298
+ return iter->rep->Valid();
299
+ }
300
+
301
+ void leveldb_iter_seek_to_first(leveldb_iterator_t* iter) {
302
+ iter->rep->SeekToFirst();
303
+ }
304
+
305
+ void leveldb_iter_seek_to_last(leveldb_iterator_t* iter) {
306
+ iter->rep->SeekToLast();
307
+ }
308
+
309
+ void leveldb_iter_seek(leveldb_iterator_t* iter, const char* k, size_t klen) {
310
+ iter->rep->Seek(Slice(k, klen));
311
+ }
312
+
313
+ void leveldb_iter_next(leveldb_iterator_t* iter) {
314
+ iter->rep->Next();
315
+ }
316
+
317
+ void leveldb_iter_prev(leveldb_iterator_t* iter) {
318
+ iter->rep->Prev();
319
+ }
320
+
321
+ const char* leveldb_iter_key(const leveldb_iterator_t* iter, size_t* klen) {
322
+ Slice s = iter->rep->key();
323
+ *klen = s.size();
324
+ return s.data();
325
+ }
326
+
327
+ const char* leveldb_iter_value(const leveldb_iterator_t* iter, size_t* vlen) {
328
+ Slice s = iter->rep->value();
329
+ *vlen = s.size();
330
+ return s.data();
331
+ }
332
+
333
+ void leveldb_iter_get_error(const leveldb_iterator_t* iter, char** errptr) {
334
+ SaveError(errptr, iter->rep->status());
335
+ }
336
+
337
+ leveldb_writebatch_t* leveldb_writebatch_create() {
338
+ return new leveldb_writebatch_t;
339
+ }
340
+
341
+ void leveldb_writebatch_destroy(leveldb_writebatch_t* b) {
342
+ delete b;
343
+ }
344
+
345
+ void leveldb_writebatch_clear(leveldb_writebatch_t* b) {
346
+ b->rep.Clear();
347
+ }
348
+
349
+ void leveldb_writebatch_put(
350
+ leveldb_writebatch_t* b,
351
+ const char* key, size_t klen,
352
+ const char* val, size_t vlen) {
353
+ b->rep.Put(Slice(key, klen), Slice(val, vlen));
354
+ }
355
+
356
+ void leveldb_writebatch_delete(
357
+ leveldb_writebatch_t* b,
358
+ const char* key, size_t klen) {
359
+ b->rep.Delete(Slice(key, klen));
360
+ }
361
+
362
+ void leveldb_writebatch_iterate(
363
+ leveldb_writebatch_t* b,
364
+ void* state,
365
+ void (*put)(void*, const char* k, size_t klen, const char* v, size_t vlen),
366
+ void (*deleted)(void*, const char* k, size_t klen)) {
367
+ class H : public WriteBatch::Handler {
368
+ public:
369
+ void* state_;
370
+ void (*put_)(void*, const char* k, size_t klen, const char* v, size_t vlen);
371
+ void (*deleted_)(void*, const char* k, size_t klen);
372
+ virtual void Put(const Slice& key, const Slice& value) {
373
+ (*put_)(state_, key.data(), key.size(), value.data(), value.size());
374
+ }
375
+ virtual void Delete(const Slice& key) {
376
+ (*deleted_)(state_, key.data(), key.size());
377
+ }
378
+ };
379
+ H handler;
380
+ handler.state_ = state;
381
+ handler.put_ = put;
382
+ handler.deleted_ = deleted;
383
+ b->rep.Iterate(&handler);
384
+ }
385
+
386
+ leveldb_options_t* leveldb_options_create() {
387
+ return new leveldb_options_t;
388
+ }
389
+
390
+ void leveldb_options_destroy(leveldb_options_t* options) {
391
+ delete options;
392
+ }
393
+
394
+ void leveldb_options_set_comparator(
395
+ leveldb_options_t* opt,
396
+ leveldb_comparator_t* cmp) {
397
+ opt->rep.comparator = cmp;
398
+ }
399
+
400
+ void leveldb_options_set_filter_policy(
401
+ leveldb_options_t* opt,
402
+ leveldb_filterpolicy_t* policy) {
403
+ opt->rep.filter_policy = policy;
404
+ }
405
+
406
+ void leveldb_options_set_create_if_missing(
407
+ leveldb_options_t* opt, unsigned char v) {
408
+ opt->rep.create_if_missing = v;
409
+ }
410
+
411
+ void leveldb_options_set_error_if_exists(
412
+ leveldb_options_t* opt, unsigned char v) {
413
+ opt->rep.error_if_exists = v;
414
+ }
415
+
416
+ void leveldb_options_set_paranoid_checks(
417
+ leveldb_options_t* opt, unsigned char v) {
418
+ opt->rep.paranoid_checks = v;
419
+ }
420
+
421
+ void leveldb_options_set_env(leveldb_options_t* opt, leveldb_env_t* env) {
422
+ opt->rep.env = (env ? env->rep : NULL);
423
+ }
424
+
425
+ void leveldb_options_set_info_log(leveldb_options_t* opt, leveldb_logger_t* l) {
426
+ opt->rep.info_log = (l ? l->rep : NULL);
427
+ }
428
+
429
+ void leveldb_options_set_write_buffer_size(leveldb_options_t* opt, size_t s) {
430
+ opt->rep.write_buffer_size = s;
431
+ }
432
+
433
+ void leveldb_options_set_max_open_files(leveldb_options_t* opt, int n) {
434
+ opt->rep.max_open_files = n;
435
+ }
436
+
437
+ void leveldb_options_set_cache(leveldb_options_t* opt, leveldb_cache_t* c) {
438
+ opt->rep.block_cache = c->rep;
439
+ }
440
+
441
+ void leveldb_options_set_block_size(leveldb_options_t* opt, size_t s) {
442
+ opt->rep.block_size = s;
443
+ }
444
+
445
+ void leveldb_options_set_block_restart_interval(leveldb_options_t* opt, int n) {
446
+ opt->rep.block_restart_interval = n;
447
+ }
448
+
449
+ void leveldb_options_set_compression(leveldb_options_t* opt, int t) {
450
+ opt->rep.compression = static_cast<CompressionType>(t);
451
+ }
452
+
453
+ leveldb_comparator_t* leveldb_comparator_create(
454
+ void* state,
455
+ void (*destructor)(void*),
456
+ int (*compare)(
457
+ void*,
458
+ const char* a, size_t alen,
459
+ const char* b, size_t blen),
460
+ const char* (*name)(void*)) {
461
+ leveldb_comparator_t* result = new leveldb_comparator_t;
462
+ result->state_ = state;
463
+ result->destructor_ = destructor;
464
+ result->compare_ = compare;
465
+ result->name_ = name;
466
+ return result;
467
+ }
468
+
469
+ void leveldb_comparator_destroy(leveldb_comparator_t* cmp) {
470
+ delete cmp;
471
+ }
472
+
473
+ leveldb_filterpolicy_t* leveldb_filterpolicy_create(
474
+ void* state,
475
+ void (*destructor)(void*),
476
+ char* (*create_filter)(
477
+ void*,
478
+ const char* const* key_array, const size_t* key_length_array,
479
+ int num_keys,
480
+ size_t* filter_length),
481
+ unsigned char (*key_may_match)(
482
+ void*,
483
+ const char* key, size_t length,
484
+ const char* filter, size_t filter_length),
485
+ const char* (*name)(void*)) {
486
+ leveldb_filterpolicy_t* result = new leveldb_filterpolicy_t;
487
+ result->state_ = state;
488
+ result->destructor_ = destructor;
489
+ result->create_ = create_filter;
490
+ result->key_match_ = key_may_match;
491
+ result->name_ = name;
492
+ return result;
493
+ }
494
+
495
+ void leveldb_filterpolicy_destroy(leveldb_filterpolicy_t* filter) {
496
+ delete filter;
497
+ }
498
+
499
+ leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom(int bits_per_key) {
500
+ // Make a leveldb_filterpolicy_t, but override all of its methods so
501
+ // they delegate to a NewBloomFilterPolicy() instead of user
502
+ // supplied C functions.
503
+ struct Wrapper : public leveldb_filterpolicy_t {
504
+ const FilterPolicy* rep_;
505
+ ~Wrapper() { delete rep_; }
506
+ const char* Name() const { return rep_->Name(); }
507
+ void CreateFilter(const Slice* keys, int n, std::string* dst) const {
508
+ return rep_->CreateFilter(keys, n, dst);
509
+ }
510
+ bool KeyMayMatch(const Slice& key, const Slice& filter) const {
511
+ return rep_->KeyMayMatch(key, filter);
512
+ }
513
+ static void DoNothing(void*) { }
514
+ };
515
+ Wrapper* wrapper = new Wrapper;
516
+ wrapper->rep_ = NewBloomFilterPolicy(bits_per_key);
517
+ wrapper->state_ = NULL;
518
+ wrapper->destructor_ = &Wrapper::DoNothing;
519
+ return wrapper;
520
+ }
521
+
522
+ leveldb_readoptions_t* leveldb_readoptions_create() {
523
+ return new leveldb_readoptions_t;
524
+ }
525
+
526
+ void leveldb_readoptions_destroy(leveldb_readoptions_t* opt) {
527
+ delete opt;
528
+ }
529
+
530
+ void leveldb_readoptions_set_verify_checksums(
531
+ leveldb_readoptions_t* opt,
532
+ unsigned char v) {
533
+ opt->rep.verify_checksums = v;
534
+ }
535
+
536
+ void leveldb_readoptions_set_fill_cache(
537
+ leveldb_readoptions_t* opt, unsigned char v) {
538
+ opt->rep.fill_cache = v;
539
+ }
540
+
541
+ void leveldb_readoptions_set_snapshot(
542
+ leveldb_readoptions_t* opt,
543
+ const leveldb_snapshot_t* snap) {
544
+ opt->rep.snapshot = (snap ? snap->rep : NULL);
545
+ }
546
+
547
+ leveldb_writeoptions_t* leveldb_writeoptions_create() {
548
+ return new leveldb_writeoptions_t;
549
+ }
550
+
551
+ void leveldb_writeoptions_destroy(leveldb_writeoptions_t* opt) {
552
+ delete opt;
553
+ }
554
+
555
+ void leveldb_writeoptions_set_sync(
556
+ leveldb_writeoptions_t* opt, unsigned char v) {
557
+ opt->rep.sync = v;
558
+ }
559
+
560
+ leveldb_cache_t* leveldb_cache_create_lru(size_t capacity) {
561
+ leveldb_cache_t* c = new leveldb_cache_t;
562
+ c->rep = NewLRUCache(capacity);
563
+ return c;
564
+ }
565
+
566
+ void leveldb_cache_destroy(leveldb_cache_t* cache) {
567
+ delete cache->rep;
568
+ delete cache;
569
+ }
570
+
571
+ leveldb_env_t* leveldb_create_default_env() {
572
+ leveldb_env_t* result = new leveldb_env_t;
573
+ result->rep = Env::Default();
574
+ result->is_default = true;
575
+ return result;
576
+ }
577
+
578
+ void leveldb_env_destroy(leveldb_env_t* env) {
579
+ if (!env->is_default) delete env->rep;
580
+ delete env;
581
+ }
582
+
583
+ void leveldb_free(void* ptr) {
584
+ free(ptr);
585
+ }
586
+
587
+ int leveldb_major_version() {
588
+ return kMajorVersion;
589
+ }
590
+
591
+ int leveldb_minor_version() {
592
+ return kMinorVersion;
593
+ }
594
+
595
+ } // end extern "C"