"Fossies" - the Fresh Open Source Software Archive

Member "flatbuffers-23.1.21/tests/monster_test/my_game/example/any_ambiguous_aliases_generated.rs" (21 Jan 2023, 6342 Bytes) of package /linux/misc/flatbuffers-23.1.21.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Rust source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 // automatically generated by the FlatBuffers compiler, do not modify
    2 // @generated
    3 extern crate alloc;
    4 extern crate flatbuffers;
    5 use alloc::boxed::Box;
    6 use alloc::string::{String, ToString};
    7 use alloc::vec::Vec;
    8 use core::mem;
    9 use core::cmp::Ordering;
   10 use self::flatbuffers::{EndianScalar, Follow};
   11 use super::*;
   12 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
   13 pub const ENUM_MIN_ANY_AMBIGUOUS_ALIASES: u8 = 0;
   14 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
   15 pub const ENUM_MAX_ANY_AMBIGUOUS_ALIASES: u8 = 3;
   16 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
   17 #[allow(non_camel_case_types)]
   18 pub const ENUM_VALUES_ANY_AMBIGUOUS_ALIASES: [AnyAmbiguousAliases; 4] = [
   19   AnyAmbiguousAliases::NONE,
   20   AnyAmbiguousAliases::M1,
   21   AnyAmbiguousAliases::M2,
   22   AnyAmbiguousAliases::M3,
   23 ];
   24 
   25 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
   26 #[repr(transparent)]
   27 pub struct AnyAmbiguousAliases(pub u8);
   28 #[allow(non_upper_case_globals)]
   29 impl AnyAmbiguousAliases {
   30   pub const NONE: Self = Self(0);
   31   pub const M1: Self = Self(1);
   32   pub const M2: Self = Self(2);
   33   pub const M3: Self = Self(3);
   34 
   35   pub const ENUM_MIN: u8 = 0;
   36   pub const ENUM_MAX: u8 = 3;
   37   pub const ENUM_VALUES: &'static [Self] = &[
   38     Self::NONE,
   39     Self::M1,
   40     Self::M2,
   41     Self::M3,
   42   ];
   43   /// Returns the variant's name or "" if unknown.
   44   pub fn variant_name(self) -> Option<&'static str> {
   45     match self {
   46       Self::NONE => Some("NONE"),
   47       Self::M1 => Some("M1"),
   48       Self::M2 => Some("M2"),
   49       Self::M3 => Some("M3"),
   50       _ => None,
   51     }
   52   }
   53 }
   54 impl core::fmt::Debug for AnyAmbiguousAliases {
   55   fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
   56     if let Some(name) = self.variant_name() {
   57       f.write_str(name)
   58     } else {
   59       f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
   60     }
   61   }
   62 }
   63 impl<'a> flatbuffers::Follow<'a> for AnyAmbiguousAliases {
   64   type Inner = Self;
   65   #[inline]
   66   unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
   67     let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
   68     Self(b)
   69   }
   70 }
   71 
   72 impl flatbuffers::Push for AnyAmbiguousAliases {
   73     type Output = AnyAmbiguousAliases;
   74     #[inline]
   75     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
   76         flatbuffers::emplace_scalar::<u8>(dst, self.0);
   77     }
   78 }
   79 
   80 impl flatbuffers::EndianScalar for AnyAmbiguousAliases {
   81   type Scalar = u8;
   82   #[inline]
   83   fn to_little_endian(self) -> u8 {
   84     self.0.to_le()
   85   }
   86   #[inline]
   87   #[allow(clippy::wrong_self_convention)]
   88   fn from_little_endian(v: u8) -> Self {
   89     let b = u8::from_le(v);
   90     Self(b)
   91   }
   92 }
   93 
   94 impl<'a> flatbuffers::Verifiable for AnyAmbiguousAliases {
   95   #[inline]
   96   fn run_verifier(
   97     v: &mut flatbuffers::Verifier, pos: usize
   98   ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
   99     use self::flatbuffers::Verifiable;
  100     u8::run_verifier(v, pos)
  101   }
  102 }
  103 
  104 impl flatbuffers::SimpleToVerifyInSlice for AnyAmbiguousAliases {}
  105 pub struct AnyAmbiguousAliasesUnionTableOffset {}
  106 
  107 #[allow(clippy::upper_case_acronyms)]
  108 #[non_exhaustive]
  109 #[derive(Debug, Clone, PartialEq)]
  110 pub enum AnyAmbiguousAliasesT {
  111   NONE,
  112   M1(Box<MonsterT>),
  113   M2(Box<MonsterT>),
  114   M3(Box<MonsterT>),
  115 }
  116 impl Default for AnyAmbiguousAliasesT {
  117   fn default() -> Self {
  118     Self::NONE
  119   }
  120 }
  121 impl AnyAmbiguousAliasesT {
  122   pub fn any_ambiguous_aliases_type(&self) -> AnyAmbiguousAliases {
  123     match self {
  124       Self::NONE => AnyAmbiguousAliases::NONE,
  125       Self::M1(_) => AnyAmbiguousAliases::M1,
  126       Self::M2(_) => AnyAmbiguousAliases::M2,
  127       Self::M3(_) => AnyAmbiguousAliases::M3,
  128     }
  129   }
  130   pub fn pack(&self, fbb: &mut flatbuffers::FlatBufferBuilder) -> Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>> {
  131     match self {
  132       Self::NONE => None,
  133       Self::M1(v) => Some(v.pack(fbb).as_union_value()),
  134       Self::M2(v) => Some(v.pack(fbb).as_union_value()),
  135       Self::M3(v) => Some(v.pack(fbb).as_union_value()),
  136     }
  137   }
  138   /// If the union variant matches, return the owned MonsterT, setting the union to NONE.
  139   pub fn take_m1(&mut self) -> Option<Box<MonsterT>> {
  140     if let Self::M1(_) = self {
  141       let v = core::mem::replace(self, Self::NONE);
  142       if let Self::M1(w) = v {
  143         Some(w)
  144       } else {
  145         unreachable!()
  146       }
  147     } else {
  148       None
  149     }
  150   }
  151   /// If the union variant matches, return a reference to the MonsterT.
  152   pub fn as_m1(&self) -> Option<&MonsterT> {
  153     if let Self::M1(v) = self { Some(v.as_ref()) } else { None }
  154   }
  155   /// If the union variant matches, return a mutable reference to the MonsterT.
  156   pub fn as_m1_mut(&mut self) -> Option<&mut MonsterT> {
  157     if let Self::M1(v) = self { Some(v.as_mut()) } else { None }
  158   }
  159   /// If the union variant matches, return the owned MonsterT, setting the union to NONE.
  160   pub fn take_m2(&mut self) -> Option<Box<MonsterT>> {
  161     if let Self::M2(_) = self {
  162       let v = core::mem::replace(self, Self::NONE);
  163       if let Self::M2(w) = v {
  164         Some(w)
  165       } else {
  166         unreachable!()
  167       }
  168     } else {
  169       None
  170     }
  171   }
  172   /// If the union variant matches, return a reference to the MonsterT.
  173   pub fn as_m2(&self) -> Option<&MonsterT> {
  174     if let Self::M2(v) = self { Some(v.as_ref()) } else { None }
  175   }
  176   /// If the union variant matches, return a mutable reference to the MonsterT.
  177   pub fn as_m2_mut(&mut self) -> Option<&mut MonsterT> {
  178     if let Self::M2(v) = self { Some(v.as_mut()) } else { None }
  179   }
  180   /// If the union variant matches, return the owned MonsterT, setting the union to NONE.
  181   pub fn take_m3(&mut self) -> Option<Box<MonsterT>> {
  182     if let Self::M3(_) = self {
  183       let v = core::mem::replace(self, Self::NONE);
  184       if let Self::M3(w) = v {
  185         Some(w)
  186       } else {
  187         unreachable!()
  188       }
  189     } else {
  190       None
  191     }
  192   }
  193   /// If the union variant matches, return a reference to the MonsterT.
  194   pub fn as_m3(&self) -> Option<&MonsterT> {
  195     if let Self::M3(v) = self { Some(v.as_ref()) } else { None }
  196   }
  197   /// If the union variant matches, return a mutable reference to the MonsterT.
  198   pub fn as_m3_mut(&mut self) -> Option<&mut MonsterT> {
  199     if let Self::M3(v) = self { Some(v.as_mut()) } else { None }
  200   }
  201 }