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

/// RF Band
pub struct RFB<'a> {
  pub _tab: flatbuffers::Table<'a>,
}

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

impl<'a> RFB<'a> {
  pub const VT_ID: flatbuffers::VOffsetT = 4;
  pub const VT_ID_ENTITY: flatbuffers::VOffsetT = 6;
  pub const VT_NAME: flatbuffers::VOffsetT = 8;
  pub const VT_BAND: flatbuffers::VOffsetT = 10;
  pub const VT_MODE: flatbuffers::VOffsetT = 12;
  pub const VT_PURPOSE: flatbuffers::VOffsetT = 14;
  pub const VT_FREQ_MIN: flatbuffers::VOffsetT = 16;
  pub const VT_FREQ_MAX: flatbuffers::VOffsetT = 18;
  pub const VT_CENTER_FREQ: flatbuffers::VOffsetT = 20;
  pub const VT_PEAK_GAIN: flatbuffers::VOffsetT = 22;
  pub const VT_EDGE_GAIN: flatbuffers::VOffsetT = 24;
  pub const VT_BANDWIDTH: flatbuffers::VOffsetT = 26;
  pub const VT_BEAMWIDTH: flatbuffers::VOffsetT = 28;
  pub const VT_POLARIZATION: flatbuffers::VOffsetT = 30;
  pub const VT_ERP: flatbuffers::VOffsetT = 32;
  pub const VT_EIRP: flatbuffers::VOffsetT = 34;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    RFB { _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 RFBArgs<'args>
  ) -> flatbuffers::WIPOffset<RFB<'bldr>> {
    let mut builder = RFBBuilder::new(_fbb);
    builder.add_EIRP(args.EIRP);
    builder.add_ERP(args.ERP);
    builder.add_BEAMWIDTH(args.BEAMWIDTH);
    builder.add_BANDWIDTH(args.BANDWIDTH);
    builder.add_EDGE_GAIN(args.EDGE_GAIN);
    builder.add_PEAK_GAIN(args.PEAK_GAIN);
    builder.add_CENTER_FREQ(args.CENTER_FREQ);
    builder.add_FREQ_MAX(args.FREQ_MAX);
    builder.add_FREQ_MIN(args.FREQ_MIN);
    if let Some(x) = args.POLARIZATION { builder.add_POLARIZATION(x); }
    if let Some(x) = args.PURPOSE { builder.add_PURPOSE(x); }
    if let Some(x) = args.MODE { builder.add_MODE(x); }
    if let Some(x) = args.BAND { builder.add_BAND(x); }
    if let Some(x) = args.NAME { builder.add_NAME(x); }
    if let Some(x) = args.ID_ENTITY { builder.add_ID_ENTITY(x); }
    if let Some(x) = args.ID { builder.add_ID(x); }
    builder.finish()
  }

  pub fn unpack(&self) -> RFBT {
    let ID = self.ID().map(|x| {
      x.to_string()
    });
    let ID_ENTITY = self.ID_ENTITY().map(|x| {
      x.to_string()
    });
    let NAME = self.NAME().map(|x| {
      x.to_string()
    });
    let BAND = self.BAND().map(|x| {
      x.to_string()
    });
    let MODE = self.MODE().map(|x| {
      x.to_string()
    });
    let PURPOSE = self.PURPOSE().map(|x| {
      x.to_string()
    });
    let FREQ_MIN = self.FREQ_MIN();
    let FREQ_MAX = self.FREQ_MAX();
    let CENTER_FREQ = self.CENTER_FREQ();
    let PEAK_GAIN = self.PEAK_GAIN();
    let EDGE_GAIN = self.EDGE_GAIN();
    let BANDWIDTH = self.BANDWIDTH();
    let BEAMWIDTH = self.BEAMWIDTH();
    let POLARIZATION = self.POLARIZATION().map(|x| {
      x.to_string()
    });
    let ERP = self.ERP();
    let EIRP = self.EIRP();
    RFBT {
      ID,
      ID_ENTITY,
      NAME,
      BAND,
      MODE,
      PURPOSE,
      FREQ_MIN,
      FREQ_MAX,
      CENTER_FREQ,
      PEAK_GAIN,
      EDGE_GAIN,
      BANDWIDTH,
      BEAMWIDTH,
      POLARIZATION,
      ERP,
      EIRP,
    }
  }

  #[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>>(RFB::VT_ID, None)}
  }
  #[inline]
  pub fn ID_ENTITY(&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>>(RFB::VT_ID_ENTITY, None)}
  }
  #[inline]
  pub fn 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>>(RFB::VT_NAME, None)}
  }
  #[inline]
  pub fn BAND(&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>>(RFB::VT_BAND, None)}
  }
  #[inline]
  pub fn MODE(&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>>(RFB::VT_MODE, None)}
  }
  #[inline]
  pub fn PURPOSE(&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>>(RFB::VT_PURPOSE, None)}
  }
  #[inline]
  pub fn FREQ_MIN(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(RFB::VT_FREQ_MIN, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn FREQ_MAX(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(RFB::VT_FREQ_MAX, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn CENTER_FREQ(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(RFB::VT_CENTER_FREQ, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn PEAK_GAIN(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(RFB::VT_PEAK_GAIN, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn EDGE_GAIN(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(RFB::VT_EDGE_GAIN, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn BANDWIDTH(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(RFB::VT_BANDWIDTH, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn BEAMWIDTH(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(RFB::VT_BEAMWIDTH, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn POLARIZATION(&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>>(RFB::VT_POLARIZATION, None)}
  }
  #[inline]
  pub fn ERP(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(RFB::VT_ERP, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn EIRP(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(RFB::VT_EIRP, Some(0.0)).unwrap()}
  }
}

impl flatbuffers::Verifiable for RFB<'_> {
  #[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>>("ID_ENTITY", Self::VT_ID_ENTITY, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("NAME", Self::VT_NAME, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("BAND", Self::VT_BAND, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("MODE", Self::VT_MODE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("PURPOSE", Self::VT_PURPOSE, false)?
     .visit_field::<f64>("FREQ_MIN", Self::VT_FREQ_MIN, false)?
     .visit_field::<f64>("FREQ_MAX", Self::VT_FREQ_MAX, false)?
     .visit_field::<f64>("CENTER_FREQ", Self::VT_CENTER_FREQ, false)?
     .visit_field::<f64>("PEAK_GAIN", Self::VT_PEAK_GAIN, false)?
     .visit_field::<f64>("EDGE_GAIN", Self::VT_EDGE_GAIN, false)?
     .visit_field::<f64>("BANDWIDTH", Self::VT_BANDWIDTH, false)?
     .visit_field::<f64>("BEAMWIDTH", Self::VT_BEAMWIDTH, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("POLARIZATION", Self::VT_POLARIZATION, false)?
     .visit_field::<f64>("ERP", Self::VT_ERP, false)?
     .visit_field::<f64>("EIRP", Self::VT_EIRP, false)?
     .finish();
    Ok(())
  }
}
pub struct RFBArgs<'a> {
    pub ID: Option<flatbuffers::WIPOffset<&'a str>>,
    pub ID_ENTITY: Option<flatbuffers::WIPOffset<&'a str>>,
    pub NAME: Option<flatbuffers::WIPOffset<&'a str>>,
    pub BAND: Option<flatbuffers::WIPOffset<&'a str>>,
    pub MODE: Option<flatbuffers::WIPOffset<&'a str>>,
    pub PURPOSE: Option<flatbuffers::WIPOffset<&'a str>>,
    pub FREQ_MIN: f64,
    pub FREQ_MAX: f64,
    pub CENTER_FREQ: f64,
    pub PEAK_GAIN: f64,
    pub EDGE_GAIN: f64,
    pub BANDWIDTH: f64,
    pub BEAMWIDTH: f64,
    pub POLARIZATION: Option<flatbuffers::WIPOffset<&'a str>>,
    pub ERP: f64,
    pub EIRP: f64,
}
impl<'a> Default for RFBArgs<'a> {
  #[inline]
  fn default() -> Self {
    RFBArgs {
      ID: None,
      ID_ENTITY: None,
      NAME: None,
      BAND: None,
      MODE: None,
      PURPOSE: None,
      FREQ_MIN: 0.0,
      FREQ_MAX: 0.0,
      CENTER_FREQ: 0.0,
      PEAK_GAIN: 0.0,
      EDGE_GAIN: 0.0,
      BANDWIDTH: 0.0,
      BEAMWIDTH: 0.0,
      POLARIZATION: None,
      ERP: 0.0,
      EIRP: 0.0,
    }
  }
}

pub struct RFBBuilder<'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> RFBBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_ID(&mut self, ID: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RFB::VT_ID, ID);
  }
  #[inline]
  pub fn add_ID_ENTITY(&mut self, ID_ENTITY: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RFB::VT_ID_ENTITY, ID_ENTITY);
  }
  #[inline]
  pub fn add_NAME(&mut self, NAME: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RFB::VT_NAME, NAME);
  }
  #[inline]
  pub fn add_BAND(&mut self, BAND: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RFB::VT_BAND, BAND);
  }
  #[inline]
  pub fn add_MODE(&mut self, MODE: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RFB::VT_MODE, MODE);
  }
  #[inline]
  pub fn add_PURPOSE(&mut self, PURPOSE: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RFB::VT_PURPOSE, PURPOSE);
  }
  #[inline]
  pub fn add_FREQ_MIN(&mut self, FREQ_MIN: f64) {
    self.fbb_.push_slot::<f64>(RFB::VT_FREQ_MIN, FREQ_MIN, 0.0);
  }
  #[inline]
  pub fn add_FREQ_MAX(&mut self, FREQ_MAX: f64) {
    self.fbb_.push_slot::<f64>(RFB::VT_FREQ_MAX, FREQ_MAX, 0.0);
  }
  #[inline]
  pub fn add_CENTER_FREQ(&mut self, CENTER_FREQ: f64) {
    self.fbb_.push_slot::<f64>(RFB::VT_CENTER_FREQ, CENTER_FREQ, 0.0);
  }
  #[inline]
  pub fn add_PEAK_GAIN(&mut self, PEAK_GAIN: f64) {
    self.fbb_.push_slot::<f64>(RFB::VT_PEAK_GAIN, PEAK_GAIN, 0.0);
  }
  #[inline]
  pub fn add_EDGE_GAIN(&mut self, EDGE_GAIN: f64) {
    self.fbb_.push_slot::<f64>(RFB::VT_EDGE_GAIN, EDGE_GAIN, 0.0);
  }
  #[inline]
  pub fn add_BANDWIDTH(&mut self, BANDWIDTH: f64) {
    self.fbb_.push_slot::<f64>(RFB::VT_BANDWIDTH, BANDWIDTH, 0.0);
  }
  #[inline]
  pub fn add_BEAMWIDTH(&mut self, BEAMWIDTH: f64) {
    self.fbb_.push_slot::<f64>(RFB::VT_BEAMWIDTH, BEAMWIDTH, 0.0);
  }
  #[inline]
  pub fn add_POLARIZATION(&mut self, POLARIZATION: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(RFB::VT_POLARIZATION, POLARIZATION);
  }
  #[inline]
  pub fn add_ERP(&mut self, ERP: f64) {
    self.fbb_.push_slot::<f64>(RFB::VT_ERP, ERP, 0.0);
  }
  #[inline]
  pub fn add_EIRP(&mut self, EIRP: f64) {
    self.fbb_.push_slot::<f64>(RFB::VT_EIRP, EIRP, 0.0);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> RFBBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    RFBBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<RFB<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for RFB<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("RFB");
      ds.field("ID", &self.ID());
      ds.field("ID_ENTITY", &self.ID_ENTITY());
      ds.field("NAME", &self.NAME());
      ds.field("BAND", &self.BAND());
      ds.field("MODE", &self.MODE());
      ds.field("PURPOSE", &self.PURPOSE());
      ds.field("FREQ_MIN", &self.FREQ_MIN());
      ds.field("FREQ_MAX", &self.FREQ_MAX());
      ds.field("CENTER_FREQ", &self.CENTER_FREQ());
      ds.field("PEAK_GAIN", &self.PEAK_GAIN());
      ds.field("EDGE_GAIN", &self.EDGE_GAIN());
      ds.field("BANDWIDTH", &self.BANDWIDTH());
      ds.field("BEAMWIDTH", &self.BEAMWIDTH());
      ds.field("POLARIZATION", &self.POLARIZATION());
      ds.field("ERP", &self.ERP());
      ds.field("EIRP", &self.EIRP());
      ds.finish()
  }
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct RFBT {
  pub ID: Option<String>,
  pub ID_ENTITY: Option<String>,
  pub NAME: Option<String>,
  pub BAND: Option<String>,
  pub MODE: Option<String>,
  pub PURPOSE: Option<String>,
  pub FREQ_MIN: f64,
  pub FREQ_MAX: f64,
  pub CENTER_FREQ: f64,
  pub PEAK_GAIN: f64,
  pub EDGE_GAIN: f64,
  pub BANDWIDTH: f64,
  pub BEAMWIDTH: f64,
  pub POLARIZATION: Option<String>,
  pub ERP: f64,
  pub EIRP: f64,
}
impl Default for RFBT {
  fn default() -> Self {
    Self {
      ID: None,
      ID_ENTITY: None,
      NAME: None,
      BAND: None,
      MODE: None,
      PURPOSE: None,
      FREQ_MIN: 0.0,
      FREQ_MAX: 0.0,
      CENTER_FREQ: 0.0,
      PEAK_GAIN: 0.0,
      EDGE_GAIN: 0.0,
      BANDWIDTH: 0.0,
      BEAMWIDTH: 0.0,
      POLARIZATION: None,
      ERP: 0.0,
      EIRP: 0.0,
    }
  }
}
impl RFBT {
  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
    &self,
    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
  ) -> flatbuffers::WIPOffset<RFB<'b>> {
    let ID = self.ID.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let ID_ENTITY = self.ID_ENTITY.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let NAME = self.NAME.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let BAND = self.BAND.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let MODE = self.MODE.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let PURPOSE = self.PURPOSE.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let FREQ_MIN = self.FREQ_MIN;
    let FREQ_MAX = self.FREQ_MAX;
    let CENTER_FREQ = self.CENTER_FREQ;
    let PEAK_GAIN = self.PEAK_GAIN;
    let EDGE_GAIN = self.EDGE_GAIN;
    let BANDWIDTH = self.BANDWIDTH;
    let BEAMWIDTH = self.BEAMWIDTH;
    let POLARIZATION = self.POLARIZATION.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let ERP = self.ERP;
    let EIRP = self.EIRP;
    RFB::create(_fbb, &RFBArgs{
      ID,
      ID_ENTITY,
      NAME,
      BAND,
      MODE,
      PURPOSE,
      FREQ_MIN,
      FREQ_MAX,
      CENTER_FREQ,
      PEAK_GAIN,
      EDGE_GAIN,
      BANDWIDTH,
      BEAMWIDTH,
      POLARIZATION,
      ERP,
      EIRP,
    })
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `RFB`
/// 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_RFB_unchecked`.
pub fn root_as_RFB(buf: &[u8]) -> Result<RFB, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root::<RFB>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `RFB` 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_RFB_unchecked`.
pub fn size_prefixed_root_as_RFB(buf: &[u8]) -> Result<RFB, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root::<RFB>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `RFB` 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_RFB_unchecked`.
pub fn root_as_RFB_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<RFB<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root_with_opts::<RFB<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `RFB` 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_RFB_unchecked`.
pub fn size_prefixed_root_as_RFB_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<RFB<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root_with_opts::<RFB<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a RFB and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `RFB`.
pub unsafe fn root_as_RFB_unchecked(buf: &[u8]) -> RFB {
  flatbuffers::root_unchecked::<RFB>(buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed RFB and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `RFB`.
pub unsafe fn size_prefixed_root_as_RFB_unchecked(buf: &[u8]) -> RFB {
  flatbuffers::size_prefixed_root_unchecked::<RFB>(buf)
}
pub const RFB_IDENTIFIER: &str = "$RFB";

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

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

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

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