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_CLTU_PDU_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_CLTU_PDU_TYPE: i8 = 10;
#[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_CLTU_PDU_TYPE: [cltuPduType; 11] = [
  cltuPduType::BIND_INVOCATION,
  cltuPduType::BIND_RETURN,
  cltuPduType::UNBIND_INVOCATION,
  cltuPduType::UNBIND_RETURN,
  cltuPduType::START_INVOCATION,
  cltuPduType::START_RETURN,
  cltuPduType::STOP_INVOCATION,
  cltuPduType::STOP_RETURN,
  cltuPduType::TRANSFER_DATA_INVOCATION,
  cltuPduType::TRANSFER_DATA_RETURN,
  cltuPduType::PEER_ABORT,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct cltuPduType(pub i8);
#[allow(non_upper_case_globals)]
impl cltuPduType {
  pub const BIND_INVOCATION: Self = Self(0);
  pub const BIND_RETURN: Self = Self(1);
  pub const UNBIND_INVOCATION: Self = Self(2);
  pub const UNBIND_RETURN: Self = Self(3);
  pub const START_INVOCATION: Self = Self(4);
  pub const START_RETURN: Self = Self(5);
  pub const STOP_INVOCATION: Self = Self(6);
  pub const STOP_RETURN: Self = Self(7);
  pub const TRANSFER_DATA_INVOCATION: Self = Self(8);
  pub const TRANSFER_DATA_RETURN: Self = Self(9);
  pub const PEER_ABORT: Self = Self(10);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 10;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::BIND_INVOCATION,
    Self::BIND_RETURN,
    Self::UNBIND_INVOCATION,
    Self::UNBIND_RETURN,
    Self::START_INVOCATION,
    Self::START_RETURN,
    Self::STOP_INVOCATION,
    Self::STOP_RETURN,
    Self::TRANSFER_DATA_INVOCATION,
    Self::TRANSFER_DATA_RETURN,
    Self::PEER_ABORT,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::BIND_INVOCATION => Some("BIND_INVOCATION"),
      Self::BIND_RETURN => Some("BIND_RETURN"),
      Self::UNBIND_INVOCATION => Some("UNBIND_INVOCATION"),
      Self::UNBIND_RETURN => Some("UNBIND_RETURN"),
      Self::START_INVOCATION => Some("START_INVOCATION"),
      Self::START_RETURN => Some("START_RETURN"),
      Self::STOP_INVOCATION => Some("STOP_INVOCATION"),
      Self::STOP_RETURN => Some("STOP_RETURN"),
      Self::TRANSFER_DATA_INVOCATION => Some("TRANSFER_DATA_INVOCATION"),
      Self::TRANSFER_DATA_RETURN => Some("TRANSFER_DATA_RETURN"),
      Self::PEER_ABORT => Some("PEER_ABORT"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for cltuPduType {
  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 cltuPduType {
  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 cltuPduType {
    type Output = cltuPduType;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        flatbuffers::emplace_scalar::<i8>(dst, self.0);
    }
}

impl flatbuffers::EndianScalar for cltuPduType {
  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 cltuPduType {
  #[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 cltuPduType {}
pub enum CLTOffset {}
#[derive(Copy, Clone, PartialEq)]

/// Command Link Transmission Unit Service (CCSDS 912.3-B-2)
pub struct CLT<'a> {
  pub _tab: flatbuffers::Table<'a>,
}

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

impl<'a> CLT<'a> {
  pub const VT_PDU_TYPE: flatbuffers::VOffsetT = 4;
  pub const VT_INITIATOR_ID: flatbuffers::VOffsetT = 6;
  pub const VT_RESPONDER_PORT_ID: flatbuffers::VOffsetT = 8;
  pub const VT_SERVICE_TYPE: flatbuffers::VOffsetT = 10;
  pub const VT_VERSION: flatbuffers::VOffsetT = 12;
  pub const VT_INVOKE_ID: flatbuffers::VOffsetT = 14;
  pub const VT_DATA: flatbuffers::VOffsetT = 16;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    CLT { _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 CLTArgs<'args>
  ) -> flatbuffers::WIPOffset<CLT<'bldr>> {
    let mut builder = CLTBuilder::new(_fbb);
    if let Some(x) = args.DATA { builder.add_DATA(x); }
    builder.add_INVOKE_ID(args.INVOKE_ID);
    if let Some(x) = args.RESPONDER_PORT_ID { builder.add_RESPONDER_PORT_ID(x); }
    if let Some(x) = args.INITIATOR_ID { builder.add_INITIATOR_ID(x); }
    builder.add_VERSION(args.VERSION);
    builder.add_SERVICE_TYPE(args.SERVICE_TYPE);
    builder.add_PDU_TYPE(args.PDU_TYPE);
    builder.finish()
  }

  pub fn unpack(&self) -> CLTT {
    let PDU_TYPE = self.PDU_TYPE();
    let INITIATOR_ID = self.INITIATOR_ID().map(|x| {
      x.to_string()
    });
    let RESPONDER_PORT_ID = self.RESPONDER_PORT_ID().map(|x| {
      x.to_string()
    });
    let SERVICE_TYPE = self.SERVICE_TYPE();
    let VERSION = self.VERSION();
    let INVOKE_ID = self.INVOKE_ID();
    let DATA = self.DATA().map(|x| {
      x.into_iter().collect()
    });
    CLTT {
      PDU_TYPE,
      INITIATOR_ID,
      RESPONDER_PORT_ID,
      SERVICE_TYPE,
      VERSION,
      INVOKE_ID,
      DATA,
    }
  }

  /// PDU type
  #[inline]
  pub fn PDU_TYPE(&self) -> cltuPduType {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<cltuPduType>(CLT::VT_PDU_TYPE, Some(cltuPduType::BIND_INVOCATION)).unwrap()}
  }
  /// Initiator identifier
  #[inline]
  pub fn INITIATOR_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>>(CLT::VT_INITIATOR_ID, None)}
  }
  /// Responder port identifier
  #[inline]
  pub fn RESPONDER_PORT_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>>(CLT::VT_RESPONDER_PORT_ID, None)}
  }
  /// Service type
  #[inline]
  pub fn SERVICE_TYPE(&self) -> u8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(CLT::VT_SERVICE_TYPE, Some(0)).unwrap()}
  }
  /// Version number
  #[inline]
  pub fn VERSION(&self) -> u16 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u16>(CLT::VT_VERSION, Some(0)).unwrap()}
  }
  /// Invoke ID
  #[inline]
  pub fn INVOKE_ID(&self) -> u32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u32>(CLT::VT_INVOKE_ID, Some(0)).unwrap()}
  }
  /// CLTU data
  #[inline]
  pub fn DATA(&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>>>(CLT::VT_DATA, None)}
  }
}

impl flatbuffers::Verifiable for CLT<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<cltuPduType>("PDU_TYPE", Self::VT_PDU_TYPE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("INITIATOR_ID", Self::VT_INITIATOR_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("RESPONDER_PORT_ID", Self::VT_RESPONDER_PORT_ID, false)?
     .visit_field::<u8>("SERVICE_TYPE", Self::VT_SERVICE_TYPE, false)?
     .visit_field::<u16>("VERSION", Self::VT_VERSION, false)?
     .visit_field::<u32>("INVOKE_ID", Self::VT_INVOKE_ID, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("DATA", Self::VT_DATA, false)?
     .finish();
    Ok(())
  }
}
pub struct CLTArgs<'a> {
    pub PDU_TYPE: cltuPduType,
    pub INITIATOR_ID: Option<flatbuffers::WIPOffset<&'a str>>,
    pub RESPONDER_PORT_ID: Option<flatbuffers::WIPOffset<&'a str>>,
    pub SERVICE_TYPE: u8,
    pub VERSION: u16,
    pub INVOKE_ID: u32,
    pub DATA: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for CLTArgs<'a> {
  #[inline]
  fn default() -> Self {
    CLTArgs {
      PDU_TYPE: cltuPduType::BIND_INVOCATION,
      INITIATOR_ID: None,
      RESPONDER_PORT_ID: None,
      SERVICE_TYPE: 0,
      VERSION: 0,
      INVOKE_ID: 0,
      DATA: None,
    }
  }
}

pub struct CLTBuilder<'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> CLTBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_PDU_TYPE(&mut self, PDU_TYPE: cltuPduType) {
    self.fbb_.push_slot::<cltuPduType>(CLT::VT_PDU_TYPE, PDU_TYPE, cltuPduType::BIND_INVOCATION);
  }
  #[inline]
  pub fn add_INITIATOR_ID(&mut self, INITIATOR_ID: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CLT::VT_INITIATOR_ID, INITIATOR_ID);
  }
  #[inline]
  pub fn add_RESPONDER_PORT_ID(&mut self, RESPONDER_PORT_ID: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CLT::VT_RESPONDER_PORT_ID, RESPONDER_PORT_ID);
  }
  #[inline]
  pub fn add_SERVICE_TYPE(&mut self, SERVICE_TYPE: u8) {
    self.fbb_.push_slot::<u8>(CLT::VT_SERVICE_TYPE, SERVICE_TYPE, 0);
  }
  #[inline]
  pub fn add_VERSION(&mut self, VERSION: u16) {
    self.fbb_.push_slot::<u16>(CLT::VT_VERSION, VERSION, 0);
  }
  #[inline]
  pub fn add_INVOKE_ID(&mut self, INVOKE_ID: u32) {
    self.fbb_.push_slot::<u32>(CLT::VT_INVOKE_ID, INVOKE_ID, 0);
  }
  #[inline]
  pub fn add_DATA(&mut self, DATA: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(CLT::VT_DATA, DATA);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> CLTBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    CLTBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<CLT<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for CLT<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("CLT");
      ds.field("PDU_TYPE", &self.PDU_TYPE());
      ds.field("INITIATOR_ID", &self.INITIATOR_ID());
      ds.field("RESPONDER_PORT_ID", &self.RESPONDER_PORT_ID());
      ds.field("SERVICE_TYPE", &self.SERVICE_TYPE());
      ds.field("VERSION", &self.VERSION());
      ds.field("INVOKE_ID", &self.INVOKE_ID());
      ds.field("DATA", &self.DATA());
      ds.finish()
  }
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct CLTT {
  pub PDU_TYPE: cltuPduType,
  pub INITIATOR_ID: Option<String>,
  pub RESPONDER_PORT_ID: Option<String>,
  pub SERVICE_TYPE: u8,
  pub VERSION: u16,
  pub INVOKE_ID: u32,
  pub DATA: Option<Vec<u8>>,
}
impl Default for CLTT {
  fn default() -> Self {
    Self {
      PDU_TYPE: cltuPduType::BIND_INVOCATION,
      INITIATOR_ID: None,
      RESPONDER_PORT_ID: None,
      SERVICE_TYPE: 0,
      VERSION: 0,
      INVOKE_ID: 0,
      DATA: None,
    }
  }
}
impl CLTT {
  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
    &self,
    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
  ) -> flatbuffers::WIPOffset<CLT<'b>> {
    let PDU_TYPE = self.PDU_TYPE;
    let INITIATOR_ID = self.INITIATOR_ID.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let RESPONDER_PORT_ID = self.RESPONDER_PORT_ID.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let SERVICE_TYPE = self.SERVICE_TYPE;
    let VERSION = self.VERSION;
    let INVOKE_ID = self.INVOKE_ID;
    let DATA = self.DATA.as_ref().map(|x|{
      _fbb.create_vector(x)
    });
    CLT::create(_fbb, &CLTArgs{
      PDU_TYPE,
      INITIATOR_ID,
      RESPONDER_PORT_ID,
      SERVICE_TYPE,
      VERSION,
      INVOKE_ID,
      DATA,
    })
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `CLT`
/// 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_CLT_unchecked`.
pub fn root_as_CLT(buf: &[u8]) -> Result<CLT, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root::<CLT>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `CLT` 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_CLT_unchecked`.
pub fn size_prefixed_root_as_CLT(buf: &[u8]) -> Result<CLT, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root::<CLT>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `CLT` 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_CLT_unchecked`.
pub fn root_as_CLT_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<CLT<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root_with_opts::<CLT<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `CLT` 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_CLT_unchecked`.
pub fn size_prefixed_root_as_CLT_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<CLT<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root_with_opts::<CLT<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a CLT and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `CLT`.
pub unsafe fn root_as_CLT_unchecked(buf: &[u8]) -> CLT {
  flatbuffers::root_unchecked::<CLT>(buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed CLT and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `CLT`.
pub unsafe fn size_prefixed_root_as_CLT_unchecked(buf: &[u8]) -> CLT {
  flatbuffers::size_prefixed_root_unchecked::<CLT>(buf)
}
pub const CLT_IDENTIFIER: &str = "$CLT";

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

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

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

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