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_ATMOSPHERE_MODEL: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_ATMOSPHERE_MODEL: i8 = 4;
#[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_ATMOSPHERE_MODEL: [AtmosphereModel; 5] = [
  AtmosphereModel::ISA,
  AtmosphereModel::US_STD_1976,
  AtmosphereModel::NRLMSISE_00,
  AtmosphereModel::SIMPLE,
  AtmosphereModel::CUSTOM,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct AtmosphereModel(pub i8);
#[allow(non_upper_case_globals)]
impl AtmosphereModel {
  pub const ISA: Self = Self(0);
  pub const US_STD_1976: Self = Self(1);
  pub const NRLMSISE_00: Self = Self(2);
  pub const SIMPLE: Self = Self(3);
  pub const CUSTOM: Self = Self(4);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 4;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::ISA,
    Self::US_STD_1976,
    Self::NRLMSISE_00,
    Self::SIMPLE,
    Self::CUSTOM,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::ISA => Some("ISA"),
      Self::US_STD_1976 => Some("US_STD_1976"),
      Self::NRLMSISE_00 => Some("NRLMSISE_00"),
      Self::SIMPLE => Some("SIMPLE"),
      Self::CUSTOM => Some("CUSTOM"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for AtmosphereModel {
  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 AtmosphereModel {
  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 AtmosphereModel {
    type Output = AtmosphereModel;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        flatbuffers::emplace_scalar::<i8>(dst, self.0);
    }
}

impl flatbuffers::EndianScalar for AtmosphereModel {
  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 AtmosphereModel {
  #[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 AtmosphereModel {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_WEATHER_CONDITION: i8 = 0;
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MAX_WEATHER_CONDITION: i8 = 15;
#[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_WEATHER_CONDITION: [WeatherCondition; 16] = [
  WeatherCondition::CLEAR,
  WeatherCondition::FEW_CLOUDS,
  WeatherCondition::SCATTERED,
  WeatherCondition::BROKEN,
  WeatherCondition::OVERCAST,
  WeatherCondition::RAIN_LIGHT,
  WeatherCondition::RAIN_MODERATE,
  WeatherCondition::RAIN_HEAVY,
  WeatherCondition::SNOW_LIGHT,
  WeatherCondition::SNOW_MODERATE,
  WeatherCondition::SNOW_HEAVY,
  WeatherCondition::FOG,
  WeatherCondition::MIST,
  WeatherCondition::HAZE,
  WeatherCondition::THUNDERSTORM,
  WeatherCondition::SANDSTORM,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct WeatherCondition(pub i8);
#[allow(non_upper_case_globals)]
impl WeatherCondition {
  pub const CLEAR: Self = Self(0);
  pub const FEW_CLOUDS: Self = Self(1);
  pub const SCATTERED: Self = Self(2);
  pub const BROKEN: Self = Self(3);
  pub const OVERCAST: Self = Self(4);
  pub const RAIN_LIGHT: Self = Self(5);
  pub const RAIN_MODERATE: Self = Self(6);
  pub const RAIN_HEAVY: Self = Self(7);
  pub const SNOW_LIGHT: Self = Self(8);
  pub const SNOW_MODERATE: Self = Self(9);
  pub const SNOW_HEAVY: Self = Self(10);
  pub const FOG: Self = Self(11);
  pub const MIST: Self = Self(12);
  pub const HAZE: Self = Self(13);
  pub const THUNDERSTORM: Self = Self(14);
  pub const SANDSTORM: Self = Self(15);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 15;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::CLEAR,
    Self::FEW_CLOUDS,
    Self::SCATTERED,
    Self::BROKEN,
    Self::OVERCAST,
    Self::RAIN_LIGHT,
    Self::RAIN_MODERATE,
    Self::RAIN_HEAVY,
    Self::SNOW_LIGHT,
    Self::SNOW_MODERATE,
    Self::SNOW_HEAVY,
    Self::FOG,
    Self::MIST,
    Self::HAZE,
    Self::THUNDERSTORM,
    Self::SANDSTORM,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::CLEAR => Some("CLEAR"),
      Self::FEW_CLOUDS => Some("FEW_CLOUDS"),
      Self::SCATTERED => Some("SCATTERED"),
      Self::BROKEN => Some("BROKEN"),
      Self::OVERCAST => Some("OVERCAST"),
      Self::RAIN_LIGHT => Some("RAIN_LIGHT"),
      Self::RAIN_MODERATE => Some("RAIN_MODERATE"),
      Self::RAIN_HEAVY => Some("RAIN_HEAVY"),
      Self::SNOW_LIGHT => Some("SNOW_LIGHT"),
      Self::SNOW_MODERATE => Some("SNOW_MODERATE"),
      Self::SNOW_HEAVY => Some("SNOW_HEAVY"),
      Self::FOG => Some("FOG"),
      Self::MIST => Some("MIST"),
      Self::HAZE => Some("HAZE"),
      Self::THUNDERSTORM => Some("THUNDERSTORM"),
      Self::SANDSTORM => Some("SANDSTORM"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for WeatherCondition {
  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 WeatherCondition {
  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 WeatherCondition {
    type Output = WeatherCondition;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        flatbuffers::emplace_scalar::<i8>(dst, self.0);
    }
}

impl flatbuffers::EndianScalar for WeatherCondition {
  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 WeatherCondition {
  #[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 WeatherCondition {}
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
pub const ENUM_MIN_TERRAIN_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_TERRAIN_TYPE: i8 = 11;
#[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_TERRAIN_TYPE: [TerrainType; 12] = [
  TerrainType::OCEAN,
  TerrainType::WATER_FRESH,
  TerrainType::SAND,
  TerrainType::GRASS,
  TerrainType::FOREST,
  TerrainType::CONCRETE,
  TerrainType::ASPHALT,
  TerrainType::SNOW,
  TerrainType::ICE,
  TerrainType::ROCK,
  TerrainType::MARSH,
  TerrainType::URBAN,
];

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
#[repr(transparent)]
pub struct TerrainType(pub i8);
#[allow(non_upper_case_globals)]
impl TerrainType {
  pub const OCEAN: Self = Self(0);
  pub const WATER_FRESH: Self = Self(1);
  pub const SAND: Self = Self(2);
  pub const GRASS: Self = Self(3);
  pub const FOREST: Self = Self(4);
  pub const CONCRETE: Self = Self(5);
  pub const ASPHALT: Self = Self(6);
  pub const SNOW: Self = Self(7);
  pub const ICE: Self = Self(8);
  pub const ROCK: Self = Self(9);
  pub const MARSH: Self = Self(10);
  pub const URBAN: Self = Self(11);

  pub const ENUM_MIN: i8 = 0;
  pub const ENUM_MAX: i8 = 11;
  pub const ENUM_VALUES: &'static [Self] = &[
    Self::OCEAN,
    Self::WATER_FRESH,
    Self::SAND,
    Self::GRASS,
    Self::FOREST,
    Self::CONCRETE,
    Self::ASPHALT,
    Self::SNOW,
    Self::ICE,
    Self::ROCK,
    Self::MARSH,
    Self::URBAN,
  ];
  /// Returns the variant's name or "" if unknown.
  pub fn variant_name(self) -> Option<&'static str> {
    match self {
      Self::OCEAN => Some("OCEAN"),
      Self::WATER_FRESH => Some("WATER_FRESH"),
      Self::SAND => Some("SAND"),
      Self::GRASS => Some("GRASS"),
      Self::FOREST => Some("FOREST"),
      Self::CONCRETE => Some("CONCRETE"),
      Self::ASPHALT => Some("ASPHALT"),
      Self::SNOW => Some("SNOW"),
      Self::ICE => Some("ICE"),
      Self::ROCK => Some("ROCK"),
      Self::MARSH => Some("MARSH"),
      Self::URBAN => Some("URBAN"),
      _ => None,
    }
  }
}
impl core::fmt::Debug for TerrainType {
  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 TerrainType {
  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 TerrainType {
    type Output = TerrainType;
    #[inline]
    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
        flatbuffers::emplace_scalar::<i8>(dst, self.0);
    }
}

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

/// Atmosphere and Environment
pub struct ENV<'a> {
  pub _tab: flatbuffers::Table<'a>,
}

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

impl<'a> ENV<'a> {
  pub const VT_ATMOSPHERE: flatbuffers::VOffsetT = 4;
  pub const VT_WEATHER: flatbuffers::VOffsetT = 6;
  pub const VT_TIME_UTC: flatbuffers::VOffsetT = 8;
  pub const VT_LATITUDE: flatbuffers::VOffsetT = 10;
  pub const VT_LONGITUDE: flatbuffers::VOffsetT = 12;
  pub const VT_SUN_AZIMUTH: flatbuffers::VOffsetT = 14;
  pub const VT_SUN_ELEVATION: flatbuffers::VOffsetT = 16;
  pub const VT_MOON_PHASE: flatbuffers::VOffsetT = 18;
  pub const VT_ILLUMINATION: flatbuffers::VOffsetT = 20;
  pub const VT_MAGNETIC_DECLINATION: flatbuffers::VOffsetT = 22;
  pub const VT_MAGNETIC_INCLINATION: flatbuffers::VOffsetT = 24;
  pub const VT_RESERVED: flatbuffers::VOffsetT = 26;

  #[inline]
  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
    ENV { _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 ENVArgs<'args>
  ) -> flatbuffers::WIPOffset<ENV<'bldr>> {
    let mut builder = ENVBuilder::new(_fbb);
    builder.add_LONGITUDE(args.LONGITUDE);
    builder.add_LATITUDE(args.LATITUDE);
    builder.add_TIME_UTC(args.TIME_UTC);
    if let Some(x) = args.RESERVED { builder.add_RESERVED(x); }
    builder.add_MAGNETIC_INCLINATION(args.MAGNETIC_INCLINATION);
    builder.add_MAGNETIC_DECLINATION(args.MAGNETIC_DECLINATION);
    builder.add_ILLUMINATION(args.ILLUMINATION);
    builder.add_MOON_PHASE(args.MOON_PHASE);
    builder.add_SUN_ELEVATION(args.SUN_ELEVATION);
    builder.add_SUN_AZIMUTH(args.SUN_AZIMUTH);
    if let Some(x) = args.WEATHER { builder.add_WEATHER(x); }
    if let Some(x) = args.ATMOSPHERE { builder.add_ATMOSPHERE(x); }
    builder.finish()
  }

  pub fn unpack(&self) -> ENVT {
    let ATMOSPHERE = self.ATMOSPHERE().map(|x| {
      x.to_string()
    });
    let WEATHER = self.WEATHER().map(|x| {
      x.to_string()
    });
    let TIME_UTC = self.TIME_UTC();
    let LATITUDE = self.LATITUDE();
    let LONGITUDE = self.LONGITUDE();
    let SUN_AZIMUTH = self.SUN_AZIMUTH();
    let SUN_ELEVATION = self.SUN_ELEVATION();
    let MOON_PHASE = self.MOON_PHASE();
    let ILLUMINATION = self.ILLUMINATION();
    let MAGNETIC_DECLINATION = self.MAGNETIC_DECLINATION();
    let MAGNETIC_INCLINATION = self.MAGNETIC_INCLINATION();
    let RESERVED = self.RESERVED().map(|x| {
      x.into_iter().collect()
    });
    ENVT {
      ATMOSPHERE,
      WEATHER,
      TIME_UTC,
      LATITUDE,
      LONGITUDE,
      SUN_AZIMUTH,
      SUN_ELEVATION,
      MOON_PHASE,
      ILLUMINATION,
      MAGNETIC_DECLINATION,
      MAGNETIC_INCLINATION,
      RESERVED,
    }
  }

  #[inline]
  pub fn ATMOSPHERE(&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>>(ENV::VT_ATMOSPHERE, None)}
  }
  #[inline]
  pub fn WEATHER(&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>>(ENV::VT_WEATHER, None)}
  }
  #[inline]
  pub fn TIME_UTC(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ENV::VT_TIME_UTC, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn LATITUDE(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ENV::VT_LATITUDE, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn LONGITUDE(&self) -> f64 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f64>(ENV::VT_LONGITUDE, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn SUN_AZIMUTH(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(ENV::VT_SUN_AZIMUTH, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn SUN_ELEVATION(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(ENV::VT_SUN_ELEVATION, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn MOON_PHASE(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(ENV::VT_MOON_PHASE, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn ILLUMINATION(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(ENV::VT_ILLUMINATION, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn MAGNETIC_DECLINATION(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(ENV::VT_MAGNETIC_DECLINATION, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn MAGNETIC_INCLINATION(&self) -> f32 {
    // Safety:
    // Created from valid Table for this object
    // which contains a valid value in this slot
    unsafe { self._tab.get::<f32>(ENV::VT_MAGNETIC_INCLINATION, Some(0.0)).unwrap()}
  }
  #[inline]
  pub fn RESERVED(&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>>>(ENV::VT_RESERVED, None)}
  }
}

impl flatbuffers::Verifiable for ENV<'_> {
  #[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>>("ATMOSPHERE", Self::VT_ATMOSPHERE, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<&str>>("WEATHER", Self::VT_WEATHER, false)?
     .visit_field::<f64>("TIME_UTC", Self::VT_TIME_UTC, false)?
     .visit_field::<f64>("LATITUDE", Self::VT_LATITUDE, false)?
     .visit_field::<f64>("LONGITUDE", Self::VT_LONGITUDE, false)?
     .visit_field::<f32>("SUN_AZIMUTH", Self::VT_SUN_AZIMUTH, false)?
     .visit_field::<f32>("SUN_ELEVATION", Self::VT_SUN_ELEVATION, false)?
     .visit_field::<f32>("MOON_PHASE", Self::VT_MOON_PHASE, false)?
     .visit_field::<f32>("ILLUMINATION", Self::VT_ILLUMINATION, false)?
     .visit_field::<f32>("MAGNETIC_DECLINATION", Self::VT_MAGNETIC_DECLINATION, false)?
     .visit_field::<f32>("MAGNETIC_INCLINATION", Self::VT_MAGNETIC_INCLINATION, false)?
     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("RESERVED", Self::VT_RESERVED, false)?
     .finish();
    Ok(())
  }
}
pub struct ENVArgs<'a> {
    pub ATMOSPHERE: Option<flatbuffers::WIPOffset<&'a str>>,
    pub WEATHER: Option<flatbuffers::WIPOffset<&'a str>>,
    pub TIME_UTC: f64,
    pub LATITUDE: f64,
    pub LONGITUDE: f64,
    pub SUN_AZIMUTH: f32,
    pub SUN_ELEVATION: f32,
    pub MOON_PHASE: f32,
    pub ILLUMINATION: f32,
    pub MAGNETIC_DECLINATION: f32,
    pub MAGNETIC_INCLINATION: f32,
    pub RESERVED: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
}
impl<'a> Default for ENVArgs<'a> {
  #[inline]
  fn default() -> Self {
    ENVArgs {
      ATMOSPHERE: None,
      WEATHER: None,
      TIME_UTC: 0.0,
      LATITUDE: 0.0,
      LONGITUDE: 0.0,
      SUN_AZIMUTH: 0.0,
      SUN_ELEVATION: 0.0,
      MOON_PHASE: 0.0,
      ILLUMINATION: 0.0,
      MAGNETIC_DECLINATION: 0.0,
      MAGNETIC_INCLINATION: 0.0,
      RESERVED: None,
    }
  }
}

pub struct ENVBuilder<'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> ENVBuilder<'a, 'b, A> {
  #[inline]
  pub fn add_ATMOSPHERE(&mut self, ATMOSPHERE: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ENV::VT_ATMOSPHERE, ATMOSPHERE);
  }
  #[inline]
  pub fn add_WEATHER(&mut self, WEATHER: flatbuffers::WIPOffset<&'b  str>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ENV::VT_WEATHER, WEATHER);
  }
  #[inline]
  pub fn add_TIME_UTC(&mut self, TIME_UTC: f64) {
    self.fbb_.push_slot::<f64>(ENV::VT_TIME_UTC, TIME_UTC, 0.0);
  }
  #[inline]
  pub fn add_LATITUDE(&mut self, LATITUDE: f64) {
    self.fbb_.push_slot::<f64>(ENV::VT_LATITUDE, LATITUDE, 0.0);
  }
  #[inline]
  pub fn add_LONGITUDE(&mut self, LONGITUDE: f64) {
    self.fbb_.push_slot::<f64>(ENV::VT_LONGITUDE, LONGITUDE, 0.0);
  }
  #[inline]
  pub fn add_SUN_AZIMUTH(&mut self, SUN_AZIMUTH: f32) {
    self.fbb_.push_slot::<f32>(ENV::VT_SUN_AZIMUTH, SUN_AZIMUTH, 0.0);
  }
  #[inline]
  pub fn add_SUN_ELEVATION(&mut self, SUN_ELEVATION: f32) {
    self.fbb_.push_slot::<f32>(ENV::VT_SUN_ELEVATION, SUN_ELEVATION, 0.0);
  }
  #[inline]
  pub fn add_MOON_PHASE(&mut self, MOON_PHASE: f32) {
    self.fbb_.push_slot::<f32>(ENV::VT_MOON_PHASE, MOON_PHASE, 0.0);
  }
  #[inline]
  pub fn add_ILLUMINATION(&mut self, ILLUMINATION: f32) {
    self.fbb_.push_slot::<f32>(ENV::VT_ILLUMINATION, ILLUMINATION, 0.0);
  }
  #[inline]
  pub fn add_MAGNETIC_DECLINATION(&mut self, MAGNETIC_DECLINATION: f32) {
    self.fbb_.push_slot::<f32>(ENV::VT_MAGNETIC_DECLINATION, MAGNETIC_DECLINATION, 0.0);
  }
  #[inline]
  pub fn add_MAGNETIC_INCLINATION(&mut self, MAGNETIC_INCLINATION: f32) {
    self.fbb_.push_slot::<f32>(ENV::VT_MAGNETIC_INCLINATION, MAGNETIC_INCLINATION, 0.0);
  }
  #[inline]
  pub fn add_RESERVED(&mut self, RESERVED: flatbuffers::WIPOffset<flatbuffers::Vector<'b , u8>>) {
    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(ENV::VT_RESERVED, RESERVED);
  }
  #[inline]
  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>) -> ENVBuilder<'a, 'b, A> {
    let start = _fbb.start_table();
    ENVBuilder {
      fbb_: _fbb,
      start_: start,
    }
  }
  #[inline]
  pub fn finish(self) -> flatbuffers::WIPOffset<ENV<'a>> {
    let o = self.fbb_.end_table(self.start_);
    flatbuffers::WIPOffset::new(o.value())
  }
}

impl core::fmt::Debug for ENV<'_> {
  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
    let mut ds = f.debug_struct("ENV");
      ds.field("ATMOSPHERE", &self.ATMOSPHERE());
      ds.field("WEATHER", &self.WEATHER());
      ds.field("TIME_UTC", &self.TIME_UTC());
      ds.field("LATITUDE", &self.LATITUDE());
      ds.field("LONGITUDE", &self.LONGITUDE());
      ds.field("SUN_AZIMUTH", &self.SUN_AZIMUTH());
      ds.field("SUN_ELEVATION", &self.SUN_ELEVATION());
      ds.field("MOON_PHASE", &self.MOON_PHASE());
      ds.field("ILLUMINATION", &self.ILLUMINATION());
      ds.field("MAGNETIC_DECLINATION", &self.MAGNETIC_DECLINATION());
      ds.field("MAGNETIC_INCLINATION", &self.MAGNETIC_INCLINATION());
      ds.field("RESERVED", &self.RESERVED());
      ds.finish()
  }
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq)]
pub struct ENVT {
  pub ATMOSPHERE: Option<String>,
  pub WEATHER: Option<String>,
  pub TIME_UTC: f64,
  pub LATITUDE: f64,
  pub LONGITUDE: f64,
  pub SUN_AZIMUTH: f32,
  pub SUN_ELEVATION: f32,
  pub MOON_PHASE: f32,
  pub ILLUMINATION: f32,
  pub MAGNETIC_DECLINATION: f32,
  pub MAGNETIC_INCLINATION: f32,
  pub RESERVED: Option<Vec<u8>>,
}
impl Default for ENVT {
  fn default() -> Self {
    Self {
      ATMOSPHERE: None,
      WEATHER: None,
      TIME_UTC: 0.0,
      LATITUDE: 0.0,
      LONGITUDE: 0.0,
      SUN_AZIMUTH: 0.0,
      SUN_ELEVATION: 0.0,
      MOON_PHASE: 0.0,
      ILLUMINATION: 0.0,
      MAGNETIC_DECLINATION: 0.0,
      MAGNETIC_INCLINATION: 0.0,
      RESERVED: None,
    }
  }
}
impl ENVT {
  pub fn pack<'b, A: flatbuffers::Allocator + 'b>(
    &self,
    _fbb: &mut flatbuffers::FlatBufferBuilder<'b, A>
  ) -> flatbuffers::WIPOffset<ENV<'b>> {
    let ATMOSPHERE = self.ATMOSPHERE.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let WEATHER = self.WEATHER.as_ref().map(|x|{
      _fbb.create_string(x)
    });
    let TIME_UTC = self.TIME_UTC;
    let LATITUDE = self.LATITUDE;
    let LONGITUDE = self.LONGITUDE;
    let SUN_AZIMUTH = self.SUN_AZIMUTH;
    let SUN_ELEVATION = self.SUN_ELEVATION;
    let MOON_PHASE = self.MOON_PHASE;
    let ILLUMINATION = self.ILLUMINATION;
    let MAGNETIC_DECLINATION = self.MAGNETIC_DECLINATION;
    let MAGNETIC_INCLINATION = self.MAGNETIC_INCLINATION;
    let RESERVED = self.RESERVED.as_ref().map(|x|{
      _fbb.create_vector(x)
    });
    ENV::create(_fbb, &ENVArgs{
      ATMOSPHERE,
      WEATHER,
      TIME_UTC,
      LATITUDE,
      LONGITUDE,
      SUN_AZIMUTH,
      SUN_ELEVATION,
      MOON_PHASE,
      ILLUMINATION,
      MAGNETIC_DECLINATION,
      MAGNETIC_INCLINATION,
      RESERVED,
    })
  }
}
#[inline]
/// Verifies that a buffer of bytes contains a `ENV`
/// 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_ENV_unchecked`.
pub fn root_as_ENV(buf: &[u8]) -> Result<ENV, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root::<ENV>(buf)
}
#[inline]
/// Verifies that a buffer of bytes contains a size prefixed
/// `ENV` 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_ENV_unchecked`.
pub fn size_prefixed_root_as_ENV(buf: &[u8]) -> Result<ENV, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root::<ENV>(buf)
}
#[inline]
/// Verifies, with the given options, that a buffer of bytes
/// contains a `ENV` 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_ENV_unchecked`.
pub fn root_as_ENV_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<ENV<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::root_with_opts::<ENV<'b>>(opts, buf)
}
#[inline]
/// Verifies, with the given verifier options, that a buffer of
/// bytes contains a size prefixed `ENV` 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_ENV_unchecked`.
pub fn size_prefixed_root_as_ENV_with_opts<'b, 'o>(
  opts: &'o flatbuffers::VerifierOptions,
  buf: &'b [u8],
) -> Result<ENV<'b>, flatbuffers::InvalidFlatbuffer> {
  flatbuffers::size_prefixed_root_with_opts::<ENV<'b>>(opts, buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a ENV and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid `ENV`.
pub unsafe fn root_as_ENV_unchecked(buf: &[u8]) -> ENV {
  flatbuffers::root_unchecked::<ENV>(buf)
}
#[inline]
/// Assumes, without verification, that a buffer of bytes contains a size prefixed ENV and returns it.
/// # Safety
/// Callers must trust the given bytes do indeed contain a valid size prefixed `ENV`.
pub unsafe fn size_prefixed_root_as_ENV_unchecked(buf: &[u8]) -> ENV {
  flatbuffers::size_prefixed_root_unchecked::<ENV>(buf)
}
pub const ENV_IDENTIFIER: &str = "$ENV";

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

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

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

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