Inside Bitcoin

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#ifndef STORAGE_LEVELDB_TABLE_FORMAT_H_
6#define STORAGE_LEVELDB_TABLE_FORMAT_H_
7
8#include <stdint.h>
9
10#include <string>
11
12#include "leveldb/slice.h"
13#include "leveldb/status.h"
14#include "leveldb/table_builder.h"
15
16namespace leveldb {
17
18class Block;
19class RandomAccessFile;
20struct ReadOptions;
21
22// BlockHandle is a pointer to the extent of a file that stores a data
23// block or a meta block.
24class BlockHandle {
25 public:
26  // Maximum encoding length of a BlockHandle
27  enum { kMaxEncodedLength = 10 + 10 };
28
29  BlockHandle();
30
31  // The offset of the block in the file.
32  uint64_t offset() const { return offset_; }
33  void set_offset(uint64_t offset) { offset_ = offset; }
34
35  // The size of the stored block
36  uint64_t size() const { return size_; }
37  void set_size(uint64_t size) { size_ = size; }
38
39  void EncodeTo(std::string* dst) const;
40  Status DecodeFrom(Slice* input);
41
42 private:
43  uint64_t offset_;
44  uint64_t size_;
45};
46
47// Footer encapsulates the fixed information stored at the tail
48// end of every table file.
49class Footer {
50 public:
51  // Encoded length of a Footer.  Note that the serialization of a
52  // Footer will always occupy exactly this many bytes.  It consists
53  // of two block handles and a magic number.
54  enum { kEncodedLength = 2 * BlockHandle::kMaxEncodedLength + 8 };
55
56  Footer() = default;
57
58  // The block handle for the metaindex block of the table
59  const BlockHandle& metaindex_handle() const { return metaindex_handle_; }
60  void set_metaindex_handle(const BlockHandle& h) { metaindex_handle_ = h; }
61
62  // The block handle for the index block of the table
63  const BlockHandle& index_handle() const { return index_handle_; }
64  void set_index_handle(const BlockHandle& h) { index_handle_ = h; }
65
66  void EncodeTo(std::string* dst) const;
67  Status DecodeFrom(Slice* input);
68
69 private:
70  BlockHandle metaindex_handle_;
71  BlockHandle index_handle_;
72};
73
74// kTableMagicNumber was picked by running
75//    echo http://code.google.com/p/leveldb/ | sha1sum
76// and taking the leading 64 bits.
77static const uint64_t kTableMagicNumber = 0xdb4775248b80fb57ull;
78
79// 1-byte type + 32-bit crc
80static const size_t kBlockTrailerSize = 5;
81
82struct BlockContents {
83  Slice data;           // Actual contents of data
84  bool cachable;        // True iff data can be cached
85  bool heap_allocated;  // True iff caller should delete[] data.data()
86};
87
88// Read the block identified by "handle" from "file".  On failure
89// return non-OK.  On success fill *result and return OK.
90Status ReadBlock(RandomAccessFile* file, const ReadOptions& options,
91                 const BlockHandle& handle, BlockContents* result);
92
93// Implementation details follow.  Clients should ignore,
94
95inline BlockHandle::BlockHandle()
96    : offset_(~static_cast<uint64_t>(0)), size_(~static_cast<uint64_t>(0)) {}
97
98}  // namespace leveldb
99
100#endif  // STORAGE_LEVELDB_TABLE_FORMAT_H_
101