KUKAiiwa_generated.h

Go to the documentation of this file.

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

#ifndef FLATBUFFERS_GENERATED_KUKAIIWA_GRL_FLATBUFFER_H_
#define FLATBUFFERS_GENERATED_KUKAIIWA_GRL_FLATBUFFER_H_

#include "flatbuffers/flatbuffers.h"

#include "ArmControlState_generated.h"
#include "Euler_generated.h"
#include "Geometry_generated.h"
#include "JointState_generated.h"
#include "LinkObject_generated.h"

namespace grl {
namespace flatbuffer {
struct Vector3d;
struct Quaternion;
struct Pose;
struct Wrench;
struct Inertia;
}  // namespace flatbuffer
}  // namespace grl
namespace grl {
namespace flatbuffer {
struct LinkObject;
}  // namespace flatbuffer
}  // namespace grl
namespace grl {
namespace flatbuffer {
struct JointState;
}  // namespace flatbuffer
}  // namespace grl
namespace grl {
namespace flatbuffer {
struct EulerXYZd;
struct EulerRotation;
struct EulerPose;
struct EulerTranslationParams;
struct EulerRotationParams;
struct EulerPoseParams;
}  // 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;
}  // namespace flatbuffer
}  // namespace grl

namespace grl {
namespace flatbuffer {

struct CartesianImpedenceControlMode;
struct JointImpedenceControlMode;
struct Disabled;
struct FRI;
struct SmartServo;
struct ProcessData;
struct KUKAiiwaArmConfiguration;
struct KUKAiiwaMonitorConfiguration;
struct KUKAiiwaMonitorState;
struct KUKAiiwaState;
struct KUKAiiwaStates;

enum KUKAiiwaInterface {
  KUKAiiwaInterface_Disabled = 0,
  KUKAiiwaInterface_SmartServo = 1,
  KUKAiiwaInterface_DirectServo = 2,
  KUKAiiwaInterface_FRI = 3
};

inline const char **EnumNamesKUKAiiwaInterface() {
  static const char *names[] = { "Disabled", "SmartServo", "DirectServo", "FRI", nullptr };
  return names;
}

inline const char *EnumNameKUKAiiwaInterface(KUKAiiwaInterface e) { return EnumNamesKUKAiiwaInterface()[static_cast<int>(e)]; }

enum ESessionState {
  /// No session
  ESessionState_IDLE = 0,
  /// Monitoring mode, receive state but connection too inconsistent to command
  ESessionState_MONITORING_WAIT = 1,
  /// Monitoring mode 
  ESessionState_MONITORING_READY = 2,
  /// About to command (Overlay created in Java interface)
  ESessionState_COMMANDING_WAIT = 3,
  /// Actively commanding the arm with FRI
  ESessionState_COMMANDING_ACTIVE = 4
};

inline const char **EnumNamesESessionState() {
  static const char *names[] = { "IDLE", "MONITORING_WAIT", "MONITORING_READY", "COMMANDING_WAIT", "COMMANDING_ACTIVE", nullptr };
  return names;
}

inline const char *EnumNameESessionState(ESessionState e) { return EnumNamesESessionState()[static_cast<int>(e)]; }

enum EConnectionQuality {
  EConnectionQuality_POOR = 0,
  EConnectionQuality_FAIR = 1,
  EConnectionQuality_GOOD = 2,
  EConnectionQuality_EXCELLENT = 3
};

inline const char **EnumNamesEConnectionQuality() {
  static const char *names[] = { "POOR", "FAIR", "GOOD", "EXCELLENT", nullptr };
  return names;
}

inline const char *EnumNameEConnectionQuality(EConnectionQuality e) { return EnumNamesEConnectionQuality()[static_cast<int>(e)]; }

enum ESafetyState {
  ESafetyState_NORMAL_OPERATION = 0,
  ESafetyState_SAFETY_STOP_LEVEL_0 = 1,
  ESafetyState_SAFETY_STOP_LEVEL_1 = 2,
  ESafetyState_SAFETY_STOP_LEVEL_2 = 3
};

inline const char **EnumNamesESafetyState() {
  static const char *names[] = { "NORMAL_OPERATION", "SAFETY_STOP_LEVEL_0", "SAFETY_STOP_LEVEL_1", "SAFETY_STOP_LEVEL_2", nullptr };
  return names;
}

inline const char *EnumNameESafetyState(ESafetyState e) { return EnumNamesESafetyState()[static_cast<int>(e)]; }

enum EOperationMode {
  EOperationMode_TEST_MODE_1 = 0,
  EOperationMode_TEST_MODE_2 = 1,
  EOperationMode_AUTOMATIC_MODE = 2
};

inline const char **EnumNamesEOperationMode() {
  static const char *names[] = { "TEST_MODE_1", "TEST_MODE_2", "AUTOMATIC_MODE", nullptr };
  return names;
}

inline const char *EnumNameEOperationMode(EOperationMode e) { return EnumNamesEOperationMode()[static_cast<int>(e)]; }

enum EDriveState {
  /// Driving mode currently unused
  EDriveState_OFF = 1,
  /// About to drive
  EDriveState_TRANSITIONING = 2,
  /// Actively commanding arm
  EDriveState_ACTIVE = 3
};

inline const char **EnumNamesEDriveState() {
  static const char *names[] = { "OFF", "TRANSITIONING", "ACTIVE", nullptr };
  return names;
}

inline const char *EnumNameEDriveState(EDriveState e) { return EnumNamesEDriveState()[static_cast<int>(e) - static_cast<int>(EDriveState_OFF)]; }

enum EControlMode {
  EControlMode_POSITION_CONTROL_MODE = 0,
  EControlMode_CART_IMP_CONTROL_MODE = 1,
  EControlMode_JOINT_IMP_CONTROL_MODE = 2,
  EControlMode_NO_CONTROL = 3
};

inline const char **EnumNamesEControlMode() {
  static const char *names[] = { "POSITION_CONTROL_MODE", "CART_IMP_CONTROL_MODE", "JOINT_IMP_CONTROL_MODE", "NO_CONTROL", nullptr };
  return names;
}

inline const char *EnumNameEControlMode(EControlMode e) { return EnumNamesEControlMode()[static_cast<int>(e)]; }

/// Type of command being sent to the arm (Dimensonal units)
enum EClientCommandMode {
  EClientCommandMode_NO_COMMAND_MODE = 0,
  EClientCommandMode_POSITION = 1,
  EClientCommandMode_WRENCH = 2,
  EClientCommandMode_TORQUE = 3
};

inline const char **EnumNamesEClientCommandMode() {
  static const char *names[] = { "NO_COMMAND_MODE", "POSITION", "WRENCH", "TORQUE", nullptr };
  return names;
}

inline const char *EnumNameEClientCommandMode(EClientCommandMode e) { return EnumNamesEClientCommandMode()[static_cast<int>(e)]; }

enum EOverlayType {
  EOverlayType_NO_OVERLAY = 0,
  EOverlayType_JOINT = 1,
  EOverlayType_CARTESIAN = 2
};

inline const char **EnumNamesEOverlayType() {
  static const char *names[] = { "NO_OVERLAY", "JOINT", "CARTESIAN", nullptr };
  return names;
}

inline const char *EnumNameEOverlayType(EOverlayType e) { return EnumNamesEOverlayType()[static_cast<int>(e)]; }

struct CartesianImpedenceControlMode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  /// actual stiffness to set rot:[nm/rad]
  const grl::flatbuffer::EulerPoseParams *stiffness() const { return GetPointer<const grl::flatbuffer::EulerPoseParams *>(4); }
  /// maximum deviation from set goal in mm and radians
  const grl::flatbuffer::EulerPose *maxPathDeviation() const { return GetStruct<const grl::flatbuffer::EulerPose *>(6); }
  /// sets the maximum joint speed
  const flatbuffers::Vector<double> *maxJointSpeed() const { return GetPointer<const flatbuffers::Vector<double> *>(8); }
  /// trans: [mm/s] rot: [rad/s]
  const grl::flatbuffer::EulerPose *maxCartesianVelocity() const { return GetStruct<const grl::flatbuffer::EulerPose *>(10); }
  /// xyz: Newtons rpy:Nm (all >=0)
  const grl::flatbuffer::EulerPose *maxControlForce() const { return GetStruct<const grl::flatbuffer::EulerPose *>(12); }
  /// stop if max control force is exceeded
  uint8_t maxControlForceExceededStop() const { return GetField<uint8_t>(14, 0); }
  /// must be between 0.3-1.0 suggested is 0.7
  double nullspaceDamping() const { return GetField<double>(16, 0); }
  /// [Nm/rad] must be => 0.0
  double nullspaceStiffness() const { return GetField<double>(18, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* stiffness */) &&
           verifier.VerifyTable(stiffness()) &&
           VerifyField<grl::flatbuffer::EulerPose>(verifier, 6 /* maxPathDeviation */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* maxJointSpeed */) &&
           verifier.Verify(maxJointSpeed()) &&
           VerifyField<grl::flatbuffer::EulerPose>(verifier, 10 /* maxCartesianVelocity */) &&
           VerifyField<grl::flatbuffer::EulerPose>(verifier, 12 /* maxControlForce */) &&
           VerifyField<uint8_t>(verifier, 14 /* maxControlForceExceededStop */) &&
           VerifyField<double>(verifier, 16 /* nullspaceDamping */) &&
           VerifyField<double>(verifier, 18 /* nullspaceStiffness */) &&
           verifier.EndTable();
  }
};

struct CartesianImpedenceControlModeBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_stiffness(flatbuffers::Offset<grl::flatbuffer::EulerPoseParams> stiffness) { fbb_.AddOffset(4, stiffness); }
  void add_maxPathDeviation(const grl::flatbuffer::EulerPose *maxPathDeviation) { fbb_.AddStruct(6, maxPathDeviation); }
  void add_maxJointSpeed(flatbuffers::Offset<flatbuffers::Vector<double>> maxJointSpeed) { fbb_.AddOffset(8, maxJointSpeed); }
  void add_maxCartesianVelocity(const grl::flatbuffer::EulerPose *maxCartesianVelocity) { fbb_.AddStruct(10, maxCartesianVelocity); }
  void add_maxControlForce(const grl::flatbuffer::EulerPose *maxControlForce) { fbb_.AddStruct(12, maxControlForce); }
  void add_maxControlForceExceededStop(uint8_t maxControlForceExceededStop) { fbb_.AddElement<uint8_t>(14, maxControlForceExceededStop, 0); }
  void add_nullspaceDamping(double nullspaceDamping) { fbb_.AddElement<double>(16, nullspaceDamping, 0); }
  void add_nullspaceStiffness(double nullspaceStiffness) { fbb_.AddElement<double>(18, nullspaceStiffness, 0); }
  CartesianImpedenceControlModeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  CartesianImpedenceControlModeBuilder &operator=(const CartesianImpedenceControlModeBuilder &);
  flatbuffers::Offset<CartesianImpedenceControlMode> Finish() {
    auto o = flatbuffers::Offset<CartesianImpedenceControlMode>(fbb_.EndTable(start_, 8));
    return o;
  }
};

inline flatbuffers::Offset<CartesianImpedenceControlMode> CreateCartesianImpedenceControlMode(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<grl::flatbuffer::EulerPoseParams> stiffness = 0,
   const grl::flatbuffer::EulerPose *maxPathDeviation = 0,
   flatbuffers::Offset<flatbuffers::Vector<double>> maxJointSpeed = 0,
   const grl::flatbuffer::EulerPose *maxCartesianVelocity = 0,
   const grl::flatbuffer::EulerPose *maxControlForce = 0,
   uint8_t maxControlForceExceededStop = 0,
   double nullspaceDamping = 0,
   double nullspaceStiffness = 0) {
  CartesianImpedenceControlModeBuilder builder_(_fbb);
  builder_.add_nullspaceStiffness(nullspaceStiffness);
  builder_.add_nullspaceDamping(nullspaceDamping);
  builder_.add_maxControlForce(maxControlForce);
  builder_.add_maxCartesianVelocity(maxCartesianVelocity);
  builder_.add_maxJointSpeed(maxJointSpeed);
  builder_.add_maxPathDeviation(maxPathDeviation);
  builder_.add_stiffness(stiffness);
  builder_.add_maxControlForceExceededStop(maxControlForceExceededStop);
  return builder_.Finish();
}

struct JointImpedenceControlMode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const flatbuffers::Vector<double> *stiffness() const { return GetPointer<const flatbuffers::Vector<double> *>(4); }
  const flatbuffers::Vector<double> *damping() const { return GetPointer<const flatbuffers::Vector<double> *>(6); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* stiffness */) &&
           verifier.Verify(stiffness()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* damping */) &&
           verifier.Verify(damping()) &&
           verifier.EndTable();
  }
};

struct JointImpedenceControlModeBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_stiffness(flatbuffers::Offset<flatbuffers::Vector<double>> stiffness) { fbb_.AddOffset(4, stiffness); }
  void add_damping(flatbuffers::Offset<flatbuffers::Vector<double>> damping) { fbb_.AddOffset(6, damping); }
  JointImpedenceControlModeBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  JointImpedenceControlModeBuilder &operator=(const JointImpedenceControlModeBuilder &);
  flatbuffers::Offset<JointImpedenceControlMode> Finish() {
    auto o = flatbuffers::Offset<JointImpedenceControlMode>(fbb_.EndTable(start_, 2));
    return o;
  }
};

inline flatbuffers::Offset<JointImpedenceControlMode> CreateJointImpedenceControlMode(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::Vector<double>> stiffness = 0,
   flatbuffers::Offset<flatbuffers::Vector<double>> damping = 0) {
  JointImpedenceControlModeBuilder builder_(_fbb);
  builder_.add_damping(damping);
  builder_.add_stiffness(stiffness);
  return builder_.Finish();
}

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

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

inline flatbuffers::Offset<Disabled> CreateDisabled(flatbuffers::FlatBufferBuilder &_fbb) {
  DisabledBuilder builder_(_fbb);
  return builder_.Finish();
}

struct FRI FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  EOverlayType overlayType() const { return static_cast<EOverlayType>(GetField<int8_t>(4, 1)); }
  /// Set the value for the send period of the connection from the KUKA controller to the remote side in [ms]. 
  /// This means, the KUKA controller will send cyclic FRI messages every sendPeriod milliseconds to the remote side. 
  /// 
  /// 
  /// Parameters:
  /// sendPeriod - the send period in milliseconds, 1 <= sendPeriod <= 100. 
  /// Note: The recommended value for good performance should be between 1-5 milliseconds. 
  int32_t sendPeriodMillisec() const { return GetField<int32_t>(6, 4); }
  /// Set the receive multiplier of the cycle time from the remote side to the KUKA controller. 
  /// This multiplier defines the value of the receivePeriod which is calculated:
  /// receivePeriod = receiveMultiplier * sendPeriod 
  /// 
  /// The KUKA controller will expect a FRI response message every receivePeriod milliseconds from the remote side. 
  /// 
  /// The receivePeriod has to be within the range of:
  /// 1 <= receivePeriod <= 100. 
  int32_t setReceiveMultiplier() const { return GetField<int32_t>(8, 5); }
  uint8_t updatePortOnRemote() const { return GetField<uint8_t>(10, 0); }
  /// Set the port ID of the socket at the controller side. 
  /// Note: Do not change this port ID, unless your application requires different port IDs on both ends of the FRI channel.
  /// For changing the FRI port ID on both sides, it is sufficient to call setPortOnRemote(int). 
  /// Values of controllerPortID:  
  /// "-1" - The configuration of setPortOnRemote(int) is used. This is the default. 
  /// recommended range of port IDs: 30200 <= controllerPortID < 30210
  int16_t portOnRemote() const { return GetField<int16_t>(12, 0); }
  uint8_t updatePortOnController() const { return GetField<uint8_t>(14, 0); }
  ///  Set the port ID of the FRI channel at the remote side. 
  ///  By default, this port ID is used on both sides of the FRI channel, unless specified otherwise by setPortOnController(int). 
  ///
  ///  Values of portID: 
  ///
  ///  default port ID: 30200 
  ///  recommended range of port IDs: 30200 <= portID < 30210 
  ///  Since the FRI channel utilizes UDP as connection layer, make sure, that your network topology (firewall, network services) are chosen accordingly. 
  ///
  ///  Parameters:
  ///  portID - the port ID > 0 (also known as UDP port number)
  int16_t portOnController() const { return GetField<int16_t>(16, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int8_t>(verifier, 4 /* overlayType */) &&
           VerifyField<int32_t>(verifier, 6 /* sendPeriodMillisec */) &&
           VerifyField<int32_t>(verifier, 8 /* setReceiveMultiplier */) &&
           VerifyField<uint8_t>(verifier, 10 /* updatePortOnRemote */) &&
           VerifyField<int16_t>(verifier, 12 /* portOnRemote */) &&
           VerifyField<uint8_t>(verifier, 14 /* updatePortOnController */) &&
           VerifyField<int16_t>(verifier, 16 /* portOnController */) &&
           verifier.EndTable();
  }
};

struct FRIBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_overlayType(EOverlayType overlayType) { fbb_.AddElement<int8_t>(4, static_cast<int8_t>(overlayType), 1); }
  void add_sendPeriodMillisec(int32_t sendPeriodMillisec) { fbb_.AddElement<int32_t>(6, sendPeriodMillisec, 4); }
  void add_setReceiveMultiplier(int32_t setReceiveMultiplier) { fbb_.AddElement<int32_t>(8, setReceiveMultiplier, 5); }
  void add_updatePortOnRemote(uint8_t updatePortOnRemote) { fbb_.AddElement<uint8_t>(10, updatePortOnRemote, 0); }
  void add_portOnRemote(int16_t portOnRemote) { fbb_.AddElement<int16_t>(12, portOnRemote, 0); }
  void add_updatePortOnController(uint8_t updatePortOnController) { fbb_.AddElement<uint8_t>(14, updatePortOnController, 0); }
  void add_portOnController(int16_t portOnController) { fbb_.AddElement<int16_t>(16, portOnController, 0); }
  FRIBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  FRIBuilder &operator=(const FRIBuilder &);
  flatbuffers::Offset<FRI> Finish() {
    auto o = flatbuffers::Offset<FRI>(fbb_.EndTable(start_, 7));
    return o;
  }
};

inline flatbuffers::Offset<FRI> CreateFRI(flatbuffers::FlatBufferBuilder &_fbb,
   EOverlayType overlayType = EOverlayType_JOINT,
   int32_t sendPeriodMillisec = 4,
   int32_t setReceiveMultiplier = 5,
   uint8_t updatePortOnRemote = 0,
   int16_t portOnRemote = 0,
   uint8_t updatePortOnController = 0,
   int16_t portOnController = 0) {
  FRIBuilder builder_(_fbb);
  builder_.add_setReceiveMultiplier(setReceiveMultiplier);
  builder_.add_sendPeriodMillisec(sendPeriodMillisec);
  builder_.add_portOnController(portOnController);
  builder_.add_portOnRemote(portOnRemote);
  builder_.add_updatePortOnController(updatePortOnController);
  builder_.add_updatePortOnRemote(updatePortOnRemote);
  builder_.add_overlayType(overlayType);
  return builder_.Finish();
}

struct SmartServo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  /// normalized joint accelerations from 0 to 1 relative to system capabilities
  const flatbuffers::Vector<double> *jointAccelerationRel() const { return GetPointer<const flatbuffers::Vector<double> *>(4); }
  /// normalized joint velocity from 0 to 1 relative to system capabilities
  const flatbuffers::Vector<double> *jointVelocityRel() const { return GetPointer<const flatbuffers::Vector<double> *>(6); }
  uint8_t updateMinimumTrajectoryExecutionTime() const { return GetField<uint8_t>(8, 0); }
  double minimumTrajectoryExecutionTime() const { return GetField<double>(10, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* jointAccelerationRel */) &&
           verifier.Verify(jointAccelerationRel()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* jointVelocityRel */) &&
           verifier.Verify(jointVelocityRel()) &&
           VerifyField<uint8_t>(verifier, 8 /* updateMinimumTrajectoryExecutionTime */) &&
           VerifyField<double>(verifier, 10 /* minimumTrajectoryExecutionTime */) &&
           verifier.EndTable();
  }
};

struct SmartServoBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_jointAccelerationRel(flatbuffers::Offset<flatbuffers::Vector<double>> jointAccelerationRel) { fbb_.AddOffset(4, jointAccelerationRel); }
  void add_jointVelocityRel(flatbuffers::Offset<flatbuffers::Vector<double>> jointVelocityRel) { fbb_.AddOffset(6, jointVelocityRel); }
  void add_updateMinimumTrajectoryExecutionTime(uint8_t updateMinimumTrajectoryExecutionTime) { fbb_.AddElement<uint8_t>(8, updateMinimumTrajectoryExecutionTime, 0); }
  void add_minimumTrajectoryExecutionTime(double minimumTrajectoryExecutionTime) { fbb_.AddElement<double>(10, minimumTrajectoryExecutionTime, 0); }
  SmartServoBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  SmartServoBuilder &operator=(const SmartServoBuilder &);
  flatbuffers::Offset<SmartServo> Finish() {
    auto o = flatbuffers::Offset<SmartServo>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<SmartServo> CreateSmartServo(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::Vector<double>> jointAccelerationRel = 0,
   flatbuffers::Offset<flatbuffers::Vector<double>> jointVelocityRel = 0,
   uint8_t updateMinimumTrajectoryExecutionTime = 0,
   double minimumTrajectoryExecutionTime = 0) {
  SmartServoBuilder builder_(_fbb);
  builder_.add_minimumTrajectoryExecutionTime(minimumTrajectoryExecutionTime);
  builder_.add_jointVelocityRel(jointVelocityRel);
  builder_.add_jointAccelerationRel(jointAccelerationRel);
  builder_.add_updateMinimumTrajectoryExecutionTime(updateMinimumTrajectoryExecutionTime);
  return builder_.Finish();
}

/// "ProcessData" is a field that appears 
/// on your physical kuka tablet. 
/// This message allows you to update these
/// fields on the tablet yourself.
struct ProcessData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const flatbuffers::String *dataType() const { return GetPointer<const flatbuffers::String *>(4); }
  const flatbuffers::String *defaultValue() const { return GetPointer<const flatbuffers::String *>(6); }
  const flatbuffers::String *displayName() const { return GetPointer<const flatbuffers::String *>(8); }
  const flatbuffers::String *id() const { return GetPointer<const flatbuffers::String *>(10); }
  const flatbuffers::String *min() const { return GetPointer<const flatbuffers::String *>(12); }
  const flatbuffers::String *max() const { return GetPointer<const flatbuffers::String *>(14); }
  const flatbuffers::String *unit() const { return GetPointer<const flatbuffers::String *>(16); }
  const flatbuffers::String *value() const { return GetPointer<const flatbuffers::String *>(18); }
  /// should the data be removed completely?
  uint8_t shouldRemove() const { return GetField<uint8_t>(20, 0); }
  /// should the data be updated to these values? 
  uint8_t shouldUpdate() const { return GetField<uint8_t>(22, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* dataType */) &&
           verifier.Verify(dataType()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* defaultValue */) &&
           verifier.Verify(defaultValue()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* displayName */) &&
           verifier.Verify(displayName()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* id */) &&
           verifier.Verify(id()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* min */) &&
           verifier.Verify(min()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* max */) &&
           verifier.Verify(max()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 16 /* unit */) &&
           verifier.Verify(unit()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 18 /* value */) &&
           verifier.Verify(value()) &&
           VerifyField<uint8_t>(verifier, 20 /* shouldRemove */) &&
           VerifyField<uint8_t>(verifier, 22 /* shouldUpdate */) &&
           verifier.EndTable();
  }
};

struct ProcessDataBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_dataType(flatbuffers::Offset<flatbuffers::String> dataType) { fbb_.AddOffset(4, dataType); }
  void add_defaultValue(flatbuffers::Offset<flatbuffers::String> defaultValue) { fbb_.AddOffset(6, defaultValue); }
  void add_displayName(flatbuffers::Offset<flatbuffers::String> displayName) { fbb_.AddOffset(8, displayName); }
  void add_id(flatbuffers::Offset<flatbuffers::String> id) { fbb_.AddOffset(10, id); }
  void add_min(flatbuffers::Offset<flatbuffers::String> min) { fbb_.AddOffset(12, min); }
  void add_max(flatbuffers::Offset<flatbuffers::String> max) { fbb_.AddOffset(14, max); }
  void add_unit(flatbuffers::Offset<flatbuffers::String> unit) { fbb_.AddOffset(16, unit); }
  void add_value(flatbuffers::Offset<flatbuffers::String> value) { fbb_.AddOffset(18, value); }
  void add_shouldRemove(uint8_t shouldRemove) { fbb_.AddElement<uint8_t>(20, shouldRemove, 0); }
  void add_shouldUpdate(uint8_t shouldUpdate) { fbb_.AddElement<uint8_t>(22, shouldUpdate, 0); }
  ProcessDataBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  ProcessDataBuilder &operator=(const ProcessDataBuilder &);
  flatbuffers::Offset<ProcessData> Finish() {
    auto o = flatbuffers::Offset<ProcessData>(fbb_.EndTable(start_, 10));
    return o;
  }
};

inline flatbuffers::Offset<ProcessData> CreateProcessData(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> dataType = 0,
   flatbuffers::Offset<flatbuffers::String> defaultValue = 0,
   flatbuffers::Offset<flatbuffers::String> displayName = 0,
   flatbuffers::Offset<flatbuffers::String> id = 0,
   flatbuffers::Offset<flatbuffers::String> min = 0,
   flatbuffers::Offset<flatbuffers::String> max = 0,
   flatbuffers::Offset<flatbuffers::String> unit = 0,
   flatbuffers::Offset<flatbuffers::String> value = 0,
   uint8_t shouldRemove = 0,
   uint8_t shouldUpdate = 0) {
  ProcessDataBuilder builder_(_fbb);
  builder_.add_value(value);
  builder_.add_unit(unit);
  builder_.add_max(max);
  builder_.add_min(min);
  builder_.add_id(id);
  builder_.add_displayName(displayName);
  builder_.add_defaultValue(defaultValue);
  builder_.add_dataType(dataType);
  builder_.add_shouldUpdate(shouldUpdate);
  builder_.add_shouldRemove(shouldRemove);
  return builder_.Finish();
}

struct KUKAiiwaArmConfiguration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(4); }
  /// how commands will be sent to robot
  KUKAiiwaInterface commandInterface() const { return static_cast<KUKAiiwaInterface>(GetField<int8_t>(6, 0)); }
  /// how robot state will be sent to driver
  KUKAiiwaInterface monitorInterface() const { return static_cast<KUKAiiwaInterface>(GetField<int8_t>(8, 0)); }
  /// motion command mode: cartesian, wrench, torque commands
  EClientCommandMode clientCommandMode() const { return static_cast<EClientCommandMode>(GetField<int8_t>(10, 0)); }
  /// The type of commands FRI will use: cartesian, joint
  EOverlayType overlayType() const { return static_cast<EOverlayType>(GetField<int8_t>(12, 0)); }
  /// position, cartesian impedence, or joint impedence low level controller adjustments   
  EControlMode controlMode() const { return static_cast<EControlMode>(GetField<int8_t>(14, 0)); }
  const SmartServo *smartServoConfig() const { return GetPointer<const SmartServo *>(16); }
  const FRI *FRIConfig() const { return GetPointer<const FRI *>(18); }
  const flatbuffers::Vector<flatbuffers::Offset<grl::flatbuffer::LinkObject>> *tools() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<grl::flatbuffer::LinkObject>> *>(20); }
  /// set kuka tablet "processData" panel UI config strings
  const flatbuffers::Vector<flatbuffers::Offset<ProcessData>> *processData() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<ProcessData>> *>(22); }
  const flatbuffers::String *currentMotionCenter() const { return GetPointer<const flatbuffers::String *>(24); }
  uint8_t requestMonitorProcessData() const { return GetField<uint8_t>(26, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* name */) &&
           verifier.Verify(name()) &&
           VerifyField<int8_t>(verifier, 6 /* commandInterface */) &&
           VerifyField<int8_t>(verifier, 8 /* monitorInterface */) &&
           VerifyField<int8_t>(verifier, 10 /* clientCommandMode */) &&
           VerifyField<int8_t>(verifier, 12 /* overlayType */) &&
           VerifyField<int8_t>(verifier, 14 /* controlMode */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 16 /* smartServoConfig */) &&
           verifier.VerifyTable(smartServoConfig()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 18 /* FRIConfig */) &&
           verifier.VerifyTable(FRIConfig()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 20 /* tools */) &&
           verifier.Verify(tools()) &&
           verifier.VerifyVectorOfTables(tools()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 22 /* processData */) &&
           verifier.Verify(processData()) &&
           verifier.VerifyVectorOfTables(processData()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 24 /* currentMotionCenter */) &&
           verifier.Verify(currentMotionCenter()) &&
           VerifyField<uint8_t>(verifier, 26 /* requestMonitorProcessData */) &&
           verifier.EndTable();
  }
};

struct KUKAiiwaArmConfigurationBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(4, name); }
  void add_commandInterface(KUKAiiwaInterface commandInterface) { fbb_.AddElement<int8_t>(6, static_cast<int8_t>(commandInterface), 0); }
  void add_monitorInterface(KUKAiiwaInterface monitorInterface) { fbb_.AddElement<int8_t>(8, static_cast<int8_t>(monitorInterface), 0); }
  void add_clientCommandMode(EClientCommandMode clientCommandMode) { fbb_.AddElement<int8_t>(10, static_cast<int8_t>(clientCommandMode), 0); }
  void add_overlayType(EOverlayType overlayType) { fbb_.AddElement<int8_t>(12, static_cast<int8_t>(overlayType), 0); }
  void add_controlMode(EControlMode controlMode) { fbb_.AddElement<int8_t>(14, static_cast<int8_t>(controlMode), 0); }
  void add_smartServoConfig(flatbuffers::Offset<SmartServo> smartServoConfig) { fbb_.AddOffset(16, smartServoConfig); }
  void add_FRIConfig(flatbuffers::Offset<FRI> FRIConfig) { fbb_.AddOffset(18, FRIConfig); }
  void add_tools(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<grl::flatbuffer::LinkObject>>> tools) { fbb_.AddOffset(20, tools); }
  void add_processData(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ProcessData>>> processData) { fbb_.AddOffset(22, processData); }
  void add_currentMotionCenter(flatbuffers::Offset<flatbuffers::String> currentMotionCenter) { fbb_.AddOffset(24, currentMotionCenter); }
  void add_requestMonitorProcessData(uint8_t requestMonitorProcessData) { fbb_.AddElement<uint8_t>(26, requestMonitorProcessData, 0); }
  KUKAiiwaArmConfigurationBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  KUKAiiwaArmConfigurationBuilder &operator=(const KUKAiiwaArmConfigurationBuilder &);
  flatbuffers::Offset<KUKAiiwaArmConfiguration> Finish() {
    auto o = flatbuffers::Offset<KUKAiiwaArmConfiguration>(fbb_.EndTable(start_, 12));
    return o;
  }
};

inline flatbuffers::Offset<KUKAiiwaArmConfiguration> CreateKUKAiiwaArmConfiguration(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> name = 0,
   KUKAiiwaInterface commandInterface = KUKAiiwaInterface_Disabled,
   KUKAiiwaInterface monitorInterface = KUKAiiwaInterface_Disabled,
   EClientCommandMode clientCommandMode = EClientCommandMode_NO_COMMAND_MODE,
   EOverlayType overlayType = EOverlayType_NO_OVERLAY,
   EControlMode controlMode = EControlMode_POSITION_CONTROL_MODE,
   flatbuffers::Offset<SmartServo> smartServoConfig = 0,
   flatbuffers::Offset<FRI> FRIConfig = 0,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<grl::flatbuffer::LinkObject>>> tools = 0,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ProcessData>>> processData = 0,
   flatbuffers::Offset<flatbuffers::String> currentMotionCenter = 0,
   uint8_t requestMonitorProcessData = 0) {
  KUKAiiwaArmConfigurationBuilder builder_(_fbb);
  builder_.add_currentMotionCenter(currentMotionCenter);
  builder_.add_processData(processData);
  builder_.add_tools(tools);
  builder_.add_FRIConfig(FRIConfig);
  builder_.add_smartServoConfig(smartServoConfig);
  builder_.add_name(name);
  builder_.add_requestMonitorProcessData(requestMonitorProcessData);
  builder_.add_controlMode(controlMode);
  builder_.add_overlayType(overlayType);
  builder_.add_clientCommandMode(clientCommandMode);
  builder_.add_monitorInterface(monitorInterface);
  builder_.add_commandInterface(commandInterface);
  return builder_.Finish();
}

struct KUKAiiwaMonitorConfiguration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const flatbuffers::String *hardwareVersion() const { return GetPointer<const flatbuffers::String *>(4); }
  const flatbuffers::Vector<double> *torqueSensorLimits() const { return GetPointer<const flatbuffers::Vector<double> *>(6); }
  uint8_t isReadyToMove() const { return GetField<uint8_t>(8, 0); }
  uint8_t isMastered() const { return GetField<uint8_t>(10, 0); }
  /// set kuka tablet "processData" panel UI config strings
  const flatbuffers::Vector<flatbuffers::Offset<ProcessData>> *processData() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<ProcessData>> *>(12); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* hardwareVersion */) &&
           verifier.Verify(hardwareVersion()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* torqueSensorLimits */) &&
           verifier.Verify(torqueSensorLimits()) &&
           VerifyField<uint8_t>(verifier, 8 /* isReadyToMove */) &&
           VerifyField<uint8_t>(verifier, 10 /* isMastered */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* processData */) &&
           verifier.Verify(processData()) &&
           verifier.VerifyVectorOfTables(processData()) &&
           verifier.EndTable();
  }
};

struct KUKAiiwaMonitorConfigurationBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_hardwareVersion(flatbuffers::Offset<flatbuffers::String> hardwareVersion) { fbb_.AddOffset(4, hardwareVersion); }
  void add_torqueSensorLimits(flatbuffers::Offset<flatbuffers::Vector<double>> torqueSensorLimits) { fbb_.AddOffset(6, torqueSensorLimits); }
  void add_isReadyToMove(uint8_t isReadyToMove) { fbb_.AddElement<uint8_t>(8, isReadyToMove, 0); }
  void add_isMastered(uint8_t isMastered) { fbb_.AddElement<uint8_t>(10, isMastered, 0); }
  void add_processData(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ProcessData>>> processData) { fbb_.AddOffset(12, processData); }
  KUKAiiwaMonitorConfigurationBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  KUKAiiwaMonitorConfigurationBuilder &operator=(const KUKAiiwaMonitorConfigurationBuilder &);
  flatbuffers::Offset<KUKAiiwaMonitorConfiguration> Finish() {
    auto o = flatbuffers::Offset<KUKAiiwaMonitorConfiguration>(fbb_.EndTable(start_, 5));
    return o;
  }
};

inline flatbuffers::Offset<KUKAiiwaMonitorConfiguration> CreateKUKAiiwaMonitorConfiguration(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> hardwareVersion = 0,
   flatbuffers::Offset<flatbuffers::Vector<double>> torqueSensorLimits = 0,
   uint8_t isReadyToMove = 0,
   uint8_t isMastered = 0,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ProcessData>>> processData = 0) {
  KUKAiiwaMonitorConfigurationBuilder builder_(_fbb);
  builder_.add_processData(processData);
  builder_.add_torqueSensorLimits(torqueSensorLimits);
  builder_.add_hardwareVersion(hardwareVersion);
  builder_.add_isMastered(isMastered);
  builder_.add_isReadyToMove(isReadyToMove);
  return builder_.Finish();
}

struct KUKAiiwaMonitorState FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const grl::flatbuffer::JointState *measuredState() const { return GetPointer<const grl::flatbuffer::JointState *>(4); }
  const grl::flatbuffer::Pose *cartesianFlangePose() const { return GetStruct<const grl::flatbuffer::Pose *>(6); }
  const grl::flatbuffer::JointState *jointStateReal() const { return GetPointer<const grl::flatbuffer::JointState *>(8); }
  /// FRI can adjust the java commanded position. "Interpolated" is the original Java commanded position.
  const grl::flatbuffer::JointState *jointStateInterpolated() const { return GetPointer<const grl::flatbuffer::JointState *>(10); }
  /// The state of the arm as calculated by kuka after 
  /// subtracting the known weights of the arm
  /// and any attachments configured to be present.
  ///
  /// Most likely only contains torque.
  const grl::flatbuffer::JointState *externalState() const { return GetPointer<const grl::flatbuffer::JointState *>(12); }
  EOperationMode operationMode() const { return static_cast<EOperationMode>(GetField<int8_t>(14, 0)); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* measuredState */) &&
           verifier.VerifyTable(measuredState()) &&
           VerifyField<grl::flatbuffer::Pose>(verifier, 6 /* cartesianFlangePose */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* jointStateReal */) &&
           verifier.VerifyTable(jointStateReal()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* jointStateInterpolated */) &&
           verifier.VerifyTable(jointStateInterpolated()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 12 /* externalState */) &&
           verifier.VerifyTable(externalState()) &&
           VerifyField<int8_t>(verifier, 14 /* operationMode */) &&
           verifier.EndTable();
  }
};

struct KUKAiiwaMonitorStateBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_measuredState(flatbuffers::Offset<grl::flatbuffer::JointState> measuredState) { fbb_.AddOffset(4, measuredState); }
  void add_cartesianFlangePose(const grl::flatbuffer::Pose *cartesianFlangePose) { fbb_.AddStruct(6, cartesianFlangePose); }
  void add_jointStateReal(flatbuffers::Offset<grl::flatbuffer::JointState> jointStateReal) { fbb_.AddOffset(8, jointStateReal); }
  void add_jointStateInterpolated(flatbuffers::Offset<grl::flatbuffer::JointState> jointStateInterpolated) { fbb_.AddOffset(10, jointStateInterpolated); }
  void add_externalState(flatbuffers::Offset<grl::flatbuffer::JointState> externalState) { fbb_.AddOffset(12, externalState); }
  void add_operationMode(EOperationMode operationMode) { fbb_.AddElement<int8_t>(14, static_cast<int8_t>(operationMode), 0); }
  KUKAiiwaMonitorStateBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  KUKAiiwaMonitorStateBuilder &operator=(const KUKAiiwaMonitorStateBuilder &);
  flatbuffers::Offset<KUKAiiwaMonitorState> Finish() {
    auto o = flatbuffers::Offset<KUKAiiwaMonitorState>(fbb_.EndTable(start_, 6));
    return o;
  }
};

inline flatbuffers::Offset<KUKAiiwaMonitorState> CreateKUKAiiwaMonitorState(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<grl::flatbuffer::JointState> measuredState = 0,
   const grl::flatbuffer::Pose *cartesianFlangePose = 0,
   flatbuffers::Offset<grl::flatbuffer::JointState> jointStateReal = 0,
   flatbuffers::Offset<grl::flatbuffer::JointState> jointStateInterpolated = 0,
   flatbuffers::Offset<grl::flatbuffer::JointState> externalState = 0,
   EOperationMode operationMode = EOperationMode_TEST_MODE_1) {
  KUKAiiwaMonitorStateBuilder builder_(_fbb);
  builder_.add_externalState(externalState);
  builder_.add_jointStateInterpolated(jointStateInterpolated);
  builder_.add_jointStateReal(jointStateReal);
  builder_.add_cartesianFlangePose(cartesianFlangePose);
  builder_.add_measuredState(measuredState);
  builder_.add_operationMode(operationMode);
  return builder_.Finish();
}

struct KUKAiiwaState FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(4); }
  const flatbuffers::String *destination() const { return GetPointer<const flatbuffers::String *>(6); }
  const flatbuffers::String *source() const { return GetPointer<const flatbuffers::String *>(8); }
  double timestamp() const { return GetField<double>(10, 0); }
  uint8_t setArmControlState() const { return GetField<uint8_t>(12, 0); }
  const grl::flatbuffer::ArmControlState *armControlState() const { return GetPointer<const grl::flatbuffer::ArmControlState *>(14); }
  uint8_t setArmConfiguration() const { return GetField<uint8_t>(16, 0); }
  const KUKAiiwaArmConfiguration *armConfiguration() const { return GetPointer<const KUKAiiwaArmConfiguration *>(18); }
  uint8_t hasMonitorState() const { return GetField<uint8_t>(20, 0); }
  const KUKAiiwaMonitorState *monitorState() const { return GetPointer<const KUKAiiwaMonitorState *>(22); }
  uint8_t hasMonitorConfig() const { return GetField<uint8_t>(24, 0); }
  const KUKAiiwaMonitorConfiguration *monitorConfig() const { return GetPointer<const KUKAiiwaMonitorConfiguration *>(26); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* name */) &&
           verifier.Verify(name()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 6 /* destination */) &&
           verifier.Verify(destination()) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 8 /* source */) &&
           verifier.Verify(source()) &&
           VerifyField<double>(verifier, 10 /* timestamp */) &&
           VerifyField<uint8_t>(verifier, 12 /* setArmControlState */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* armControlState */) &&
           verifier.VerifyTable(armControlState()) &&
           VerifyField<uint8_t>(verifier, 16 /* setArmConfiguration */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 18 /* armConfiguration */) &&
           verifier.VerifyTable(armConfiguration()) &&
           VerifyField<uint8_t>(verifier, 20 /* hasMonitorState */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 22 /* monitorState */) &&
           verifier.VerifyTable(monitorState()) &&
           VerifyField<uint8_t>(verifier, 24 /* hasMonitorConfig */) &&
           VerifyField<flatbuffers::uoffset_t>(verifier, 26 /* monitorConfig */) &&
           verifier.VerifyTable(monitorConfig()) &&
           verifier.EndTable();
  }
};

struct KUKAiiwaStateBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(4, name); }
  void add_destination(flatbuffers::Offset<flatbuffers::String> destination) { fbb_.AddOffset(6, destination); }
  void add_source(flatbuffers::Offset<flatbuffers::String> source) { fbb_.AddOffset(8, source); }
  void add_timestamp(double timestamp) { fbb_.AddElement<double>(10, timestamp, 0); }
  void add_setArmControlState(uint8_t setArmControlState) { fbb_.AddElement<uint8_t>(12, setArmControlState, 0); }
  void add_armControlState(flatbuffers::Offset<grl::flatbuffer::ArmControlState> armControlState) { fbb_.AddOffset(14, armControlState); }
  void add_setArmConfiguration(uint8_t setArmConfiguration) { fbb_.AddElement<uint8_t>(16, setArmConfiguration, 0); }
  void add_armConfiguration(flatbuffers::Offset<KUKAiiwaArmConfiguration> armConfiguration) { fbb_.AddOffset(18, armConfiguration); }
  void add_hasMonitorState(uint8_t hasMonitorState) { fbb_.AddElement<uint8_t>(20, hasMonitorState, 0); }
  void add_monitorState(flatbuffers::Offset<KUKAiiwaMonitorState> monitorState) { fbb_.AddOffset(22, monitorState); }
  void add_hasMonitorConfig(uint8_t hasMonitorConfig) { fbb_.AddElement<uint8_t>(24, hasMonitorConfig, 0); }
  void add_monitorConfig(flatbuffers::Offset<KUKAiiwaMonitorConfiguration> monitorConfig) { fbb_.AddOffset(26, monitorConfig); }
  KUKAiiwaStateBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  KUKAiiwaStateBuilder &operator=(const KUKAiiwaStateBuilder &);
  flatbuffers::Offset<KUKAiiwaState> Finish() {
    auto o = flatbuffers::Offset<KUKAiiwaState>(fbb_.EndTable(start_, 12));
    return o;
  }
};

inline flatbuffers::Offset<KUKAiiwaState> CreateKUKAiiwaState(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::String> name = 0,
   flatbuffers::Offset<flatbuffers::String> destination = 0,
   flatbuffers::Offset<flatbuffers::String> source = 0,
   double timestamp = 0,
   uint8_t setArmControlState = 0,
   flatbuffers::Offset<grl::flatbuffer::ArmControlState> armControlState = 0,
   uint8_t setArmConfiguration = 0,
   flatbuffers::Offset<KUKAiiwaArmConfiguration> armConfiguration = 0,
   uint8_t hasMonitorState = 0,
   flatbuffers::Offset<KUKAiiwaMonitorState> monitorState = 0,
   uint8_t hasMonitorConfig = 0,
   flatbuffers::Offset<KUKAiiwaMonitorConfiguration> monitorConfig = 0) {
  KUKAiiwaStateBuilder builder_(_fbb);
  builder_.add_timestamp(timestamp);
  builder_.add_monitorConfig(monitorConfig);
  builder_.add_monitorState(monitorState);
  builder_.add_armConfiguration(armConfiguration);
  builder_.add_armControlState(armControlState);
  builder_.add_source(source);
  builder_.add_destination(destination);
  builder_.add_name(name);
  builder_.add_hasMonitorConfig(hasMonitorConfig);
  builder_.add_hasMonitorState(hasMonitorState);
  builder_.add_setArmConfiguration(setArmConfiguration);
  builder_.add_setArmControlState(setArmControlState);
  return builder_.Finish();
}

struct KUKAiiwaStates FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const flatbuffers::Vector<flatbuffers::Offset<KUKAiiwaState>> *states() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<KUKAiiwaState>> *>(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 KUKAiiwaStatesBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_states(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KUKAiiwaState>>> states) { fbb_.AddOffset(4, states); }
  KUKAiiwaStatesBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  KUKAiiwaStatesBuilder &operator=(const KUKAiiwaStatesBuilder &);
  flatbuffers::Offset<KUKAiiwaStates> Finish() {
    auto o = flatbuffers::Offset<KUKAiiwaStates>(fbb_.EndTable(start_, 1));
    return o;
  }
};

inline flatbuffers::Offset<KUKAiiwaStates> CreateKUKAiiwaStates(flatbuffers::FlatBufferBuilder &_fbb,
   flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KUKAiiwaState>>> states = 0) {
  KUKAiiwaStatesBuilder builder_(_fbb);
  builder_.add_states(states);
  return builder_.Finish();
}

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

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

inline const char *KUKAiiwaStatesIdentifier() { return "iiwa"; }

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

inline const char *KUKAiiwaStatesExtension() { return "iiwa"; }

inline void FinishKUKAiiwaStatesBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset<grl::flatbuffer::KUKAiiwaStates> root) { fbb.Finish(root, KUKAiiwaStatesIdentifier()); }

}  // namespace flatbuffer
}  // namespace grl

#endif  // FLATBUFFERS_GENERATED_KUKAIIWA_GRL_FLATBUFFER_H_