Skip to content

Commit aedab82

Browse files
kwvgkwvg
committed
libgrovedb: style corrections and ergonomic cleanup
1 parent 29cddc3 commit aedab82

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

56 files changed

+631
-749
lines changed

‎src/ffi/grovedb/contrib/examples/absence_proofs.cpp‎

Lines changed: 21 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -13,29 +13,8 @@
1313
#include <util/logging.h>
1414

1515
#include <cstdlib>
16-
#include <format>
1716
#include <string>
1817

19-
namespace {
20-
std::string BytesToString(const grovedb::Bytes& b)
21-
{
22-
return std::string(b.begin(), b.end());
23-
}
24-
25-
grovedb::Bytes StringToBytes(const std::string& s)
26-
{
27-
return grovedb::Bytes(s.begin(), s.end());
28-
}
29-
30-
std::string HashToHex(const grovedb::Hash& h)
31-
{
32-
std::string hex;
33-
hex.reserve(64);
34-
for (auto b : h) hex += std::format("{:02x}", b);
35-
return hex;
36-
}
37-
} // namespace
38-
3918
int main()
4019
{
4120
Log(INFO, "=== Absence Proofs ===");
@@ -56,12 +35,12 @@ int main()
5635
// -------------------------------------------------------------------------
5736

5837
for (const char* k : {"a", "c", "e"}) {
59-
auto elem = grovedb::Element::Item(StringToBytes(std::string("val_") + k));
38+
auto elem = grovedb::Element::Item(grovedb::Bytes::FromString(std::string("val_") + k));
6039
if (!elem.has_value()) {
6140
Log(ERROR, "failed to create element: {}", elem.error().message());
6241
return EXIT_FAILURE;
6342
}
64-
auto cost = db.Put(root, StringToBytes(k), *elem);
43+
auto cost = db.Put(root, grovedb::Bytes::FromString(k), *elem);
6544
if (!cost.has_value()) {
6645
Log(ERROR, "put failed: {}", cost.error().message());
6746
return EXIT_FAILURE;
@@ -76,11 +55,11 @@ int main()
7655

7756
Log(INFO, "--- VerifyQueryWithAbsenceProof ---");
7857
auto q1 = grovedb::PathQuery::New(root,
79-
{grovedb::QueryItem::Key(StringToBytes("a")),
80-
grovedb::QueryItem::Key(StringToBytes("b")),
81-
grovedb::QueryItem::Key(StringToBytes("c")),
82-
grovedb::QueryItem::Key(StringToBytes("d")),
83-
grovedb::QueryItem::Key(StringToBytes("e"))},
58+
{grovedb::QueryItem::Key(grovedb::Bytes::FromString("a")),
59+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("b")),
60+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("c")),
61+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("d")),
62+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("e"))},
8463
/*limit=*/100);
8564
if (!q1.has_value()) {
8665
Log(ERROR, "PathQuery::New failed: {}", q1.error().message());
@@ -95,11 +74,11 @@ int main()
9574
Log(INFO, "proof generated: {} bytes", proof->value().size());
9675

9776
auto q1v = grovedb::PathQuery::New(root,
98-
{grovedb::QueryItem::Key(StringToBytes("a")),
99-
grovedb::QueryItem::Key(StringToBytes("b")),
100-
grovedb::QueryItem::Key(StringToBytes("c")),
101-
grovedb::QueryItem::Key(StringToBytes("d")),
102-
grovedb::QueryItem::Key(StringToBytes("e"))},
77+
{grovedb::QueryItem::Key(grovedb::Bytes::FromString("a")),
78+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("b")),
79+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("c")),
80+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("d")),
81+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("e"))},
10382
/*limit=*/100);
10483
if (!q1v.has_value()) {
10584
Log(ERROR, "PathQuery::New failed: {}", q1v.error().message());
@@ -112,11 +91,11 @@ int main()
11291
return EXIT_FAILURE;
11392
}
11493

115-
Log(INFO, "verification succeeded, root hash: {}", HashToHex(vap->value().m_root_hash));
94+
Log(INFO, "verification succeeded, root hash: {}", vap->value().m_root_hash.ToString());
11695
Log(INFO, "{} entries in result", vap->value().m_entries.size());
11796
for (const auto& entry : vap->value().m_entries) {
11897
Log(INFO, " key='{}', present={}",
119-
BytesToString(entry.m_key), entry.m_element.has_value());
98+
entry.m_key.ToString(), entry.m_element.has_value());
12099
}
121100

122101
// -------------------------------------------------------------------------
@@ -125,7 +104,7 @@ int main()
125104

126105
Log(INFO, "--- VerifySubsetQuery ---");
127106
auto q_sub = grovedb::PathQuery::New(root,
128-
{grovedb::QueryItem::Key(StringToBytes("c"))});
107+
{grovedb::QueryItem::Key(grovedb::Bytes::FromString("c"))});
129108
if (!q_sub.has_value()) {
130109
Log(ERROR, "PathQuery::New failed: {}", q_sub.error().message());
131110
return EXIT_FAILURE;
@@ -144,7 +123,7 @@ int main()
144123

145124
Log(INFO, "--- VerifySubsetQueryWithAbsenceProof ---");
146125
auto q_suba = grovedb::PathQuery::New(root,
147-
{grovedb::QueryItem::Key(StringToBytes("c"))},
126+
{grovedb::QueryItem::Key(grovedb::Bytes::FromString("c"))},
148127
/*limit=*/100);
149128
if (!q_suba.has_value()) {
150129
Log(ERROR, "PathQuery::New failed: {}", q_suba.error().message());
@@ -165,11 +144,11 @@ int main()
165144

166145
Log(INFO, "--- VerifyQueryWithOptions ---");
167146
auto q_opts = grovedb::PathQuery::New(root,
168-
{grovedb::QueryItem::Key(StringToBytes("a")),
169-
grovedb::QueryItem::Key(StringToBytes("b")),
170-
grovedb::QueryItem::Key(StringToBytes("c")),
171-
grovedb::QueryItem::Key(StringToBytes("d")),
172-
grovedb::QueryItem::Key(StringToBytes("e"))},
147+
{grovedb::QueryItem::Key(grovedb::Bytes::FromString("a")),
148+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("b")),
149+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("c")),
150+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("d")),
151+
grovedb::QueryItem::Key(grovedb::Bytes::FromString("e"))},
173152
/*limit=*/100);
174153
if (!q_opts.has_value()) {
175154
Log(ERROR, "PathQuery::New failed: {}", q_opts.error().message());

‎src/ffi/grovedb/contrib/examples/auxiliary_storage.cpp‎

Lines changed: 12 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -9,29 +9,8 @@
99
#include <util/logging.h>
1010

1111
#include <cstdlib>
12-
#include <format>
1312
#include <string>
1413

15-
namespace {
16-
std::string BytesToString(const grovedb::Bytes& b)
17-
{
18-
return std::string(b.begin(), b.end());
19-
}
20-
21-
grovedb::Bytes StringToBytes(const std::string& s)
22-
{
23-
return grovedb::Bytes(s.begin(), s.end());
24-
}
25-
26-
std::string HashToHex(const grovedb::Hash& h)
27-
{
28-
std::string hex;
29-
hex.reserve(64);
30-
for (auto b : h) hex += std::format("{:02x}", b);
31-
return hex;
32-
}
33-
} // namespace
34-
3514
int main()
3615
{
3716
Log(INFO, "=== Auxiliary Storage ===");
@@ -50,28 +29,28 @@ int main()
5029
// -------------------------------------------------------------------------
5130

5231
Log(INFO, "--- PutAux / GetAux ---");
53-
auto put1 = db.PutAux(StringToBytes("schema_version"), StringToBytes("3"));
32+
auto put1 = db.PutAux(grovedb::Bytes::FromString("schema_version"), grovedb::Bytes::FromString("3"));
5433
if (!put1.has_value()) {
5534
Log(ERROR, "PutAux failed: {}", put1.error().message());
5635
return EXIT_FAILURE;
5736
}
5837
Log(INFO, "PutAux('schema_version', '3'): {} seeks", put1->m_seek_count);
5938

60-
auto get1 = db.GetAux(StringToBytes("schema_version"));
39+
auto get1 = db.GetAux(grovedb::Bytes::FromString("schema_version"));
6140
if (!get1.has_value()) {
6241
Log(ERROR, "GetAux failed: {}", get1.error().message());
6342
return EXIT_FAILURE;
6443
}
6544
if (get1->value().has_value()) {
66-
Log(INFO, "GetAux('schema_version') = '{}'", BytesToString(*get1->value()));
45+
Log(INFO, "GetAux('schema_version') = '{}'", std::string(get1->value()->begin(), get1->value()->end()));
6746
}
6847

6948
// -------------------------------------------------------------------------
7049
// 2. GetAux for nonexistent key → nullopt.
7150
// -------------------------------------------------------------------------
7251

7352
Log(INFO, "--- GetAux nonexistent ---");
74-
auto get2 = db.GetAux(StringToBytes("nonexistent"));
53+
auto get2 = db.GetAux(grovedb::Bytes::FromString("nonexistent"));
7554
if (!get2.has_value()) {
7655
Log(ERROR, "GetAux failed: {}", get2.error().message());
7756
return EXIT_FAILURE;
@@ -83,35 +62,35 @@ int main()
8362
// -------------------------------------------------------------------------
8463

8564
Log(INFO, "--- PutAux overwrite ---");
86-
auto put2 = db.PutAux(StringToBytes("schema_version"), StringToBytes("4"));
65+
auto put2 = db.PutAux(grovedb::Bytes::FromString("schema_version"), grovedb::Bytes::FromString("4"));
8766
if (!put2.has_value()) {
8867
Log(ERROR, "PutAux overwrite failed: {}", put2.error().message());
8968
return EXIT_FAILURE;
9069
}
9170

92-
auto get3 = db.GetAux(StringToBytes("schema_version"));
71+
auto get3 = db.GetAux(grovedb::Bytes::FromString("schema_version"));
9372
if (!get3.has_value()) {
9473
Log(ERROR, "GetAux failed: {}", get3.error().message());
9574
return EXIT_FAILURE;
9675
}
9776
if (get3->value().has_value()) {
9877
Log(INFO, "GetAux('schema_version') after overwrite = '{}'",
99-
BytesToString(*get3->value()));
78+
std::string(get3->value()->begin(), get3->value()->end()));
10079
}
10180

10281
// -------------------------------------------------------------------------
10382
// 4. DeleteAux.
10483
// -------------------------------------------------------------------------
10584

10685
Log(INFO, "--- DeleteAux ---");
107-
auto del = db.DeleteAux(StringToBytes("schema_version"));
86+
auto del = db.DeleteAux(grovedb::Bytes::FromString("schema_version"));
10887
if (!del.has_value()) {
10988
Log(ERROR, "DeleteAux failed: {}", del.error().message());
11089
return EXIT_FAILURE;
11190
}
11291
Log(INFO, "DeleteAux('schema_version') succeeded");
11392

114-
auto get4 = db.GetAux(StringToBytes("schema_version"));
93+
auto get4 = db.GetAux(grovedb::Bytes::FromString("schema_version"));
11594
if (!get4.has_value()) {
11695
Log(ERROR, "GetAux failed: {}", get4.error().message());
11796
return EXIT_FAILURE;
@@ -128,9 +107,9 @@ int main()
128107
Log(ERROR, "GetRootHash failed: {}", hash_before.error().message());
129108
return EXIT_FAILURE;
130109
}
131-
Log(INFO, "root hash before aux write: {}", HashToHex(hash_before->value()));
110+
Log(INFO, "root hash before aux write: {}", hash_before->value().ToString());
132111

133-
auto put3 = db.PutAux(StringToBytes("metadata"), StringToBytes("some_value"));
112+
auto put3 = db.PutAux(grovedb::Bytes::FromString("metadata"), grovedb::Bytes::FromString("some_value"));
134113
if (!put3.has_value()) {
135114
Log(ERROR, "PutAux failed: {}", put3.error().message());
136115
return EXIT_FAILURE;
@@ -141,7 +120,7 @@ int main()
141120
Log(ERROR, "GetRootHash failed: {}", hash_after.error().message());
142121
return EXIT_FAILURE;
143122
}
144-
Log(INFO, "root hash after aux write: {}", HashToHex(hash_after->value()));
123+
Log(INFO, "root hash after aux write: {}", hash_after->value().ToString());
145124
Log(INFO, "root hash unchanged by aux: {}", hash_before->value() == hash_after->value());
146125

147126
Log(INFO, "done");

‎src/ffi/grovedb/contrib/examples/basic_crud.cpp‎

Lines changed: 10 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -14,13 +14,6 @@
1414
#include <cstdlib>
1515
#include <string>
1616

17-
namespace {
18-
grovedb::Bytes StringToBytes(const std::string& s)
19-
{
20-
return grovedb::Bytes(s.begin(), s.end());
21-
}
22-
} // namespace
23-
2417
int main()
2518
{
2619
Log(INFO, "=== Basic CRUD ===");
@@ -42,13 +35,13 @@ int main()
4235
// 1. Create — Put an item.
4336
// -------------------------------------------------------------------------
4437

45-
auto greeting = grovedb::Element::Item(StringToBytes("Hello GroveDB!"));
38+
auto greeting = grovedb::Element::Item(grovedb::Bytes::FromString("Hello GroveDB!"));
4639
if (!greeting.has_value()) {
4740
Log(ERROR, "failed to create element: {}", greeting.error().message());
4841
return EXIT_FAILURE;
4942
}
5043

51-
auto put1 = db.Put(root, StringToBytes("greeting"), *greeting);
44+
auto put1 = db.Put(root, grovedb::Bytes::FromString("greeting"), *greeting);
5245
if (!put1.has_value()) {
5346
Log(ERROR, "put failed: {}", put1.error().message());
5447
return EXIT_FAILURE;
@@ -60,7 +53,7 @@ int main()
6053
// 2. Read — Get the item back.
6154
// -------------------------------------------------------------------------
6255

63-
auto get1 = db.Get(root, StringToBytes("greeting"));
56+
auto get1 = db.Get(root, grovedb::Bytes::FromString("greeting"));
6457
if (!get1.has_value()) {
6558
Log(ERROR, "get failed: {}", get1.error().message());
6659
return EXIT_FAILURE;
@@ -72,14 +65,14 @@ int main()
7265
// 3. KeyExists — check presence.
7366
// -------------------------------------------------------------------------
7467

75-
auto exists1 = db.KeyExists(root, StringToBytes("greeting"));
68+
auto exists1 = db.KeyExists(root, grovedb::Bytes::FromString("greeting"));
7669
if (!exists1.has_value()) {
7770
Log(ERROR, "key exists check failed: {}", exists1.error().message());
7871
return EXIT_FAILURE;
7972
}
8073
Log(INFO, "KeyExists('greeting') = {}", exists1->value());
8174

82-
auto exists2 = db.KeyExists(root, StringToBytes("missing"));
75+
auto exists2 = db.KeyExists(root, grovedb::Bytes::FromString("missing"));
8376
if (!exists2.has_value()) {
8477
Log(ERROR, "key exists check failed: {}", exists2.error().message());
8578
return EXIT_FAILURE;
@@ -90,13 +83,13 @@ int main()
9083
// 4. Insert another item.
9184
// -------------------------------------------------------------------------
9285

93-
auto name = grovedb::Element::Item(StringToBytes("Dash"));
86+
auto name = grovedb::Element::Item(grovedb::Bytes::FromString("Dash"));
9487
if (!name.has_value()) {
9588
Log(ERROR, "failed to create element: {}", name.error().message());
9689
return EXIT_FAILURE;
9790
}
9891

99-
auto put2 = db.Put(root, StringToBytes("name"), *name);
92+
auto put2 = db.Put(root, grovedb::Bytes::FromString("name"), *name);
10093
if (!put2.has_value()) {
10194
Log(ERROR, "put failed: {}", put2.error().message());
10295
return EXIT_FAILURE;
@@ -108,7 +101,7 @@ int main()
108101
// 5. Delete — remove the greeting.
109102
// -------------------------------------------------------------------------
110103

111-
auto del = db.Delete(root, StringToBytes("greeting"));
104+
auto del = db.Delete(root, grovedb::Bytes::FromString("greeting"));
112105
if (!del.has_value()) {
113106
Log(ERROR, "delete failed: {}", del.error().message());
114107
return EXIT_FAILURE;
@@ -117,15 +110,15 @@ int main()
117110
del->m_seek_count, del->m_storage_removed_bytes);
118111

119112
// Confirm deletion.
120-
auto exists3 = db.KeyExists(root, StringToBytes("greeting"));
113+
auto exists3 = db.KeyExists(root, grovedb::Bytes::FromString("greeting"));
121114
if (!exists3.has_value()) {
122115
Log(ERROR, "key exists check failed: {}", exists3.error().message());
123116
return EXIT_FAILURE;
124117
}
125118
Log(INFO, "KeyExists('greeting') after delete = {}", exists3->value());
126119

127120
// Verify 'name' is still present.
128-
auto get2 = db.Get(root, StringToBytes("name"));
121+
auto get2 = db.Get(root, grovedb::Bytes::FromString("name"));
129122
if (!get2.has_value()) {
130123
Log(ERROR, "get failed: {}", get2.error().message());
131124
return EXIT_FAILURE;

0 commit comments

Comments
 (0)