...

Text file src/github.com/google/flatbuffers/tests/monster_test/my_game/example/vec_3_generated.rs

Documentation: github.com/google/flatbuffers/tests/monster_test/my_game/example

     1// automatically generated by the FlatBuffers compiler, do not modify
     2// @generated
     3extern crate alloc;
     4extern crate flatbuffers;
     5use alloc::boxed::Box;
     6use alloc::string::{String, ToString};
     7use alloc::vec::Vec;
     8use core::mem;
     9use core::cmp::Ordering;
    10use self::flatbuffers::{EndianScalar, Follow};
    11use super::*;
    12// struct Vec3, aligned to 8
    13#[repr(transparent)]
    14#[derive(Clone, Copy, PartialEq)]
    15pub struct Vec3(pub [u8; 32]);
    16impl Default for Vec3 { 
    17  fn default() -> Self { 
    18    Self([0; 32])
    19  }
    20}
    21impl core::fmt::Debug for Vec3 {
    22  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
    23    f.debug_struct("Vec3")
    24      .field("x", &self.x())
    25      .field("y", &self.y())
    26      .field("z", &self.z())
    27      .field("test1", &self.test1())
    28      .field("test2", &self.test2())
    29      .field("test3", &self.test3())
    30      .finish()
    31  }
    32}
    33
    34impl flatbuffers::SimpleToVerifyInSlice for Vec3 {}
    35impl<'a> flatbuffers::Follow<'a> for Vec3 {
    36  type Inner = &'a Vec3;
    37  #[inline]
    38  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    39    <&'a Vec3>::follow(buf, loc)
    40  }
    41}
    42impl<'a> flatbuffers::Follow<'a> for &'a Vec3 {
    43  type Inner = &'a Vec3;
    44  #[inline]
    45  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    46    flatbuffers::follow_cast_ref::<Vec3>(buf, loc)
    47  }
    48}
    49impl<'b> flatbuffers::Push for Vec3 {
    50    type Output = Vec3;
    51    #[inline]
    52    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
    53        let src = ::core::slice::from_raw_parts(self as *const Vec3 as *const u8, Self::size());
    54        dst.copy_from_slice(src);
    55    }
    56}
    57
    58impl<'a> flatbuffers::Verifiable for Vec3 {
    59  #[inline]
    60  fn run_verifier(
    61    v: &mut flatbuffers::Verifier, pos: usize
    62  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    63    use self::flatbuffers::Verifiable;
    64    v.in_buffer::<Self>(pos)
    65  }
    66}
    67
    68impl<'a> Vec3 {
    69  #[allow(clippy::too_many_arguments)]
    70  pub fn new(
    71    x: f32,
    72    y: f32,
    73    z: f32,
    74    test1: f64,
    75    test2: Color,
    76    test3: &Test,
    77  ) -> Self {
    78    let mut s = Self([0; 32]);
    79    s.set_x(x);
    80    s.set_y(y);
    81    s.set_z(z);
    82    s.set_test1(test1);
    83    s.set_test2(test2);
    84    s.set_test3(test3);
    85    s
    86  }
    87
    88  pub const fn get_fully_qualified_name() -> &'static str {
    89    "MyGame.Example.Vec3"
    90  }
    91
    92  pub fn x(&self) -> f32 {
    93    let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
    94    // Safety:
    95    // Created from a valid Table for this object
    96    // Which contains a valid value in this slot
    97    EndianScalar::from_little_endian(unsafe {
    98      core::ptr::copy_nonoverlapping(
    99        self.0[0..].as_ptr(),
   100        mem.as_mut_ptr() as *mut u8,
   101        core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
   102      );
   103      mem.assume_init()
   104    })
   105  }
   106
   107  pub fn set_x(&mut self, x: f32) {
   108    let x_le = x.to_little_endian();
   109    // Safety:
   110    // Created from a valid Table for this object
   111    // Which contains a valid value in this slot
   112    unsafe {
   113      core::ptr::copy_nonoverlapping(
   114        &x_le as *const _ as *const u8,
   115        self.0[0..].as_mut_ptr(),
   116        core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
   117      );
   118    }
   119  }
   120
   121  pub fn y(&self) -> f32 {
   122    let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
   123    // Safety:
   124    // Created from a valid Table for this object
   125    // Which contains a valid value in this slot
   126    EndianScalar::from_little_endian(unsafe {
   127      core::ptr::copy_nonoverlapping(
   128        self.0[4..].as_ptr(),
   129        mem.as_mut_ptr() as *mut u8,
   130        core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
   131      );
   132      mem.assume_init()
   133    })
   134  }
   135
   136  pub fn set_y(&mut self, x: f32) {
   137    let x_le = x.to_little_endian();
   138    // Safety:
   139    // Created from a valid Table for this object
   140    // Which contains a valid value in this slot
   141    unsafe {
   142      core::ptr::copy_nonoverlapping(
   143        &x_le as *const _ as *const u8,
   144        self.0[4..].as_mut_ptr(),
   145        core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
   146      );
   147    }
   148  }
   149
   150  pub fn z(&self) -> f32 {
   151    let mut mem = core::mem::MaybeUninit::<<f32 as EndianScalar>::Scalar>::uninit();
   152    // Safety:
   153    // Created from a valid Table for this object
   154    // Which contains a valid value in this slot
   155    EndianScalar::from_little_endian(unsafe {
   156      core::ptr::copy_nonoverlapping(
   157        self.0[8..].as_ptr(),
   158        mem.as_mut_ptr() as *mut u8,
   159        core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
   160      );
   161      mem.assume_init()
   162    })
   163  }
   164
   165  pub fn set_z(&mut self, x: f32) {
   166    let x_le = x.to_little_endian();
   167    // Safety:
   168    // Created from a valid Table for this object
   169    // Which contains a valid value in this slot
   170    unsafe {
   171      core::ptr::copy_nonoverlapping(
   172        &x_le as *const _ as *const u8,
   173        self.0[8..].as_mut_ptr(),
   174        core::mem::size_of::<<f32 as EndianScalar>::Scalar>(),
   175      );
   176    }
   177  }
   178
   179  pub fn test1(&self) -> f64 {
   180    let mut mem = core::mem::MaybeUninit::<<f64 as EndianScalar>::Scalar>::uninit();
   181    // Safety:
   182    // Created from a valid Table for this object
   183    // Which contains a valid value in this slot
   184    EndianScalar::from_little_endian(unsafe {
   185      core::ptr::copy_nonoverlapping(
   186        self.0[16..].as_ptr(),
   187        mem.as_mut_ptr() as *mut u8,
   188        core::mem::size_of::<<f64 as EndianScalar>::Scalar>(),
   189      );
   190      mem.assume_init()
   191    })
   192  }
   193
   194  pub fn set_test1(&mut self, x: f64) {
   195    let x_le = x.to_little_endian();
   196    // Safety:
   197    // Created from a valid Table for this object
   198    // Which contains a valid value in this slot
   199    unsafe {
   200      core::ptr::copy_nonoverlapping(
   201        &x_le as *const _ as *const u8,
   202        self.0[16..].as_mut_ptr(),
   203        core::mem::size_of::<<f64 as EndianScalar>::Scalar>(),
   204      );
   205    }
   206  }
   207
   208  pub fn test2(&self) -> Color {
   209    let mut mem = core::mem::MaybeUninit::<<Color as EndianScalar>::Scalar>::uninit();
   210    // Safety:
   211    // Created from a valid Table for this object
   212    // Which contains a valid value in this slot
   213    EndianScalar::from_little_endian(unsafe {
   214      core::ptr::copy_nonoverlapping(
   215        self.0[24..].as_ptr(),
   216        mem.as_mut_ptr() as *mut u8,
   217        core::mem::size_of::<<Color as EndianScalar>::Scalar>(),
   218      );
   219      mem.assume_init()
   220    })
   221  }
   222
   223  pub fn set_test2(&mut self, x: Color) {
   224    let x_le = x.to_little_endian();
   225    // Safety:
   226    // Created from a valid Table for this object
   227    // Which contains a valid value in this slot
   228    unsafe {
   229      core::ptr::copy_nonoverlapping(
   230        &x_le as *const _ as *const u8,
   231        self.0[24..].as_mut_ptr(),
   232        core::mem::size_of::<<Color as EndianScalar>::Scalar>(),
   233      );
   234    }
   235  }
   236
   237  pub fn test3(&self) -> &Test {
   238    // Safety:
   239    // Created from a valid Table for this object
   240    // Which contains a valid struct in this slot
   241    unsafe { &*(self.0[26..].as_ptr() as *const Test) }
   242  }
   243
   244  #[allow(clippy::identity_op)]
   245  pub fn set_test3(&mut self, x: &Test) {
   246    self.0[26..26 + 4].copy_from_slice(&x.0)
   247  }
   248
   249  pub fn unpack(&self) -> Vec3T {
   250    Vec3T {
   251      x: self.x(),
   252      y: self.y(),
   253      z: self.z(),
   254      test1: self.test1(),
   255      test2: self.test2(),
   256      test3: self.test3().unpack(),
   257    }
   258  }
   259}
   260
   261#[derive(Debug, Clone, PartialEq, Default)]
   262pub struct Vec3T {
   263  pub x: f32,
   264  pub y: f32,
   265  pub z: f32,
   266  pub test1: f64,
   267  pub test2: Color,
   268  pub test3: TestT,
   269}
   270impl Vec3T {
   271  pub fn pack(&self) -> Vec3 {
   272    Vec3::new(
   273      self.x,
   274      self.y,
   275      self.z,
   276      self.test1,
   277      self.test2,
   278      &self.test3.pack(),
   279    )
   280  }
   281}
   282

View as plain text