spacedatastandards-org 1.73.12

// automatically generated by the FlatBuffers compiler, do not modify


// @generated

use core::mem;
use core::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_FCSMODE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_FCSMODE: i8 = 7;
#[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_FCSMODE: [FCSMode; 8] = [
  FCSMode::OFF,
  FCSMode::STANDBY,
  FCSMode::RANGING,
  FCSMode::TRACKING,
  FCSMode::SOLUTION,
  FCSMode::CCIP,
  FCSMode::CCRP,
  FCSMode::MANUAL,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct FCSMode(pub i8);
#[allow(non_upper_case_globals)]
impl FCSMode {
  pub const OFF: Self = Self(0);
  pub const STANDBY: Self = Self(1);
  pub const RANGING: Self = Self(2);
  pub const TRACKING: Self = Self(3);
  pub const SOLUTION: Self = Self(4);
  pub const CCIP: Self = Self(5);
  pub const CCRP: Self = Self(6);
  pub const MANUAL: Self = Self(7);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 7;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::OFF,
    Self::STANDBY,
    Self::RANGING,
    Self::TRACKING,
    Self::SOLUTION,
    Self::CCIP,
    Self::CCRP,
    Self::MANUAL,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::OFF => Some("OFF"),
      Self::STANDBY => Some("STANDBY"),
      Self::RANGING => Some("RANGING"),
      Self::TRACKING => Some("TRACKING"),
      Self::SOLUTION => Some("SOLUTION"),
      Self::CCIP => Some("CCIP"),
      Self::CCRP => Some("CCRP"),
      Self::MANUAL => Some("MANUAL"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for FCSMode {
  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::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 FCSMode {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
    Self(b)
  }
}

impl flatbuffers::Push for FCSMode {
    type Output = FCSMode;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        flatbuffers::emplace_scalar::<i8>(dst, self.0);
    }
}

impl flatbuffers::EndianScalar for FCSMode {
  type Scalar = i8;
  #[inline]
  fn to_little_endian(self) -> i8 {
    self.0.to_le()
  }
  #[inline]
  #[allow(clippy::wrong_self_convention)]
  fn from_little_endian(v: i8) -> Self {
    let b = i8::from_le(v);
    Self(b)
  }
}

impl<'a> flatbuffers::Verifiable for FCSMode {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    i8::run_verifier(v, pos)
  }
}

impl flatbuffers::SimpleToVerifyInSlice for FCSMode {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_LEAD_METHOD: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_LEAD_METHOD: i8 = 4;
#[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_LEAD_METHOD: [LeadMethod; 5] = [
  LeadMethod::NONE,
  LeadMethod::PREDICTIVE,
  LeadMethod::COLLISION,
  LeadMethod::CONSTANT_BEARING,
  LeadMethod::PURSUIT,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct LeadMethod(pub i8);
#[allow(non_upper_case_globals)]
impl LeadMethod {
  pub const NONE: Self = Self(0);
  pub const PREDICTIVE: Self = Self(1);
  pub const COLLISION: Self = Self(2);
  pub const CONSTANT_BEARING: Self = Self(3);
  pub const PURSUIT: Self = Self(4);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 4;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::NONE,
    Self::PREDICTIVE,
    Self::COLLISION,
    Self::CONSTANT_BEARING,
    Self::PURSUIT,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::NONE => Some("NONE"),
      Self::PREDICTIVE => Some("PREDICTIVE"),
      Self::COLLISION => Some("COLLISION"),
      Self::CONSTANT_BEARING => Some("CONSTANT_BEARING"),
      Self::PURSUIT => Some("PURSUIT"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for LeadMethod {
  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::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 LeadMethod {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
    Self(b)
  }
}

impl flatbuffers::Push for LeadMethod {
    type Output = LeadMethod;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        flatbuffers::emplace_scalar::<i8>(dst, self.0);
    }
}

impl flatbuffers::EndianScalar for LeadMethod {
  type Scalar = i8;
  #[inline]
  fn to_little_endian(self) -> i8 {
    self.0.to_le()
  }
  #[inline]
  #[allow(clippy::wrong_self_convention)]
  fn from_little_endian(v: i8) -> Self {
    let b = i8::from_le(v);
    Self(b)
  }
}

impl<'a> flatbuffers::Verifiable for LeadMethod {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    i8::run_verifier(v, pos)
  }
}

impl flatbuffers::SimpleToVerifyInSlice for LeadMethod {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_RANGEFINDER_TYPE: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_RANGEFINDER_TYPE: i8 = 4;
#[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_RANGEFINDER_TYPE: [RangefinderType; 5] = [
  RangefinderType::STADIAMETRIC,
  RangefinderType::STEREOSCOPIC,
  RangefinderType::COINCIDENCE,
  RangefinderType::LASER,
  RangefinderType::RADAR,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct RangefinderType(pub i8);
#[allow(non_upper_case_globals)]
impl RangefinderType {
  pub const STADIAMETRIC: Self = Self(0);
  pub const STEREOSCOPIC: Self = Self(1);
  pub const COINCIDENCE: Self = Self(2);
  pub const LASER: Self = Self(3);
  pub const RADAR: Self = Self(4);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 4;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::STADIAMETRIC,
    Self::STEREOSCOPIC,
    Self::COINCIDENCE,
    Self::LASER,
    Self::RADAR,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::STADIAMETRIC => Some("STADIAMETRIC"),
      Self::STEREOSCOPIC => Some("STEREOSCOPIC"),
      Self::COINCIDENCE => Some("COINCIDENCE"),
      Self::LASER => Some("LASER"),
      Self::RADAR => Some("RADAR"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for RangefinderType {
  fn fmt(&self, f: &mut core::fmt::Formatter) -> core::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 RangefinderType {
  type Inner = Self;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
    Self(b)
  }
}

impl flatbuffers::Push for RangefinderType {
    type Output = RangefinderType;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        flatbuffers::emplace_scalar::<i8>(dst, self.0);
    }
}

impl flatbuffers::EndianScalar for RangefinderType {
  type Scalar = i8;
  #[inline]
  fn to_little_endian(self) -> i8 {
    self.0.to_le()
  }
  #[inline]
  #[allow(clippy::wrong_self_convention)]
  fn from_little_endian(v: i8) -> Self {
    let b = i8::from_le(v);
    Self(b)
  }
}

impl<'a> flatbuffers::Verifiable for RangefinderType {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    i8::run_verifier(v, pos)
  }
}

impl flatbuffers::SimpleToVerifyInSlice for RangefinderType {}
pub enum FCSOffset {}
#[derive(Copy, Clone, PartialEq)]

/// Fire Control Systems
pub struct FCS<'a> {
  pub _tab: flatbuffers::Table<'a>,
}

impl<'a> flatbuffers::Follow<'a> for FCS<'a> {
  type Inner = FCS<'a>;
  #[inline]
  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
    Self { _tab: flatbuffers::Table::new(buf, loc) }
  }
}

impl<'a> FCS<'a> {
  pub const VT_MODE: flatbuffers::VOffsetT = 4;
  pub const VT_LEAD_METHOD: flatbuffers::VOffsetT = 6;
  pub const VT_RANGEFINDER_TYPE: flatbuffers::VOffsetT = 8;
  pub const VT_AMMO_SELECTED: flatbuffers::VOffsetT = 10;
  pub const VT_TARGET: flatbuffers::VOffsetT = 12;
  pub const VT_SOLUTION: flatbuffers::VOffsetT = 14;
  pub const VT_LAST_RANGE: flatbuffers::VOffsetT = 16;
  pub const VT_RANGE_RATE: flatbuffers::VOffsetT = 18;
  pub const VT_ROUNDS_REMAINING: flatbuffers::VOffsetT = 20;
  pub const VT_TEMPERATURE: flatbuffers::VOffsetT = 22;
  pub const VT_RESERVED: flatbuffers::VOffsetT = 24;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    FCS { _tab: table }
  }
  #[allow(unused_mut)]
  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: flatbuffers::Allocator + 'bldr>(
    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr, A>,
    args: &'args FCSArgs<'args>
  ) -> flatbuffers::WIPOffset<FCS<'bldr>> {
    let mut builder = FCSBuilder::new(_fbb);
    builder.add_RANGE_RATE(args.RANGE_RATE);
    builder.add_LAST_RANGE(args.LAST_RANGE);
    if let Some(x) = args.RESERVED { builder.add_RESERVED(x); }
    builder.add_TEMPERATURE(args.TEMPERATURE);
    if let Some(x) = args.SOLUTION { builder.add_SOLUTION(x); }
    if let Some(x) = args.TARGET { builder.add_TARGET(x); }
    builder.add_ROUNDS_REMAINING(args.ROUNDS_REMAINING);
    builder.add_AMMO_SELECTED(args.AMMO_SELECTED);
    builder.add_RANGEFINDER_TYPE(args.RANGEFINDER_TYPE);
    builder.add_LEAD_METHOD(args.LEAD_METHOD);
    builder.add_MODE(args.MODE);
    builder.finish()
  }

  pub fn unpack(&self) -> FCST {
    let MODE = self.MODE();
    let LEAD_METHOD = self.LEAD_METHOD();
    let RANGEFINDER_TYPE = self.RANGEFINDER_TYPE();
    let AMMO_SELECTED = self.AMMO_SELECTED();
    let TARGET = self.TARGET().map(|x| {
      x.to_string()
    });
    let SOLUTION = self.SOLUTION().map(|x| {
      x.to_string()
    });
    let LAST_RANGE = self.LAST_RANGE();
    let RANGE_RATE = self.RANGE_RATE();
    let ROUNDS_REMAINING = self.ROUNDS_REMAINING();
    let TEMPERATURE = self.TEMPERATURE();
    let RESERVED = self.RESERVED().map(|x| {
      x.into_iter().collect()
    });
    FCST {
      MODE,
      LEAD_METHOD,
      RANGEFINDER_TYPE,
      AMMO_SELECTED,
      TARGET,
      SOLUTION,
      LAST_RANGE,
      RANGE_RATE,
      ROUNDS_REMAINING,
      TEMPERATURE,
      RESERVED,
    }
  }

  #[inline]
  pub fn MODE(&self) -> u8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(FCS::VT_MODE, Some(0)).unwrap()}
  }
  #[inline]
  pub fn LEAD_METHOD(&self) -> u8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(FCS::VT_LEAD_METHOD, Some(0)).unwrap()}
  }
  #[inline]
  pub fn RANGEFINDER_TYPE(&self) -> u8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(FCS::VT_RANGEFINDER_TYPE, Some(0)).unwrap()}
  }
  #[inline]
  pub fn AMMO_SELECTED(&self) -> u8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(FCS::VT_AMMO_SELECTED, Some(0)).unwrap()}
  }
  #[inline]
  pub fn TARGET(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(FCS::VT_TARGET, None)}
  }
  #[inline]
  pub fn SOLUTION(&self) -> Option<&'a str> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(FCS::VT_SOLUTION, None)}
  }
  #[inline]
  pub fn LAST_RANGE(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(FCS::VT_LAST_RANGE, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn RANGE_RATE(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(FCS::VT_RANGE_RATE, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn ROUNDS_REMAINING(&self) -> u16 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u16>(FCS::VT_ROUNDS_REMAINING, Some(0)).unwrap()}
  }
  #[inline]
  pub fn TEMPERATURE(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(FCS::VT_TEMPERATURE, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn RESERVED(&self) -> Option<flatbuffers::Vector<'a, u8>> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, u8>>>(FCS::VT_RESERVED, None)}
  }
}

impl flatbuffers::Verifiable for FCS<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<u8>("MODE", Self::VT_MODE, false)?
     .visit_field::<u8>("LEAD_METHOD", Self::VT_LEAD_METHOD, false)?
     .visit_field::<u8>("RANGEFINDER_TYPE", Self::VT_RANGEFINDER_TYPE, false)?
     .visit_field::<u8>("AMMO_SELECTED", Self::VT_AMMO_SELECTED, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("TARGET", Self::VT_TARGET, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("SOLUTION", Self::VT_SOLUTION, false)?
     .visit_field::<f64>("LAST_RANGE", Self::VT_LAST_RANGE, false)?
     .visit_field::<f64>("RANGE_RATE", Self::VT_RANGE_RATE, false)?
     .visit_field::<u16>("ROUNDS_REMAINING", Self::VT_ROUNDS_REMAINING, false)?
     .visit_field::<f32>("TEMPERATURE", Self::VT_TEMPERATURE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("RESERVED", Self::VT_RESERVED, false)?
     .finish();
    Ok(())
  }
}
pub struct FCSArgs<'a> {
    pub MODE: u8,
    pub LEAD_METHOD: u8,
    pub RANGEFINDER_TYPE: u8,
    pub AMMO_SELECTED: u8,
    pub TARGET: Option<flatbuffers::WIPOffset<&'a str>>,
    pub SOLUTION: Option<flatbuffers::WIPOffset<&'a str>>,
    pub LAST_RANGE: f64,
    pub RANGE_RATE: f64,
    pub ROUNDS_REMAINING: u16,
    pub TEMPERATURE: f32,
    pub RESERVED: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for FCSArgs<'a> {
  #[inline]
  fn default() -> Self {
    FCSArgs {
      MODE: 0,
      LEAD_METHOD: 0,
      RANGEFINDER_TYPE: 0,
      AMMO_SELECTED: 0,
      TARGET: None,
      SOLUTION: None,
      LAST_RANGE: 0.0,
      RANGE_RATE: 0.0,
      ROUNDS_REMAINING: 0,
      TEMPERATURE: 0.0,
      RESERVED: None,
    }
  }
}

pub struct FCSBuilder<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> {
  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
}
impl<'a: 'b, 'b, A: flatbuffers::Allocator + 'a> FCSBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_MODE(&mut self, MODE: u8) {
    self.fbb_.push_slot::<u8>(FCS::VT_MODE, MODE, 0);
  }
  #[inline]
  pub fn add_LEAD_METHOD(&mut self, LEAD_METHOD: u8) {
    self.fbb_.push_slot::<u8>(FCS::VT_LEAD_METHOD, LEAD_METHOD, 0);
  }
  #[inline]
  pub fn add_RANGEFINDER_TYPE(&mut self, RANGEFINDER_TYPE: u8) {
    self.fbb_.push_slot::<u8>(FCS::VT_RANGEFINDER_TYPE, RANGEFINDER_TYPE, 0);
  }
  #[inline]
  pub fn add_AMMO_SELECTED(&mut self, AMMO_SELECTED: u8) {
    self.fbb_.push_slot::<u8>(FCS::VT_AMMO_SELECTED, AMMO_SELECTED, 0);
  }
  #[inline]
  pub fn add_TARGET(&mut self, TARGET: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FCS::VT_TARGET, TARGET);
  }
  #[inline]
  pub fn add_SOLUTION(&mut self, SOLUTION: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FCS::VT_SOLUTION, SOLUTION);
  }
  #[inline]
  pub fn add_LAST_RANGE(&mut self, LAST_RANGE: f64) {
    self.fbb_.push_slot::<f64>(FCS::VT_LAST_RANGE, LAST_RANGE, 0.0);
  }
  #[inline]
  pub fn add_RANGE_RATE(&mut self, RANGE_RATE: f64) {
    self.fbb_.push_slot::<f64>(FCS::VT_RANGE_RATE, RANGE_RATE, 0.0);
  }
  #[inline]
  pub fn add_ROUNDS_REMAINING(&mut self, ROUNDS_REMAINING: u16) {
    self.fbb_.push_slot::<u16>(FCS::VT_ROUNDS_REMAINING, ROUNDS_REMAINING, 0);
  }
  #[inline]
  pub fn add_TEMPERATURE(&mut self, TEMPERATURE: f32) {
    self.fbb_.push_slot::<f32>(FCS::VT_TEMPERATURE, TEMPERATURE, 0.0);
  }
  #[inline]
  pub fn add_RESERVED(&mut self, RESERVED: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(FCS::VT_RESERVED, RESERVED);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> FCSBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    FCSBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<FCS<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for FCS<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("FCS");
      ds.field("MODE", &self.MODE());
      ds.field("LEAD_METHOD", &self.LEAD_METHOD());
      ds.field("RANGEFINDER_TYPE", &self.RANGEFINDER_TYPE());
      ds.field("AMMO_SELECTED", &self.AMMO_SELECTED());
      ds.field("TARGET", &self.TARGET());
      ds.field("SOLUTION", &self.SOLUTION());
      ds.field("LAST_RANGE", &self.LAST_RANGE());
      ds.field("RANGE_RATE", &self.RANGE_RATE());
      ds.field("ROUNDS_REMAINING", &self.ROUNDS_REMAINING());
      ds.field("TEMPERATURE", &self.TEMPERATURE());
      ds.field("RESERVED", &self.RESERVED());
      ds.finish()
  }
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct FCST {
  pub MODE: u8,
  pub LEAD_METHOD: u8,
  pub RANGEFINDER_TYPE: u8,
  pub AMMO_SELECTED: u8,
  pub TARGET: Option<String>,
  pub SOLUTION: Option<String>,
  pub LAST_RANGE: f64,
  pub RANGE_RATE: f64,
  pub ROUNDS_REMAINING: u16,
  pub TEMPERATURE: f32,
  pub RESERVED: Option<Vec<u8>>,
}
impl Default for FCST {
  fn default() -> Self {
    Self {
      MODE: 0,
      LEAD_METHOD: 0,
      RANGEFINDER_TYPE: 0,
      AMMO_SELECTED: 0,
      TARGET: None,
      SOLUTION: None,
      LAST_RANGE: 0.0,
      RANGE_RATE: 0.0,
      ROUNDS_REMAINING: 0,
      TEMPERATURE: 0.0,
      RESERVED: None,
    }
  }
}
impl FCST {
  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
    &self,
    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
  ) -> flatbuffers::WIPOffset<FCS<'b>> {
    let MODE = self.MODE;
    let LEAD_METHOD = self.LEAD_METHOD;
    let RANGEFINDER_TYPE = self.RANGEFINDER_TYPE;
    let AMMO_SELECTED = self.AMMO_SELECTED;
    let TARGET = self.TARGET.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let SOLUTION = self.SOLUTION.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let LAST_RANGE = self.LAST_RANGE;
    let RANGE_RATE = self.RANGE_RATE;
    let ROUNDS_REMAINING = self.ROUNDS_REMAINING;
    let TEMPERATURE = self.TEMPERATURE;
    let RESERVED = self.RESERVED.as_ref().map(|x|{
      _fbb.create_vector(x)
    });
    FCS::create(_fbb, &FCSArgs{
      MODE,
      LEAD_METHOD,
      RANGEFINDER_TYPE,
      AMMO_SELECTED,
      TARGET,
      SOLUTION,
      LAST_RANGE,
      RANGE_RATE,
      ROUNDS_REMAINING,
      TEMPERATURE,
      RESERVED,
    })
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `FCS`
/// and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_FCS_unchecked`.
pub fn root_as_FCS(buf: &[u8]) -> Result<FCS, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root::<FCS>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `FCS` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `size_prefixed_root_as_FCS_unchecked`.
pub fn size_prefixed_root_as_FCS(buf: &[u8]) -> Result<FCS, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root::<FCS>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `FCS` and returns it.
/// Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_FCS_unchecked`.
pub fn root_as_FCS_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<FCS<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root_with_opts::<FCS<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `FCS` and returns
/// it. Note that verification is still experimental and may not
/// catch every error, or be maximally performant. For the
/// previous, unchecked, behavior use
/// `root_as_FCS_unchecked`.
pub fn size_prefixed_root_as_FCS_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<FCS<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root_with_opts::<FCS<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a FCS and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `FCS`.
pub unsafe fn root_as_FCS_unchecked(buf: &[u8]) -> FCS {
  flatbuffers::root_unchecked::<FCS>(buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed FCS and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `FCS`.
pub unsafe fn size_prefixed_root_as_FCS_unchecked(buf: &[u8]) -> FCS {
  flatbuffers::size_prefixed_root_unchecked::<FCS>(buf)
}
pub const FCS_IDENTIFIER: &str = "$FCS";

#[inline]
pub fn FCS_buffer_has_identifier(buf: &[u8]) -> bool {
  flatbuffers::buffer_has_identifier(buf, FCS_IDENTIFIER, false)
}

#[inline]
pub fn FCS_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
  flatbuffers::buffer_has_identifier(buf, FCS_IDENTIFIER, true)
}

#[inline]
pub fn finish_FCS_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
    fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
    root: flatbuffers::WIPOffset<FCS<'a>>) {
  fbb.finish(root, Some(FCS_IDENTIFIER));
}

#[inline]
pub fn finish_size_prefixed_FCS_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>, root: flatbuffers::WIPOffset<FCS<'a>>) {
  fbb.finish_size_prefixed(root, Some(FCS_IDENTIFIER));
}