VrepControlPoint_generated.h

Go to the documentation of this file.

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

#ifndef FLATBUFFERS_GENERATED_VREPCONTROLPOINT_GRL_FLATBUFFER_H_
#define FLATBUFFERS_GENERATED_VREPCONTROLPOINT_GRL_FLATBUFFER_H_

#include "flatbuffers/flatbuffers.h"

#include "Euler_generated.h"
#include "Geometry_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 EulerXYZd;
struct EulerRotation;
struct EulerPose;
struct EulerTranslationParams;
struct EulerRotationParams;
struct EulerPoseParams;
}  // namespace flatbuffer
}  // namespace grl

namespace grl {
namespace flatbuffer {

struct VrepControlPoint;

struct VrepControlPoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const grl::flatbuffer::Vector3d *position() const { return GetStruct<const grl::flatbuffer::Vector3d *>(4); }
  const grl::flatbuffer::EulerXYZd *rotation() const { return GetStruct<const grl::flatbuffer::EulerXYZd *>(6); }
  double relativeVelocity() const { return GetField<double>(8, 1.0); }
  int32_t bezierPointCount() const { return GetField<int32_t>(10, 1); }
  double interpolationFactor1() const { return GetField<double>(12, 0.5); }
  double interpolationFactor2() const { return GetField<double>(14, 0.5); }
  double virtualDistance() const { return GetField<double>(16, 0.0); }
  int32_t auxiliaryFlags() const { return GetField<int32_t>(18, 0); }
  double auxiliaryChannel1() const { return GetField<double>(20, 0.0); }
  double auxiliaryChannel2() const { return GetField<double>(22, 0.0); }
  double auxiliaryChannel3() const { return GetField<double>(24, 0.0); }
  double auxiliaryChannel4() const { return GetField<double>(26, 0.0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<grl::flatbuffer::Vector3d>(verifier, 4 /* position */) &&
           VerifyField<grl::flatbuffer::EulerXYZd>(verifier, 6 /* rotation */) &&
           VerifyField<double>(verifier, 8 /* relativeVelocity */) &&
           VerifyField<int32_t>(verifier, 10 /* bezierPointCount */) &&
           VerifyField<double>(verifier, 12 /* interpolationFactor1 */) &&
           VerifyField<double>(verifier, 14 /* interpolationFactor2 */) &&
           VerifyField<double>(verifier, 16 /* virtualDistance */) &&
           VerifyField<int32_t>(verifier, 18 /* auxiliaryFlags */) &&
           VerifyField<double>(verifier, 20 /* auxiliaryChannel1 */) &&
           VerifyField<double>(verifier, 22 /* auxiliaryChannel2 */) &&
           VerifyField<double>(verifier, 24 /* auxiliaryChannel3 */) &&
           VerifyField<double>(verifier, 26 /* auxiliaryChannel4 */) &&
           verifier.EndTable();
  }
};

struct VrepControlPointBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_position(const grl::flatbuffer::Vector3d *position) { fbb_.AddStruct(4, position); }
  void add_rotation(const grl::flatbuffer::EulerXYZd *rotation) { fbb_.AddStruct(6, rotation); }
  void add_relativeVelocity(double relativeVelocity) { fbb_.AddElement<double>(8, relativeVelocity, 1.0); }
  void add_bezierPointCount(int32_t bezierPointCount) { fbb_.AddElement<int32_t>(10, bezierPointCount, 1); }
  void add_interpolationFactor1(double interpolationFactor1) { fbb_.AddElement<double>(12, interpolationFactor1, 0.5); }
  void add_interpolationFactor2(double interpolationFactor2) { fbb_.AddElement<double>(14, interpolationFactor2, 0.5); }
  void add_virtualDistance(double virtualDistance) { fbb_.AddElement<double>(16, virtualDistance, 0.0); }
  void add_auxiliaryFlags(int32_t auxiliaryFlags) { fbb_.AddElement<int32_t>(18, auxiliaryFlags, 0); }
  void add_auxiliaryChannel1(double auxiliaryChannel1) { fbb_.AddElement<double>(20, auxiliaryChannel1, 0.0); }
  void add_auxiliaryChannel2(double auxiliaryChannel2) { fbb_.AddElement<double>(22, auxiliaryChannel2, 0.0); }
  void add_auxiliaryChannel3(double auxiliaryChannel3) { fbb_.AddElement<double>(24, auxiliaryChannel3, 0.0); }
  void add_auxiliaryChannel4(double auxiliaryChannel4) { fbb_.AddElement<double>(26, auxiliaryChannel4, 0.0); }
  VrepControlPointBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  VrepControlPointBuilder &operator=(const VrepControlPointBuilder &);
  flatbuffers::Offset<VrepControlPoint> Finish() {
    auto o = flatbuffers::Offset<VrepControlPoint>(fbb_.EndTable(start_, 12));
    return o;
  }
};

inline flatbuffers::Offset<VrepControlPoint> CreateVrepControlPoint(flatbuffers::FlatBufferBuilder &_fbb,
   const grl::flatbuffer::Vector3d *position = 0,
   const grl::flatbuffer::EulerXYZd *rotation = 0,
   double relativeVelocity = 1.0,
   int32_t bezierPointCount = 1,
   double interpolationFactor1 = 0.5,
   double interpolationFactor2 = 0.5,
   double virtualDistance = 0.0,
   int32_t auxiliaryFlags = 0,
   double auxiliaryChannel1 = 0.0,
   double auxiliaryChannel2 = 0.0,
   double auxiliaryChannel3 = 0.0,
   double auxiliaryChannel4 = 0.0) {
  VrepControlPointBuilder builder_(_fbb);
  builder_.add_auxiliaryChannel4(auxiliaryChannel4);
  builder_.add_auxiliaryChannel3(auxiliaryChannel3);
  builder_.add_auxiliaryChannel2(auxiliaryChannel2);
  builder_.add_auxiliaryChannel1(auxiliaryChannel1);
  builder_.add_virtualDistance(virtualDistance);
  builder_.add_interpolationFactor2(interpolationFactor2);
  builder_.add_interpolationFactor1(interpolationFactor1);
  builder_.add_relativeVelocity(relativeVelocity);
  builder_.add_auxiliaryFlags(auxiliaryFlags);
  builder_.add_bezierPointCount(bezierPointCount);
  builder_.add_rotation(rotation);
  builder_.add_position(position);
  return builder_.Finish();
}

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

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

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

}  // namespace flatbuffer
}  // namespace grl

#endif  // FLATBUFFERS_GENERATED_VREPCONTROLPOINT_GRL_FLATBUFFER_H_