use std::mem;
use std::cmp::Ordering;
extern crate flatbuffers;
use self::flatbuffers::{EndianScalar, Follow};
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_FUNCTION: u8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_FUNCTION: u8 = 1;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
#[allow(non_camel_case_types)]
pub const ENUM_VALUES_FUNCTION: [Function; 2] = [
Function::NONE,
Function::Request,
];
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct Function(pub u8);
#[allow(non_upper_case_globals)]
impl Function {
pub const NONE: Self = Self(0);
pub const Request: Self = Self(1);
pub const ENUM_MIN: u8 = 0;
pub const ENUM_MAX: u8 = 1;
pub const ENUM_VALUES: &'static [Self] = &[
Self::NONE,
Self::Request,
];
pub fn variant_name(self) -> Option<&'static str> {
match self {
Self::NONE => Some("NONE"),
Self::Request => Some("Request"),
_ => None,
}
}
}
impl std::fmt::Debug for Function {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
if let Some(name) = self.variant_name() {
f.write_str(name)
} else {
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
}
}
}
impl<'a> flatbuffers::Follow<'a> for Function {
type Inner = Self;
#[inline]
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
let b = unsafe {
flatbuffers::read_scalar_at::<u8>(buf, loc)
};
Self(b)
}
}
impl flatbuffers::Push for Function {
type Output = Function;
#[inline]
fn push(&self, dst: &mut [u8], _rest: &[u8]) {
unsafe { flatbuffers::emplace_scalar::<u8>(dst, self.0); }
}
}
impl flatbuffers::EndianScalar for Function {
#[inline]
fn to_little_endian(self) -> Self {
let b = u8::to_le(self.0);
Self(b)
}
#[inline]
#[allow(clippy::wrong_self_convention)]
fn from_little_endian(self) -> Self {
let b = u8::from_le(self.0);
Self(b)
}
}
impl<'a> flatbuffers::Verifiable for Function {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier, pos: usize
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
u8::run_verifier(v, pos)
}
}
impl flatbuffers::SimpleToVerifyInSlice for Function {}
pub struct FunctionUnionTableOffset {}
pub enum RequestOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct Request<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for Request<'a> {
type Inner = Request<'a>;
#[inline]
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: flatbuffers::Table { buf, loc } }
}
}
impl<'a> Request<'a> {
#[inline]
pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
Request { _tab: table }
}
#[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args RequestArgs<'args>) -> flatbuffers::WIPOffset<Request<'bldr>> {
let mut builder = RequestBuilder::new(_fbb);
if let Some(x) = args.body { builder.add_body(x); }
if let Some(x) = args.content_type { builder.add_content_type(x); }
if let Some(x) = args.uri { builder.add_uri(x); }
if let Some(x) = args.method { builder.add_method(x); }
builder.finish()
}
pub const VT_METHOD: flatbuffers::VOffsetT = 4;
pub const VT_URI: flatbuffers::VOffsetT = 6;
pub const VT_CONTENT_TYPE: flatbuffers::VOffsetT = 8;
pub const VT_BODY: flatbuffers::VOffsetT = 10;
#[inline]
pub fn method(&self) -> Option<&'a str> {
self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(Request::VT_METHOD, None)
}
#[inline]
pub fn uri(&self) -> Option<&'a str> {
self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(Request::VT_URI, None)
}
#[inline]
pub fn content_type(&self) -> Option<&'a str> {
self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(Request::VT_CONTENT_TYPE, None)
}
#[inline]
pub fn body(&self) -> Option<&'a [u8]> {
self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(Request::VT_BODY, None).map(|v| v.safe_slice())
}
}
impl flatbuffers::Verifiable for Request<'_> {
#[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>>(&"method", Self::VT_METHOD, false)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(&"uri", Self::VT_URI, false)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(&"content_type", Self::VT_CONTENT_TYPE, false)?
.visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(&"body", Self::VT_BODY, false)?
.finish();
Ok(())
}
}
pub struct RequestArgs<'a> {
pub method: Option<flatbuffers::WIPOffset<&'a str>>,
pub uri: Option<flatbuffers::WIPOffset<&'a str>>,
pub content_type: Option<flatbuffers::WIPOffset<&'a str>>,
pub body: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for RequestArgs<'a> {
#[inline]
fn default() -> Self {
RequestArgs {
method: None,
uri: None,
content_type: None,
body: None,
}
}
}
pub struct RequestBuilder<'a: 'b, 'b> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b> RequestBuilder<'a, 'b> {
#[inline]
pub fn add_method(&mut self, method: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Request::VT_METHOD, method);
}
#[inline]
pub fn add_uri(&mut self, uri: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Request::VT_URI, uri);
}
#[inline]
pub fn add_content_type(&mut self, content_type: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Request::VT_CONTENT_TYPE, content_type);
}
#[inline]
pub fn add_body(&mut self, body: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Request::VT_BODY, body);
}
#[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> RequestBuilder<'a, 'b> {
let start = _fbb.start_table();
RequestBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<Request<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl std::fmt::Debug for Request<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut ds = f.debug_struct("Request");
ds.field("method", &self.method());
ds.field("uri", &self.uri());
ds.field("content_type", &self.content_type());
ds.field("body", &self.body());
ds.finish()
}
}
pub enum ResponseOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct Response<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for Response<'a> {
type Inner = Response<'a>;
#[inline]
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: flatbuffers::Table { buf, loc } }
}
}
impl<'a> Response<'a> {
#[inline]
pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
Response { _tab: table }
}
#[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args ResponseArgs<'args>) -> flatbuffers::WIPOffset<Response<'bldr>> {
let mut builder = ResponseBuilder::new(_fbb);
if let Some(x) = args.body { builder.add_body(x); }
if let Some(x) = args.content_type { builder.add_content_type(x); }
builder.add_status_code(args.status_code);
builder.finish()
}
pub const VT_STATUS_CODE: flatbuffers::VOffsetT = 4;
pub const VT_CONTENT_TYPE: flatbuffers::VOffsetT = 6;
pub const VT_BODY: flatbuffers::VOffsetT = 8;
#[inline]
pub fn status_code(&self) -> u16 {
self._tab.get::<u16>(Response::VT_STATUS_CODE, Some(0)).unwrap()
}
#[inline]
pub fn content_type(&self) -> Option<&'a str> {
self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(Response::VT_CONTENT_TYPE, None)
}
#[inline]
pub fn body(&self) -> Option<&'a [u8]> {
self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(Response::VT_BODY, None).map(|v| v.safe_slice())
}
}
impl flatbuffers::Verifiable for Response<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier, pos: usize
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_field::<u16>(&"status_code", Self::VT_STATUS_CODE, false)?
.visit_field::<flatbuffers::ForwardsUOffset<&str>>(&"content_type", Self::VT_CONTENT_TYPE, false)?
.visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>(&"body", Self::VT_BODY, false)?
.finish();
Ok(())
}
}
pub struct ResponseArgs<'a> {
pub status_code: u16,
pub content_type: Option<flatbuffers::WIPOffset<&'a str>>,
pub body: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for ResponseArgs<'a> {
#[inline]
fn default() -> Self {
ResponseArgs {
status_code: 0,
content_type: None,
body: None,
}
}
}
pub struct ResponseBuilder<'a: 'b, 'b> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b> ResponseBuilder<'a, 'b> {
#[inline]
pub fn add_status_code(&mut self, status_code: u16) {
self.fbb_.push_slot::<u16>(Response::VT_STATUS_CODE, status_code, 0);
}
#[inline]
pub fn add_content_type(&mut self, content_type: flatbuffers::WIPOffset<&'b str>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Response::VT_CONTENT_TYPE, content_type);
}
#[inline]
pub fn add_body(&mut self, body: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Response::VT_BODY, body);
}
#[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> ResponseBuilder<'a, 'b> {
let start = _fbb.start_table();
ResponseBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<Response<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl std::fmt::Debug for Response<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut ds = f.debug_struct("Response");
ds.field("status_code", &self.status_code());
ds.field("content_type", &self.content_type());
ds.field("body", &self.body());
ds.finish()
}
}
pub enum CallOffset {}
#[derive(Copy, Clone, PartialEq)]
pub struct Call<'a> {
pub _tab: flatbuffers::Table<'a>,
}
impl<'a> flatbuffers::Follow<'a> for Call<'a> {
type Inner = Call<'a>;
#[inline]
fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
Self { _tab: flatbuffers::Table { buf, loc } }
}
}
impl<'a> Call<'a> {
#[inline]
pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
Call { _tab: table }
}
#[allow(unused_mut)]
pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
_fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
args: &'args CallArgs) -> flatbuffers::WIPOffset<Call<'bldr>> {
let mut builder = CallBuilder::new(_fbb);
if let Some(x) = args.function { builder.add_function(x); }
builder.add_function_type(args.function_type);
builder.finish()
}
pub const VT_FUNCTION_TYPE: flatbuffers::VOffsetT = 4;
pub const VT_FUNCTION: flatbuffers::VOffsetT = 6;
#[inline]
pub fn function_type(&self) -> Function {
self._tab.get::<Function>(Call::VT_FUNCTION_TYPE, Some(Function::NONE)).unwrap()
}
#[inline]
pub fn function(&self) -> Option<flatbuffers::Table<'a>> {
self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(Call::VT_FUNCTION, None)
}
#[inline]
#[allow(non_snake_case)]
pub fn function_as_request(&self) -> Option<Request<'a>> {
if self.function_type() == Function::Request {
self.function().map(Request::init_from_table)
} else {
None
}
}
}
impl flatbuffers::Verifiable for Call<'_> {
#[inline]
fn run_verifier(
v: &mut flatbuffers::Verifier, pos: usize
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
use self::flatbuffers::Verifiable;
v.visit_table(pos)?
.visit_union::<Function, _>(&"function_type", Self::VT_FUNCTION_TYPE, &"function", Self::VT_FUNCTION, false, |key, v, pos| {
match key {
Function::Request => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Request>>("Function::Request", pos),
_ => Ok(()),
}
})?
.finish();
Ok(())
}
}
pub struct CallArgs {
pub function_type: Function,
pub function: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
}
impl<'a> Default for CallArgs {
#[inline]
fn default() -> Self {
CallArgs {
function_type: Function::NONE,
function: None,
}
}
}
pub struct CallBuilder<'a: 'b, 'b> {
fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b> CallBuilder<'a, 'b> {
#[inline]
pub fn add_function_type(&mut self, function_type: Function) {
self.fbb_.push_slot::<Function>(Call::VT_FUNCTION_TYPE, function_type, Function::NONE);
}
#[inline]
pub fn add_function(&mut self, function: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>) {
self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Call::VT_FUNCTION, function);
}
#[inline]
pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> CallBuilder<'a, 'b> {
let start = _fbb.start_table();
CallBuilder {
fbb_: _fbb,
start_: start,
}
}
#[inline]
pub fn finish(self) -> flatbuffers::WIPOffset<Call<'a>> {
let o = self.fbb_.end_table(self.start_);
flatbuffers::WIPOffset::new(o.value())
}
}
impl std::fmt::Debug for Call<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut ds = f.debug_struct("Call");
ds.field("function_type", &self.function_type());
match self.function_type() {
Function::Request => {
if let Some(x) = self.function_as_request() {
ds.field("function", &x)
} else {
ds.field("function", &"InvalidFlatbuffer: Union discriminant does not match value.")
}
},
_ => {
let x: Option<()> = None;
ds.field("function", &x)
},
};
ds.finish()
}
}