reftable/record.h

   1 /*
   2 Copyright 2020 Google LLC
   3
   4 Use of this source code is governed by a BSD-style
   5 license that can be found in the LICENSE file or at
   6 https://developers.google.com/open-source/licenses/bsd
   7 */
   8
   9 #ifndef RECORD_H
  10 #define RECORD_H
  11
  12 #include "system.h"
  13
  14 #include <stdint.h>
  15
  16 #include "reftable-record.h"
  17
  18 /*
  19  * A substring of existing string data. This structure takes no responsibility
  20  * for the lifetime of the data it points to.
  21  */
  22 struct string_view {
  23         uint8_t *buf;
  24         size_t len;
  25 };
  26
  27 /* Advance `s.buf` by `n`, and decrease length. */
  28 static inline void string_view_consume(struct string_view *s, int n)
  29 {
  30         s->buf += n;
  31         s->len -= n;
  32 }
  33
  34 /* utilities for de/encoding varints */
  35
  36 int get_var_int(uint64_t *dest, struct string_view *in);
  37 int put_var_int(struct string_view *dest, uint64_t val);
  38
  39 /* Methods for records. */
  40 struct reftable_record_vtable {
  41         /* encode the key of to a uint8_t strbuf. */
  42         void (*key)(const void *rec, struct strbuf *dest);
  43
  44         /* The record type of ('r' for ref). */
  45         uint8_t type;
  46
  47         void (*copy_from)(void *dest, const void *src, int hash_size);
  48
  49         /* a value of [0..7], indicating record subvariants (eg. ref vs. symref
  50          * vs ref deletion) */
  51         uint8_t (*val_type)(const void *rec);
  52
  53         /* encodes rec into dest, returning how much space was used. */
  54         int (*encode)(const void *rec, struct string_view dest, int hash_size);
  55
  56         /* decode data from `src` into the record. */
  57         int (*decode)(void *rec, struct strbuf key, uint8_t extra,
  58                       struct string_view src, int hash_size);
  59
  60         /* deallocate and null the record. */
  61         void (*release)(void *rec);
  62
  63         /* is this a tombstone? */
  64         int (*is_deletion)(const void *rec);
  65
  66         /* Are two records equal? This assumes they have the same type. Returns 0 for non-equal. */
  67         int (*equal)(const void *a, const void *b, int hash_size);
  68
  69         /*
  70          * Compare keys of two records with each other. The records must have
  71          * the same type.
  72          */
  73         int (*cmp)(const void *a, const void *b);
  74
  75         /* Print on stdout, for debugging. */
  76         void (*print)(const void *rec, int hash_size);
  77 };
  78
  79 /* returns true for recognized block types. Block start with the block type. */
  80 int reftable_is_block_type(uint8_t typ);
  81
  82 /* Encode `key` into `dest`. Sets `is_restart` to indicate a restart. Returns
  83  * number of bytes written. */
  84 int reftable_encode_key(int *is_restart, struct string_view dest,
  85                         struct strbuf prev_key, struct strbuf key,
  86                         uint8_t extra);
  87
  88 /*
  89  * Decode into `last_key` and `extra` from `in`. `last_key` is expected to
  90  * contain the decoded key of the preceding record, if any.
  91  */
  92 int reftable_decode_key(struct strbuf *last_key, uint8_t *extra,
  93                         struct string_view in);
  94
  95 /* reftable_index_record are used internally to speed up lookups. */
  96 struct reftable_index_record {
  97         uint64_t offset; /* Offset of block */
  98         struct strbuf last_key; /* Last key of the block. */
  99 };
 100
 101 /* reftable_obj_record stores an object ID => ref mapping. */
 102 struct reftable_obj_record {
 103         uint8_t *hash_prefix; /* leading bytes of the object ID */
 104         int hash_prefix_len; /* number of leading bytes. Constant
 105                               * across a single table. */
 106         uint64_t *offsets; /* a vector of file offsets. */
 107         int offset_len;
 108 };
 109
 110 /* record is a generic wrapper for different types of records. It is normally
 111  * created on the stack, or embedded within another struct. If the type is
 112  * known, a fresh instance can be initialized explicitly. Otherwise, use
 113  * `reftable_record_init()` to initialize generically (as the index_record is
 114  * not valid as 0-initialized structure)
 115  */
 116 struct reftable_record {
 117         uint8_t type;
 118         union {
 119                 struct reftable_ref_record ref;
 120                 struct reftable_log_record log;
 121                 struct reftable_obj_record obj;
 122                 struct reftable_index_record idx;
 123         } u;
 124 };
 125
 126 /* Initialize the reftable record for the given type */
 127 void reftable_record_init(struct reftable_record *rec, uint8_t typ);
 128
 129 /* see struct record_vtable */
 130 int reftable_record_cmp(struct reftable_record *a, struct reftable_record *b);
 131 int reftable_record_equal(struct reftable_record *a, struct reftable_record *b, int hash_size);
 132 void reftable_record_print(struct reftable_record *rec, int hash_size);
 133 void reftable_record_key(struct reftable_record *rec, struct strbuf *dest);
 134 void reftable_record_copy_from(struct reftable_record *rec,
 135                                struct reftable_record *src, int hash_size);
 136 uint8_t reftable_record_val_type(struct reftable_record *rec);
 137 int reftable_record_encode(struct reftable_record *rec, struct string_view dest,
 138                            int hash_size);
 139 int reftable_record_decode(struct reftable_record *rec, struct strbuf key,
 140                            uint8_t extra, struct string_view src,
 141                            int hash_size);
 142 int reftable_record_is_deletion(struct reftable_record *rec);
 143
 144 static inline uint8_t reftable_record_type(struct reftable_record *rec)
 145 {
 146         return rec->type;
 147 }
 148
 149 /* frees and zeroes out the embedded record */
 150 void reftable_record_release(struct reftable_record *rec);
 151
 152 /* for qsort. */
 153 int reftable_ref_record_compare_name(const void *a, const void *b);
 154
 155 /* for qsort. */
 156 int reftable_log_record_compare_key(const void *a, const void *b);
 157
 158 #endif