]>
Commit | Line | Data |
---|---|---|
17df8dbe HWN |
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 | ||
66c0daba | 9 | #include "constants.h" |
17df8dbe HWN |
10 | #include "record.h" |
11 | #include "generic.h" | |
12 | #include "reftable-iterator.h" | |
13 | #include "reftable-generic.h" | |
14 | ||
15 | int reftable_table_seek_ref(struct reftable_table *tab, | |
16 | struct reftable_iterator *it, const char *name) | |
17 | { | |
66c0daba HWN |
18 | struct reftable_record rec = { .type = BLOCK_TYPE_REF, |
19 | .u.ref = { | |
20 | .refname = (char *)name, | |
21 | } }; | |
17df8dbe HWN |
22 | return tab->ops->seek_record(tab->table_arg, it, &rec); |
23 | } | |
24 | ||
25 | int reftable_table_seek_log(struct reftable_table *tab, | |
26 | struct reftable_iterator *it, const char *name) | |
27 | { | |
66c0daba HWN |
28 | struct reftable_record rec = { .type = BLOCK_TYPE_LOG, |
29 | .u.log = { | |
30 | .refname = (char *)name, | |
31 | .update_index = ~((uint64_t)0), | |
32 | } }; | |
17df8dbe HWN |
33 | return tab->ops->seek_record(tab->table_arg, it, &rec); |
34 | } | |
35 | ||
36 | int reftable_table_read_ref(struct reftable_table *tab, const char *name, | |
37 | struct reftable_ref_record *ref) | |
38 | { | |
39 | struct reftable_iterator it = { NULL }; | |
40 | int err = reftable_table_seek_ref(tab, &it, name); | |
41 | if (err) | |
42 | goto done; | |
43 | ||
44 | err = reftable_iterator_next_ref(&it, ref); | |
45 | if (err) | |
46 | goto done; | |
47 | ||
48 | if (strcmp(ref->refname, name) || | |
49 | reftable_ref_record_is_deletion(ref)) { | |
50 | reftable_ref_record_release(ref); | |
51 | err = 1; | |
52 | goto done; | |
53 | } | |
54 | ||
55 | done: | |
56 | reftable_iterator_destroy(&it); | |
57 | return err; | |
58 | } | |
59 | ||
60 | int reftable_table_print(struct reftable_table *tab) { | |
61 | struct reftable_iterator it = { NULL }; | |
62 | struct reftable_ref_record ref = { NULL }; | |
63 | struct reftable_log_record log = { NULL }; | |
64 | uint32_t hash_id = reftable_table_hash_id(tab); | |
65 | int err = reftable_table_seek_ref(tab, &it, ""); | |
66 | if (err < 0) { | |
67 | return err; | |
68 | } | |
69 | ||
70 | while (1) { | |
71 | err = reftable_iterator_next_ref(&it, &ref); | |
72 | if (err > 0) { | |
73 | break; | |
74 | } | |
75 | if (err < 0) { | |
76 | return err; | |
77 | } | |
78 | reftable_ref_record_print(&ref, hash_id); | |
79 | } | |
80 | reftable_iterator_destroy(&it); | |
81 | reftable_ref_record_release(&ref); | |
82 | ||
83 | err = reftable_table_seek_log(tab, &it, ""); | |
84 | if (err < 0) { | |
85 | return err; | |
86 | } | |
87 | while (1) { | |
88 | err = reftable_iterator_next_log(&it, &log); | |
89 | if (err > 0) { | |
90 | break; | |
91 | } | |
92 | if (err < 0) { | |
93 | return err; | |
94 | } | |
95 | reftable_log_record_print(&log, hash_id); | |
96 | } | |
97 | reftable_iterator_destroy(&it); | |
98 | reftable_log_record_release(&log); | |
99 | return 0; | |
100 | } | |
101 | ||
102 | uint64_t reftable_table_max_update_index(struct reftable_table *tab) | |
103 | { | |
104 | return tab->ops->max_update_index(tab->table_arg); | |
105 | } | |
106 | ||
107 | uint64_t reftable_table_min_update_index(struct reftable_table *tab) | |
108 | { | |
109 | return tab->ops->min_update_index(tab->table_arg); | |
110 | } | |
111 | ||
112 | uint32_t reftable_table_hash_id(struct reftable_table *tab) | |
113 | { | |
114 | return tab->ops->hash_id(tab->table_arg); | |
115 | } | |
116 | ||
117 | void reftable_iterator_destroy(struct reftable_iterator *it) | |
118 | { | |
119 | if (!it->ops) { | |
120 | return; | |
121 | } | |
122 | it->ops->close(it->iter_arg); | |
123 | it->ops = NULL; | |
124 | FREE_AND_NULL(it->iter_arg); | |
125 | } | |
126 | ||
127 | int reftable_iterator_next_ref(struct reftable_iterator *it, | |
128 | struct reftable_ref_record *ref) | |
129 | { | |
66c0daba HWN |
130 | struct reftable_record rec = { |
131 | .type = BLOCK_TYPE_REF, | |
33665d98 ÆAB |
132 | .u = { |
133 | .ref = *ref | |
134 | }, | |
66c0daba HWN |
135 | }; |
136 | int err = iterator_next(it, &rec); | |
137 | *ref = rec.u.ref; | |
138 | return err; | |
17df8dbe HWN |
139 | } |
140 | ||
141 | int reftable_iterator_next_log(struct reftable_iterator *it, | |
142 | struct reftable_log_record *log) | |
143 | { | |
66c0daba HWN |
144 | struct reftable_record rec = { |
145 | .type = BLOCK_TYPE_LOG, | |
33665d98 ÆAB |
146 | .u = { |
147 | .log = *log, | |
148 | }, | |
66c0daba HWN |
149 | }; |
150 | int err = iterator_next(it, &rec); | |
151 | *log = rec.u.log; | |
152 | return err; | |
17df8dbe HWN |
153 | } |
154 | ||
155 | int iterator_next(struct reftable_iterator *it, struct reftable_record *rec) | |
156 | { | |
157 | return it->ops->next(it->iter_arg, rec); | |
158 | } | |
159 | ||
160 | static int empty_iterator_next(void *arg, struct reftable_record *rec) | |
161 | { | |
162 | return 1; | |
163 | } | |
164 | ||
165 | static void empty_iterator_close(void *arg) | |
166 | { | |
167 | } | |
168 | ||
169 | static struct reftable_iterator_vtable empty_vtable = { | |
170 | .next = &empty_iterator_next, | |
171 | .close = &empty_iterator_close, | |
172 | }; | |
173 | ||
174 | void iterator_set_empty(struct reftable_iterator *it) | |
175 | { | |
176 | assert(!it->ops); | |
177 | it->iter_arg = NULL; | |
178 | it->ops = &empty_vtable; | |
179 | } |