Euler_generated.h

Go to the documentation of this file.

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

#ifndef FLATBUFFERS_GENERATED_EULER_GRL_FLATBUFFER_H_
#define FLATBUFFERS_GENERATED_EULER_GRL_FLATBUFFER_H_

#include "flatbuffers/flatbuffers.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;

enum EulerOrder {
  EulerOrder_xyz = 0,
  EulerOrder_yzx = 1,
  EulerOrder_zxy = 2,
  EulerOrder_xzy = 3,
  EulerOrder_zyx = 4,
  EulerOrder_yxz = 5,
  EulerOrder_zxz = 6,
  EulerOrder_xyx = 7,
  EulerOrder_yzy = 8,
  EulerOrder_xzx = 9,
  EulerOrder_yxy = 10
};

inline const char **EnumNamesEulerOrder() {
  static const char *names[] = { "xyz", "yzx", "zxy", "xzy", "zyx", "yxz", "zxz", "xyx", "yzy", "xzx", "yxy", nullptr };
  return names;
}

inline const char *EnumNameEulerOrder(EulerOrder e) { return EnumNamesEulerOrder()[static_cast<int>(e)]; }

MANUALLY_ALIGNED_STRUCT(8) EulerXYZd FLATBUFFERS_FINAL_CLASS {
 private:
  double rx_;
  double ry_;
  double rz_;

 public:
  EulerXYZd(double rx, double ry, double rz)
    : rx_(flatbuffers::EndianScalar(rx)), ry_(flatbuffers::EndianScalar(ry)), rz_(flatbuffers::EndianScalar(rz)) { }

  double rx() const { return flatbuffers::EndianScalar(rx_); }
  double ry() const { return flatbuffers::EndianScalar(ry_); }
  double rz() const { return flatbuffers::EndianScalar(rz_); }
};
STRUCT_END(EulerXYZd, 24);

MANUALLY_ALIGNED_STRUCT(8) EulerRotation FLATBUFFERS_FINAL_CLASS {
 private:
  double r1_;
  double r2_;
  double r3_;
  int8_t eulerOrder_;
  int8_t __padding0;
  int16_t __padding1;
  int32_t __padding2;

 public:
  EulerRotation(double r1, double r2, double r3, EulerOrder eulerOrder)
    : r1_(flatbuffers::EndianScalar(r1)), r2_(flatbuffers::EndianScalar(r2)), r3_(flatbuffers::EndianScalar(r3)), eulerOrder_(flatbuffers::EndianScalar(static_cast<int8_t>(eulerOrder))), __padding0(0), __padding1(0), __padding2(0) { (void)__padding0; (void)__padding1; (void)__padding2; }

  double r1() const { return flatbuffers::EndianScalar(r1_); }
  double r2() const { return flatbuffers::EndianScalar(r2_); }
  double r3() const { return flatbuffers::EndianScalar(r3_); }
  EulerOrder eulerOrder() const { return static_cast<EulerOrder>(flatbuffers::EndianScalar(eulerOrder_)); }
};
STRUCT_END(EulerRotation, 32);

MANUALLY_ALIGNED_STRUCT(8) EulerPose FLATBUFFERS_FINAL_CLASS {
 private:
  grl::flatbuffer::Vector3d position_;
  EulerRotation rotation_;

 public:
  EulerPose(const grl::flatbuffer::Vector3d &position, const EulerRotation &rotation)
    : position_(position), rotation_(rotation) { }

  const grl::flatbuffer::Vector3d &position() const { return position_; }
  const EulerRotation &rotation() const { return rotation_; }
};
STRUCT_END(EulerPose, 56);

struct EulerTranslationParams FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  double x() const { return GetField<double>(4, 0); }
  double y() const { return GetField<double>(6, 0); }
  double z() const { return GetField<double>(8, 0); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<double>(verifier, 4 /* x */) &&
           VerifyField<double>(verifier, 6 /* y */) &&
           VerifyField<double>(verifier, 8 /* z */) &&
           verifier.EndTable();
  }
};

struct EulerTranslationParamsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_x(double x) { fbb_.AddElement<double>(4, x, 0); }
  void add_y(double y) { fbb_.AddElement<double>(6, y, 0); }
  void add_z(double z) { fbb_.AddElement<double>(8, z, 0); }
  EulerTranslationParamsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  EulerTranslationParamsBuilder &operator=(const EulerTranslationParamsBuilder &);
  flatbuffers::Offset<EulerTranslationParams> Finish() {
    auto o = flatbuffers::Offset<EulerTranslationParams>(fbb_.EndTable(start_, 3));
    return o;
  }
};

inline flatbuffers::Offset<EulerTranslationParams> CreateEulerTranslationParams(flatbuffers::FlatBufferBuilder &_fbb,
   double x = 0,
   double y = 0,
   double z = 0) {
  EulerTranslationParamsBuilder builder_(_fbb);
  builder_.add_z(z);
  builder_.add_y(y);
  builder_.add_x(x);
  return builder_.Finish();
}

struct EulerRotationParams FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  double r1() const { return GetField<double>(4, 0); }
  double r2() const { return GetField<double>(6, 0); }
  double r3() const { return GetField<double>(8, 0); }
  EulerOrder eulerOrder() const { return static_cast<EulerOrder>(GetField<int8_t>(10, 0)); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<double>(verifier, 4 /* r1 */) &&
           VerifyField<double>(verifier, 6 /* r2 */) &&
           VerifyField<double>(verifier, 8 /* r3 */) &&
           VerifyField<int8_t>(verifier, 10 /* eulerOrder */) &&
           verifier.EndTable();
  }
};

struct EulerRotationParamsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_r1(double r1) { fbb_.AddElement<double>(4, r1, 0); }
  void add_r2(double r2) { fbb_.AddElement<double>(6, r2, 0); }
  void add_r3(double r3) { fbb_.AddElement<double>(8, r3, 0); }
  void add_eulerOrder(EulerOrder eulerOrder) { fbb_.AddElement<int8_t>(10, static_cast<int8_t>(eulerOrder), 0); }
  EulerRotationParamsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  EulerRotationParamsBuilder &operator=(const EulerRotationParamsBuilder &);
  flatbuffers::Offset<EulerRotationParams> Finish() {
    auto o = flatbuffers::Offset<EulerRotationParams>(fbb_.EndTable(start_, 4));
    return o;
  }
};

inline flatbuffers::Offset<EulerRotationParams> CreateEulerRotationParams(flatbuffers::FlatBufferBuilder &_fbb,
   double r1 = 0,
   double r2 = 0,
   double r3 = 0,
   EulerOrder eulerOrder = EulerOrder_xyz) {
  EulerRotationParamsBuilder builder_(_fbb);
  builder_.add_r3(r3);
  builder_.add_r2(r2);
  builder_.add_r1(r1);
  builder_.add_eulerOrder(eulerOrder);
  return builder_.Finish();
}

struct EulerPoseParams FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  const grl::flatbuffer::Vector3d *position() const { return GetStruct<const grl::flatbuffer::Vector3d *>(4); }
  const EulerRotation *rotation() const { return GetStruct<const EulerRotation *>(6); }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<grl::flatbuffer::Vector3d>(verifier, 4 /* position */) &&
           VerifyField<EulerRotation>(verifier, 6 /* rotation */) &&
           verifier.EndTable();
  }
};

struct EulerPoseParamsBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_position(const grl::flatbuffer::Vector3d *position) { fbb_.AddStruct(4, position); }
  void add_rotation(const EulerRotation *rotation) { fbb_.AddStruct(6, rotation); }
  EulerPoseParamsBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
  EulerPoseParamsBuilder &operator=(const EulerPoseParamsBuilder &);
  flatbuffers::Offset<EulerPoseParams> Finish() {
    auto o = flatbuffers::Offset<EulerPoseParams>(fbb_.EndTable(start_, 2));
    return o;
  }
};

inline flatbuffers::Offset<EulerPoseParams> CreateEulerPoseParams(flatbuffers::FlatBufferBuilder &_fbb,
   const grl::flatbuffer::Vector3d *position = 0,
   const EulerRotation *rotation = 0) {
  EulerPoseParamsBuilder builder_(_fbb);
  builder_.add_rotation(rotation);
  builder_.add_position(position);
  return builder_.Finish();
}

}  // namespace flatbuffer
}  // namespace grl

#endif  // FLATBUFFERS_GENERATED_EULER_GRL_FLATBUFFER_H_