Inside Bitcoin

251  Range* ranges = new Range[num_ranges];
252  for (int i = 0; i < num_ranges; i++) {
253    ranges[i].start = Slice(range_start_key[i], range_start_key_len[i]);
254    ranges[i].limit = Slice(range_limit_key[i], range_limit_key_len[i]);
255  }
256  db->rep->GetApproximateSizes(ranges, num_ranges, sizes);
257  delete[] ranges;
258}
259
260void leveldb_compact_range(leveldb_t* db, const char* start_key,
261                           size_t start_key_len, const char* limit_key,
262                           size_t limit_key_len) {
263  Slice a, b;
264  db->rep->CompactRange(
265      // Pass null Slice if corresponding "const char*" is null
266      (start_key ? (a = Slice(start_key, start_key_len), &a) : nullptr),
267      (limit_key ? (b = Slice(limit_key, limit_key_len), &b) : nullptr));
268}
269
270void leveldb_destroy_db(const leveldb_options_t* options, const char* name,
271                        char** errptr) {
272  SaveError(errptr, DestroyDB(name, options->rep));
273}
274
275void leveldb_repair_db(const leveldb_options_t* options, const char* name,
276                       char** errptr) {
277  SaveError(errptr, RepairDB(name, options->rep));
278}
279
280void leveldb_iter_destroy(leveldb_iterator_t* iter) {
281  delete iter->rep;
282  delete iter;
283}
284
285uint8_t leveldb_iter_valid(const leveldb_iterator_t* iter) {
286  return iter->rep->Valid();
287}
288
289void leveldb_iter_seek_to_first(leveldb_iterator_t* iter) {
290  iter->rep->SeekToFirst();
291}
292
293void leveldb_iter_seek_to_last(leveldb_iterator_t* iter) {
294  iter->rep->SeekToLast();
295}
296
297void leveldb_iter_seek(leveldb_iterator_t* iter, const char* k, size_t klen) {
298  iter->rep->Seek(Slice(k, klen));
299}
300
301void leveldb_iter_next(leveldb_iterator_t* iter) { iter->rep->Next(); }
302
303void leveldb_iter_prev(leveldb_iterator_t* iter) { iter->rep->Prev(); }
304
305const char* leveldb_iter_key(const leveldb_iterator_t* iter, size_t* klen) {
306  Slice s = iter->rep->key();
307  *klen = s.size();
308  return s.data();
309}
310
311const char* leveldb_iter_value(const leveldb_iterator_t* iter, size_t* vlen) {
312  Slice s = iter->rep->value();
313  *vlen = s.size();
314  return s.data();
315}
316
317void leveldb_iter_get_error(const leveldb_iterator_t* iter, char** errptr) {
318  SaveError(errptr, iter->rep->status());
319}
320
321leveldb_writebatch_t* leveldb_writebatch_create() {
322  return new leveldb_writebatch_t;
323}
324
325void leveldb_writebatch_destroy(leveldb_writebatch_t* b) { delete b; }
326
327void leveldb_writebatch_clear(leveldb_writebatch_t* b) { b->rep.Clear(); }
328
329void leveldb_writebatch_put(leveldb_writebatch_t* b, const char* key,
330                            size_t klen, const char* val, size_t vlen) {
331  b->rep.Put(Slice(key, klen), Slice(val, vlen));
332}
333
334void leveldb_writebatch_delete(leveldb_writebatch_t* b, const char* key,
335                               size_t klen) {
336  b->rep.Delete(Slice(key, klen));
337}
338
339void leveldb_writebatch_iterate(const leveldb_writebatch_t* b, void* state,
340                                void (*put)(void*, const char* k, size_t klen,
341                                            const char* v, size_t vlen),
342                                void (*deleted)(void*, const char* k,
343                                                size_t klen)) {
344  class H : public WriteBatch::Handler {
345   public:
346    void* state_;
347    void (*put_)(void*, const char* k, size_t klen, const char* v, size_t vlen);
348    void (*deleted_)(void*, const char* k, size_t klen);
349    void Put(const Slice& key, const Slice& value) override {
350      (*put_)(state_, key.data(), key.size(), value.data(), value.size());
351    }
352    void Delete(const Slice& key) override {
353      (*deleted_)(state_, key.data(), key.size());
354    }
355  };
356  H handler;
357  handler.state_ = state;
358  handler.put_ = put;
359  handler.deleted_ = deleted;
360  b->rep.Iterate(&handler);
361}
362
363void leveldb_writebatch_append(leveldb_writebatch_t* destination,
364                               const leveldb_writebatch_t* source) {
365  destination->rep.Append(source->rep);
366}
367
368leveldb_options_t* leveldb_options_create() { return new leveldb_options_t; }
369
370void leveldb_options_destroy(leveldb_options_t* options) { delete options; }
371
372void leveldb_options_set_comparator(leveldb_options_t* opt,
373                                    leveldb_comparator_t* cmp) {
374  opt->rep.comparator = cmp;
375}
376
377void leveldb_options_set_filter_policy(leveldb_options_t* opt,
378                                       leveldb_filterpolicy_t* policy) {
379  opt->rep.filter_policy = policy;
380}
381
382void leveldb_options_set_create_if_missing(leveldb_options_t* opt, uint8_t v) {
383  opt->rep.create_if_missing = v;
384}
385
386void leveldb_options_set_error_if_exists(leveldb_options_t* opt, uint8_t v) {
387  opt->rep.error_if_exists = v;
388}
389
390void leveldb_options_set_paranoid_checks(leveldb_options_t* opt, uint8_t v) {
391  opt->rep.paranoid_checks = v;
392}
393
394void leveldb_options_set_env(leveldb_options_t* opt, leveldb_env_t* env) {
395  opt->rep.env = (env ? env->rep : nullptr);
396}
397
398void leveldb_options_set_info_log(leveldb_options_t* opt, leveldb_logger_t* l) {
399  opt->rep.info_log = (l ? l->rep : nullptr);
400}
401
402void leveldb_options_set_write_buffer_size(leveldb_options_t* opt, size_t s) {
403  opt->rep.write_buffer_size = s;
404}
405
406void leveldb_options_set_max_open_files(leveldb_options_t* opt, int n) {
407  opt->rep.max_open_files = n;
408}
409
410void leveldb_options_set_cache(leveldb_options_t* opt, leveldb_cache_t* c) {
411  opt->rep.block_cache = c->rep;
412}
413
414void leveldb_options_set_block_size(leveldb_options_t* opt, size_t s) {
415  opt->rep.block_size = s;
416}
417
418void leveldb_options_set_block_restart_interval(leveldb_options_t* opt, int n) {
419  opt->rep.block_restart_interval = n;
420}
421
422void leveldb_options_set_max_file_size(leveldb_options_t* opt, size_t s) {
423  opt->rep.max_file_size = s;
424}
425
426void leveldb_options_set_compression(leveldb_options_t* opt, int t) {
427  opt->rep.compression = static_cast<CompressionType>(t);
428}
429
430leveldb_comparator_t* leveldb_comparator_create(
431    void* state, void (*destructor)(void*),
432    int (*compare)(void*, const char* a, size_t alen, const char* b,
433                   size_t blen),
434    const char* (*name)(void*)) {
435  leveldb_comparator_t* result = new leveldb_comparator_t;
436  result->state_ = state;
437  result->destructor_ = destructor;
438  result->compare_ = compare;
439  result->name_ = name;
440  return result;
441}
442
443void leveldb_comparator_destroy(leveldb_comparator_t* cmp) { delete cmp; }
444
445leveldb_filterpolicy_t* leveldb_filterpolicy_create(
446    void* state, void (*destructor)(void*),
447    char* (*create_filter)(void*, const char* const* key_array,
448                           const size_t* key_length_array, int num_keys,
449                           size_t* filter_length),
450    uint8_t (*key_may_match)(void*, const char* key, size_t length,
451                             const char* filter, size_t filter_length),
452    const char* (*name)(void*)) {
453  leveldb_filterpolicy_t* result = new leveldb_filterpolicy_t;
454  result->state_ = state;
455  result->destructor_ = destructor;
456  result->create_ = create_filter;
457  result->key_match_ = key_may_match;
458  result->name_ = name;
459  return result;
460}
461
462void leveldb_filterpolicy_destroy(leveldb_filterpolicy_t* filter) {
463  delete filter;
464}
465
466leveldb_filterpolicy_t* leveldb_filterpolicy_create_bloom(int bits_per_key) {
467  // Make a leveldb_filterpolicy_t, but override all of its methods so
468  // they delegate to a NewBloomFilterPolicy() instead of user
469  // supplied C functions.
470  struct Wrapper : public leveldb_filterpolicy_t {
471    static void DoNothing(void*) {}
472
473    ~Wrapper() { delete rep_; }
474    const char* Name() const override { return rep_->Name(); }
475    void CreateFilter(const Slice* keys, int n, std::string* dst) const override {
476      return rep_->CreateFilter(keys, n, dst);
477    }
478    bool KeyMayMatch(const Slice& key, const Slice& filter) const override {
479      return rep_->KeyMayMatch(key, filter);
480    }
481
482    const FilterPolicy* rep_;
483  };
484  Wrapper* wrapper = new Wrapper;
485  wrapper->rep_ = NewBloomFilterPolicy(bits_per_key);
486  wrapper->state_ = nullptr;
487  wrapper->destructor_ = &Wrapper::DoNothing;
488  return wrapper;
489}
490
491leveldb_readoptions_t* leveldb_readoptions_create() {
492  return new leveldb_readoptions_t;
493}
494
495void leveldb_readoptions_destroy(leveldb_readoptions_t* opt) { delete opt; }
496
497void leveldb_readoptions_set_verify_checksums(leveldb_readoptions_t* opt,
498                                              uint8_t v) {
499  opt->rep.verify_checksums = v;
500}