mirror of
https://github.com/git/git.git
synced 2025-12-12 20:36:24 +01:00
b648bd6549
The `struct reftable_reader` subsystem encapsulates a table that has been read from the disk. As such, the current name of that structure is somewhat hard to understand as it only talks about the fact that we read something from disk, without really giving an indicator _what_ that is. Furthermore, this naming schema doesn't really fit well into how the other structures are named: `reftable_merged_table`, `reftable_stack`, `reftable_block` and `reftable_record` are all named after what they encapsulate. Rename the subsystem to `reftable_table`, which directly gives a hint that the data structure is about handling the individual tables part of the stack. While this change results in a lot of churn, it prepares for us exposing the APIs to third-party callers now that the reftable library is a standalone library that can be linked against by other projects. Signed-off-by: Patrick Steinhardt <ps@pks.im> Signed-off-by: Junio C Hamano <gitster@pobox.com>
62 lines
2.1 KiB
C
62 lines
2.1 KiB
C
/*
|
|
* 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 REFTABLE_MERGED_H
|
|
#define REFTABLE_MERGED_H
|
|
|
|
#include "reftable-iterator.h"
|
|
|
|
/*
|
|
* Merged tables
|
|
*
|
|
* A ref database kept in a sequence of table files. The merged_table presents a
|
|
* unified view to reading (seeking, iterating) a sequence of immutable tables.
|
|
*
|
|
* The merged tables are on purpose kept disconnected from their actual storage
|
|
* (eg. files on disk), because it is useful to merge tables aren't files. For
|
|
* example, the per-workspace and global ref namespace can be implemented as a
|
|
* merged table of two stacks of file-backed reftables.
|
|
*/
|
|
|
|
/* A merged table is implements seeking/iterating over a stack of tables. */
|
|
struct reftable_merged_table;
|
|
|
|
struct reftable_table;
|
|
|
|
/*
|
|
* reftable_merged_table_new creates a new merged table. The tables must be
|
|
* kept alive as long as the merged table is still in use.
|
|
*/
|
|
int reftable_merged_table_new(struct reftable_merged_table **dest,
|
|
struct reftable_table **tables, size_t n,
|
|
enum reftable_hash hash_id);
|
|
|
|
/* Initialize a merged table iterator for reading refs. */
|
|
int reftable_merged_table_init_ref_iterator(struct reftable_merged_table *mt,
|
|
struct reftable_iterator *it);
|
|
|
|
/* Initialize a merged table iterator for reading logs. */
|
|
int reftable_merged_table_init_log_iterator(struct reftable_merged_table *mt,
|
|
struct reftable_iterator *it);
|
|
|
|
/* returns the max update_index covered by this merged table. */
|
|
uint64_t
|
|
reftable_merged_table_max_update_index(struct reftable_merged_table *mt);
|
|
|
|
/* returns the min update_index covered by this merged table. */
|
|
uint64_t
|
|
reftable_merged_table_min_update_index(struct reftable_merged_table *mt);
|
|
|
|
/* releases memory for the merged_table */
|
|
void reftable_merged_table_free(struct reftable_merged_table *m);
|
|
|
|
/* return the hash ID of the merged table. */
|
|
enum reftable_hash reftable_merged_table_hash_id(struct reftable_merged_table *m);
|
|
|
|
#endif
|