// generated from rosidl_generator_cpp/resource/idl__struct.hpp.em
// with input from g29_msg:msg/G29Msg.idl
// generated code does not contain a copyright notice

#ifndef G29_MSG__MSG__DETAIL__G29_MSG__STRUCT_HPP_
#define G29_MSG__MSG__DETAIL__G29_MSG__STRUCT_HPP_

#include <algorithm>
#include <array>
#include <memory>
#include <string>
#include <vector>

#include "rosidl_runtime_cpp/bounded_vector.hpp"
#include "rosidl_runtime_cpp/message_initialization.hpp"


#ifndef _WIN32
# define DEPRECATED__g29_msg__msg__G29Msg __attribute__((deprecated))
#else
# define DEPRECATED__g29_msg__msg__G29Msg __declspec(deprecated)
#endif

namespace g29_msg
{

namespace msg
{

// message struct
template<class ContainerAllocator>
struct G29Msg_
{
  using Type = G29Msg_<ContainerAllocator>;

  explicit G29Msg_(rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
  {
    if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
      rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
    {
      this->heartbeat = 0l;
      this->axis0 = 0l;
      this->axis1 = 0l;
      this->axis2 = 0l;
      this->axis3 = 0l;
      this->axis4 = 0l;
      this->axis5 = 0l;
      this->button0 = false;
      this->button1 = false;
      this->button2 = false;
      this->button3 = false;
      this->button4 = false;
      this->button5 = false;
      this->button6 = false;
      this->button7 = false;
      this->button8 = false;
      this->button9 = false;
      this->button10 = false;
      this->button11 = false;
      this->button12 = false;
      this->button13 = false;
      this->button14 = false;
      this->button15 = false;
      this->button16 = false;
      this->button17 = false;
      this->button18 = false;
      this->button19 = false;
      this->button20 = false;
      this->button21 = false;
      this->button22 = false;
      this->button23 = false;
      this->button24 = false;
    }
  }

  explicit G29Msg_(const ContainerAllocator & _alloc, rosidl_runtime_cpp::MessageInitialization _init = rosidl_runtime_cpp::MessageInitialization::ALL)
  {
    (void)_alloc;
    if (rosidl_runtime_cpp::MessageInitialization::ALL == _init ||
      rosidl_runtime_cpp::MessageInitialization::ZERO == _init)
    {
      this->heartbeat = 0l;
      this->axis0 = 0l;
      this->axis1 = 0l;
      this->axis2 = 0l;
      this->axis3 = 0l;
      this->axis4 = 0l;
      this->axis5 = 0l;
      this->button0 = false;
      this->button1 = false;
      this->button2 = false;
      this->button3 = false;
      this->button4 = false;
      this->button5 = false;
      this->button6 = false;
      this->button7 = false;
      this->button8 = false;
      this->button9 = false;
      this->button10 = false;
      this->button11 = false;
      this->button12 = false;
      this->button13 = false;
      this->button14 = false;
      this->button15 = false;
      this->button16 = false;
      this->button17 = false;
      this->button18 = false;
      this->button19 = false;
      this->button20 = false;
      this->button21 = false;
      this->button22 = false;
      this->button23 = false;
      this->button24 = false;
    }
  }

  // field types and members
  using _heartbeat_type =
    int32_t;
  _heartbeat_type heartbeat;
  using _axis0_type =
    int32_t;
  _axis0_type axis0;
  using _axis1_type =
    int32_t;
  _axis1_type axis1;
  using _axis2_type =
    int32_t;
  _axis2_type axis2;
  using _axis3_type =
    int32_t;
  _axis3_type axis3;
  using _axis4_type =
    int32_t;
  _axis4_type axis4;
  using _axis5_type =
    int32_t;
  _axis5_type axis5;
  using _button0_type =
    bool;
  _button0_type button0;
  using _button1_type =
    bool;
  _button1_type button1;
  using _button2_type =
    bool;
  _button2_type button2;
  using _button3_type =
    bool;
  _button3_type button3;
  using _button4_type =
    bool;
  _button4_type button4;
  using _button5_type =
    bool;
  _button5_type button5;
  using _button6_type =
    bool;
  _button6_type button6;
  using _button7_type =
    bool;
  _button7_type button7;
  using _button8_type =
    bool;
  _button8_type button8;
  using _button9_type =
    bool;
  _button9_type button9;
  using _button10_type =
    bool;
  _button10_type button10;
  using _button11_type =
    bool;
  _button11_type button11;
  using _button12_type =
    bool;
  _button12_type button12;
  using _button13_type =
    bool;
  _button13_type button13;
  using _button14_type =
    bool;
  _button14_type button14;
  using _button15_type =
    bool;
  _button15_type button15;
  using _button16_type =
    bool;
  _button16_type button16;
  using _button17_type =
    bool;
  _button17_type button17;
  using _button18_type =
    bool;
  _button18_type button18;
  using _button19_type =
    bool;
  _button19_type button19;
  using _button20_type =
    bool;
  _button20_type button20;
  using _button21_type =
    bool;
  _button21_type button21;
  using _button22_type =
    bool;
  _button22_type button22;
  using _button23_type =
    bool;
  _button23_type button23;
  using _button24_type =
    bool;
  _button24_type button24;

  // setters for named parameter idiom
  Type & set__heartbeat(
    const int32_t & _arg)
  {
    this->heartbeat = _arg;
    return *this;
  }
  Type & set__axis0(
    const int32_t & _arg)
  {
    this->axis0 = _arg;
    return *this;
  }
  Type & set__axis1(
    const int32_t & _arg)
  {
    this->axis1 = _arg;
    return *this;
  }
  Type & set__axis2(
    const int32_t & _arg)
  {
    this->axis2 = _arg;
    return *this;
  }
  Type & set__axis3(
    const int32_t & _arg)
  {
    this->axis3 = _arg;
    return *this;
  }
  Type & set__axis4(
    const int32_t & _arg)
  {
    this->axis4 = _arg;
    return *this;
  }
  Type & set__axis5(
    const int32_t & _arg)
  {
    this->axis5 = _arg;
    return *this;
  }
  Type & set__button0(
    const bool & _arg)
  {
    this->button0 = _arg;
    return *this;
  }
  Type & set__button1(
    const bool & _arg)
  {
    this->button1 = _arg;
    return *this;
  }
  Type & set__button2(
    const bool & _arg)
  {
    this->button2 = _arg;
    return *this;
  }
  Type & set__button3(
    const bool & _arg)
  {
    this->button3 = _arg;
    return *this;
  }
  Type & set__button4(
    const bool & _arg)
  {
    this->button4 = _arg;
    return *this;
  }
  Type & set__button5(
    const bool & _arg)
  {
    this->button5 = _arg;
    return *this;
  }
  Type & set__button6(
    const bool & _arg)
  {
    this->button6 = _arg;
    return *this;
  }
  Type & set__button7(
    const bool & _arg)
  {
    this->button7 = _arg;
    return *this;
  }
  Type & set__button8(
    const bool & _arg)
  {
    this->button8 = _arg;
    return *this;
  }
  Type & set__button9(
    const bool & _arg)
  {
    this->button9 = _arg;
    return *this;
  }
  Type & set__button10(
    const bool & _arg)
  {
    this->button10 = _arg;
    return *this;
  }
  Type & set__button11(
    const bool & _arg)
  {
    this->button11 = _arg;
    return *this;
  }
  Type & set__button12(
    const bool & _arg)
  {
    this->button12 = _arg;
    return *this;
  }
  Type & set__button13(
    const bool & _arg)
  {
    this->button13 = _arg;
    return *this;
  }
  Type & set__button14(
    const bool & _arg)
  {
    this->button14 = _arg;
    return *this;
  }
  Type & set__button15(
    const bool & _arg)
  {
    this->button15 = _arg;
    return *this;
  }
  Type & set__button16(
    const bool & _arg)
  {
    this->button16 = _arg;
    return *this;
  }
  Type & set__button17(
    const bool & _arg)
  {
    this->button17 = _arg;
    return *this;
  }
  Type & set__button18(
    const bool & _arg)
  {
    this->button18 = _arg;
    return *this;
  }
  Type & set__button19(
    const bool & _arg)
  {
    this->button19 = _arg;
    return *this;
  }
  Type & set__button20(
    const bool & _arg)
  {
    this->button20 = _arg;
    return *this;
  }
  Type & set__button21(
    const bool & _arg)
  {
    this->button21 = _arg;
    return *this;
  }
  Type & set__button22(
    const bool & _arg)
  {
    this->button22 = _arg;
    return *this;
  }
  Type & set__button23(
    const bool & _arg)
  {
    this->button23 = _arg;
    return *this;
  }
  Type & set__button24(
    const bool & _arg)
  {
    this->button24 = _arg;
    return *this;
  }

  // constant declarations

  // pointer types
  using RawPtr =
    g29_msg::msg::G29Msg_<ContainerAllocator> *;
  using ConstRawPtr =
    const g29_msg::msg::G29Msg_<ContainerAllocator> *;
  using SharedPtr =
    std::shared_ptr<g29_msg::msg::G29Msg_<ContainerAllocator>>;
  using ConstSharedPtr =
    std::shared_ptr<g29_msg::msg::G29Msg_<ContainerAllocator> const>;

  template<typename Deleter = std::default_delete<
      g29_msg::msg::G29Msg_<ContainerAllocator>>>
  using UniquePtrWithDeleter =
    std::unique_ptr<g29_msg::msg::G29Msg_<ContainerAllocator>, Deleter>;

  using UniquePtr = UniquePtrWithDeleter<>;

  template<typename Deleter = std::default_delete<
      g29_msg::msg::G29Msg_<ContainerAllocator>>>
  using ConstUniquePtrWithDeleter =
    std::unique_ptr<g29_msg::msg::G29Msg_<ContainerAllocator> const, Deleter>;
  using ConstUniquePtr = ConstUniquePtrWithDeleter<>;

  using WeakPtr =
    std::weak_ptr<g29_msg::msg::G29Msg_<ContainerAllocator>>;
  using ConstWeakPtr =
    std::weak_ptr<g29_msg::msg::G29Msg_<ContainerAllocator> const>;

  // pointer types similar to ROS 1, use SharedPtr / ConstSharedPtr instead
  // NOTE: Can't use 'using' here because GNU C++ can't parse attributes properly
  typedef DEPRECATED__g29_msg__msg__G29Msg
    std::shared_ptr<g29_msg::msg::G29Msg_<ContainerAllocator>>
    Ptr;
  typedef DEPRECATED__g29_msg__msg__G29Msg
    std::shared_ptr<g29_msg::msg::G29Msg_<ContainerAllocator> const>
    ConstPtr;

  // comparison operators
  bool operator==(const G29Msg_ & other) const
  {
    if (this->heartbeat != other.heartbeat) {
      return false;
    }
    if (this->axis0 != other.axis0) {
      return false;
    }
    if (this->axis1 != other.axis1) {
      return false;
    }
    if (this->axis2 != other.axis2) {
      return false;
    }
    if (this->axis3 != other.axis3) {
      return false;
    }
    if (this->axis4 != other.axis4) {
      return false;
    }
    if (this->axis5 != other.axis5) {
      return false;
    }
    if (this->button0 != other.button0) {
      return false;
    }
    if (this->button1 != other.button1) {
      return false;
    }
    if (this->button2 != other.button2) {
      return false;
    }
    if (this->button3 != other.button3) {
      return false;
    }
    if (this->button4 != other.button4) {
      return false;
    }
    if (this->button5 != other.button5) {
      return false;
    }
    if (this->button6 != other.button6) {
      return false;
    }
    if (this->button7 != other.button7) {
      return false;
    }
    if (this->button8 != other.button8) {
      return false;
    }
    if (this->button9 != other.button9) {
      return false;
    }
    if (this->button10 != other.button10) {
      return false;
    }
    if (this->button11 != other.button11) {
      return false;
    }
    if (this->button12 != other.button12) {
      return false;
    }
    if (this->button13 != other.button13) {
      return false;
    }
    if (this->button14 != other.button14) {
      return false;
    }
    if (this->button15 != other.button15) {
      return false;
    }
    if (this->button16 != other.button16) {
      return false;
    }
    if (this->button17 != other.button17) {
      return false;
    }
    if (this->button18 != other.button18) {
      return false;
    }
    if (this->button19 != other.button19) {
      return false;
    }
    if (this->button20 != other.button20) {
      return false;
    }
    if (this->button21 != other.button21) {
      return false;
    }
    if (this->button22 != other.button22) {
      return false;
    }
    if (this->button23 != other.button23) {
      return false;
    }
    if (this->button24 != other.button24) {
      return false;
    }
    return true;
  }
  bool operator!=(const G29Msg_ & other) const
  {
    return !this->operator==(other);
  }
};  // struct G29Msg_

// alias to use template instance with default allocator
using G29Msg =
  g29_msg::msg::G29Msg_<std::allocator<void>>;

// constant definitions

}  // namespace msg

}  // namespace g29_msg

#endif  // G29_MSG__MSG__DETAIL__G29_MSG__STRUCT_HPP_
