Skip to content

Commit

Permalink
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
add flatbuffer gRPC demo
Browse files Browse the repository at this point in the history
zealchen committed May 2, 2024
1 parent 7b4549e commit 08fd173
Showing 16 changed files with 343 additions and 1,006 deletions.
18 changes: 14 additions & 4 deletions Cargo.toml
Original file line number Diff line number Diff line change
@@ -1,18 +1,28 @@
[package]
[workspace.package]
name = "serialization-benchmark-rs"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[workspace]
resolver = "2"
# In alphabetical order
members = [
"fb_tonic_demo",
]

[dependencies]
[workspace.dependencies]
bytes = "1.6.0"
clap = { version = "4.5.4", features = ["derive", "env"] }
flatbuffers = "24.3.25"
fury = { git= "https://github.com/apache/incubator-fury.git", branch = "main" }
lazy_static = "1.4.0"
prettytable-rs = "0.10.0"
prost = "0.12.4"
sysinfo = "0.30.11"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0.116"
tokio = { version = "1.37.0", features = ["macros", "rt-multi-thread"] }
tonic = "0.11.0"

[build-dependencies]
[workspace.build-dependencies]
tonic-build = "0.11.0"
14 changes: 7 additions & 7 deletions fb_tonic_demo/Cargo.toml
Original file line number Diff line number Diff line change
@@ -6,13 +6,13 @@ edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
bytes = "1.6.0"
flatbuffers = "24.3.25"
prost = "0.12.4"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0.116"
tokio = { version = "1.37.0", features = ["macros", "rt-multi-thread"] }
tonic = "0.11.0"
bytes = { workspace = true }
flatbuffers = { workspace = true }
prost = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
tokio = { workspace = true }
tonic = { workspace = true }

[build-dependencies]
tonic-build = "0.11.0"
6 changes: 6 additions & 0 deletions fb_tonic_demo/READEME.md
Original file line number Diff line number Diff line change
@@ -0,0 +1,6 @@
# How to run flatbuffer tonic demo?

```sh
cargo run --bin server
cargo run --bin client
```
8 changes: 2 additions & 6 deletions fb_tonic_demo/build.rs
Original file line number Diff line number Diff line change
@@ -1,19 +1,15 @@
use std::io::Result;

fn main() -> Result<()> {
// tonic_build::configure()
// .out_dir("src/util")
// .compile(&["src/util/service.proto"], &["src/util"])?;
// Ok(())
let greeter_service = tonic_build::manual::Service::builder()
.name("Greeter")
.package("fb.helloworld")
.method(
tonic_build::manual::Method::builder()
.name("say_hello")
.route_name("SayHello")
.input_type("crate::util::common::FlatBuffersObject<'static>")
.output_type("crate::util::common::FlatBuffersObject<'static>")
.input_type("crate::util::common::FlatBufferBytes")
.output_type("crate::util::common::FlatBufferBytes")
.codec_path("crate::util::common::FlatBufferCodec")
.build(),
)
70 changes: 20 additions & 50 deletions fb_tonic_demo/src/client.rs
Original file line number Diff line number Diff line change
@@ -1,43 +1,8 @@
// // main.rs (客户端)
// extern crate flatbuffers;
// use tonic::Request;
// mod util;

// #[tokio::main]
// async fn main() -> Result<(), Box<dyn std::error::Error>> {
// // 连接到服务端
// let mut client = util::MonsterServiceClient::connect("http://[::1]:8000").await?;

// // 创建请求
// let request = tonic::Request::new(util::GetMonsterRequest { id: 123 });

// // 发起请求并等待响应
// let response = client.get_monster(request).await?;

// // 获取 MonsterResponse 中的 monster_data 字段
// let monster_data_bytes = response.get_ref().monster_data.as_slice();

// // 使用 flatbuffers 的逻辑来解析字节数据
// // let monster = match flatbuffers::root::<util::Monster>(monster_data_bytes) {
// // Ok(monster): {},
// // Error(_): {}
// // };
// if let Ok(monster) = flatbuffers::root::<util::Monster>(monster_data_bytes) {
// println!("Received Monster with ID: {}", monster.id());
// println!("Received Monster with Name: {:?}", monster.name());
// } else {
// println!("bad ass.");
// }

// // 处理 monster

// Ok(())
// }

#![allow(unused)]
pub mod util;
use util::common::FlatBuffersObject;
use util::fbperson_generated::fbdemo::FBPerson;
use util::fbperson_generated::fbdemo::FBPersonArgs;
use util::common::FlatBufferBytes;
use util::fbgreeting_generated::fbdemo::Greetings;
use util::fbgreeting_generated::fbdemo::GreetingsArgs;

pub mod hello_world {
include!("util/fb.helloworld.Greeter.rs");
@@ -48,25 +13,30 @@ use hello_world::greeter_client::GreeterClient;
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut client = GreeterClient::connect("http://[::1]:50051").await?;

let mut builder = flatbuffers::FlatBufferBuilder::with_capacity(1024);
let mut builder: flatbuffers::FlatBufferBuilder<'_> =
flatbuffers::FlatBufferBuilder::with_capacity(1024);

let name = builder.create_string("from_sender");
let name = builder.create_string("Alice");
let words = builder.create_string("Hello~~");

let data: flatbuffers::WIPOffset<FBPerson<'_>> = FBPerson::create(
let root_offset: flatbuffers::WIPOffset<Greetings<'_>> = Greetings::create(
&mut builder,
&FBPersonArgs {
&GreetingsArgs {
name: Some(name),
age: 11,
pets: None,
words: Some(words),
},
);
let req = FlatBuffersObject::new(data, builder);

let request = tonic::Request::new(req);

let request = tonic::Request::new(FlatBufferBytes::serialize(builder, root_offset));
let response = client.say_hello(request).await?;

// println!("RESPONSE={:?}", response);
let r = response.into_inner();
if let Ok(greetings) = r.deserialize::<Greetings>() {
println!(
"Greetings from {:?}: {:?}",
greetings.name().unwrap(),
greetings.words().unwrap()
);
}

Ok(())
}
81 changes: 20 additions & 61 deletions fb_tonic_demo/src/server.rs
Original file line number Diff line number Diff line change
@@ -1,52 +1,10 @@
// use flatbuffers::FlatBufferBuilder;
// use tonic::{transport::Server, Request, Response, Status};
// mod util;

// #[derive(Debug, Default)]
// struct MyMonsterService;

// #[tonic::async_trait]
// impl util::monster_service_server::MonsterService for MyMonsterService {
// async fn get_monster(
// &self,
// request: Request<util::GetMonsterRequest>,
// ) -> Result<Response<util::MonsterResponse>, Status> {
// let mut builder = FlatBufferBuilder::new();
// let name = builder.create_string("bob");
// let data: flatbuffers::WIPOffset<util::Monster<'_>> = util::Monster::create(
// &mut builder,
// &util::MonsterArgs {
// name: Some(name),
// id: 11,
// },
// );
// builder.finish(data, None);
// let monster_data_bytes = builder.finished_data();

// Ok(Response::new(util::MonsterResponse {
// monster_data: monster_data_bytes.to_vec(),
// }))
// }
// }

// #[tokio::main]
// async fn main() -> Result<(), Box<dyn std::error::Error>> {
// let address = "[::1]:8000".parse().unwrap();
// let voting_service = MyMonsterService::default();

// Server::builder()
// .add_service(util::MonsterServiceServer::new(voting_service))
// .serve(address)
// .await?;
// Ok(())
// }

#![allow(unused)]
use tonic::{transport::Server, Request, Response, Status};

pub mod util;
use util::common::FlatBuffersObject;
use util::fbperson_generated::fbdemo::FBPerson;
use util::fbperson_generated::fbdemo::FBPersonArgs;
use util::common::FlatBufferBytes;
use util::fbgreeting_generated::fbdemo::Greetings;
use util::fbgreeting_generated::fbdemo::GreetingsArgs;

pub mod hello_world {
include!("util/fb.helloworld.Greeter.rs");
@@ -60,28 +18,29 @@ pub struct MyGreeter {}
impl Greeter for MyGreeter {
async fn say_hello(
&self,
request: Request<FlatBuffersObject<'static>>,
) -> Result<Response<FlatBuffersObject<'static>>, Status> {
// println!("Got a request from {:?}", request.remote_addr());
request: Request<FlatBufferBytes>,
) -> Result<Response<FlatBufferBytes>, Status> {
let req = request.into_inner();
if let Ok(greetings) = req.deserialize::<Greetings>() {
println!(
"Greetings from {:?}: {:?}",
greetings.name().unwrap(),
greetings.words().unwrap()
);
}

let mut builder = flatbuffers::FlatBufferBuilder::with_capacity(1024);
let name = builder.create_string("bob");
let words = builder.create_string("world~~");

let name = builder.create_string("from_receiver");

let data: flatbuffers::WIPOffset<FBPerson<'_>> = FBPerson::create(
let root_offset: flatbuffers::WIPOffset<Greetings<'_>> = Greetings::create(
&mut builder,
&FBPersonArgs {
&GreetingsArgs {
name: Some(name),
age: 11,
pets: None,
words: Some(words),
},
);

let resp: FlatBuffersObject<'_> = FlatBuffersObject::new(data, builder);

// let reply = HelloResponse {
// message: format!("Hello {}!", request.into_inner().name),
// };
let resp = FlatBufferBytes::serialize(builder, root_offset);
Ok(Response::new(resp))
}
}
111 changes: 48 additions & 63 deletions fb_tonic_demo/src/util/common.rs
Original file line number Diff line number Diff line change
@@ -2,112 +2,97 @@
//! json.helloworld.Greeter service which is defined manually (instead of via proto files) by the
//! `build_json_codec_service` function in the `examples/build.rs` file.
extern crate flatbuffers;
use crate::util::fbperson_generated::fbdemo::FBPerson;
use bytes::{Buf, BufMut};
use serde::{Deserialize, Serialize};
use std::marker::PhantomData;
use std::io::Read;
use tonic::{
codec::{Codec, DecodeBuf, Decoder, EncodeBuf, Encoder},
Status,
};

#[derive(Debug, Deserialize, Serialize)]
pub struct HelloRequest {
pub name: String,
// TODO: Any better solutions to manage the flatbuffer objects?
// As the associated type Encode / Decode of Trait Codec has a 'static lifetime bound which means
// items been encoded or decoded shall not have any non static references.
// However flatbuffer related types always have a 'fbb lifetime bound, I found no way to implement
// something like serde do.
pub struct FlatBufferBytes {
data: Vec<u8>,
head: usize,
}

#[derive(Debug, Deserialize, Serialize)]
pub struct HelloResponse {
pub message: String,
}

pub trait FlatBufferSerializable {
fn serialize(&self) -> &[u8];
}
impl FlatBufferBytes {
pub fn new(data: Vec<u8>, head: usize) -> Self {
Self { data, head }
}

pub struct FlatBuffersObject<'a> {
data: flatbuffers::WIPOffset<FBPerson<'a>>,
builder: flatbuffers::FlatBufferBuilder<'a>,
}
pub fn valid_slice(&self) -> &[u8] {
&(self.data[self.head..])
}

impl<'a> FlatBuffersObject<'a> {
pub fn new(
data: flatbuffers::WIPOffset<FBPerson<'a>>,
builder: flatbuffers::FlatBufferBuilder<'a>,
pub fn serialize<'buf, T: flatbuffers::Follow<'buf> + 'buf>(
mut builder: flatbuffers::FlatBufferBuilder<'buf>,
root_offset: flatbuffers::WIPOffset<T>,
) -> Self {
Self { data, builder }
builder.finish(root_offset, None);
let (data, head) = builder.collapse();
Self { data, head }
}
}

impl FlatBufferSerializable for FlatBuffersObject<'_> {
fn serialize(&self) -> &[u8] {
self.builder.finish(self.data, None);
let buf = self.builder.finished_data();
buf
pub fn deserialize<'buf, T: flatbuffers::Follow<'buf> + flatbuffers::Verifiable + 'buf>(
&'buf self,
) -> Result<T::Inner, Box<dyn std::error::Error>> {
let data = self.valid_slice();
flatbuffers::root::<T>(data).map_err(|x| Box::new(x) as Box<dyn std::error::Error>)
}
}

#[derive(Debug)]
pub struct FlatBufferEncoder<T>(PhantomData<T>);
pub struct FlatBufferEncoder();

impl<T: FlatBufferSerializable> Encoder for FlatBufferEncoder<T> {
type Item = T;
impl Encoder for FlatBufferEncoder {
type Item = FlatBufferBytes;
type Error = Status;

fn encode(&mut self, item: Self::Item, buf: &mut EncodeBuf<'_>) -> Result<(), Self::Error> {
let out = item.serialize();
buf.put_slice(out);
buf.put_slice(item.valid_slice());
Ok(())
//serde_json::to_writer(buf.writer(), &item).map_err(|e| Status::internal(e.to_string()))
}
}

#[derive(Debug)]
pub struct FlatBufferDecoder<U: 'static>(PhantomData<&'static U>);
pub struct FlatBufferDecoder();

impl<U: 'static + flatbuffers::Follow<'static> + flatbuffers::Verifiable> Decoder
for FlatBufferDecoder<U>
{
type Item = U::Inner;
impl Decoder for FlatBufferDecoder {
type Item = FlatBufferBytes;
type Error = Status;

fn decode(&mut self, buf: &mut DecodeBuf<'_>) -> Result<Option<Self::Item>, Self::Error> {
if !buf.has_remaining() {
return Ok(None);
}

let item =
flatbuffers::root::<U>(buf.chunk()).map_err(|e| Status::internal(e.to_string()))?;
let mut data: Vec<u8> = Vec::new();
buf.reader()
.read_to_end(&mut data)
.map_err(|e| Status::internal(e.to_string()))?;
let item = FlatBufferBytes::new(data, 0);
Ok(Some(item))
}
}

/// A [`Codec`] that implements `application/grpc+json` via the serde library.
#[derive(Debug, Clone)]
pub struct FlatBufferCodec<T, U: 'static>(PhantomData<(T, &'static U)>);

impl<T, U> Default for FlatBufferCodec<T, U> {
fn default() -> Self {
Self(PhantomData)
}
}
#[derive(Debug, Clone, Default)]
pub struct FlatBufferCodec();

impl<T, U> Codec for FlatBufferCodec<T, U>
where
T: FlatBufferSerializable + Send + 'static,
U: flatbuffers::Follow<'static> + flatbuffers::Verifiable + Sync + Send + 'static,
U::Inner: Send + 'static,
{
type Encode = T;
type Decode = U::Inner;
type Encoder = FlatBufferEncoder<T>;
type Decoder = FlatBufferDecoder<U>;
impl Codec for FlatBufferCodec {
type Encode = FlatBufferBytes;
type Decode = FlatBufferBytes;
type Encoder = FlatBufferEncoder;
type Decoder = FlatBufferDecoder;

fn encoder(&mut self) -> Self::Encoder {
FlatBufferEncoder(PhantomData)
FlatBufferEncoder()
}

fn decoder(&mut self) -> Self::Decoder {
FlatBufferDecoder(PhantomData)
FlatBufferDecoder()
}
}
21 changes: 8 additions & 13 deletions fb_tonic_demo/src/util/fb.helloworld.Greeter.rs
Original file line number Diff line number Diff line change
@@ -85,11 +85,9 @@ pub mod greeter_client {
}
pub async fn say_hello(
&mut self,
request: impl tonic::IntoRequest<
crate::util::common::FlatBuffersObject<'static>,
>,
request: impl tonic::IntoRequest<crate::util::common::FlatBufferBytes>,
) -> std::result::Result<
tonic::Response<crate::util::common::FlatBuffersObject<'static>>,
tonic::Response<crate::util::common::FlatBufferBytes>,
tonic::Status,
> {
self.inner
@@ -121,9 +119,9 @@ pub mod greeter_server {
pub trait Greeter: Send + Sync + 'static {
async fn say_hello(
&self,
request: tonic::Request<crate::util::common::FlatBuffersObject<'static>>,
request: tonic::Request<crate::util::common::FlatBufferBytes>,
) -> std::result::Result<
tonic::Response<crate::util::common::FlatBuffersObject<'static>>,
tonic::Response<crate::util::common::FlatBufferBytes>,
tonic::Status,
>;
}
@@ -211,19 +209,16 @@ pub mod greeter_server {
struct SayHelloSvc<T: Greeter>(pub Arc<T>);
impl<
T: Greeter,
> tonic::server::UnaryService<
crate::util::common::FlatBuffersObject<'static>,
> for SayHelloSvc<T> {
type Response = crate::util::common::FlatBuffersObject<'static>;
> tonic::server::UnaryService<crate::util::common::FlatBufferBytes>
for SayHelloSvc<T> {
type Response = crate::util::common::FlatBufferBytes;
type Future = BoxFuture<
tonic::Response<Self::Response>,
tonic::Status,
>;
fn call(
&mut self,
request: tonic::Request<
crate::util::common::FlatBuffersObject<'static>,
>,
request: tonic::Request<crate::util::common::FlatBufferBytes>,
) -> Self::Future {
let inner = Arc::clone(&self.0);
let fut = async move {
10 changes: 10 additions & 0 deletions fb_tonic_demo/src/util/fbgreeting.fbs
Original file line number Diff line number Diff line change
@@ -0,0 +1,10 @@
// Example IDL file for our monster's schema.

namespace FBDemo;

table Greetings {
name:string;
words:string;
}

root_type Greetings;
207 changes: 207 additions & 0 deletions fb_tonic_demo/src/util/fbgreeting_generated.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,207 @@
// automatically generated by the FlatBuffers compiler, do not modify


// @generated

use core::mem;
use core::cmp::Ordering;

extern crate flatbuffers;
use self::flatbuffers::{EndianScalar, Follow};

#[allow(unused_imports, dead_code)]
pub mod fbdemo {

use core::mem;
use core::cmp::Ordering;

extern crate flatbuffers;
use self::flatbuffers::{EndianScalar, Follow};

pub enum GreetingsOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct Greetings<'a> {
pub _tab: flatbuffers::Table<'a>,
}

impl<'a> flatbuffers::Follow<'a> for Greetings<'a> {
type Inner = Greetings<'a>;
#[inline]
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: flatbuffers::Table::new(buf, loc) }
}
}

impl<'a> Greetings<'a> {
pub const VT_NAME: flatbuffers::VOffsetT = 4;
pub const VT_WORDS: flatbuffers::VOffsetT = 6;

#[inline]
pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
Greetings { _tab: table }
}
#[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
args: &'args GreetingsArgs<'args>
) -> flatbuffers::WIPOffset<Greetings<'bldr>> {
let mut builder = GreetingsBuilder::new(_fbb);
if let Some(x) = args.words { builder.add_words(x); }
if let Some(x) = args.name { builder.add_name(x); }
builder.finish()
}


#[inline]
pub fn name(&self) -> Option<&'a str> {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(Greetings::VT_NAME, None)}
}
#[inline]
pub fn words(&self) -> Option<&'a str> {
// Safety:
// Created from valid Table for this object
// which contains a valid value in this slot
unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(Greetings::VT_WORDS, None)}
}
}

impl flatbuffers::Verifiable for Greetings<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier, pos: usize
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>("words", Self::VT_WORDS, false)?
.finish();
Ok(())
}
}
pub struct GreetingsArgs<'a> {
pub name: Option<flatbuffers::WIPOffset<&'a str>>,
pub words: Option<flatbuffers::WIPOffset<&'a str>>,
}
impl<'a> Default for GreetingsArgs<'a> {
#[inline]
fn default() -> Self {
GreetingsArgs {
name: None,
words: None,
}
}
}

pub struct GreetingsBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> GreetingsBuilder<'a, 'b, A> {
#[inline]
pub fn add_name(&mut self, name: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Greetings::VT_NAME, name);
}
#[inline]
pub fn add_words(&mut self, words: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Greetings::VT_WORDS, words);
}
#[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> GreetingsBuilder<'a, 'b, A> {
let start = _fbb.start_table();
GreetingsBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<Greetings<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}

impl core::fmt::Debug for Greetings<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let mut ds = f.debug_struct("Greetings");
ds.field("name", &self.name());
ds.field("words", &self.words());
ds.finish()
}
}
#[inline]
/// Verifies that a buffer of bytes contains a `Greetings`
/// and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_greetings_unchecked`.
pub fn root_as_greetings(buf: &[u8]) -> Result<Greetings, flatbuffers::InvalidFlatbuffer> {
flatbuffers::root::<Greetings>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `Greetings` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `size_prefixed_root_as_greetings_unchecked`.
pub fn size_prefixed_root_as_greetings(buf: &[u8]) -> Result<Greetings, flatbuffers::InvalidFlatbuffer> {
flatbuffers::size_prefixed_root::<Greetings>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `Greetings` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_greetings_unchecked`.
pub fn root_as_greetings_with_opts<'b, 'o>(
opts: &'o flatbuffers::VerifierOptions,
buf: &'b [u8],
) -> Result<Greetings<'b>, flatbuffers::InvalidFlatbuffer> {
flatbuffers::root_with_opts::<Greetings<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `Greetings` and returns
/// it. Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_greetings_unchecked`.
pub fn size_prefixed_root_as_greetings_with_opts<'b, 'o>(
opts: &'o flatbuffers::VerifierOptions,
buf: &'b [u8],
) -> Result<Greetings<'b>, flatbuffers::InvalidFlatbuffer> {
flatbuffers::size_prefixed_root_with_opts::<Greetings<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a Greetings and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `Greetings`.
pub unsafe fn root_as_greetings_unchecked(buf: &[u8]) -> Greetings {
flatbuffers::root_unchecked::<Greetings>(buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed Greetings and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `Greetings`.
pub unsafe fn size_prefixed_root_as_greetings_unchecked(buf: &[u8]) -> Greetings {
flatbuffers::size_prefixed_root_unchecked::<Greetings>(buf)
}
#[inline]
pub fn finish_greetings_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
root: flatbuffers::WIPOffset<Greetings<'a>>) {
fbb.finish(root, None);
}

#[inline]
pub fn finish_size_prefixed_greetings_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<Greetings<'a>>) {
fbb.finish_size_prefixed(root, None);
}
} // pub mod FBDemo

321 changes: 0 additions & 321 deletions fb_tonic_demo/src/util/fbperson_generated.rs

This file was deleted.

7 changes: 0 additions & 7 deletions fb_tonic_demo/src/util/message.fbs

This file was deleted.

145 changes: 0 additions & 145 deletions fb_tonic_demo/src/util/message_generated.rs

This file was deleted.

11 changes: 1 addition & 10 deletions fb_tonic_demo/src/util/mod.rs
Original file line number Diff line number Diff line change
@@ -1,11 +1,2 @@
pub mod message_generated;
pub mod my_game;
pub use message_generated::my_game::sample::Monster;
pub use message_generated::my_game::sample::MonsterArgs;
pub use my_game::monster_service_client::MonsterServiceClient;
pub use my_game::monster_service_server;
pub use my_game::monster_service_server::MonsterServiceServer;
pub use my_game::GetMonsterRequest;
pub use my_game::MonsterResponse;
pub mod common;
pub mod fbperson_generated;
pub mod fbgreeting_generated;
303 changes: 0 additions & 303 deletions fb_tonic_demo/src/util/my_game.rs

This file was deleted.

16 changes: 0 additions & 16 deletions fb_tonic_demo/src/util/service.proto

This file was deleted.

0 comments on commit 08fd173

Please sign in to comment.