git/reftable/record.h

/*
Copyright 2020 Google LLC

Use of this source code is governed by a BSD-style
license that can be found in the LICENSE file or at
https://developers.google.com/open-source/licenses/bsd
*/

#ifndef RECORD_H
#define RECORD_H

#include "basics.h"
#include "system.h"

#include <stdint.h>

#include "reftable-record.h"

/*
 * A substring of existing string data. This structure takes no responsibility
 * for the lifetime of the data it points to.
 */
struct string_view { … };

/* Advance `s.buf` by `n`, and decrease length. */
static inline void string_view_consume(struct string_view *s, int n)
{ … }

/* utilities for de/encoding varints */

int get_var_int(uint64_t *dest, struct string_view *in);
int put_var_int(struct string_view *dest, uint64_t val);

/* Methods for records. */
struct reftable_record_vtable { … };

/* returns true for recognized block types. Block start with the block type. */
int reftable_is_block_type(uint8_t typ);

/* Encode `key` into `dest`. Sets `is_restart` to indicate a restart. Returns
 * number of bytes written. */
int reftable_encode_key(int *is_restart, struct string_view dest,
			struct reftable_buf prev_key, struct reftable_buf key,
			uint8_t extra);

/* Decode a record's key lengths. */
int reftable_decode_keylen(struct string_view in,
			   uint64_t *prefix_len,
			   uint64_t *suffix_len,
			   uint8_t *extra);

/*
 * Decode into `last_key` and `extra` from `in`. `last_key` is expected to
 * contain the decoded key of the preceding record, if any.
 */
int reftable_decode_key(struct reftable_buf *last_key, uint8_t *extra,
			struct string_view in);

/* reftable_index_record are used internally to speed up lookups. */
struct reftable_index_record { … };

/* reftable_obj_record stores an object ID => ref mapping. */
struct reftable_obj_record { … };

/* record is a generic wrapper for different types of records. It is normally
 * created on the stack, or embedded within another struct. If the type is
 * known, a fresh instance can be initialized explicitly. Otherwise, use
 * `reftable_record_init()` to initialize generically (as the index_record is
 * not valid as 0-initialized structure)
 */
struct reftable_record { … };

/* Initialize the reftable record for the given type */
void reftable_record_init(struct reftable_record *rec, uint8_t typ);

/* see struct record_vtable */
int reftable_record_cmp(struct reftable_record *a, struct reftable_record *b);
int reftable_record_equal(struct reftable_record *a, struct reftable_record *b, int hash_size);
int reftable_record_key(struct reftable_record *rec, struct reftable_buf *dest);
int reftable_record_copy_from(struct reftable_record *rec,
			      struct reftable_record *src, int hash_size);
uint8_t reftable_record_val_type(struct reftable_record *rec);
int reftable_record_encode(struct reftable_record *rec, struct string_view dest,
			   int hash_size);
int reftable_record_decode(struct reftable_record *rec, struct reftable_buf key,
			   uint8_t extra, struct string_view src,
			   int hash_size, struct reftable_buf *scratch);
int reftable_record_is_deletion(struct reftable_record *rec);

static inline uint8_t reftable_record_type(struct reftable_record *rec)
{ … }

/* frees and zeroes out the embedded record */
void reftable_record_release(struct reftable_record *rec);

/* for qsort. */
int reftable_ref_record_compare_name(const void *a, const void *b);

/* for qsort. */
int reftable_log_record_compare_key(const void *a, const void *b);

#endif