ArmControlState_generated.h

Go to the documentation of this file.

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

#ifndef FLATBUFFERS_GENERATED_ARMCONTROLSTATE_GRL_FLATBUFFER_H_
#define FLATBUFFERS_GENERATED_ARMCONTROLSTATE_GRL_FLATBUFFER_H_

#include "flatbuffers/flatbuffers.h"

#include "Geometry_generated.h"
#include "JointState_generated.h"

namespace grl {
namespace flatbuffer {
struct JointState;
}  // namespace flatbuffer
}  // namespace grl
namespace grl {
namespace flatbuffer {
struct Vector3d;
struct Quaternion;
struct Pose;
struct Wrench;
struct Inertia;
}  // namespace flatbuffer
}  // namespace grl

namespace grl {
namespace flatbuffer {

struct StartArm;
struct StopArm;
struct PauseArm;
struct TeachArm;
struct ShutdownArm;
struct MoveArmTrajectory;
struct MoveArmJointServo;
struct MoveArmCartesianServo;
struct ArmControlState;
struct ArmControlSeries;

enum ArmState {
  ArmState_NONE = 0,
  ArmState_StartArm = 1,
  ArmState_StopArm = 2,
  ArmState_PauseArm = 3,
  ArmState_ShutdownArm = 4,
  ArmState_TeachArm = 5,
  ArmState_MoveArmTrajectory = 6,
  ArmState_MoveArmJointServo = 7,
  ArmState_MoveArmCartesianServo = 8
};

inline const char **EnumNamesArmState() {
  static const char *names[] = { "NONE", "StartArm", "StopArm", "PauseArm", "ShutdownArm", "TeachArm", "MoveArmTrajectory", "MoveArmJointServo", "MoveArmCartesianServo", nullptr };
  return names;
}

inline const char *EnumNameArmState(ArmState e) { return EnumNamesArmState()[static_cast<int>(e)]; }

inline bool VerifyArmState(flatbuffers::Verifier &verifier, const void *union_obj, ArmState type);

struct StartArm FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct StartArmBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  StartArmBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  StartArmBuilder &operator=(const StartArmBuilder &);
  flatbuffers::Offset<StartArm> Finish() {
    auto o = flatbuffers::Offset<StartArm>(fbb_.EndTable(start_, 0));
    return o;
  }
};

inline flatbuffers::Offset<StartArm> CreateStartArm(flatbuffers::FlatBufferBuilder &_fbb) {
  StartArmBuilder builder_(_fbb);
  return builder_.Finish();
}

struct StopArm FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct StopArmBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  StopArmBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  StopArmBuilder &operator=(const StopArmBuilder &);
  flatbuffers::Offset<StopArm> Finish() {
    auto o = flatbuffers::Offset<StopArm>(fbb_.EndTable(start_, 0));
    return o;
  }
};

inline flatbuffers::Offset<StopArm> CreateStopArm(flatbuffers::FlatBufferBuilder &_fbb) {
  StopArmBuilder builder_(_fbb);
  return builder_.Finish();
}

struct PauseArm FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct PauseArmBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  PauseArmBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  PauseArmBuilder &operator=(const PauseArmBuilder &);
  flatbuffers::Offset<PauseArm> Finish() {
    auto o = flatbuffers::Offset<PauseArm>(fbb_.EndTable(start_, 0));
    return o;
  }
};

inline flatbuffers::Offset<PauseArm> CreatePauseArm(flatbuffers::FlatBufferBuilder &_fbb) {
  PauseArmBuilder builder_(_fbb);
  return builder_.Finish();
}

struct TeachArm FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct TeachArmBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  TeachArmBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  TeachArmBuilder &operator=(const TeachArmBuilder &);
  flatbuffers::Offset<TeachArm> Finish() {
    auto o = flatbuffers::Offset<TeachArm>(fbb_.EndTable(start_, 0));
    return o;
  }
};

inline flatbuffers::Offset<TeachArm> CreateTeachArm(flatbuffers::FlatBufferBuilder &_fbb) {
  TeachArmBuilder builder_(_fbb);
  return builder_.Finish();
}

struct ShutdownArm FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};

struct ShutdownArmBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  ShutdownArmBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ShutdownArmBuilder &operator=(const ShutdownArmBuilder &);
  flatbuffers::Offset<ShutdownArm> Finish() {
    auto o = flatbuffers::Offset<ShutdownArm>(fbb_.EndTable(start_, 0));
    return o;
  }
};

inline flatbuffers::Offset<ShutdownArm> CreateShutdownArm(flatbuffers::FlatBufferBuilder &_fbb) {
  ShutdownArmBuilder builder_(_fbb);
  return builder_.Finish();
}

struct MoveArmTrajectory FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const flatbuffers::Vector<flatbuffers::Offset<grl::flatbuffer::JointState>> *traj() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<grl::flatbuffer::JointState>> *>(4); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* traj */) &&
           verifier.Verify(traj()) &&
           verifier.VerifyVectorOfTables(traj()) &&
           verifier.EndTable();
  }
};

struct MoveArmTrajectoryBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_traj(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<grl::flatbuffer::JointState>>> traj) { fbb_.AddOffset(4, traj); }
  MoveArmTrajectoryBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  MoveArmTrajectoryBuilder &operator=(const MoveArmTrajectoryBuilder &);
  flatbuffers::Offset<MoveArmTrajectory> Finish() {
    auto o = flatbuffers::Offset<MoveArmTrajectory>(fbb_.EndTable(start_, 1));
    return o;
  }
};

inline flatbuffers::Offset<MoveArmTrajectory> CreateMoveArmTrajectory(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<grl::flatbuffer::JointState>>> traj = 0) {
  MoveArmTrajectoryBuilder builder_(_fbb);
  builder_.add_traj(traj);
  return builder_.Finish();
}

struct MoveArmJointServo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const grl::flatbuffer::JointState *goal() const { return GetPointer<const grl::flatbuffer::JointState *>(4); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* goal */) &&
           verifier.VerifyTable(goal()) &&
           verifier.EndTable();
  }
};

struct MoveArmJointServoBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_goal(flatbuffers::Offset<grl::flatbuffer::JointState> goal) { fbb_.AddOffset(4, goal); }
  MoveArmJointServoBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  MoveArmJointServoBuilder &operator=(const MoveArmJointServoBuilder &);
  flatbuffers::Offset<MoveArmJointServo> Finish() {
    auto o = flatbuffers::Offset<MoveArmJointServo>(fbb_.EndTable(start_, 1));
    return o;
  }
};

inline flatbuffers::Offset<MoveArmJointServo> CreateMoveArmJointServo(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<grl::flatbuffer::JointState> goal = 0) {
  MoveArmJointServoBuilder builder_(_fbb);
  builder_.add_goal(goal);
  return builder_.Finish();
}

struct MoveArmCartesianServo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const flatbuffers::String *parent() const { return GetPointer<const flatbuffers::String *>(4); }
  const grl::flatbuffer::Pose *goal() const { return GetStruct<const grl::flatbuffer::Pose *>(6); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* parent */) &&
           verifier.Verify(parent()) &&
           VerifyField<grl::flatbuffer::Pose>(verifier, 6 /* goal */) &&
           verifier.EndTable();
  }
};

struct MoveArmCartesianServoBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_parent(flatbuffers::Offset<flatbuffers::String> parent) { fbb_.AddOffset(4, parent); }
  void add_goal(const grl::flatbuffer::Pose *goal) { fbb_.AddStruct(6, goal); }
  MoveArmCartesianServoBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  MoveArmCartesianServoBuilder &operator=(const MoveArmCartesianServoBuilder &);
  flatbuffers::Offset<MoveArmCartesianServo> Finish() {
    auto o = flatbuffers::Offset<MoveArmCartesianServo>(fbb_.EndTable(start_, 2));
    return o;
  }
};

inline flatbuffers::Offset<MoveArmCartesianServo> CreateMoveArmCartesianServo(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> parent = 0,
   const grl::flatbuffer::Pose *goal = 0) {
  MoveArmCartesianServoBuilder builder_(_fbb);
  builder_.add_goal(goal);
  builder_.add_parent(parent);
  return builder_.Finish();
}

struct ArmControlState FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(4); }
  int64_t sequenceNumber() const { return GetField<int64_t>(6, 0); }
  double timeStamp() const { return GetField<double>(8, 0); }
  ArmState state_type() const { return static_cast<ArmState>(GetField<uint8_t>(10, 0)); }
  const void *state() const { return GetPointer<const void *>(12); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* name */) &&
           verifier.Verify(name()) &&
           VerifyField<int64_t>(verifier, 6 /* sequenceNumber */) &&
           VerifyField<double>(verifier, 8 /* timeStamp */) &&
           VerifyField<uint8_t>(verifier, 10 /* state_type */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* state */) &&
           VerifyArmState(verifier, state(), state_type()) &&
           verifier.EndTable();
  }
};

struct ArmControlStateBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(4, name); }
  void add_sequenceNumber(int64_t sequenceNumber) { fbb_.AddElement<int64_t>(6, sequenceNumber, 0); }
  void add_timeStamp(double timeStamp) { fbb_.AddElement<double>(8, timeStamp, 0); }
  void add_state_type(ArmState state_type) { fbb_.AddElement<uint8_t>(10, static_cast<uint8_t>(state_type), 0); }
  void add_state(flatbuffers::Offset<void> state) { fbb_.AddOffset(12, state); }
  ArmControlStateBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ArmControlStateBuilder &operator=(const ArmControlStateBuilder &);
  flatbuffers::Offset<ArmControlState> Finish() {
    auto o = flatbuffers::Offset<ArmControlState>(fbb_.EndTable(start_, 5));
    return o;
  }
};

inline flatbuffers::Offset<ArmControlState> CreateArmControlState(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> name = 0,
   int64_t sequenceNumber = 0,
   double timeStamp = 0,
   ArmState state_type = ArmState_NONE,
   flatbuffers::Offset<void> state = 0) {
  ArmControlStateBuilder builder_(_fbb);
  builder_.add_timeStamp(timeStamp);
  builder_.add_sequenceNumber(sequenceNumber);
  builder_.add_state(state);
  builder_.add_name(name);
  builder_.add_state_type(state_type);
  return builder_.Finish();
}

struct ArmControlSeries FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const flatbuffers::Vector<flatbuffers::Offset<ArmControlState>> *states() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<ArmControlState>> *>(4); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* states */) &&
           verifier.Verify(states()) &&
           verifier.VerifyVectorOfTables(states()) &&
           verifier.EndTable();
  }
};

struct ArmControlSeriesBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_states(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ArmControlState>>> states) { fbb_.AddOffset(4, states); }
  ArmControlSeriesBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ArmControlSeriesBuilder &operator=(const ArmControlSeriesBuilder &);
  flatbuffers::Offset<ArmControlSeries> Finish() {
    auto o = flatbuffers::Offset<ArmControlSeries>(fbb_.EndTable(start_, 1));
    return o;
  }
};

inline flatbuffers::Offset<ArmControlSeries> CreateArmControlSeries(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ArmControlState>>> states = 0) {
  ArmControlSeriesBuilder builder_(_fbb);
  builder_.add_states(states);
  return builder_.Finish();
}

inline bool VerifyArmState(flatbuffers::Verifier &verifier, const void *union_obj, ArmState type) {
  switch (type) {
    case ArmState_NONE: return true;
    case ArmState_StartArm: return verifier.VerifyTable(reinterpret_cast<const StartArm *>(union_obj));
    case ArmState_StopArm: return verifier.VerifyTable(reinterpret_cast<const StopArm *>(union_obj));
    case ArmState_PauseArm: return verifier.VerifyTable(reinterpret_cast<const PauseArm *>(union_obj));
    case ArmState_ShutdownArm: return verifier.VerifyTable(reinterpret_cast<const ShutdownArm *>(union_obj));
    case ArmState_TeachArm: return verifier.VerifyTable(reinterpret_cast<const TeachArm *>(union_obj));
    case ArmState_MoveArmTrajectory: return verifier.VerifyTable(reinterpret_cast<const MoveArmTrajectory *>(union_obj));
    case ArmState_MoveArmJointServo: return verifier.VerifyTable(reinterpret_cast<const MoveArmJointServo *>(union_obj));
    case ArmState_MoveArmCartesianServo: return verifier.VerifyTable(reinterpret_cast<const MoveArmCartesianServo *>(union_obj));
    default: return false;
  }
}

inline const grl::flatbuffer::ArmControlSeries *GetArmControlSeries(const void *buf) { return flatbuffers::GetRoot<grl::flatbuffer::ArmControlSeries>(buf); }

inline bool VerifyArmControlSeriesBuffer(flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer<grl::flatbuffer::ArmControlSeries>(); }

inline const char *ArmControlSeriesIdentifier() { return "armc"; }

inline bool ArmControlSeriesBufferHasIdentifier(const void *buf) { return flatbuffers::BufferHasIdentifier(buf, ArmControlSeriesIdentifier()); }

inline const char *ArmControlSeriesExtension() { return "armc"; }

inline void FinishArmControlSeriesBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset<grl::flatbuffer::ArmControlSeries> root) { fbb.Finish(root, ArmControlSeriesIdentifier()); }

}  // namespace flatbuffer
}  // namespace grl

#endif  // FLATBUFFERS_GENERATED_ARMCONTROLSTATE_GRL_FLATBUFFER_H_