#[doc(hidden)]
pub mod __fb {
include!("test_generated.rs");
}
::flatbed::inventory::submit! {
::flatbed::FlatbedSchema { bfbs: include_bytes!("test.bfbs") }
}
pub mod test {
use ::flatbed::flatbuffers::FlatBufferBuilder;
use ::flatbed::serde::{Deserialize, Serialize};
use ::flatbed::utoipa;
use utoipa::ToSchema;
pub use super::__fb::test::Severity;
#[doc(hidden)]
pub mod _severity_serde {
use super::Severity;
use ::flatbed::serde::{Deserialize, Deserializer, Serialize, Serializer};
const VALID_NAMES: &[&str] = &["Info", "Warning", "Error"];
pub fn serialize<S: Serializer>(v: &Severity, s: S) -> Result<S::Ok, S::Error> {
let name: &'static str = {
if *v == Severity::Info {
"Info"
} else if *v == Severity::Warning {
"Warning"
} else if *v == Severity::Error {
"Error"
} else {
return Err(<S::Error as ::flatbed::serde::ser::Error>::custom(format!(
"unknown Severity variant: {:?}",
v.0
)));
}
};
name.serialize(s)
}
pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Severity, D::Error> {
let raw = String::deserialize(d)?;
match raw.as_str() {
"Info" => Ok(Severity::Info),
"Warning" => Ok(Severity::Warning),
"Error" => Ok(Severity::Error),
other => Err(<D::Error as ::flatbed::serde::de::Error>::unknown_variant(
other,
VALID_NAMES,
)),
}
}
}
#[doc(hidden)]
pub mod _severity_opt_vec_serde {
use super::Severity;
use ::flatbed::serde::{Deserialize, Deserializer, Serialize, Serializer};
const VALID_NAMES: &[&str] = &["Info", "Warning", "Error"];
fn variant_to_name<S: Serializer>(v: &Severity) -> Result<&'static str, S::Error> {
let name: &'static str = {
if *v == Severity::Info {
"Info"
} else if *v == Severity::Warning {
"Warning"
} else if *v == Severity::Error {
"Error"
} else {
return Err(<S::Error as ::flatbed::serde::ser::Error>::custom(format!(
"unknown Severity variant: {:?}",
v.0
)));
}
};
Ok(name)
}
pub fn serialize<S: Serializer>(
v: &Option<Vec<Severity>>,
s: S,
) -> Result<S::Ok, S::Error> {
match v {
Some(items) => {
let names: Result<Vec<&'static str>, S::Error> =
items.iter().map(variant_to_name::<S>).collect();
Some(names?).serialize(s)
}
None => Option::<Vec<&'static str>>::None.serialize(s),
}
}
pub fn deserialize<'de, D: Deserializer<'de>>(
d: D,
) -> Result<Option<Vec<Severity>>, D::Error> {
let raw: Option<Vec<String>> = Option::deserialize(d)?;
match raw {
Some(names) => {
let parsed: Result<Vec<Severity>, D::Error> = names
.into_iter()
.map(|raw| match raw.as_str() {
"Info" => Ok(Severity::Info),
"Warning" => Ok(Severity::Warning),
"Error" => Ok(Severity::Error),
other => {
Err(<D::Error as ::flatbed::serde::de::Error>::unknown_variant(
other,
VALID_NAMES,
))
}
})
.collect();
parsed.map(Some)
}
None => Ok(None),
}
}
}
::flatbed::inventory::submit! {
::flatbed::EnumSchema { name: "Severity", namespace: "test", variants: &["Info", "Warning", "Error"] }
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, ToSchema)]
#[serde(crate = "::flatbed::serde")]
pub struct TestRequest {
pub message: Option<String>,
pub value: u64,
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, ToSchema)]
#[serde(crate = "::flatbed::serde")]
pub struct TestResponse {
pub message: Option<String>,
pub value: u64,
pub success: bool,
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, ToSchema)]
#[serde(crate = "::flatbed::serde")]
pub struct Address {
pub street: Option<String>,
pub city: Option<String>,
pub zip_code: i32,
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, ToSchema)]
#[serde(crate = "::flatbed::serde")]
pub struct UserRequest {
pub name: Option<String>,
pub age: i32,
pub address: Option<Address>,
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, ToSchema)]
#[serde(crate = "::flatbed::serde")]
pub struct UserResponse {
pub user_id: u64,
pub name: Option<String>,
pub address: Option<Address>,
pub success: bool,
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, ToSchema)]
#[serde(crate = "::flatbed::serde")]
pub struct AddressBook {
pub owner: Option<String>,
pub addresses: Option<Vec<Address>>,
pub contact_names: Option<Vec<String>>,
}
#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, ToSchema)]
#[serde(crate = "::flatbed::serde")]
pub struct LogEvent {
pub message: Option<String>,
#[schema(value_type = String)]
#[serde(with = "_severity_serde", default)]
pub severity: Severity,
#[schema(value_type = Vec<String>)]
#[serde(with = "_severity_opt_vec_serde", default)]
pub history: Option<Vec<Severity>>,
}
fn default_Defaulted_count() -> i32 {
25
}
fn default_Defaulted_flag() -> bool {
true
}
fn default_Defaulted_ratio() -> f64 {
1.5_f64
}
fn default_Defaulted_level() -> Severity {
Severity::Warning
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, ToSchema)]
#[serde(crate = "::flatbed::serde")]
pub struct Defaulted {
#[serde(default = "default_Defaulted_count")]
pub count: i32,
#[serde(default = "default_Defaulted_flag")]
pub flag: bool,
#[serde(default = "default_Defaulted_ratio")]
pub ratio: f64,
#[schema(value_type = String)]
#[serde(with = "_severity_serde", default = "default_Defaulted_level")]
pub level: Severity,
}
impl TestRequest {
pub fn to_flatbuffer(&self) -> Vec<u8> {
let mut builder = FlatBufferBuilder::new();
let root = self.build_flatbuffer(&mut builder);
builder.finish(root, None);
builder.finished_data().to_vec()
}
pub fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
let fb = ::flatbed::flatbuffers::root::<super::__fb::test::TestRequest>(&bytes)?;
Ok(Self::from_fb(&fb))
}
#[doc(hidden)]
pub fn build_flatbuffer<'a>(
&self,
builder: &mut FlatBufferBuilder<'a>,
) -> ::flatbed::flatbuffers::WIPOffset<super::__fb::test::TestRequest<'a>> {
let message_offset = self.message.as_ref().map(|s| builder.create_string(s));
super::__fb::test::TestRequest::create(
builder,
&super::__fb::test::TestRequestArgs {
message: message_offset,
value: self.value,
},
)
}
#[doc(hidden)]
pub fn from_fb(fb: &super::__fb::test::TestRequest) -> Self {
Self {
message: fb.message().map(|s| s.to_string()),
value: fb.value(),
}
}
}
impl ::flatbed::ToFlatBuffer for TestRequest {
const SCHEMA_FIELDS: &'static [::flatbed::FieldInfo] = &[
::flatbed::FieldInfo {
name: "message",
fbs_type: "string",
required: false,
},
::flatbed::FieldInfo {
name: "value",
fbs_type: "uint64",
required: true,
},
];
const SCHEMA_NAME: &'static str = "TestRequest";
fn to_flatbuffer(&self) -> Vec<u8> {
self.to_flatbuffer()
}
}
impl ::flatbed::FromFlatBuffer for TestRequest {
fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
Self::from_flatbuffer(bytes)
}
}
impl ::flatbed::HasJsonCompanion for super::__fb::test::TestRequest<'_> {
type Json = TestRequest;
}
impl ::flatbed::HasPlainStruct for TestRequest {
type Plain = TestRequest;
type FlatBuffer<'a> = super::__fb::test::TestRequest<'a>;
}
::flatbed::inventory::submit! {
::flatbed::TypeSchema { name: "TestRequest", namespace: "test", fields: &[
::flatbed::TypeFieldInfo { name: "message", fbs_type: "string", field_id: 0, required: false },
::flatbed::TypeFieldInfo { name: "value", fbs_type: "uint64", field_id: 1, required: true },
] }
}
impl TestResponse {
pub fn to_flatbuffer(&self) -> Vec<u8> {
let mut builder = FlatBufferBuilder::new();
let root = self.build_flatbuffer(&mut builder);
builder.finish(root, None);
builder.finished_data().to_vec()
}
pub fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
let fb = ::flatbed::flatbuffers::root::<super::__fb::test::TestResponse>(&bytes)?;
Ok(Self::from_fb(&fb))
}
#[doc(hidden)]
pub fn build_flatbuffer<'a>(
&self,
builder: &mut FlatBufferBuilder<'a>,
) -> ::flatbed::flatbuffers::WIPOffset<super::__fb::test::TestResponse<'a>> {
let message_offset = self.message.as_ref().map(|s| builder.create_string(s));
super::__fb::test::TestResponse::create(
builder,
&super::__fb::test::TestResponseArgs {
message: message_offset,
value: self.value,
success: self.success,
},
)
}
#[doc(hidden)]
pub fn from_fb(fb: &super::__fb::test::TestResponse) -> Self {
Self {
message: fb.message().map(|s| s.to_string()),
value: fb.value(),
success: fb.success(),
}
}
}
impl ::flatbed::ToFlatBuffer for TestResponse {
const SCHEMA_FIELDS: &'static [::flatbed::FieldInfo] = &[
::flatbed::FieldInfo {
name: "message",
fbs_type: "string",
required: false,
},
::flatbed::FieldInfo {
name: "value",
fbs_type: "uint64",
required: true,
},
::flatbed::FieldInfo {
name: "success",
fbs_type: "bool",
required: true,
},
];
const SCHEMA_NAME: &'static str = "TestResponse";
fn to_flatbuffer(&self) -> Vec<u8> {
self.to_flatbuffer()
}
}
impl ::flatbed::FromFlatBuffer for TestResponse {
fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
Self::from_flatbuffer(bytes)
}
}
impl ::flatbed::HasJsonCompanion for super::__fb::test::TestResponse<'_> {
type Json = TestResponse;
}
impl ::flatbed::HasPlainStruct for TestResponse {
type Plain = TestResponse;
type FlatBuffer<'a> = super::__fb::test::TestResponse<'a>;
}
::flatbed::inventory::submit! {
::flatbed::TypeSchema { name: "TestResponse", namespace: "test", fields: &[
::flatbed::TypeFieldInfo { name: "message", fbs_type: "string", field_id: 0, required: false },
::flatbed::TypeFieldInfo { name: "value", fbs_type: "uint64", field_id: 1, required: true },
::flatbed::TypeFieldInfo { name: "success", fbs_type: "bool", field_id: 2, required: true },
] }
}
impl Address {
pub fn to_flatbuffer(&self) -> Vec<u8> {
let mut builder = FlatBufferBuilder::new();
let root = self.build_flatbuffer(&mut builder);
builder.finish(root, None);
builder.finished_data().to_vec()
}
pub fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
let fb = ::flatbed::flatbuffers::root::<super::__fb::test::Address>(&bytes)?;
Ok(Self::from_fb(&fb))
}
#[doc(hidden)]
pub fn build_flatbuffer<'a>(
&self,
builder: &mut FlatBufferBuilder<'a>,
) -> ::flatbed::flatbuffers::WIPOffset<super::__fb::test::Address<'a>> {
let street_offset = self.street.as_ref().map(|s| builder.create_string(s));
let city_offset = self.city.as_ref().map(|s| builder.create_string(s));
super::__fb::test::Address::create(
builder,
&super::__fb::test::AddressArgs {
street: street_offset,
city: city_offset,
zip_code: self.zip_code,
},
)
}
#[doc(hidden)]
pub fn from_fb(fb: &super::__fb::test::Address) -> Self {
Self {
street: fb.street().map(|s| s.to_string()),
city: fb.city().map(|s| s.to_string()),
zip_code: fb.zip_code(),
}
}
}
impl ::flatbed::ToFlatBuffer for Address {
const SCHEMA_FIELDS: &'static [::flatbed::FieldInfo] = &[
::flatbed::FieldInfo {
name: "street",
fbs_type: "string",
required: false,
},
::flatbed::FieldInfo {
name: "city",
fbs_type: "string",
required: false,
},
::flatbed::FieldInfo {
name: "zip_code",
fbs_type: "int32",
required: true,
},
];
const SCHEMA_NAME: &'static str = "Address";
fn to_flatbuffer(&self) -> Vec<u8> {
self.to_flatbuffer()
}
}
impl ::flatbed::FromFlatBuffer for Address {
fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
Self::from_flatbuffer(bytes)
}
}
impl ::flatbed::HasJsonCompanion for super::__fb::test::Address<'_> {
type Json = Address;
}
impl ::flatbed::HasPlainStruct for Address {
type Plain = Address;
type FlatBuffer<'a> = super::__fb::test::Address<'a>;
}
::flatbed::inventory::submit! {
::flatbed::TypeSchema { name: "Address", namespace: "test", fields: &[
::flatbed::TypeFieldInfo { name: "street", fbs_type: "string", field_id: 0, required: false },
::flatbed::TypeFieldInfo { name: "city", fbs_type: "string", field_id: 1, required: false },
::flatbed::TypeFieldInfo { name: "zip_code", fbs_type: "int32", field_id: 2, required: true },
] }
}
impl UserRequest {
pub fn to_flatbuffer(&self) -> Vec<u8> {
let mut builder = FlatBufferBuilder::new();
let root = self.build_flatbuffer(&mut builder);
builder.finish(root, None);
builder.finished_data().to_vec()
}
pub fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
let fb = ::flatbed::flatbuffers::root::<super::__fb::test::UserRequest>(&bytes)?;
Ok(Self::from_fb(&fb))
}
#[doc(hidden)]
pub fn build_flatbuffer<'a>(
&self,
builder: &mut FlatBufferBuilder<'a>,
) -> ::flatbed::flatbuffers::WIPOffset<super::__fb::test::UserRequest<'a>> {
let name_offset = self.name.as_ref().map(|s| builder.create_string(s));
let address_offset = self.address.as_ref().map(|t| t.build_flatbuffer(builder));
super::__fb::test::UserRequest::create(
builder,
&super::__fb::test::UserRequestArgs {
name: name_offset,
age: self.age,
address: address_offset,
},
)
}
#[doc(hidden)]
pub fn from_fb(fb: &super::__fb::test::UserRequest) -> Self {
Self {
name: fb.name().map(|s| s.to_string()),
age: fb.age(),
address: fb.address().map(|t| Address::from_fb(&t)),
}
}
}
impl ::flatbed::ToFlatBuffer for UserRequest {
const SCHEMA_FIELDS: &'static [::flatbed::FieldInfo] = &[
::flatbed::FieldInfo {
name: "name",
fbs_type: "string",
required: false,
},
::flatbed::FieldInfo {
name: "age",
fbs_type: "int32",
required: true,
},
::flatbed::FieldInfo {
name: "address",
fbs_type: "Address",
required: false,
},
];
const SCHEMA_NAME: &'static str = "UserRequest";
fn to_flatbuffer(&self) -> Vec<u8> {
self.to_flatbuffer()
}
}
impl ::flatbed::FromFlatBuffer for UserRequest {
fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
Self::from_flatbuffer(bytes)
}
}
impl ::flatbed::HasJsonCompanion for super::__fb::test::UserRequest<'_> {
type Json = UserRequest;
}
impl ::flatbed::HasPlainStruct for UserRequest {
type Plain = UserRequest;
type FlatBuffer<'a> = super::__fb::test::UserRequest<'a>;
}
::flatbed::inventory::submit! {
::flatbed::TypeSchema { name: "UserRequest", namespace: "test", fields: &[
::flatbed::TypeFieldInfo { name: "name", fbs_type: "string", field_id: 0, required: false },
::flatbed::TypeFieldInfo { name: "age", fbs_type: "int32", field_id: 1, required: true },
::flatbed::TypeFieldInfo { name: "address", fbs_type: "Address", field_id: 2, required: false },
] }
}
impl UserResponse {
pub fn to_flatbuffer(&self) -> Vec<u8> {
let mut builder = FlatBufferBuilder::new();
let root = self.build_flatbuffer(&mut builder);
builder.finish(root, None);
builder.finished_data().to_vec()
}
pub fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
let fb = ::flatbed::flatbuffers::root::<super::__fb::test::UserResponse>(&bytes)?;
Ok(Self::from_fb(&fb))
}
#[doc(hidden)]
pub fn build_flatbuffer<'a>(
&self,
builder: &mut FlatBufferBuilder<'a>,
) -> ::flatbed::flatbuffers::WIPOffset<super::__fb::test::UserResponse<'a>> {
let name_offset = self.name.as_ref().map(|s| builder.create_string(s));
let address_offset = self.address.as_ref().map(|t| t.build_flatbuffer(builder));
super::__fb::test::UserResponse::create(
builder,
&super::__fb::test::UserResponseArgs {
user_id: self.user_id,
name: name_offset,
address: address_offset,
success: self.success,
},
)
}
#[doc(hidden)]
pub fn from_fb(fb: &super::__fb::test::UserResponse) -> Self {
Self {
user_id: fb.user_id(),
name: fb.name().map(|s| s.to_string()),
address: fb.address().map(|t| Address::from_fb(&t)),
success: fb.success(),
}
}
}
impl ::flatbed::ToFlatBuffer for UserResponse {
const SCHEMA_FIELDS: &'static [::flatbed::FieldInfo] = &[
::flatbed::FieldInfo {
name: "user_id",
fbs_type: "uint64",
required: true,
},
::flatbed::FieldInfo {
name: "name",
fbs_type: "string",
required: false,
},
::flatbed::FieldInfo {
name: "address",
fbs_type: "Address",
required: false,
},
::flatbed::FieldInfo {
name: "success",
fbs_type: "bool",
required: true,
},
];
const SCHEMA_NAME: &'static str = "UserResponse";
fn to_flatbuffer(&self) -> Vec<u8> {
self.to_flatbuffer()
}
}
impl ::flatbed::FromFlatBuffer for UserResponse {
fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
Self::from_flatbuffer(bytes)
}
}
impl ::flatbed::HasJsonCompanion for super::__fb::test::UserResponse<'_> {
type Json = UserResponse;
}
impl ::flatbed::HasPlainStruct for UserResponse {
type Plain = UserResponse;
type FlatBuffer<'a> = super::__fb::test::UserResponse<'a>;
}
::flatbed::inventory::submit! {
::flatbed::TypeSchema { name: "UserResponse", namespace: "test", fields: &[
::flatbed::TypeFieldInfo { name: "user_id", fbs_type: "uint64", field_id: 0, required: true },
::flatbed::TypeFieldInfo { name: "name", fbs_type: "string", field_id: 1, required: false },
::flatbed::TypeFieldInfo { name: "address", fbs_type: "Address", field_id: 2, required: false },
::flatbed::TypeFieldInfo { name: "success", fbs_type: "bool", field_id: 3, required: true },
] }
}
impl AddressBook {
pub fn to_flatbuffer(&self) -> Vec<u8> {
let mut builder = FlatBufferBuilder::new();
let root = self.build_flatbuffer(&mut builder);
builder.finish(root, None);
builder.finished_data().to_vec()
}
pub fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
let fb = ::flatbed::flatbuffers::root::<super::__fb::test::AddressBook>(&bytes)?;
Ok(Self::from_fb(&fb))
}
#[doc(hidden)]
pub fn build_flatbuffer<'a>(
&self,
builder: &mut FlatBufferBuilder<'a>,
) -> ::flatbed::flatbuffers::WIPOffset<super::__fb::test::AddressBook<'a>> {
let owner_offset = self.owner.as_ref().map(|s| builder.create_string(s));
let addresses_offset = self.addresses.as_ref().map(|v| {
let offsets: Vec<_> = v.iter().map(|t| t.build_flatbuffer(builder)).collect();
builder.create_vector(&offsets)
});
let contact_names_offset = self.contact_names.as_ref().map(|v| {
let offsets: Vec<_> = v
.iter()
.map(|s| builder.create_string(s.as_str()))
.collect();
builder.create_vector(&offsets)
});
super::__fb::test::AddressBook::create(
builder,
&super::__fb::test::AddressBookArgs {
owner: owner_offset,
addresses: addresses_offset,
contact_names: contact_names_offset,
},
)
}
#[doc(hidden)]
pub fn from_fb(fb: &super::__fb::test::AddressBook) -> Self {
Self {
owner: fb.owner().map(|s| s.to_string()),
addresses: fb
.addresses()
.map(|v| v.iter().map(|t| Address::from_fb(&t)).collect()),
contact_names: fb
.contact_names()
.map(|v| v.iter().map(|s| s.to_string()).collect()),
}
}
}
impl ::flatbed::ToFlatBuffer for AddressBook {
const SCHEMA_FIELDS: &'static [::flatbed::FieldInfo] = &[
::flatbed::FieldInfo {
name: "owner",
fbs_type: "string",
required: false,
},
::flatbed::FieldInfo {
name: "addresses",
fbs_type: "[Address]",
required: false,
},
::flatbed::FieldInfo {
name: "contact_names",
fbs_type: "[string]",
required: false,
},
];
const SCHEMA_NAME: &'static str = "AddressBook";
fn to_flatbuffer(&self) -> Vec<u8> {
self.to_flatbuffer()
}
}
impl ::flatbed::FromFlatBuffer for AddressBook {
fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
Self::from_flatbuffer(bytes)
}
}
impl ::flatbed::HasJsonCompanion for super::__fb::test::AddressBook<'_> {
type Json = AddressBook;
}
impl ::flatbed::HasPlainStruct for AddressBook {
type Plain = AddressBook;
type FlatBuffer<'a> = super::__fb::test::AddressBook<'a>;
}
::flatbed::inventory::submit! {
::flatbed::TypeSchema { name: "AddressBook", namespace: "test", fields: &[
::flatbed::TypeFieldInfo { name: "owner", fbs_type: "string", field_id: 0, required: false },
::flatbed::TypeFieldInfo { name: "addresses", fbs_type: "[Address]", field_id: 1, required: false },
::flatbed::TypeFieldInfo { name: "contact_names", fbs_type: "[string]", field_id: 2, required: false },
] }
}
impl LogEvent {
pub fn to_flatbuffer(&self) -> Vec<u8> {
let mut builder = FlatBufferBuilder::new();
let root = self.build_flatbuffer(&mut builder);
builder.finish(root, None);
builder.finished_data().to_vec()
}
pub fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
let fb = ::flatbed::flatbuffers::root::<super::__fb::test::LogEvent>(&bytes)?;
Ok(Self::from_fb(&fb))
}
#[doc(hidden)]
pub fn build_flatbuffer<'a>(
&self,
builder: &mut FlatBufferBuilder<'a>,
) -> ::flatbed::flatbuffers::WIPOffset<super::__fb::test::LogEvent<'a>> {
let message_offset = self.message.as_ref().map(|s| builder.create_string(s));
let history_offset = self.history.as_ref().map(|v| builder.create_vector(v));
super::__fb::test::LogEvent::create(
builder,
&super::__fb::test::LogEventArgs {
message: message_offset,
severity: self.severity,
history: history_offset,
},
)
}
#[doc(hidden)]
pub fn from_fb(fb: &super::__fb::test::LogEvent) -> Self {
Self {
message: fb.message().map(|s| s.to_string()),
severity: fb.severity(),
history: fb.history().map(|v| v.iter().collect()),
}
}
}
impl ::flatbed::ToFlatBuffer for LogEvent {
const SCHEMA_FIELDS: &'static [::flatbed::FieldInfo] = &[
::flatbed::FieldInfo {
name: "message",
fbs_type: "string",
required: false,
},
::flatbed::FieldInfo {
name: "severity",
fbs_type: "Severity",
required: true,
},
::flatbed::FieldInfo {
name: "history",
fbs_type: "[Severity]",
required: false,
},
];
const SCHEMA_NAME: &'static str = "LogEvent";
fn to_flatbuffer(&self) -> Vec<u8> {
self.to_flatbuffer()
}
}
impl ::flatbed::FromFlatBuffer for LogEvent {
fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
Self::from_flatbuffer(bytes)
}
}
impl ::flatbed::HasJsonCompanion for super::__fb::test::LogEvent<'_> {
type Json = LogEvent;
}
impl ::flatbed::HasPlainStruct for LogEvent {
type Plain = LogEvent;
type FlatBuffer<'a> = super::__fb::test::LogEvent<'a>;
}
::flatbed::inventory::submit! {
::flatbed::TypeSchema { name: "LogEvent", namespace: "test", fields: &[
::flatbed::TypeFieldInfo { name: "message", fbs_type: "string", field_id: 0, required: false },
::flatbed::TypeFieldInfo { name: "severity", fbs_type: "Severity", field_id: 1, required: true },
::flatbed::TypeFieldInfo { name: "history", fbs_type: "[Severity]", field_id: 2, required: false },
] }
}
impl Defaulted {
pub fn to_flatbuffer(&self) -> Vec<u8> {
let mut builder = FlatBufferBuilder::new();
let root = self.build_flatbuffer(&mut builder);
builder.finish(root, None);
builder.finished_data().to_vec()
}
pub fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
let fb = ::flatbed::flatbuffers::root::<super::__fb::test::Defaulted>(&bytes)?;
Ok(Self::from_fb(&fb))
}
#[doc(hidden)]
pub fn build_flatbuffer<'a>(
&self,
builder: &mut FlatBufferBuilder<'a>,
) -> ::flatbed::flatbuffers::WIPOffset<super::__fb::test::Defaulted<'a>> {
super::__fb::test::Defaulted::create(
builder,
&super::__fb::test::DefaultedArgs {
count: self.count,
flag: self.flag,
ratio: self.ratio,
level: self.level,
},
)
}
#[doc(hidden)]
pub fn from_fb(fb: &super::__fb::test::Defaulted) -> Self {
Self {
count: fb.count(),
flag: fb.flag(),
ratio: fb.ratio(),
level: fb.level(),
}
}
}
impl Default for Defaulted {
fn default() -> Self {
Self {
count: 25,
flag: true,
ratio: 1.5_f64,
level: Severity::Warning,
}
}
}
impl ::flatbed::ToFlatBuffer for Defaulted {
const SCHEMA_FIELDS: &'static [::flatbed::FieldInfo] = &[
::flatbed::FieldInfo {
name: "count",
fbs_type: "int32",
required: true,
},
::flatbed::FieldInfo {
name: "flag",
fbs_type: "bool",
required: true,
},
::flatbed::FieldInfo {
name: "ratio",
fbs_type: "float64",
required: true,
},
::flatbed::FieldInfo {
name: "level",
fbs_type: "Severity",
required: true,
},
];
const SCHEMA_NAME: &'static str = "Defaulted";
fn to_flatbuffer(&self) -> Vec<u8> {
self.to_flatbuffer()
}
}
impl ::flatbed::FromFlatBuffer for Defaulted {
fn from_flatbuffer(
bytes: &[u8],
) -> Result<Self, ::flatbed::flatbuffers::InvalidFlatbuffer> {
Self::from_flatbuffer(bytes)
}
}
impl ::flatbed::HasJsonCompanion for super::__fb::test::Defaulted<'_> {
type Json = Defaulted;
}
impl ::flatbed::HasPlainStruct for Defaulted {
type Plain = Defaulted;
type FlatBuffer<'a> = super::__fb::test::Defaulted<'a>;
}
::flatbed::inventory::submit! {
::flatbed::TypeSchema { name: "Defaulted", namespace: "test", fields: &[
::flatbed::TypeFieldInfo { name: "count", fbs_type: "int32", field_id: 0, required: true },
::flatbed::TypeFieldInfo { name: "flag", fbs_type: "bool", field_id: 1, required: true },
::flatbed::TypeFieldInfo { name: "ratio", fbs_type: "float64", field_id: 2, required: true },
::flatbed::TypeFieldInfo { name: "level", fbs_type: "Severity", field_id: 3, required: true },
] }
}
}