Skip to content

Commit 1212be9

Browse files
SwishSwushPowSwishSwushPow
committed
improve basic example
now includes a custom type and an async function
1 parent 9c3a51f commit 1212be9

File tree

7 files changed

+350
-4
lines changed

7 files changed

+350
-4
lines changed

‎Cargo.lock

Lines changed: 83 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎example/buffi_example/Cargo.toml

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,11 @@ name = "buffi_example"
33
version = "0.1.0"
44
edition = "2021"
55

6+
[lib]
7+
crate-type = ["staticlib"]
8+
69
[dependencies]
710
buffi_macro = { path = "../../buffi_macro" }
811
bincode = "1.3.3"
9-
serde = { version = "1.0.214", features = ["derive"] }
12+
serde = { version = "1.0.214", features = ["derive"] }
13+
tokio = { version = "1.41.1", features = ["rt-multi-thread"] }

‎example/buffi_example/src/errors.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
1-
use serde::{Deserialize, Serialize};
1+
use serde::Serialize;
22
use std::any::Any;
33

4-
#[derive(Serialize, Deserialize)]
4+
#[derive(Serialize)]
55
pub struct SerializableError {
66
pub message: String,
77
}

‎example/buffi_example/src/include/BUFFI_NAMESPACE.hpp

Lines changed: 202 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,20 @@
55

66
namespace BUFFI_NAMESPACE {
77

8+
struct CustomType;
9+
10+
/// A custom type that needs to be available in C++ as well
11+
struct CustomType {
12+
/// Some content
13+
int64_t some_content;
14+
/// A cyclic reference that's a bit more complex
15+
std::optional<serde::value_ptr<BUFFI_NAMESPACE::CustomType>> itself;
16+
17+
friend bool operator==(const CustomType&, const CustomType&);
18+
std::vector<uint8_t> bincodeSerialize() const;
19+
static CustomType bincodeDeserialize(std::vector<uint8_t>);
20+
};
21+
822
struct SerializableError {
923
std::string message;
1024

@@ -13,6 +27,31 @@ namespace BUFFI_NAMESPACE {
1327
static SerializableError bincodeDeserialize(std::vector<uint8_t>);
1428
};
1529

30+
struct Result_CustomType_SerializableError {
31+
32+
struct Ok {
33+
std::tuple<BUFFI_NAMESPACE::CustomType> value;
34+
35+
friend bool operator==(const Ok&, const Ok&);
36+
std::vector<uint8_t> bincodeSerialize() const;
37+
static Ok bincodeDeserialize(std::vector<uint8_t>);
38+
};
39+
40+
struct Err {
41+
std::tuple<BUFFI_NAMESPACE::SerializableError> value;
42+
43+
friend bool operator==(const Err&, const Err&);
44+
std::vector<uint8_t> bincodeSerialize() const;
45+
static Err bincodeDeserialize(std::vector<uint8_t>);
46+
};
47+
48+
std::variant<Ok, Err> value;
49+
50+
friend bool operator==(const Result_CustomType_SerializableError&, const Result_CustomType_SerializableError&);
51+
std::vector<uint8_t> bincodeSerialize() const;
52+
static Result_CustomType_SerializableError bincodeDeserialize(std::vector<uint8_t>);
53+
};
54+
1655
struct Result_String_SerializableError {
1756

1857
struct Ok {
@@ -66,6 +105,169 @@ namespace BUFFI_NAMESPACE {
66105
} // end of namespace BUFFI_NAMESPACE
67106

68107

108+
namespace BUFFI_NAMESPACE {
109+
110+
inline bool operator==(const CustomType &lhs, const CustomType &rhs) {
111+
if (!(lhs.some_content == rhs.some_content)) { return false; }
112+
if (!(lhs.itself == rhs.itself)) { return false; }
113+
return true;
114+
}
115+
116+
inline std::vector<uint8_t> CustomType::bincodeSerialize() const {
117+
auto serializer = serde::BincodeSerializer();
118+
serde::Serializable<CustomType>::serialize(*this, serializer);
119+
return std::move(serializer).bytes();
120+
}
121+
122+
inline CustomType CustomType::bincodeDeserialize(std::vector<uint8_t> input) {
123+
auto deserializer = serde::BincodeDeserializer(input);
124+
auto value = serde::Deserializable<CustomType>::deserialize(deserializer);
125+
if (deserializer.get_buffer_offset() < input.size()) {
126+
throw serde::deserialization_error("Some input bytes were not read");
127+
}
128+
return value;
129+
}
130+
131+
} // end of namespace BUFFI_NAMESPACE
132+
133+
template <>
134+
template <typename Serializer>
135+
void serde::Serializable<BUFFI_NAMESPACE::CustomType>::serialize(const BUFFI_NAMESPACE::CustomType &obj, Serializer &serializer) {
136+
serializer.increase_container_depth();
137+
serde::Serializable<decltype(obj.some_content)>::serialize(obj.some_content, serializer);
138+
serde::Serializable<decltype(obj.itself)>::serialize(obj.itself, serializer);
139+
serializer.decrease_container_depth();
140+
}
141+
142+
template <>
143+
template <typename Deserializer>
144+
BUFFI_NAMESPACE::CustomType serde::Deserializable<BUFFI_NAMESPACE::CustomType>::deserialize(Deserializer &deserializer) {
145+
deserializer.increase_container_depth();
146+
BUFFI_NAMESPACE::CustomType obj;
147+
obj.some_content = serde::Deserializable<decltype(obj.some_content)>::deserialize(deserializer);
148+
obj.itself = serde::Deserializable<decltype(obj.itself)>::deserialize(deserializer);
149+
deserializer.decrease_container_depth();
150+
return obj;
151+
}
152+
153+
namespace BUFFI_NAMESPACE {
154+
155+
inline bool operator==(const Result_CustomType_SerializableError &lhs, const Result_CustomType_SerializableError &rhs) {
156+
if (!(lhs.value == rhs.value)) { return false; }
157+
return true;
158+
}
159+
160+
inline std::vector<uint8_t> Result_CustomType_SerializableError::bincodeSerialize() const {
161+
auto serializer = serde::BincodeSerializer();
162+
serde::Serializable<Result_CustomType_SerializableError>::serialize(*this, serializer);
163+
return std::move(serializer).bytes();
164+
}
165+
166+
inline Result_CustomType_SerializableError Result_CustomType_SerializableError::bincodeDeserialize(std::vector<uint8_t> input) {
167+
auto deserializer = serde::BincodeDeserializer(input);
168+
auto value = serde::Deserializable<Result_CustomType_SerializableError>::deserialize(deserializer);
169+
if (deserializer.get_buffer_offset() < input.size()) {
170+
throw serde::deserialization_error("Some input bytes were not read");
171+
}
172+
return value;
173+
}
174+
175+
} // end of namespace BUFFI_NAMESPACE
176+
177+
template <>
178+
template <typename Serializer>
179+
void serde::Serializable<BUFFI_NAMESPACE::Result_CustomType_SerializableError>::serialize(const BUFFI_NAMESPACE::Result_CustomType_SerializableError &obj, Serializer &serializer) {
180+
serializer.increase_container_depth();
181+
serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
182+
serializer.decrease_container_depth();
183+
}
184+
185+
template <>
186+
template <typename Deserializer>
187+
BUFFI_NAMESPACE::Result_CustomType_SerializableError serde::Deserializable<BUFFI_NAMESPACE::Result_CustomType_SerializableError>::deserialize(Deserializer &deserializer) {
188+
deserializer.increase_container_depth();
189+
BUFFI_NAMESPACE::Result_CustomType_SerializableError obj;
190+
obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
191+
deserializer.decrease_container_depth();
192+
return obj;
193+
}
194+
195+
namespace BUFFI_NAMESPACE {
196+
197+
inline bool operator==(const Result_CustomType_SerializableError::Ok &lhs, const Result_CustomType_SerializableError::Ok &rhs) {
198+
if (!(lhs.value == rhs.value)) { return false; }
199+
return true;
200+
}
201+
202+
inline std::vector<uint8_t> Result_CustomType_SerializableError::Ok::bincodeSerialize() const {
203+
auto serializer = serde::BincodeSerializer();
204+
serde::Serializable<Result_CustomType_SerializableError::Ok>::serialize(*this, serializer);
205+
return std::move(serializer).bytes();
206+
}
207+
208+
inline Result_CustomType_SerializableError::Ok Result_CustomType_SerializableError::Ok::bincodeDeserialize(std::vector<uint8_t> input) {
209+
auto deserializer = serde::BincodeDeserializer(input);
210+
auto value = serde::Deserializable<Result_CustomType_SerializableError::Ok>::deserialize(deserializer);
211+
if (deserializer.get_buffer_offset() < input.size()) {
212+
throw serde::deserialization_error("Some input bytes were not read");
213+
}
214+
return value;
215+
}
216+
217+
} // end of namespace BUFFI_NAMESPACE
218+
219+
template <>
220+
template <typename Serializer>
221+
void serde::Serializable<BUFFI_NAMESPACE::Result_CustomType_SerializableError::Ok>::serialize(const BUFFI_NAMESPACE::Result_CustomType_SerializableError::Ok &obj, Serializer &serializer) {
222+
serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
223+
}
224+
225+
template <>
226+
template <typename Deserializer>
227+
BUFFI_NAMESPACE::Result_CustomType_SerializableError::Ok serde::Deserializable<BUFFI_NAMESPACE::Result_CustomType_SerializableError::Ok>::deserialize(Deserializer &deserializer) {
228+
BUFFI_NAMESPACE::Result_CustomType_SerializableError::Ok obj;
229+
obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
230+
return obj;
231+
}
232+
233+
namespace BUFFI_NAMESPACE {
234+
235+
inline bool operator==(const Result_CustomType_SerializableError::Err &lhs, const Result_CustomType_SerializableError::Err &rhs) {
236+
if (!(lhs.value == rhs.value)) { return false; }
237+
return true;
238+
}
239+
240+
inline std::vector<uint8_t> Result_CustomType_SerializableError::Err::bincodeSerialize() const {
241+
auto serializer = serde::BincodeSerializer();
242+
serde::Serializable<Result_CustomType_SerializableError::Err>::serialize(*this, serializer);
243+
return std::move(serializer).bytes();
244+
}
245+
246+
inline Result_CustomType_SerializableError::Err Result_CustomType_SerializableError::Err::bincodeDeserialize(std::vector<uint8_t> input) {
247+
auto deserializer = serde::BincodeDeserializer(input);
248+
auto value = serde::Deserializable<Result_CustomType_SerializableError::Err>::deserialize(deserializer);
249+
if (deserializer.get_buffer_offset() < input.size()) {
250+
throw serde::deserialization_error("Some input bytes were not read");
251+
}
252+
return value;
253+
}
254+
255+
} // end of namespace BUFFI_NAMESPACE
256+
257+
template <>
258+
template <typename Serializer>
259+
void serde::Serializable<BUFFI_NAMESPACE::Result_CustomType_SerializableError::Err>::serialize(const BUFFI_NAMESPACE::Result_CustomType_SerializableError::Err &obj, Serializer &serializer) {
260+
serde::Serializable<decltype(obj.value)>::serialize(obj.value, serializer);
261+
}
262+
263+
template <>
264+
template <typename Deserializer>
265+
BUFFI_NAMESPACE::Result_CustomType_SerializableError::Err serde::Deserializable<BUFFI_NAMESPACE::Result_CustomType_SerializableError::Err>::deserialize(Deserializer &deserializer) {
266+
BUFFI_NAMESPACE::Result_CustomType_SerializableError::Err obj;
267+
obj.value = serde::Deserializable<decltype(obj.value)>::deserialize(deserializer);
268+
return obj;
269+
}
270+
69271
namespace BUFFI_NAMESPACE {
70272

71273
inline bool operator==(const Result_String_SerializableError &lhs, const Result_String_SerializableError &rhs) {

‎example/buffi_example/src/include/buffi_example_api_functions.hpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,8 @@
66

77
struct TestClient;
88

9+
extern "C" TestClient* get_test_client();
10+
extern "C" size_t buffi_async_function(TestClient* this_ptr, const std::uint8_t* content, size_t content_size, std::uint8_t** out_ptr);
911
extern "C" size_t buffi_client_function(TestClient* this_ptr, const std::uint8_t* input, size_t input_size, std::uint8_t** out_ptr);
1012
extern "C" size_t buffi_free_standing_function(const std::uint8_t* input, size_t input_size, std::uint8_t** out_ptr);
1113
extern "C" void buffi_free_byte_buffer(std::uint8_t* ptr, size_t size);

0 commit comments

Comments
 (0)