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};

pub enum ATDOffset {}
#[derive(Copy, Clone, PartialEq)]

/// Attitude Data Point
pub struct ATD<'a> {
  pub _tab: flatbuffers::Table<'a>,
}

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

impl<'a> ATD<'a> {
  pub const VT_ID: flatbuffers::VOffsetT = 4;
  pub const VT_AS_ID: flatbuffers::VOffsetT = 6;
  pub const VT_SAT_NO: flatbuffers::VOffsetT = 8;
  pub const VT_ORIG_OBJECT_ID: flatbuffers::VOffsetT = 10;
  pub const VT_TS: flatbuffers::VOffsetT = 12;
  pub const VT_MOTION_TYPE: flatbuffers::VOffsetT = 14;
  pub const VT_Q1: flatbuffers::VOffsetT = 16;
  pub const VT_Q2: flatbuffers::VOffsetT = 18;
  pub const VT_Q3: flatbuffers::VOffsetT = 20;
  pub const VT_QC: flatbuffers::VOffsetT = 22;
  pub const VT_Q1_DOT: flatbuffers::VOffsetT = 24;
  pub const VT_Q2_DOT: flatbuffers::VOffsetT = 26;
  pub const VT_Q3_DOT: flatbuffers::VOffsetT = 28;
  pub const VT_QC_DOT: flatbuffers::VOffsetT = 30;
  pub const VT_X_ANGLE: flatbuffers::VOffsetT = 32;
  pub const VT_Y_ANGLE: flatbuffers::VOffsetT = 34;
  pub const VT_Z_ANGLE: flatbuffers::VOffsetT = 36;
  pub const VT_X_RATE: flatbuffers::VOffsetT = 38;
  pub const VT_Y_RATE: flatbuffers::VOffsetT = 40;
  pub const VT_Z_RATE: flatbuffers::VOffsetT = 42;
  pub const VT_RA: flatbuffers::VOffsetT = 44;
  pub const VT_DECLINATION: flatbuffers::VOffsetT = 46;
  pub const VT_CONING_ANGLE: flatbuffers::VOffsetT = 48;
  pub const VT_PREC_PERIOD: flatbuffers::VOffsetT = 50;
  pub const VT_SPIN_PERIOD: flatbuffers::VOffsetT = 52;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ATD { _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 ATDArgs<'args>
  ) -> flatbuffers::WIPOffset<ATD<'bldr>> {
    let mut builder = ATDBuilder::new(_fbb);
    builder.add_SPIN_PERIOD(args.SPIN_PERIOD);
    builder.add_PREC_PERIOD(args.PREC_PERIOD);
    builder.add_CONING_ANGLE(args.CONING_ANGLE);
    builder.add_DECLINATION(args.DECLINATION);
    builder.add_RA(args.RA);
    builder.add_QC_DOT(args.QC_DOT);
    builder.add_Q3_DOT(args.Q3_DOT);
    builder.add_Q2_DOT(args.Q2_DOT);
    builder.add_Q1_DOT(args.Q1_DOT);
    builder.add_QC(args.QC);
    builder.add_Q3(args.Q3);
    builder.add_Q2(args.Q2);
    builder.add_Q1(args.Q1);
    if let Some(x) = args.Z_RATE { builder.add_Z_RATE(x); }
    if let Some(x) = args.Y_RATE { builder.add_Y_RATE(x); }
    if let Some(x) = args.X_RATE { builder.add_X_RATE(x); }
    if let Some(x) = args.Z_ANGLE { builder.add_Z_ANGLE(x); }
    if let Some(x) = args.Y_ANGLE { builder.add_Y_ANGLE(x); }
    if let Some(x) = args.X_ANGLE { builder.add_X_ANGLE(x); }
    if let Some(x) = args.MOTION_TYPE { builder.add_MOTION_TYPE(x); }
    if let Some(x) = args.TS { builder.add_TS(x); }
    if let Some(x) = args.ORIG_OBJECT_ID { builder.add_ORIG_OBJECT_ID(x); }
    builder.add_SAT_NO(args.SAT_NO);
    if let Some(x) = args.AS_ID { builder.add_AS_ID(x); }
    if let Some(x) = args.ID { builder.add_ID(x); }
    builder.finish()
  }

  pub fn unpack(&self) -> ATDT {
    let ID = self.ID().map(|x| {
      x.to_string()
    });
    let AS_ID = self.AS_ID().map(|x| {
      x.to_string()
    });
    let SAT_NO = self.SAT_NO();
    let ORIG_OBJECT_ID = self.ORIG_OBJECT_ID().map(|x| {
      x.to_string()
    });
    let TS = self.TS().map(|x| {
      x.to_string()
    });
    let MOTION_TYPE = self.MOTION_TYPE().map(|x| {
      x.to_string()
    });
    let Q1 = self.Q1();
    let Q2 = self.Q2();
    let Q3 = self.Q3();
    let QC = self.QC();
    let Q1_DOT = self.Q1_DOT();
    let Q2_DOT = self.Q2_DOT();
    let Q3_DOT = self.Q3_DOT();
    let QC_DOT = self.QC_DOT();
    let X_ANGLE = self.X_ANGLE().map(|x| {
      x.iter().map(|s| s.to_string()).collect()
    });
    let Y_ANGLE = self.Y_ANGLE().map(|x| {
      x.iter().map(|s| s.to_string()).collect()
    });
    let Z_ANGLE = self.Z_ANGLE().map(|x| {
      x.iter().map(|s| s.to_string()).collect()
    });
    let X_RATE = self.X_RATE().map(|x| {
      x.iter().map(|s| s.to_string()).collect()
    });
    let Y_RATE = self.Y_RATE().map(|x| {
      x.iter().map(|s| s.to_string()).collect()
    });
    let Z_RATE = self.Z_RATE().map(|x| {
      x.iter().map(|s| s.to_string()).collect()
    });
    let RA = self.RA();
    let DECLINATION = self.DECLINATION();
    let CONING_ANGLE = self.CONING_ANGLE();
    let PREC_PERIOD = self.PREC_PERIOD();
    let SPIN_PERIOD = self.SPIN_PERIOD();
    ATDT {
      ID,
      AS_ID,
      SAT_NO,
      ORIG_OBJECT_ID,
      TS,
      MOTION_TYPE,
      Q1,
      Q2,
      Q3,
      QC,
      Q1_DOT,
      Q2_DOT,
      Q3_DOT,
      QC_DOT,
      X_ANGLE,
      Y_ANGLE,
      Z_ANGLE,
      X_RATE,
      Y_RATE,
      Z_RATE,
      RA,
      DECLINATION,
      CONING_ANGLE,
      PREC_PERIOD,
      SPIN_PERIOD,
    }
  }

  #[inline]
  pub fn ID(&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>>(ATD::VT_ID, None)}
  }
  #[inline]
  pub fn AS_ID(&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>>(ATD::VT_AS_ID, None)}
  }
  #[inline]
  pub fn SAT_NO(&self) -> i32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<i32>(ATD::VT_SAT_NO, Some(0)).unwrap()}
  }
  #[inline]
  pub fn ORIG_OBJECT_ID(&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>>(ATD::VT_ORIG_OBJECT_ID, None)}
  }
  #[inline]
  pub fn TS(&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>>(ATD::VT_TS, None)}
  }
  #[inline]
  pub fn MOTION_TYPE(&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>>(ATD::VT_MOTION_TYPE, None)}
  }
  #[inline]
  pub fn Q1(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_Q1, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn Q2(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_Q2, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn Q3(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_Q3, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn QC(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_QC, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn Q1_DOT(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_Q1_DOT, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn Q2_DOT(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_Q2_DOT, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn Q3_DOT(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_Q3_DOT, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn QC_DOT(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_QC_DOT, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn X_ANGLE(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
    // 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, flatbuffers::ForwardsUOffset<&'a str>>>>(ATD::VT_X_ANGLE, None)}
  }
  #[inline]
  pub fn Y_ANGLE(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
    // 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, flatbuffers::ForwardsUOffset<&'a str>>>>(ATD::VT_Y_ANGLE, None)}
  }
  #[inline]
  pub fn Z_ANGLE(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
    // 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, flatbuffers::ForwardsUOffset<&'a str>>>>(ATD::VT_Z_ANGLE, None)}
  }
  #[inline]
  pub fn X_RATE(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
    // 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, flatbuffers::ForwardsUOffset<&'a str>>>>(ATD::VT_X_RATE, None)}
  }
  #[inline]
  pub fn Y_RATE(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
    // 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, flatbuffers::ForwardsUOffset<&'a str>>>>(ATD::VT_Y_RATE, None)}
  }
  #[inline]
  pub fn Z_RATE(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>> {
    // 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, flatbuffers::ForwardsUOffset<&'a str>>>>(ATD::VT_Z_RATE, None)}
  }
  #[inline]
  pub fn RA(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_RA, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn DECLINATION(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_DECLINATION, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn CONING_ANGLE(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_CONING_ANGLE, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn PREC_PERIOD(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_PREC_PERIOD, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn SPIN_PERIOD(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ATD::VT_SPIN_PERIOD, Some(0.0)).unwrap()}
  }
}

impl flatbuffers::Verifiable for ATD<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("ID", Self::VT_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("AS_ID", Self::VT_AS_ID, false)?
     .visit_field::<i32>("SAT_NO", Self::VT_SAT_NO, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("ORIG_OBJECT_ID", Self::VT_ORIG_OBJECT_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("TS", Self::VT_TS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("MOTION_TYPE", Self::VT_MOTION_TYPE, false)?
     .visit_field::<f64>("Q1", Self::VT_Q1, false)?
     .visit_field::<f64>("Q2", Self::VT_Q2, false)?
     .visit_field::<f64>("Q3", Self::VT_Q3, false)?
     .visit_field::<f64>("QC", Self::VT_QC, false)?
     .visit_field::<f64>("Q1_DOT", Self::VT_Q1_DOT, false)?
     .visit_field::<f64>("Q2_DOT", Self::VT_Q2_DOT, false)?
     .visit_field::<f64>("Q3_DOT", Self::VT_Q3_DOT, false)?
     .visit_field::<f64>("QC_DOT", Self::VT_QC_DOT, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("X_ANGLE", Self::VT_X_ANGLE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("Y_ANGLE", Self::VT_Y_ANGLE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("Z_ANGLE", Self::VT_Z_ANGLE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("X_RATE", Self::VT_X_RATE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("Y_RATE", Self::VT_Y_RATE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<&'_ str>>>>("Z_RATE", Self::VT_Z_RATE, false)?
     .visit_field::<f64>("RA", Self::VT_RA, false)?
     .visit_field::<f64>("DECLINATION", Self::VT_DECLINATION, false)?
     .visit_field::<f64>("CONING_ANGLE", Self::VT_CONING_ANGLE, false)?
     .visit_field::<f64>("PREC_PERIOD", Self::VT_PREC_PERIOD, false)?
     .visit_field::<f64>("SPIN_PERIOD", Self::VT_SPIN_PERIOD, false)?
     .finish();
    Ok(())
  }
}
pub struct ATDArgs<'a> {
    pub ID: Option<flatbuffers::WIPOffset<&'a str>>,
    pub AS_ID: Option<flatbuffers::WIPOffset<&'a str>>,
    pub SAT_NO: i32,
    pub ORIG_OBJECT_ID: Option<flatbuffers::WIPOffset<&'a str>>,
    pub TS: Option<flatbuffers::WIPOffset<&'a str>>,
    pub MOTION_TYPE: Option<flatbuffers::WIPOffset<&'a str>>,
    pub Q1: f64,
    pub Q2: f64,
    pub Q3: f64,
    pub QC: f64,
    pub Q1_DOT: f64,
    pub Q2_DOT: f64,
    pub Q3_DOT: f64,
    pub QC_DOT: f64,
    pub X_ANGLE: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub Y_ANGLE: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub Z_ANGLE: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub X_RATE: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub Y_RATE: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub Z_RATE: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>>,
    pub RA: f64,
    pub DECLINATION: f64,
    pub CONING_ANGLE: f64,
    pub PREC_PERIOD: f64,
    pub SPIN_PERIOD: f64,
}
impl<'a> Default for ATDArgs<'a> {
  #[inline]
  fn default() -> Self {
    ATDArgs {
      ID: None,
      AS_ID: None,
      SAT_NO: 0,
      ORIG_OBJECT_ID: None,
      TS: None,
      MOTION_TYPE: None,
      Q1: 0.0,
      Q2: 0.0,
      Q3: 0.0,
      QC: 0.0,
      Q1_DOT: 0.0,
      Q2_DOT: 0.0,
      Q3_DOT: 0.0,
      QC_DOT: 0.0,
      X_ANGLE: None,
      Y_ANGLE: None,
      Z_ANGLE: None,
      X_RATE: None,
      Y_RATE: None,
      Z_RATE: None,
      RA: 0.0,
      DECLINATION: 0.0,
      CONING_ANGLE: 0.0,
      PREC_PERIOD: 0.0,
      SPIN_PERIOD: 0.0,
    }
  }
}

pub struct ATDBuilder<'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> ATDBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_ID(&mut self, ID: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ATD::VT_ID, ID);
  }
  #[inline]
  pub fn add_AS_ID(&mut self, AS_ID: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ATD::VT_AS_ID, AS_ID);
  }
  #[inline]
  pub fn add_SAT_NO(&mut self, SAT_NO: i32) {
    self.fbb_.push_slot::<i32>(ATD::VT_SAT_NO, SAT_NO, 0);
  }
  #[inline]
  pub fn add_ORIG_OBJECT_ID(&mut self, ORIG_OBJECT_ID: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ATD::VT_ORIG_OBJECT_ID, ORIG_OBJECT_ID);
  }
  #[inline]
  pub fn add_TS(&mut self, TS: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ATD::VT_TS, TS);
  }
  #[inline]
  pub fn add_MOTION_TYPE(&mut self, MOTION_TYPE: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ATD::VT_MOTION_TYPE, MOTION_TYPE);
  }
  #[inline]
  pub fn add_Q1(&mut self, Q1: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_Q1, Q1, 0.0);
  }
  #[inline]
  pub fn add_Q2(&mut self, Q2: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_Q2, Q2, 0.0);
  }
  #[inline]
  pub fn add_Q3(&mut self, Q3: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_Q3, Q3, 0.0);
  }
  #[inline]
  pub fn add_QC(&mut self, QC: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_QC, QC, 0.0);
  }
  #[inline]
  pub fn add_Q1_DOT(&mut self, Q1_DOT: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_Q1_DOT, Q1_DOT, 0.0);
  }
  #[inline]
  pub fn add_Q2_DOT(&mut self, Q2_DOT: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_Q2_DOT, Q2_DOT, 0.0);
  }
  #[inline]
  pub fn add_Q3_DOT(&mut self, Q3_DOT: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_Q3_DOT, Q3_DOT, 0.0);
  }
  #[inline]
  pub fn add_QC_DOT(&mut self, QC_DOT: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_QC_DOT, QC_DOT, 0.0);
  }
  #[inline]
  pub fn add_X_ANGLE(&mut self, X_ANGLE: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ATD::VT_X_ANGLE, X_ANGLE);
  }
  #[inline]
  pub fn add_Y_ANGLE(&mut self, Y_ANGLE: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ATD::VT_Y_ANGLE, Y_ANGLE);
  }
  #[inline]
  pub fn add_Z_ANGLE(&mut self, Z_ANGLE: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ATD::VT_Z_ANGLE, Z_ANGLE);
  }
  #[inline]
  pub fn add_X_RATE(&mut self, X_RATE: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ATD::VT_X_RATE, X_RATE);
  }
  #[inline]
  pub fn add_Y_RATE(&mut self, Y_RATE: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ATD::VT_Y_RATE, Y_RATE);
  }
  #[inline]
  pub fn add_Z_RATE(&mut self, Z_RATE: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<&'b  str>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ATD::VT_Z_RATE, Z_RATE);
  }
  #[inline]
  pub fn add_RA(&mut self, RA: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_RA, RA, 0.0);
  }
  #[inline]
  pub fn add_DECLINATION(&mut self, DECLINATION: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_DECLINATION, DECLINATION, 0.0);
  }
  #[inline]
  pub fn add_CONING_ANGLE(&mut self, CONING_ANGLE: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_CONING_ANGLE, CONING_ANGLE, 0.0);
  }
  #[inline]
  pub fn add_PREC_PERIOD(&mut self, PREC_PERIOD: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_PREC_PERIOD, PREC_PERIOD, 0.0);
  }
  #[inline]
  pub fn add_SPIN_PERIOD(&mut self, SPIN_PERIOD: f64) {
    self.fbb_.push_slot::<f64>(ATD::VT_SPIN_PERIOD, SPIN_PERIOD, 0.0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ATDBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ATDBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ATD<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for ATD<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("ATD");
      ds.field("ID", &self.ID());
      ds.field("AS_ID", &self.AS_ID());
      ds.field("SAT_NO", &self.SAT_NO());
      ds.field("ORIG_OBJECT_ID", &self.ORIG_OBJECT_ID());
      ds.field("TS", &self.TS());
      ds.field("MOTION_TYPE", &self.MOTION_TYPE());
      ds.field("Q1", &self.Q1());
      ds.field("Q2", &self.Q2());
      ds.field("Q3", &self.Q3());
      ds.field("QC", &self.QC());
      ds.field("Q1_DOT", &self.Q1_DOT());
      ds.field("Q2_DOT", &self.Q2_DOT());
      ds.field("Q3_DOT", &self.Q3_DOT());
      ds.field("QC_DOT", &self.QC_DOT());
      ds.field("X_ANGLE", &self.X_ANGLE());
      ds.field("Y_ANGLE", &self.Y_ANGLE());
      ds.field("Z_ANGLE", &self.Z_ANGLE());
      ds.field("X_RATE", &self.X_RATE());
      ds.field("Y_RATE", &self.Y_RATE());
      ds.field("Z_RATE", &self.Z_RATE());
      ds.field("RA", &self.RA());
      ds.field("DECLINATION", &self.DECLINATION());
      ds.field("CONING_ANGLE", &self.CONING_ANGLE());
      ds.field("PREC_PERIOD", &self.PREC_PERIOD());
      ds.field("SPIN_PERIOD", &self.SPIN_PERIOD());
      ds.finish()
  }
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct ATDT {
  pub ID: Option<String>,
  pub AS_ID: Option<String>,
  pub SAT_NO: i32,
  pub ORIG_OBJECT_ID: Option<String>,
  pub TS: Option<String>,
  pub MOTION_TYPE: Option<String>,
  pub Q1: f64,
  pub Q2: f64,
  pub Q3: f64,
  pub QC: f64,
  pub Q1_DOT: f64,
  pub Q2_DOT: f64,
  pub Q3_DOT: f64,
  pub QC_DOT: f64,
  pub X_ANGLE: Option<Vec<String>>,
  pub Y_ANGLE: Option<Vec<String>>,
  pub Z_ANGLE: Option<Vec<String>>,
  pub X_RATE: Option<Vec<String>>,
  pub Y_RATE: Option<Vec<String>>,
  pub Z_RATE: Option<Vec<String>>,
  pub RA: f64,
  pub DECLINATION: f64,
  pub CONING_ANGLE: f64,
  pub PREC_PERIOD: f64,
  pub SPIN_PERIOD: f64,
}
impl Default for ATDT {
  fn default() -> Self {
    Self {
      ID: None,
      AS_ID: None,
      SAT_NO: 0,
      ORIG_OBJECT_ID: None,
      TS: None,
      MOTION_TYPE: None,
      Q1: 0.0,
      Q2: 0.0,
      Q3: 0.0,
      QC: 0.0,
      Q1_DOT: 0.0,
      Q2_DOT: 0.0,
      Q3_DOT: 0.0,
      QC_DOT: 0.0,
      X_ANGLE: None,
      Y_ANGLE: None,
      Z_ANGLE: None,
      X_RATE: None,
      Y_RATE: None,
      Z_RATE: None,
      RA: 0.0,
      DECLINATION: 0.0,
      CONING_ANGLE: 0.0,
      PREC_PERIOD: 0.0,
      SPIN_PERIOD: 0.0,
    }
  }
}
impl ATDT {
  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
    &self,
    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
  ) -> flatbuffers::WIPOffset<ATD<'b>> {
    let ID = self.ID.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let AS_ID = self.AS_ID.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let SAT_NO = self.SAT_NO;
    let ORIG_OBJECT_ID = self.ORIG_OBJECT_ID.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let TS = self.TS.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let MOTION_TYPE = self.MOTION_TYPE.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let Q1 = self.Q1;
    let Q2 = self.Q2;
    let Q3 = self.Q3;
    let QC = self.QC;
    let Q1_DOT = self.Q1_DOT;
    let Q2_DOT = self.Q2_DOT;
    let Q3_DOT = self.Q3_DOT;
    let QC_DOT = self.QC_DOT;
    let X_ANGLE = self.X_ANGLE.as_ref().map(|x|{
      let w: Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w)
    });
    let Y_ANGLE = self.Y_ANGLE.as_ref().map(|x|{
      let w: Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w)
    });
    let Z_ANGLE = self.Z_ANGLE.as_ref().map(|x|{
      let w: Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w)
    });
    let X_RATE = self.X_RATE.as_ref().map(|x|{
      let w: Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w)
    });
    let Y_RATE = self.Y_RATE.as_ref().map(|x|{
      let w: Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w)
    });
    let Z_RATE = self.Z_RATE.as_ref().map(|x|{
      let w: Vec<_> = x.iter().map(|s| _fbb.create_string(s)).collect();_fbb.create_vector(&w)
    });
    let RA = self.RA;
    let DECLINATION = self.DECLINATION;
    let CONING_ANGLE = self.CONING_ANGLE;
    let PREC_PERIOD = self.PREC_PERIOD;
    let SPIN_PERIOD = self.SPIN_PERIOD;
    ATD::create(_fbb, &ATDArgs{
      ID,
      AS_ID,
      SAT_NO,
      ORIG_OBJECT_ID,
      TS,
      MOTION_TYPE,
      Q1,
      Q2,
      Q3,
      QC,
      Q1_DOT,
      Q2_DOT,
      Q3_DOT,
      QC_DOT,
      X_ANGLE,
      Y_ANGLE,
      Z_ANGLE,
      X_RATE,
      Y_RATE,
      Z_RATE,
      RA,
      DECLINATION,
      CONING_ANGLE,
      PREC_PERIOD,
      SPIN_PERIOD,
    })
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `ATD`
/// 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_ATD_unchecked`.
pub fn root_as_ATD(buf: &[u8]) -> Result<ATD, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root::<ATD>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `ATD` 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_ATD_unchecked`.
pub fn size_prefixed_root_as_ATD(buf: &[u8]) -> Result<ATD, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root::<ATD>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `ATD` 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_ATD_unchecked`.
pub fn root_as_ATD_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<ATD<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root_with_opts::<ATD<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `ATD` 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_ATD_unchecked`.
pub fn size_prefixed_root_as_ATD_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<ATD<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root_with_opts::<ATD<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a ATD and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `ATD`.
pub unsafe fn root_as_ATD_unchecked(buf: &[u8]) -> ATD {
  flatbuffers::root_unchecked::<ATD>(buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed ATD and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `ATD`.
pub unsafe fn size_prefixed_root_as_ATD_unchecked(buf: &[u8]) -> ATD {
  flatbuffers::size_prefixed_root_unchecked::<ATD>(buf)
}
pub const ATD_IDENTIFIER: &str = "$ATD";

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

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

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

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