ocam_temps_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_OCAMTEMPS_MAGAOX_LOGGER_H_
#define FLATBUFFERS_GENERATED_OCAMTEMPS_MAGAOX_LOGGER_H_
 
#include "flatbuffers/flatbuffers.h"
 
// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
              FLATBUFFERS_VERSION_MINOR == 5 &&
              FLATBUFFERS_VERSION_REVISION == 26,
             "Non-compatible flatbuffers version included");
 
namespace MagAOX {
namespace logger {
 
struct Ocam_temps_fb;
struct Ocam_temps_fbBuilder;
 
inline const ::flatbuffers::TypeTable *Ocam_temps_fbTypeTable();
 
struct Ocam_temps_fb FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef Ocam_temps_fbBuilder Builder;
  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
    return Ocam_temps_fbTypeTable();
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CCD = 4,
    VT_CPU = 6,
    VT_POWER = 8,
    VT_BIAS = 10,
    VT_WATER = 12,
    VT_LEFT = 14,
    VT_RIGHT = 16,
    VT_COOLING = 18
  };
  float ccd() const {
    return GetField<float>(VT_CCD, 0.0f);
  }
  float cpu() const {
    return GetField<float>(VT_CPU, 0.0f);
  }
  float power() const {
    return GetField<float>(VT_POWER, 0.0f);
  }
  float bias() const {
    return GetField<float>(VT_BIAS, 0.0f);
  }
  float water() const {
    return GetField<float>(VT_WATER, 0.0f);
  }
  float left() const {
    return GetField<float>(VT_LEFT, 0.0f);
  }
  float right() const {
    return GetField<float>(VT_RIGHT, 0.0f);
  }
  float cooling() const {
    return GetField<float>(VT_COOLING, 0.0f);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<float>(verifier, VT_CCD, 4) &&
           VerifyField<float>(verifier, VT_CPU, 4) &&
           VerifyField<float>(verifier, VT_POWER, 4) &&
           VerifyField<float>(verifier, VT_BIAS, 4) &&
           VerifyField<float>(verifier, VT_WATER, 4) &&
           VerifyField<float>(verifier, VT_LEFT, 4) &&
           VerifyField<float>(verifier, VT_RIGHT, 4) &&
           VerifyField<float>(verifier, VT_COOLING, 4) &&
           verifier.EndTable();
  }
};
 
struct Ocam_temps_fbBuilder {
  typedef Ocam_temps_fb Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_ccd(float ccd) {
    fbb_.AddElement<float>(Ocam_temps_fb::VT_CCD, ccd, 0.0f);
  }
  void add_cpu(float cpu) {
    fbb_.AddElement<float>(Ocam_temps_fb::VT_CPU, cpu, 0.0f);
  }
  void add_power(float power) {
    fbb_.AddElement<float>(Ocam_temps_fb::VT_POWER, power, 0.0f);
  }
  void add_bias(float bias) {
    fbb_.AddElement<float>(Ocam_temps_fb::VT_BIAS, bias, 0.0f);
  }
  void add_water(float water) {
    fbb_.AddElement<float>(Ocam_temps_fb::VT_WATER, water, 0.0f);
  }
  void add_left(float left) {
    fbb_.AddElement<float>(Ocam_temps_fb::VT_LEFT, left, 0.0f);
  }
  void add_right(float right) {
    fbb_.AddElement<float>(Ocam_temps_fb::VT_RIGHT, right, 0.0f);
  }
  void add_cooling(float cooling) {
    fbb_.AddElement<float>(Ocam_temps_fb::VT_COOLING, cooling, 0.0f);
  }
  explicit Ocam_temps_fbBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Ocam_temps_fb> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Ocam_temps_fb>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Ocam_temps_fb> CreateOcam_temps_fb(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    float ccd = 0.0f,
    float cpu = 0.0f,
    float power = 0.0f,
    float bias = 0.0f,
    float water = 0.0f,
    float left = 0.0f,
    float right = 0.0f,
    float cooling = 0.0f) {
  Ocam_temps_fbBuilder builder_(_fbb);
  builder_.add_cooling(cooling);
  builder_.add_right(right);
  builder_.add_left(left);
  builder_.add_water(water);
  builder_.add_bias(bias);
  builder_.add_power(power);
  builder_.add_cpu(cpu);
  builder_.add_ccd(ccd);
  return builder_.Finish();
}
 
inline const ::flatbuffers::TypeTable *Ocam_temps_fbTypeTable() {
  static const ::flatbuffers::TypeCode type_codes[] = {
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 },
    { ::flatbuffers::ET_FLOAT, 0, -1 }
  };
  static const char * const names[] = {
    "ccd",
    "cpu",
    "power",
    "bias",
    "water",
    "left",
    "right",
    "cooling"
  };
  static const ::flatbuffers::TypeTable tt = {
    ::flatbuffers::ST_TABLE, 8, type_codes, nullptr, nullptr, nullptr, names
  };
  return &tt;
}
 
inline const MagAOX::logger::Ocam_temps_fb *GetOcam_temps_fb(const void *buf) {
  return ::flatbuffers::GetRoot<MagAOX::logger::Ocam_temps_fb>(buf);
}
 
inline const MagAOX::logger::Ocam_temps_fb *GetSizePrefixedOcam_temps_fb(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<MagAOX::logger::Ocam_temps_fb>(buf);
}
 
inline bool VerifyOcam_temps_fbBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<MagAOX::logger::Ocam_temps_fb>(nullptr);
}
 
inline bool VerifySizePrefixedOcam_temps_fbBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<MagAOX::logger::Ocam_temps_fb>(nullptr);
}
 
inline void FinishOcam_temps_fbBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<MagAOX::logger::Ocam_temps_fb> root) {
  fbb.Finish(root);
}
 
inline void FinishSizePrefixedOcam_temps_fbBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<MagAOX::logger::Ocam_temps_fb> root) {
  fbb.FinishSizePrefixed(root);
}
 
}  // namespace logger
}  // namespace MagAOX
 
#endif  // FLATBUFFERS_GENERATED_OCAMTEMPS_MAGAOX_LOGGER_H_