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 AEMSegmentOffset {}
#[derive(Copy, Clone, PartialEq)]

pub struct AEMSegment<'a> {
  pub _tab: flatbuffers::Table<'a>,
}

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

impl<'a> AEMSegment<'a> {
  pub const VT_OBJECT_NAME: flatbuffers::VOffsetT = 4;
  pub const VT_OBJECT_ID: flatbuffers::VOffsetT = 6;
  pub const VT_REF_FRAME_A: flatbuffers::VOffsetT = 8;
  pub const VT_REF_FRAME_B: flatbuffers::VOffsetT = 10;
  pub const VT_ATTITUDE_DIR: flatbuffers::VOffsetT = 12;
  pub const VT_TIME_SYSTEM: flatbuffers::VOffsetT = 14;
  pub const VT_ATTITUDE_TYPE: flatbuffers::VOffsetT = 16;
  pub const VT_START_TIME: flatbuffers::VOffsetT = 18;
  pub const VT_STOP_TIME: flatbuffers::VOffsetT = 20;
  pub const VT_STEP_SIZE: flatbuffers::VOffsetT = 22;
  pub const VT_ATTITUDE_COMPONENTS: flatbuffers::VOffsetT = 24;
  pub const VT_ATTITUDE_DATA: flatbuffers::VOffsetT = 26;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    AEMSegment { _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 AEMSegmentArgs<'args>
  ) -> flatbuffers::WIPOffset<AEMSegment<'bldr>> {
    let mut builder = AEMSegmentBuilder::new(_fbb);
    builder.add_STEP_SIZE(args.STEP_SIZE);
    if let Some(x) = args.ATTITUDE_DATA { builder.add_ATTITUDE_DATA(x); }
    if let Some(x) = args.STOP_TIME { builder.add_STOP_TIME(x); }
    if let Some(x) = args.START_TIME { builder.add_START_TIME(x); }
    if let Some(x) = args.ATTITUDE_TYPE { builder.add_ATTITUDE_TYPE(x); }
    if let Some(x) = args.TIME_SYSTEM { builder.add_TIME_SYSTEM(x); }
    if let Some(x) = args.ATTITUDE_DIR { builder.add_ATTITUDE_DIR(x); }
    if let Some(x) = args.REF_FRAME_B { builder.add_REF_FRAME_B(x); }
    if let Some(x) = args.REF_FRAME_A { builder.add_REF_FRAME_A(x); }
    if let Some(x) = args.OBJECT_ID { builder.add_OBJECT_ID(x); }
    if let Some(x) = args.OBJECT_NAME { builder.add_OBJECT_NAME(x); }
    builder.add_ATTITUDE_COMPONENTS(args.ATTITUDE_COMPONENTS);
    builder.finish()
  }

  pub fn unpack(&self) -> AEMSegmentT {
    let OBJECT_NAME = self.OBJECT_NAME().map(|x| {
      x.to_string()
    });
    let OBJECT_ID = self.OBJECT_ID().map(|x| {
      x.to_string()
    });
    let REF_FRAME_A = self.REF_FRAME_A().map(|x| {
      x.to_string()
    });
    let REF_FRAME_B = self.REF_FRAME_B().map(|x| {
      x.to_string()
    });
    let ATTITUDE_DIR = self.ATTITUDE_DIR().map(|x| {
      x.to_string()
    });
    let TIME_SYSTEM = self.TIME_SYSTEM().map(|x| {
      x.to_string()
    });
    let ATTITUDE_TYPE = self.ATTITUDE_TYPE().map(|x| {
      x.to_string()
    });
    let START_TIME = self.START_TIME().map(|x| {
      x.to_string()
    });
    let STOP_TIME = self.STOP_TIME().map(|x| {
      x.to_string()
    });
    let STEP_SIZE = self.STEP_SIZE();
    let ATTITUDE_COMPONENTS = self.ATTITUDE_COMPONENTS();
    let ATTITUDE_DATA = self.ATTITUDE_DATA().map(|x| {
      x.into_iter().collect()
    });
    AEMSegmentT {
      OBJECT_NAME,
      OBJECT_ID,
      REF_FRAME_A,
      REF_FRAME_B,
      ATTITUDE_DIR,
      TIME_SYSTEM,
      ATTITUDE_TYPE,
      START_TIME,
      STOP_TIME,
      STEP_SIZE,
      ATTITUDE_COMPONENTS,
      ATTITUDE_DATA,
    }
  }

  #[inline]
  pub fn OBJECT_NAME(&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>>(AEMSegment::VT_OBJECT_NAME, None)}
  }
  #[inline]
  pub fn 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>>(AEMSegment::VT_OBJECT_ID, None)}
  }
  #[inline]
  pub fn REF_FRAME_A(&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>>(AEMSegment::VT_REF_FRAME_A, None)}
  }
  #[inline]
  pub fn REF_FRAME_B(&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>>(AEMSegment::VT_REF_FRAME_B, None)}
  }
  #[inline]
  pub fn ATTITUDE_DIR(&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>>(AEMSegment::VT_ATTITUDE_DIR, None)}
  }
  #[inline]
  pub fn TIME_SYSTEM(&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>>(AEMSegment::VT_TIME_SYSTEM, None)}
  }
  #[inline]
  pub fn ATTITUDE_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>>(AEMSegment::VT_ATTITUDE_TYPE, None)}
  }
  #[inline]
  pub fn START_TIME(&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>>(AEMSegment::VT_START_TIME, None)}
  }
  #[inline]
  pub fn STOP_TIME(&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>>(AEMSegment::VT_STOP_TIME, None)}
  }
  /// Time interval between attitude states in seconds (required).
  #[inline]
  pub fn STEP_SIZE(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(AEMSegment::VT_STEP_SIZE, Some(0.0)).unwrap()}
  }
  /// Number of components per attitude state.
  /// 7 = quaternion + angular rates (Q1, Q2, Q3, QC, RATE_X, RATE_Y, RATE_Z)
  /// 4 = quaternion only (Q1, Q2, Q3, QC)
  #[inline]
  pub fn ATTITUDE_COMPONENTS(&self) -> u8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(AEMSegment::VT_ATTITUDE_COMPONENTS, Some(7)).unwrap()}
  }
  /// Attitude data as row-major array of doubles.
  /// Layout: [Q1_0, Q2_0, Q3_0, QC_0, RATE_X_0, RATE_Y_0, RATE_Z_0, Q1_1, ...]
  /// Time reconstruction: epoch[i] = START_TIME + (i * STEP_SIZE)
  /// Length must be divisible by ATTITUDE_COMPONENTS.
  #[inline]
  pub fn ATTITUDE_DATA(&self) -> Option<flatbuffers::Vector<'a, f64>> {
    // 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, f64>>>(AEMSegment::VT_ATTITUDE_DATA, None)}
  }
}

impl flatbuffers::Verifiable for AEMSegment<'_> {
  #[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>>("OBJECT_NAME", Self::VT_OBJECT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("OBJECT_ID", Self::VT_OBJECT_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("REF_FRAME_A", Self::VT_REF_FRAME_A, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("REF_FRAME_B", Self::VT_REF_FRAME_B, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("ATTITUDE_DIR", Self::VT_ATTITUDE_DIR, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("TIME_SYSTEM", Self::VT_TIME_SYSTEM, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("ATTITUDE_TYPE", Self::VT_ATTITUDE_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("START_TIME", Self::VT_START_TIME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("STOP_TIME", Self::VT_STOP_TIME, false)?
     .visit_field::<f64>("STEP_SIZE", Self::VT_STEP_SIZE, false)?
     .visit_field::<u8>("ATTITUDE_COMPONENTS", Self::VT_ATTITUDE_COMPONENTS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, f64>>>("ATTITUDE_DATA", Self::VT_ATTITUDE_DATA, false)?
     .finish();
    Ok(())
  }
}
pub struct AEMSegmentArgs<'a> {
    pub OBJECT_NAME: Option<flatbuffers::WIPOffset<&'a str>>,
    pub OBJECT_ID: Option<flatbuffers::WIPOffset<&'a str>>,
    pub REF_FRAME_A: Option<flatbuffers::WIPOffset<&'a str>>,
    pub REF_FRAME_B: Option<flatbuffers::WIPOffset<&'a str>>,
    pub ATTITUDE_DIR: Option<flatbuffers::WIPOffset<&'a str>>,
    pub TIME_SYSTEM: Option<flatbuffers::WIPOffset<&'a str>>,
    pub ATTITUDE_TYPE: Option<flatbuffers::WIPOffset<&'a str>>,
    pub START_TIME: Option<flatbuffers::WIPOffset<&'a str>>,
    pub STOP_TIME: Option<flatbuffers::WIPOffset<&'a str>>,
    pub STEP_SIZE: f64,
    pub ATTITUDE_COMPONENTS: u8,
    pub ATTITUDE_DATA: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, f64>>>,
}
impl<'a> Default for AEMSegmentArgs<'a> {
  #[inline]
  fn default() -> Self {
    AEMSegmentArgs {
      OBJECT_NAME: None,
      OBJECT_ID: None,
      REF_FRAME_A: None,
      REF_FRAME_B: None,
      ATTITUDE_DIR: None,
      TIME_SYSTEM: None,
      ATTITUDE_TYPE: None,
      START_TIME: None,
      STOP_TIME: None,
      STEP_SIZE: 0.0,
      ATTITUDE_COMPONENTS: 7,
      ATTITUDE_DATA: None,
    }
  }
}

pub struct AEMSegmentBuilder<'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> AEMSegmentBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_OBJECT_NAME(&mut self, OBJECT_NAME: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEMSegment::VT_OBJECT_NAME, OBJECT_NAME);
  }
  #[inline]
  pub fn add_OBJECT_ID(&mut self, OBJECT_ID: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEMSegment::VT_OBJECT_ID, OBJECT_ID);
  }
  #[inline]
  pub fn add_REF_FRAME_A(&mut self, REF_FRAME_A: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEMSegment::VT_REF_FRAME_A, REF_FRAME_A);
  }
  #[inline]
  pub fn add_REF_FRAME_B(&mut self, REF_FRAME_B: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEMSegment::VT_REF_FRAME_B, REF_FRAME_B);
  }
  #[inline]
  pub fn add_ATTITUDE_DIR(&mut self, ATTITUDE_DIR: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEMSegment::VT_ATTITUDE_DIR, ATTITUDE_DIR);
  }
  #[inline]
  pub fn add_TIME_SYSTEM(&mut self, TIME_SYSTEM: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEMSegment::VT_TIME_SYSTEM, TIME_SYSTEM);
  }
  #[inline]
  pub fn add_ATTITUDE_TYPE(&mut self, ATTITUDE_TYPE: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEMSegment::VT_ATTITUDE_TYPE, ATTITUDE_TYPE);
  }
  #[inline]
  pub fn add_START_TIME(&mut self, START_TIME: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEMSegment::VT_START_TIME, START_TIME);
  }
  #[inline]
  pub fn add_STOP_TIME(&mut self, STOP_TIME: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEMSegment::VT_STOP_TIME, STOP_TIME);
  }
  #[inline]
  pub fn add_STEP_SIZE(&mut self, STEP_SIZE: f64) {
    self.fbb_.push_slot::<f64>(AEMSegment::VT_STEP_SIZE, STEP_SIZE, 0.0);
  }
  #[inline]
  pub fn add_ATTITUDE_COMPONENTS(&mut self, ATTITUDE_COMPONENTS: u8) {
    self.fbb_.push_slot::<u8>(AEMSegment::VT_ATTITUDE_COMPONENTS, ATTITUDE_COMPONENTS, 7);
  }
  #[inline]
  pub fn add_ATTITUDE_DATA(&mut self, ATTITUDE_DATA: flatbuffers::WIPOffset<flatbuffers::Vector<'b , f64>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEMSegment::VT_ATTITUDE_DATA, ATTITUDE_DATA);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> AEMSegmentBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AEMSegmentBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<AEMSegment<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for AEMSegment<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("AEMSegment");
      ds.field("OBJECT_NAME", &self.OBJECT_NAME());
      ds.field("OBJECT_ID", &self.OBJECT_ID());
      ds.field("REF_FRAME_A", &self.REF_FRAME_A());
      ds.field("REF_FRAME_B", &self.REF_FRAME_B());
      ds.field("ATTITUDE_DIR", &self.ATTITUDE_DIR());
      ds.field("TIME_SYSTEM", &self.TIME_SYSTEM());
      ds.field("ATTITUDE_TYPE", &self.ATTITUDE_TYPE());
      ds.field("START_TIME", &self.START_TIME());
      ds.field("STOP_TIME", &self.STOP_TIME());
      ds.field("STEP_SIZE", &self.STEP_SIZE());
      ds.field("ATTITUDE_COMPONENTS", &self.ATTITUDE_COMPONENTS());
      ds.field("ATTITUDE_DATA", &self.ATTITUDE_DATA());
      ds.finish()
  }
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct AEMSegmentT {
  pub OBJECT_NAME: Option<String>,
  pub OBJECT_ID: Option<String>,
  pub REF_FRAME_A: Option<String>,
  pub REF_FRAME_B: Option<String>,
  pub ATTITUDE_DIR: Option<String>,
  pub TIME_SYSTEM: Option<String>,
  pub ATTITUDE_TYPE: Option<String>,
  pub START_TIME: Option<String>,
  pub STOP_TIME: Option<String>,
  pub STEP_SIZE: f64,
  pub ATTITUDE_COMPONENTS: u8,
  pub ATTITUDE_DATA: Option<Vec<f64>>,
}
impl Default for AEMSegmentT {
  fn default() -> Self {
    Self {
      OBJECT_NAME: None,
      OBJECT_ID: None,
      REF_FRAME_A: None,
      REF_FRAME_B: None,
      ATTITUDE_DIR: None,
      TIME_SYSTEM: None,
      ATTITUDE_TYPE: None,
      START_TIME: None,
      STOP_TIME: None,
      STEP_SIZE: 0.0,
      ATTITUDE_COMPONENTS: 7,
      ATTITUDE_DATA: None,
    }
  }
}
impl AEMSegmentT {
  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
    &self,
    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
  ) -> flatbuffers::WIPOffset<AEMSegment<'b>> {
    let OBJECT_NAME = self.OBJECT_NAME.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let OBJECT_ID = self.OBJECT_ID.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let REF_FRAME_A = self.REF_FRAME_A.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let REF_FRAME_B = self.REF_FRAME_B.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let ATTITUDE_DIR = self.ATTITUDE_DIR.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let TIME_SYSTEM = self.TIME_SYSTEM.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let ATTITUDE_TYPE = self.ATTITUDE_TYPE.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let START_TIME = self.START_TIME.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let STOP_TIME = self.STOP_TIME.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let STEP_SIZE = self.STEP_SIZE;
    let ATTITUDE_COMPONENTS = self.ATTITUDE_COMPONENTS;
    let ATTITUDE_DATA = self.ATTITUDE_DATA.as_ref().map(|x|{
      _fbb.create_vector(x)
    });
    AEMSegment::create(_fbb, &AEMSegmentArgs{
      OBJECT_NAME,
      OBJECT_ID,
      REF_FRAME_A,
      REF_FRAME_B,
      ATTITUDE_DIR,
      TIME_SYSTEM,
      ATTITUDE_TYPE,
      START_TIME,
      STOP_TIME,
      STEP_SIZE,
      ATTITUDE_COMPONENTS,
      ATTITUDE_DATA,
    })
  }
}
pub enum AEMOffset {}
#[derive(Copy, Clone, PartialEq)]

/// Attitude Ephemeris Message
pub struct AEM<'a> {
  pub _tab: flatbuffers::Table<'a>,
}

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

impl<'a> AEM<'a> {
  pub const VT_CCSDS_AEM_VERS: flatbuffers::VOffsetT = 4;
  pub const VT_CREATION_DATE: flatbuffers::VOffsetT = 6;
  pub const VT_ORIGINATOR: flatbuffers::VOffsetT = 8;
  pub const VT_SEGMENTS: flatbuffers::VOffsetT = 10;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    AEM { _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 AEMArgs<'args>
  ) -> flatbuffers::WIPOffset<AEM<'bldr>> {
    let mut builder = AEMBuilder::new(_fbb);
    if let Some(x) = args.SEGMENTS { builder.add_SEGMENTS(x); }
    if let Some(x) = args.ORIGINATOR { builder.add_ORIGINATOR(x); }
    if let Some(x) = args.CREATION_DATE { builder.add_CREATION_DATE(x); }
    if let Some(x) = args.CCSDS_AEM_VERS { builder.add_CCSDS_AEM_VERS(x); }
    builder.finish()
  }

  pub fn unpack(&self) -> AEMT {
    let CCSDS_AEM_VERS = self.CCSDS_AEM_VERS().map(|x| {
      x.to_string()
    });
    let CREATION_DATE = self.CREATION_DATE().map(|x| {
      x.to_string()
    });
    let ORIGINATOR = self.ORIGINATOR().map(|x| {
      x.to_string()
    });
    let SEGMENTS = self.SEGMENTS().map(|x| {
      x.iter().map(|t| t.unpack()).collect()
    });
    AEMT {
      CCSDS_AEM_VERS,
      CREATION_DATE,
      ORIGINATOR,
      SEGMENTS,
    }
  }

  #[inline]
  pub fn CCSDS_AEM_VERS(&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>>(AEM::VT_CCSDS_AEM_VERS, None)}
  }
  #[inline]
  pub fn CREATION_DATE(&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>>(AEM::VT_CREATION_DATE, None)}
  }
  #[inline]
  pub fn ORIGINATOR(&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>>(AEM::VT_ORIGINATOR, None)}
  }
  #[inline]
  pub fn SEGMENTS(&self) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AEMSegment<'a>>>> {
    // 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<AEMSegment>>>>(AEM::VT_SEGMENTS, None)}
  }
}

impl flatbuffers::Verifiable for AEM<'_> {
  #[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>>("CCSDS_AEM_VERS", Self::VT_CCSDS_AEM_VERS, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("CREATION_DATE", Self::VT_CREATION_DATE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("ORIGINATOR", Self::VT_ORIGINATOR, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<AEMSegment>>>>("SEGMENTS", Self::VT_SEGMENTS, false)?
     .finish();
    Ok(())
  }
}
pub struct AEMArgs<'a> {
    pub CCSDS_AEM_VERS: Option<flatbuffers::WIPOffset<&'a str>>,
    pub CREATION_DATE: Option<flatbuffers::WIPOffset<&'a str>>,
    pub ORIGINATOR: Option<flatbuffers::WIPOffset<&'a str>>,
    pub SEGMENTS: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<AEMSegment<'a>>>>>,
}
impl<'a> Default for AEMArgs<'a> {
  #[inline]
  fn default() -> Self {
    AEMArgs {
      CCSDS_AEM_VERS: None,
      CREATION_DATE: None,
      ORIGINATOR: None,
      SEGMENTS: None,
    }
  }
}

pub struct AEMBuilder<'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> AEMBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_CCSDS_AEM_VERS(&mut self, CCSDS_AEM_VERS: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEM::VT_CCSDS_AEM_VERS, CCSDS_AEM_VERS);
  }
  #[inline]
  pub fn add_CREATION_DATE(&mut self, CREATION_DATE: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEM::VT_CREATION_DATE, CREATION_DATE);
  }
  #[inline]
  pub fn add_ORIGINATOR(&mut self, ORIGINATOR: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEM::VT_ORIGINATOR, ORIGINATOR);
  }
  #[inline]
  pub fn add_SEGMENTS(&mut self, SEGMENTS: flatbuffers::WIPOffset<flatbuffers::Vector<'b , flatbuffers::ForwardsUOffset<AEMSegment<'b >>>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(AEM::VT_SEGMENTS, SEGMENTS);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> AEMBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    AEMBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<AEM<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for AEM<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("AEM");
      ds.field("CCSDS_AEM_VERS", &self.CCSDS_AEM_VERS());
      ds.field("CREATION_DATE", &self.CREATION_DATE());
      ds.field("ORIGINATOR", &self.ORIGINATOR());
      ds.field("SEGMENTS", &self.SEGMENTS());
      ds.finish()
  }
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct AEMT {
  pub CCSDS_AEM_VERS: Option<String>,
  pub CREATION_DATE: Option<String>,
  pub ORIGINATOR: Option<String>,
  pub SEGMENTS: Option<Vec<AEMSegmentT>>,
}
impl Default for AEMT {
  fn default() -> Self {
    Self {
      CCSDS_AEM_VERS: None,
      CREATION_DATE: None,
      ORIGINATOR: None,
      SEGMENTS: None,
    }
  }
}
impl AEMT {
  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
    &self,
    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
  ) -> flatbuffers::WIPOffset<AEM<'b>> {
    let CCSDS_AEM_VERS = self.CCSDS_AEM_VERS.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let CREATION_DATE = self.CREATION_DATE.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let ORIGINATOR = self.ORIGINATOR.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let SEGMENTS = self.SEGMENTS.as_ref().map(|x|{
      let w: Vec<_> = x.iter().map(|t| t.pack(_fbb)).collect();_fbb.create_vector(&w)
    });
    AEM::create(_fbb, &AEMArgs{
      CCSDS_AEM_VERS,
      CREATION_DATE,
      ORIGINATOR,
      SEGMENTS,
    })
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `AEM`
/// 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_AEM_unchecked`.
pub fn root_as_AEM(buf: &[u8]) -> Result<AEM, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root::<AEM>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `AEM` 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_AEM_unchecked`.
pub fn size_prefixed_root_as_AEM(buf: &[u8]) -> Result<AEM, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root::<AEM>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `AEM` 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_AEM_unchecked`.
pub fn root_as_AEM_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<AEM<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root_with_opts::<AEM<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `AEM` 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_AEM_unchecked`.
pub fn size_prefixed_root_as_AEM_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<AEM<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root_with_opts::<AEM<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a AEM and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `AEM`.
pub unsafe fn root_as_AEM_unchecked(buf: &[u8]) -> AEM {
  flatbuffers::root_unchecked::<AEM>(buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed AEM and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `AEM`.
pub unsafe fn size_prefixed_root_as_AEM_unchecked(buf: &[u8]) -> AEM {
  flatbuffers::size_prefixed_root_unchecked::<AEM>(buf)
}
pub const AEM_IDENTIFIER: &str = "$AEM";

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

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

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

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