hyperlight_common/flatbuffers/hyperlight/generated/
hldouble_generated.rs1extern crate alloc;
4extern crate flatbuffers;
5use alloc::boxed::Box;
6use alloc::string::{String, ToString};
7use alloc::vec::Vec;
8use core::cmp::Ordering;
9use core::mem;
10
11use self::flatbuffers::{EndianScalar, Follow};
12use super::*;
13pub enum hldoubleOffset {}
14#[derive(Copy, Clone, PartialEq)]
15
16pub struct hldouble<'a> {
17 pub _tab: flatbuffers::Table<'a>,
18}
19
20impl<'a> flatbuffers::Follow<'a> for hldouble<'a> {
21 type Inner = hldouble<'a>;
22 #[inline]
23 unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
24 Self {
25 _tab: unsafe { flatbuffers::Table::new(buf, loc) },
26 }
27 }
28}
29
30impl<'a> hldouble<'a> {
31 pub const VT_VALUE: flatbuffers::VOffsetT = 4;
32
33 #[inline]
34 pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
35 hldouble { _tab: table }
36 }
37 #[allow(unused_mut)]
38 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
39 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
40 args: &'args hldoubleArgs,
41 ) -> flatbuffers::WIPOffset<hldouble<'bldr>> {
42 let mut builder = hldoubleBuilder::new(_fbb);
43 builder.add_value(args.value);
44 builder.finish()
45 }
46
47 #[inline]
48 pub fn value(&self) -> f64 {
49 unsafe { self._tab.get::<f64>(hldouble::VT_VALUE, Some(0.0)).unwrap() }
53 }
54}
55
56impl flatbuffers::Verifiable for hldouble<'_> {
57 #[inline]
58 fn run_verifier(
59 v: &mut flatbuffers::Verifier,
60 pos: usize,
61 ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
62 use self::flatbuffers::Verifiable;
63 v.visit_table(pos)?
64 .visit_field::<f64>("value", Self::VT_VALUE, false)?
65 .finish();
66 Ok(())
67 }
68}
69pub struct hldoubleArgs {
70 pub value: f64,
71}
72impl<'a> Default for hldoubleArgs {
73 #[inline]
74 fn default() -> Self {
75 hldoubleArgs { value: 0.0 }
76 }
77}
78
79pub struct hldoubleBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
80 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
81 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
82}
83impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> hldoubleBuilder<'a, 'b, A> {
84 #[inline]
85 pub fn add_value(&mut self, value: f64) {
86 self.fbb_.push_slot::<f64>(hldouble::VT_VALUE, value, 0.0);
87 }
88 #[inline]
89 pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> hldoubleBuilder<'a, 'b, A> {
90 let start = _fbb.start_table();
91 hldoubleBuilder {
92 fbb_: _fbb,
93 start_: start,
94 }
95 }
96 #[inline]
97 pub fn finish(self) -> flatbuffers::WIPOffset<hldouble<'a>> {
98 let o = self.fbb_.end_table(self.start_);
99 flatbuffers::WIPOffset::new(o.value())
100 }
101}
102
103impl core::fmt::Debug for hldouble<'_> {
104 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
105 let mut ds = f.debug_struct("hldouble");
106 ds.field("value", &self.value());
107 ds.finish()
108 }
109}