1// automatically generated by the FlatBuffers compiler, do not modify
2
3
4// @generated
5
6use core::mem;
7use core::cmp::Ordering;
8
9extern crate flatbuffers;
10use self::flatbuffers::{EndianScalar, Follow};
11
12pub enum GalaxyOffset {}
13#[derive(Copy, Clone, PartialEq)]
14
15pub struct Galaxy<'a> {
16 pub _tab: flatbuffers::Table<'a>,
17}
18
19impl<'a> flatbuffers::Follow<'a> for Galaxy<'a> {
20 type Inner = Galaxy<'a>;
21 #[inline]
22 unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
23 Self { _tab: flatbuffers::Table::new(buf, loc) }
24 }
25}
26
27impl<'a> Galaxy<'a> {
28 pub const VT_NUM_STARS: flatbuffers::VOffsetT = 4;
29
30 #[inline]
31 pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
32 Galaxy { _tab: table }
33 }
34 #[allow(unused_mut)]
35 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
36 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
37 args: &'args GalaxyArgs
38 ) -> flatbuffers::WIPOffset<Galaxy<'bldr>> {
39 let mut builder = GalaxyBuilder::new(_fbb);
40 builder.add_num_stars(args.num_stars);
41 builder.finish()
42 }
43
44
45 #[inline]
46 pub fn num_stars(&self) -> i64 {
47 // Safety:
48 // Created from valid Table for this object
49 // which contains a valid value in this slot
50 unsafe { self._tab.get::<i64>(Galaxy::VT_NUM_STARS, Some(0)).unwrap()}
51 }
52}
53
54impl flatbuffers::Verifiable for Galaxy<'_> {
55 #[inline]
56 fn run_verifier(
57 v: &mut flatbuffers::Verifier, pos: usize
58 ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
59 use self::flatbuffers::Verifiable;
60 v.visit_table(pos)?
61 .visit_field::<i64>("num_stars", Self::VT_NUM_STARS, false)?
62 .finish();
63 Ok(())
64 }
65}
66pub struct GalaxyArgs {
67 pub num_stars: i64,
68}
69impl<'a> Default for GalaxyArgs {
70 #[inline]
71 fn default() -> Self {
72 GalaxyArgs {
73 num_stars: 0,
74 }
75 }
76}
77
78pub struct GalaxyBuilder<'a: 'b, 'b> {
79 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
80 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
81}
82impl<'a: 'b, 'b> GalaxyBuilder<'a, 'b> {
83 #[inline]
84 pub fn add_num_stars(&mut self, num_stars: i64) {
85 self.fbb_.push_slot::<i64>(Galaxy::VT_NUM_STARS, num_stars, 0);
86 }
87 #[inline]
88 pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> GalaxyBuilder<'a, 'b> {
89 let start = _fbb.start_table();
90 GalaxyBuilder {
91 fbb_: _fbb,
92 start_: start,
93 }
94 }
95 #[inline]
96 pub fn finish(self) -> flatbuffers::WIPOffset<Galaxy<'a>> {
97 let o = self.fbb_.end_table(self.start_);
98 flatbuffers::WIPOffset::new(o.value())
99 }
100}
101
102impl core::fmt::Debug for Galaxy<'_> {
103 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
104 let mut ds = f.debug_struct("Galaxy");
105 ds.field("num_stars", &self.num_stars());
106 ds.finish()
107 }
108}
109pub enum UniverseOffset {}
110#[derive(Copy, Clone, PartialEq)]
111
112pub struct Universe<'a> {
113 pub _tab: flatbuffers::Table<'a>,
114}
115
116impl<'a> flatbuffers::Follow<'a> for Universe<'a> {
117 type Inner = Universe<'a>;
118 #[inline]
119 unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
120 Self { _tab: flatbuffers::Table::new(buf, loc) }
121 }
122}
123
124impl<'a> Universe<'a> {
125 pub const VT_AGE: flatbuffers::VOffsetT = 4;
126 pub const VT_GALAXIES: flatbuffers::VOffsetT = 6;
127
128 #[inline]
129 pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
130 Universe { _tab: table }
131 }
132 #[allow(unused_mut)]
133 pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
134 _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
135 args: &'args UniverseArgs<'args>
136 ) -> flatbuffers::WIPOffset<Universe<'bldr>> {
137 let mut builder = UniverseBuilder::new(_fbb);
138 builder.add_age(args.age);
139 if let Some(x) = args.galaxies { builder.add_galaxies(x); }
140 builder.finish()
141 }
142
143
144 #[inline]
145 pub fn age(&self) -> f64 {
146 // Safety:
147 // Created from valid Table for this object
148 // which contains a valid value in this slot
149 unsafe { self._tab.get::<f64>(Universe::VT_AGE, Some(0.0)).unwrap()}
150 }
151 #[inline]
152 pub fn galaxies(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Galaxy<'a>>>> {
153 // Safety:
154 // Created from valid Table for this object
155 // which contains a valid value in this slot
156 unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Galaxy>>>>(Universe::VT_GALAXIES, None)}
157 }
158}
159
160impl flatbuffers::Verifiable for Universe<'_> {
161 #[inline]
162 fn run_verifier(
163 v: &mut flatbuffers::Verifier, pos: usize
164 ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
165 use self::flatbuffers::Verifiable;
166 v.visit_table(pos)?
167 .visit_field::<f64>("age", Self::VT_AGE, false)?
168 .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Galaxy>>>>("galaxies", Self::VT_GALAXIES, false)?
169 .finish();
170 Ok(())
171 }
172}
173pub struct UniverseArgs<'a> {
174 pub age: f64,
175 pub galaxies: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Galaxy<'a>>>>>,
176}
177impl<'a> Default for UniverseArgs<'a> {
178 #[inline]
179 fn default() -> Self {
180 UniverseArgs {
181 age: 0.0,
182 galaxies: None,
183 }
184 }
185}
186
187pub struct UniverseBuilder<'a: 'b, 'b> {
188 fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
189 start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
190}
191impl<'a: 'b, 'b> UniverseBuilder<'a, 'b> {
192 #[inline]
193 pub fn add_age(&mut self, age: f64) {
194 self.fbb_.push_slot::<f64>(Universe::VT_AGE, age, 0.0);
195 }
196 #[inline]
197 pub fn add_galaxies(&mut self, galaxies: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<Galaxy<'b >>>>) {
198 self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies);
199 }
200 #[inline]
201 pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> UniverseBuilder<'a, 'b> {
202 let start = _fbb.start_table();
203 UniverseBuilder {
204 fbb_: _fbb,
205 start_: start,
206 }
207 }
208 #[inline]
209 pub fn finish(self) -> flatbuffers::WIPOffset<Universe<'a>> {
210 let o = self.fbb_.end_table(self.start_);
211 flatbuffers::WIPOffset::new(o.value())
212 }
213}
214
215impl core::fmt::Debug for Universe<'_> {
216 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
217 let mut ds = f.debug_struct("Universe");
218 ds.field("age", &self.age());
219 ds.field("galaxies", &self.galaxies());
220 ds.finish()
221 }
222}
223#[inline]
224/// Verifies that a buffer of bytes contains a `Universe`
225/// and returns it.
226/// Note that verification is still experimental and may not
227/// catch every error, or be maximally performant. For the
228/// previous, unchecked, behavior use
229/// `root_as_universe_unchecked`.
230pub fn root_as_universe(buf: &[u8]) -> Result<Universe, flatbuffers::InvalidFlatbuffer> {
231 flatbuffers::root::<Universe>(buf)
232}
233#[inline]
234/// Verifies that a buffer of bytes contains a size prefixed
235/// `Universe` and returns it.
236/// Note that verification is still experimental and may not
237/// catch every error, or be maximally performant. For the
238/// previous, unchecked, behavior use
239/// `size_prefixed_root_as_universe_unchecked`.
240pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe, flatbuffers::InvalidFlatbuffer> {
241 flatbuffers::size_prefixed_root::<Universe>(buf)
242}
243#[inline]
244/// Verifies, with the given options, that a buffer of bytes
245/// contains a `Universe` and returns it.
246/// Note that verification is still experimental and may not
247/// catch every error, or be maximally performant. For the
248/// previous, unchecked, behavior use
249/// `root_as_universe_unchecked`.
250pub fn root_as_universe_with_opts<'b, 'o>(
251 opts: &'o flatbuffers::VerifierOptions,
252 buf: &'b [u8],
253) -> Result<Universe<'b>, flatbuffers::InvalidFlatbuffer> {
254 flatbuffers::root_with_opts::<Universe<'b>>(opts, buf)
255}
256#[inline]
257/// Verifies, with the given verifier options, that a buffer of
258/// bytes contains a size prefixed `Universe` and returns
259/// it. Note that verification is still experimental and may not
260/// catch every error, or be maximally performant. For the
261/// previous, unchecked, behavior use
262/// `root_as_universe_unchecked`.
263pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(
264 opts: &'o flatbuffers::VerifierOptions,
265 buf: &'b [u8],
266) -> Result<Universe<'b>, flatbuffers::InvalidFlatbuffer> {
267 flatbuffers::size_prefixed_root_with_opts::<Universe<'b>>(opts, buf)
268}
269#[inline]
270/// Assumes, without verification, that a buffer of bytes contains a Universe and returns it.
271/// # Safety
272/// Callers must trust the given bytes do indeed contain a valid `Universe`.
273pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe {
274 flatbuffers::root_unchecked::<Universe>(buf)
275}
276#[inline]
277/// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it.
278/// # Safety
279/// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`.
280pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe {
281 flatbuffers::size_prefixed_root_unchecked::<Universe>(buf)
282}
283#[inline]
284pub fn finish_universe_buffer<'a, 'b>(
285 fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
286 root: flatbuffers::WIPOffset<Universe<'a>>) {
287 fbb.finish(root, None);
288}
289
290#[inline]
291pub fn finish_size_prefixed_universe_buffer<'a, 'b>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset<Universe<'a>>) {
292 fbb.finish_size_prefixed(root, None);
293}
View as plain text