protosol 5.3.0

// automatically generated by the FlatBuffers compiler, do not modify


// @generated

use crate::context_generated::*;
use crate::metadata_generated::*;
use core::mem;
use core::cmp::Ordering;

extern crate flatbuffers;
use self::flatbuffers::{EndianScalar, Follow};

#[allow(unused_imports, dead_code)]
pub mod org {

  use crate::context_generated::*;
  use crate::metadata_generated::*;
  use core::mem;
  use core::cmp::Ordering;

  extern crate flatbuffers;
  use self::flatbuffers::{EndianScalar, Follow};
#[allow(unused_imports, dead_code)]
pub mod solana {

  use crate::context_generated::*;
  use crate::metadata_generated::*;
  use core::mem;
  use core::cmp::Ordering;

  extern crate flatbuffers;
  use self::flatbuffers::{EndianScalar, Follow};
#[allow(unused_imports, dead_code)]
pub mod sealevel {

  use crate::context_generated::*;
  use crate::metadata_generated::*;
  use core::mem;
  use core::cmp::Ordering;

  extern crate flatbuffers;
  use self::flatbuffers::{EndianScalar, Follow};
#[allow(unused_imports, dead_code)]
pub mod v_2 {

  use crate::context_generated::*;
  use crate::metadata_generated::*;
  use core::mem;
  use core::cmp::Ordering;

  extern crate flatbuffers;
  use self::flatbuffers::{EndianScalar, Follow};

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

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

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

impl<'a> ELFLoaderCtx<'a> {
  pub const VT_ELF_DATA: flatbuffers::VOffsetT = 4;
  pub const VT_FEATURES: flatbuffers::VOffsetT = 6;
  pub const VT_DEPLOY_CHECKS: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ELFLoaderCtx { _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 ELFLoaderCtxArgs<'args>
  ) -> flatbuffers::WIPOffset<ELFLoaderCtx<'bldr>> {
    let mut builder = ELFLoaderCtxBuilder::new(_fbb);
    if let Some(x) = args.features { builder.add_features(x); }
    if let Some(x) = args.elf_data { builder.add_elf_data(x); }
    builder.add_deploy_checks(args.deploy_checks);
    builder.finish()
  }

  pub fn unpack(&self) -> ELFLoaderCtxT {
    let elf_data = {
      let x = self.elf_data();
      x.into_iter().collect()
    };
    let features = {
      let x = self.features();
      Box::new(x.unpack())
    };
    let deploy_checks = self.deploy_checks();
    ELFLoaderCtxT {
      elf_data,
      features,
      deploy_checks,
    }
  }

  #[inline]
  pub fn elf_data(&self) -> 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>>>(ELFLoaderCtx::VT_ELF_DATA, None).unwrap()}
  }
  #[inline]
  pub fn features(&self) -> FeatureSet<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<FeatureSet>>(ELFLoaderCtx::VT_FEATURES, None).unwrap()}
  }
  #[inline]
  pub fn deploy_checks(&self) -> bool {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<bool>(ELFLoaderCtx::VT_DEPLOY_CHECKS, Some(false)).unwrap()}
  }
}

impl flatbuffers::Verifiable for ELFLoaderCtx<'_> {
  #[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<flatbuffers::Vector<'_, u8>>>("elf_data", Self::VT_ELF_DATA, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<FeatureSet>>("features", Self::VT_FEATURES, true)?
     .visit_field::<bool>("deploy_checks", Self::VT_DEPLOY_CHECKS, false)?
     .finish();
    Ok(())
  }
}
pub struct ELFLoaderCtxArgs<'a> {
    pub elf_data: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
    pub features: Option<flatbuffers::WIPOffset<FeatureSet<'a>>>,
    pub deploy_checks: bool,
}
impl<'a> Default for ELFLoaderCtxArgs<'a> {
  #[inline]
  fn default() -> Self {
    ELFLoaderCtxArgs {
      elf_data: None, // required field
      features: None, // required field
      deploy_checks: false,
    }
  }
}

pub struct ELFLoaderCtxBuilder<'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> ELFLoaderCtxBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_elf_data(&mut self, elf_data: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ELFLoaderCtx::VT_ELF_DATA, elf_data);
  }
  #[inline]
  pub fn add_features(&mut self, features: flatbuffers::WIPOffset<FeatureSet<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<FeatureSet>>(ELFLoaderCtx::VT_FEATURES, features);
  }
  #[inline]
  pub fn add_deploy_checks(&mut self, deploy_checks: bool) {
    self.fbb_.push_slot::<bool>(ELFLoaderCtx::VT_DEPLOY_CHECKS, deploy_checks, false);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ELFLoaderCtxBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ELFLoaderCtxBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ELFLoaderCtx<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ELFLoaderCtx::VT_ELF_DATA,"elf_data");
    self.fbb_.required(o, ELFLoaderCtx::VT_FEATURES,"features");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for ELFLoaderCtx<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("ELFLoaderCtx");
      ds.field("elf_data", &self.elf_data());
      ds.field("features", &self.features());
      ds.field("deploy_checks", &self.deploy_checks());
      ds.finish()
  }
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct ELFLoaderCtxT {
  pub elf_data: Vec<u8>,
  pub features: Box<FeatureSetT>,
  pub deploy_checks: bool,
}
impl Default for ELFLoaderCtxT {
  fn default() -> Self {
    Self {
      elf_data: Default::default(),
      features: Default::default(),
      deploy_checks: false,
    }
  }
}
impl ELFLoaderCtxT {
  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
    &self,
    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
  ) -> flatbuffers::WIPOffset<ELFLoaderCtx<'b>> {
    let elf_data = Some({
      let x = &self.elf_data;
      _fbb.create_vector(x)
    });
    let features = Some({
      let x = &self.features;
      x.pack(_fbb)
    });
    let deploy_checks = self.deploy_checks;
    ELFLoaderCtx::create(_fbb, &ELFLoaderCtxArgs{
      elf_data,
      features,
      deploy_checks,
    })
  }
}
pub enum ELFLoaderEffectsOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ELFLoaderEffects<'a> {
  pub const VT_ERR_CODE: flatbuffers::VOffsetT = 4;
  pub const VT_RODATA_HASH: flatbuffers::VOffsetT = 6;
  pub const VT_TEXT_CNT: flatbuffers::VOffsetT = 8;
  pub const VT_TEXT_OFF: flatbuffers::VOffsetT = 10;
  pub const VT_ENTRY_PC: flatbuffers::VOffsetT = 12;
  pub const VT_CALLDESTS_HASH: flatbuffers::VOffsetT = 14;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ELFLoaderEffects { _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 ELFLoaderEffectsArgs<'args>
  ) -> flatbuffers::WIPOffset<ELFLoaderEffects<'bldr>> {
    let mut builder = ELFLoaderEffectsBuilder::new(_fbb);
    builder.add_entry_pc(args.entry_pc);
    builder.add_text_off(args.text_off);
    builder.add_text_cnt(args.text_cnt);
    if let Some(x) = args.calldests_hash { builder.add_calldests_hash(x); }
    if let Some(x) = args.rodata_hash { builder.add_rodata_hash(x); }
    builder.add_err_code(args.err_code);
    builder.finish()
  }

  pub fn unpack(&self) -> ELFLoaderEffectsT {
    let err_code = self.err_code();
    let rodata_hash = self.rodata_hash().map(|x| {
      x.unpack()
    });
    let text_cnt = self.text_cnt();
    let text_off = self.text_off();
    let entry_pc = self.entry_pc();
    let calldests_hash = self.calldests_hash().map(|x| {
      x.unpack()
    });
    ELFLoaderEffectsT {
      err_code,
      rodata_hash,
      text_cnt,
      text_off,
      entry_pc,
      calldests_hash,
    }
  }

  #[inline]
  pub fn err_code(&self) -> u8 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u8>(ELFLoaderEffects::VT_ERR_CODE, Some(0)).unwrap()}
  }
  #[inline]
  pub fn rodata_hash(&self) -> Option<&'a XXHash> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<XXHash>(ELFLoaderEffects::VT_RODATA_HASH, None)}
  }
  #[inline]
  pub fn text_cnt(&self) -> u64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u64>(ELFLoaderEffects::VT_TEXT_CNT, Some(0)).unwrap()}
  }
  #[inline]
  pub fn text_off(&self) -> u64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u64>(ELFLoaderEffects::VT_TEXT_OFF, Some(0)).unwrap()}
  }
  #[inline]
  pub fn entry_pc(&self) -> u64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<u64>(ELFLoaderEffects::VT_ENTRY_PC, Some(0)).unwrap()}
  }
  #[inline]
  pub fn calldests_hash(&self) -> Option<&'a XXHash> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<XXHash>(ELFLoaderEffects::VT_CALLDESTS_HASH, None)}
  }
}

impl flatbuffers::Verifiable for ELFLoaderEffects<'_> {
  #[inline]
  fn run_verifier(
    v: &mut flatbuffers::Verifier, pos: usize
  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
    use self::flatbuffers::Verifiable;
    v.visit_table(pos)?
     .visit_field::<u8>("err_code", Self::VT_ERR_CODE, false)?
     .visit_field::<XXHash>("rodata_hash", Self::VT_RODATA_HASH, false)?
     .visit_field::<u64>("text_cnt", Self::VT_TEXT_CNT, false)?
     .visit_field::<u64>("text_off", Self::VT_TEXT_OFF, false)?
     .visit_field::<u64>("entry_pc", Self::VT_ENTRY_PC, false)?
     .visit_field::<XXHash>("calldests_hash", Self::VT_CALLDESTS_HASH, false)?
     .finish();
    Ok(())
  }
}
pub struct ELFLoaderEffectsArgs<'a> {
    pub err_code: u8,
    pub rodata_hash: Option<&'a XXHash>,
    pub text_cnt: u64,
    pub text_off: u64,
    pub entry_pc: u64,
    pub calldests_hash: Option<&'a XXHash>,
}
impl<'a> Default for ELFLoaderEffectsArgs<'a> {
  #[inline]
  fn default() -> Self {
    ELFLoaderEffectsArgs {
      err_code: 0,
      rodata_hash: None,
      text_cnt: 0,
      text_off: 0,
      entry_pc: 0,
      calldests_hash: None,
    }
  }
}

pub struct ELFLoaderEffectsBuilder<'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> ELFLoaderEffectsBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_err_code(&mut self, err_code: u8) {
    self.fbb_.push_slot::<u8>(ELFLoaderEffects::VT_ERR_CODE, err_code, 0);
  }
  #[inline]
  pub fn add_rodata_hash(&mut self, rodata_hash: &XXHash) {
    self.fbb_.push_slot_always::<&XXHash>(ELFLoaderEffects::VT_RODATA_HASH, rodata_hash);
  }
  #[inline]
  pub fn add_text_cnt(&mut self, text_cnt: u64) {
    self.fbb_.push_slot::<u64>(ELFLoaderEffects::VT_TEXT_CNT, text_cnt, 0);
  }
  #[inline]
  pub fn add_text_off(&mut self, text_off: u64) {
    self.fbb_.push_slot::<u64>(ELFLoaderEffects::VT_TEXT_OFF, text_off, 0);
  }
  #[inline]
  pub fn add_entry_pc(&mut self, entry_pc: u64) {
    self.fbb_.push_slot::<u64>(ELFLoaderEffects::VT_ENTRY_PC, entry_pc, 0);
  }
  #[inline]
  pub fn add_calldests_hash(&mut self, calldests_hash: &XXHash) {
    self.fbb_.push_slot_always::<&XXHash>(ELFLoaderEffects::VT_CALLDESTS_HASH, calldests_hash);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ELFLoaderEffectsBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ELFLoaderEffectsBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ELFLoaderEffects<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for ELFLoaderEffects<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("ELFLoaderEffects");
      ds.field("err_code", &self.err_code());
      ds.field("rodata_hash", &self.rodata_hash());
      ds.field("text_cnt", &self.text_cnt());
      ds.field("text_off", &self.text_off());
      ds.field("entry_pc", &self.entry_pc());
      ds.field("calldests_hash", &self.calldests_hash());
      ds.finish()
  }
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct ELFLoaderEffectsT {
  pub err_code: u8,
  pub rodata_hash: Option<XXHashT>,
  pub text_cnt: u64,
  pub text_off: u64,
  pub entry_pc: u64,
  pub calldests_hash: Option<XXHashT>,
}
impl Default for ELFLoaderEffectsT {
  fn default() -> Self {
    Self {
      err_code: 0,
      rodata_hash: None,
      text_cnt: 0,
      text_off: 0,
      entry_pc: 0,
      calldests_hash: None,
    }
  }
}
impl ELFLoaderEffectsT {
  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
    &self,
    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
  ) -> flatbuffers::WIPOffset<ELFLoaderEffects<'b>> {
    let err_code = self.err_code;
    let rodata_hash_tmp = self.rodata_hash.as_ref().map(|x| x.pack());
    let rodata_hash = rodata_hash_tmp.as_ref();
    let text_cnt = self.text_cnt;
    let text_off = self.text_off;
    let entry_pc = self.entry_pc;
    let calldests_hash_tmp = self.calldests_hash.as_ref().map(|x| x.pack());
    let calldests_hash = calldests_hash_tmp.as_ref();
    ELFLoaderEffects::create(_fbb, &ELFLoaderEffectsArgs{
      err_code,
      rodata_hash,
      text_cnt,
      text_off,
      entry_pc,
      calldests_hash,
    })
  }
}
pub enum ELFLoaderFixtureOffset {}
#[derive(Copy, Clone, PartialEq)]

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

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

impl<'a> ELFLoaderFixture<'a> {
  pub const VT_METADATA: flatbuffers::VOffsetT = 4;
  pub const VT_INPUT: flatbuffers::VOffsetT = 6;
  pub const VT_OUTPUT: flatbuffers::VOffsetT = 8;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ELFLoaderFixture { _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 ELFLoaderFixtureArgs<'args>
  ) -> flatbuffers::WIPOffset<ELFLoaderFixture<'bldr>> {
    let mut builder = ELFLoaderFixtureBuilder::new(_fbb);
    if let Some(x) = args.output { builder.add_output(x); }
    if let Some(x) = args.input { builder.add_input(x); }
    if let Some(x) = args.metadata { builder.add_metadata(x); }
    builder.finish()
  }

  pub fn unpack(&self) -> ELFLoaderFixtureT {
    let metadata = {
      let x = self.metadata();
      Box::new(x.unpack())
    };
    let input = {
      let x = self.input();
      Box::new(x.unpack())
    };
    let output = {
      let x = self.output();
      Box::new(x.unpack())
    };
    ELFLoaderFixtureT {
      metadata,
      input,
      output,
    }
  }

  #[inline]
  pub fn metadata(&self) -> FixtureMetadata<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<FixtureMetadata>>(ELFLoaderFixture::VT_METADATA, None).unwrap()}
  }
  #[inline]
  pub fn input(&self) -> ELFLoaderCtx<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ELFLoaderCtx>>(ELFLoaderFixture::VT_INPUT, None).unwrap()}
  }
  #[inline]
  pub fn output(&self) -> ELFLoaderEffects<'a> {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<flatbuffers::ForwardsUOffset<ELFLoaderEffects>>(ELFLoaderFixture::VT_OUTPUT, None).unwrap()}
  }
}

impl flatbuffers::Verifiable for ELFLoaderFixture<'_> {
  #[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<FixtureMetadata>>("metadata", Self::VT_METADATA, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<ELFLoaderCtx>>("input", Self::VT_INPUT, true)?
     .visit_field::<flatbuffers::ForwardsUOffset<ELFLoaderEffects>>("output", Self::VT_OUTPUT, true)?
     .finish();
    Ok(())
  }
}
pub struct ELFLoaderFixtureArgs<'a> {
    pub metadata: Option<flatbuffers::WIPOffset<FixtureMetadata<'a>>>,
    pub input: Option<flatbuffers::WIPOffset<ELFLoaderCtx<'a>>>,
    pub output: Option<flatbuffers::WIPOffset<ELFLoaderEffects<'a>>>,
}
impl<'a> Default for ELFLoaderFixtureArgs<'a> {
  #[inline]
  fn default() -> Self {
    ELFLoaderFixtureArgs {
      metadata: None, // required field
      input: None, // required field
      output: None, // required field
    }
  }
}

pub struct ELFLoaderFixtureBuilder<'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> ELFLoaderFixtureBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_metadata(&mut self, metadata: flatbuffers::WIPOffset<FixtureMetadata<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<FixtureMetadata>>(ELFLoaderFixture::VT_METADATA, metadata);
  }
  #[inline]
  pub fn add_input(&mut self, input: flatbuffers::WIPOffset<ELFLoaderCtx<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ELFLoaderCtx>>(ELFLoaderFixture::VT_INPUT, input);
  }
  #[inline]
  pub fn add_output(&mut self, output: flatbuffers::WIPOffset<ELFLoaderEffects<'b >>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<ELFLoaderEffects>>(ELFLoaderFixture::VT_OUTPUT, output);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ELFLoaderFixtureBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ELFLoaderFixtureBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ELFLoaderFixture<'a>> {
    let o = self.fbb_.end_table(self.start_);
    self.fbb_.required(o, ELFLoaderFixture::VT_METADATA,"metadata");
    self.fbb_.required(o, ELFLoaderFixture::VT_INPUT,"input");
    self.fbb_.required(o, ELFLoaderFixture::VT_OUTPUT,"output");
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for ELFLoaderFixture<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("ELFLoaderFixture");
      ds.field("metadata", &self.metadata());
      ds.field("input", &self.input());
      ds.field("output", &self.output());
      ds.finish()
  }
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct ELFLoaderFixtureT {
  pub metadata: Box<FixtureMetadataT>,
  pub input: Box<ELFLoaderCtxT>,
  pub output: Box<ELFLoaderEffectsT>,
}
impl Default for ELFLoaderFixtureT {
  fn default() -> Self {
    Self {
      metadata: Default::default(),
      input: Default::default(),
      output: Default::default(),
    }
  }
}
impl ELFLoaderFixtureT {
  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
    &self,
    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
  ) -> flatbuffers::WIPOffset<ELFLoaderFixture<'b>> {
    let metadata = Some({
      let x = &self.metadata;
      x.pack(_fbb)
    });
    let input = Some({
      let x = &self.input;
      x.pack(_fbb)
    });
    let output = Some({
      let x = &self.output;
      x.pack(_fbb)
    });
    ELFLoaderFixture::create(_fbb, &ELFLoaderFixtureArgs{
      metadata,
      input,
      output,
    })
  }
}
}  // pub mod v2
}  // pub mod sealevel
}  // pub mod solana
}  // pub mod org