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

/// Space Data Link Security (CCSDS 355.0-B-1)
pub struct SDL<'a> {
  pub _tab: flatbuffers::Table<'a>,
}

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

impl<'a> SDL<'a> {
  pub const VT_SPI: flatbuffers::VOffsetT = 4;
  pub const VT_IV_LENGTH: flatbuffers::VOffsetT = 6;
  pub const VT_IV: flatbuffers::VOffsetT = 8;
  pub const VT_MAC_LENGTH: flatbuffers::VOffsetT = 10;
  pub const VT_MAC: flatbuffers::VOffsetT = 12;
  pub const VT_PAD_LENGTH: flatbuffers::VOffsetT = 14;
  pub const VT_PAYLOAD: flatbuffers::VOffsetT = 16;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    SDL { _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 SDLArgs<'args>
  ) -> flatbuffers::WIPOffset<SDL<'bldr>> {
    let mut builder = SDLBuilder::new(_fbb);
    if let Some(x) = args.PAYLOAD { builder.add_PAYLOAD(x); }
    if let Some(x) = args.MAC { builder.add_MAC(x); }
    if let Some(x) = args.IV { builder.add_IV(x); }
    builder.add_SPI(args.SPI);
    builder.add_PAD_LENGTH(args.PAD_LENGTH);
    builder.add_MAC_LENGTH(args.MAC_LENGTH);
    builder.add_IV_LENGTH(args.IV_LENGTH);
    builder.finish()
  }

  pub fn unpack(&self) -> SDLT {
    let SPI = self.SPI();
    let IV_LENGTH = self.IV_LENGTH();
    let IV = self.IV().map(|x| {
      x.into_iter().collect()
    });
    let MAC_LENGTH = self.MAC_LENGTH();
    let MAC = self.MAC().map(|x| {
      x.into_iter().collect()
    });
    let PAD_LENGTH = self.PAD_LENGTH();
    let PAYLOAD = self.PAYLOAD().map(|x| {
      x.into_iter().collect()
    });
    SDLT {
      SPI,
      IV_LENGTH,
      IV,
      MAC_LENGTH,
      MAC,
      PAD_LENGTH,
      PAYLOAD,
    }
  }

  /// Security Parameter Index
  #[inline]
  pub fn SPI(&self) -> u16 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u16>(SDL::VT_SPI, Some(0)).unwrap()}
  }
  /// Initialization vector length in bytes
  #[inline]
  pub fn IV_LENGTH(&self) -> u8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(SDL::VT_IV_LENGTH, Some(0)).unwrap()}
  }
  /// Initialization vector
  #[inline]
  pub fn IV(&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>>>(SDL::VT_IV, None)}
  }
  /// MAC length in bytes
  #[inline]
  pub fn MAC_LENGTH(&self) -> u8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(SDL::VT_MAC_LENGTH, Some(0)).unwrap()}
  }
  /// Message authentication code
  #[inline]
  pub fn MAC(&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>>>(SDL::VT_MAC, None)}
  }
  /// Pad length
  #[inline]
  pub fn PAD_LENGTH(&self) -> u8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(SDL::VT_PAD_LENGTH, Some(0)).unwrap()}
  }
  /// Security payload
  #[inline]
  pub fn PAYLOAD(&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>>>(SDL::VT_PAYLOAD, None)}
  }
}

impl flatbuffers::Verifiable for SDL<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<u16>("SPI", Self::VT_SPI, false)?
     .visit_field::<u8>("IV_LENGTH", Self::VT_IV_LENGTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("IV", Self::VT_IV, false)?
     .visit_field::<u8>("MAC_LENGTH", Self::VT_MAC_LENGTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("MAC", Self::VT_MAC, false)?
     .visit_field::<u8>("PAD_LENGTH", Self::VT_PAD_LENGTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("PAYLOAD", Self::VT_PAYLOAD, false)?
     .finish();
    Ok(())
  }
}
pub struct SDLArgs<'a> {
    pub SPI: u16,
    pub IV_LENGTH: u8,
    pub IV: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
    pub MAC_LENGTH: u8,
    pub MAC: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
    pub PAD_LENGTH: u8,
    pub PAYLOAD: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for SDLArgs<'a> {
  #[inline]
  fn default() -> Self {
    SDLArgs {
      SPI: 0,
      IV_LENGTH: 0,
      IV: None,
      MAC_LENGTH: 0,
      MAC: None,
      PAD_LENGTH: 0,
      PAYLOAD: None,
    }
  }
}

pub struct SDLBuilder<'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> SDLBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_SPI(&mut self, SPI: u16) {
    self.fbb_.push_slot::<u16>(SDL::VT_SPI, SPI, 0);
  }
  #[inline]
  pub fn add_IV_LENGTH(&mut self, IV_LENGTH: u8) {
    self.fbb_.push_slot::<u8>(SDL::VT_IV_LENGTH, IV_LENGTH, 0);
  }
  #[inline]
  pub fn add_IV(&mut self, IV: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SDL::VT_IV, IV);
  }
  #[inline]
  pub fn add_MAC_LENGTH(&mut self, MAC_LENGTH: u8) {
    self.fbb_.push_slot::<u8>(SDL::VT_MAC_LENGTH, MAC_LENGTH, 0);
  }
  #[inline]
  pub fn add_MAC(&mut self, MAC: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SDL::VT_MAC, MAC);
  }
  #[inline]
  pub fn add_PAD_LENGTH(&mut self, PAD_LENGTH: u8) {
    self.fbb_.push_slot::<u8>(SDL::VT_PAD_LENGTH, PAD_LENGTH, 0);
  }
  #[inline]
  pub fn add_PAYLOAD(&mut self, PAYLOAD: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(SDL::VT_PAYLOAD, PAYLOAD);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> SDLBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    SDLBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<SDL<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for SDL<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("SDL");
      ds.field("SPI", &self.SPI());
      ds.field("IV_LENGTH", &self.IV_LENGTH());
      ds.field("IV", &self.IV());
      ds.field("MAC_LENGTH", &self.MAC_LENGTH());
      ds.field("MAC", &self.MAC());
      ds.field("PAD_LENGTH", &self.PAD_LENGTH());
      ds.field("PAYLOAD", &self.PAYLOAD());
      ds.finish()
  }
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct SDLT {
  pub SPI: u16,
  pub IV_LENGTH: u8,
  pub IV: Option<Vec<u8>>,
  pub MAC_LENGTH: u8,
  pub MAC: Option<Vec<u8>>,
  pub PAD_LENGTH: u8,
  pub PAYLOAD: Option<Vec<u8>>,
}
impl Default for SDLT {
  fn default() -> Self {
    Self {
      SPI: 0,
      IV_LENGTH: 0,
      IV: None,
      MAC_LENGTH: 0,
      MAC: None,
      PAD_LENGTH: 0,
      PAYLOAD: None,
    }
  }
}
impl SDLT {
  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
    &self,
    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
  ) -> flatbuffers::WIPOffset<SDL<'b>> {
    let SPI = self.SPI;
    let IV_LENGTH = self.IV_LENGTH;
    let IV = self.IV.as_ref().map(|x|{
      _fbb.create_vector(x)
    });
    let MAC_LENGTH = self.MAC_LENGTH;
    let MAC = self.MAC.as_ref().map(|x|{
      _fbb.create_vector(x)
    });
    let PAD_LENGTH = self.PAD_LENGTH;
    let PAYLOAD = self.PAYLOAD.as_ref().map(|x|{
      _fbb.create_vector(x)
    });
    SDL::create(_fbb, &SDLArgs{
      SPI,
      IV_LENGTH,
      IV,
      MAC_LENGTH,
      MAC,
      PAD_LENGTH,
      PAYLOAD,
    })
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `SDL`
/// 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_SDL_unchecked`.
pub fn root_as_SDL(buf: &[u8]) -> Result<SDL, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root::<SDL>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `SDL` 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_SDL_unchecked`.
pub fn size_prefixed_root_as_SDL(buf: &[u8]) -> Result<SDL, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root::<SDL>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `SDL` 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_SDL_unchecked`.
pub fn root_as_SDL_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<SDL<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root_with_opts::<SDL<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `SDL` 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_SDL_unchecked`.
pub fn size_prefixed_root_as_SDL_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<SDL<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root_with_opts::<SDL<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a SDL and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `SDL`.
pub unsafe fn root_as_SDL_unchecked(buf: &[u8]) -> SDL {
  flatbuffers::root_unchecked::<SDL>(buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed SDL and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `SDL`.
pub unsafe fn size_prefixed_root_as_SDL_unchecked(buf: &[u8]) -> SDL {
  flatbuffers::size_prefixed_root_unchecked::<SDL>(buf)
}
pub const SDL_IDENTIFIER: &str = "$SDL";

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

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

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

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