file_path
stringlengths 21
207
| content
stringlengths 5
1.02M
| size
int64 5
1.02M
| lang
stringclasses 9
values | avg_line_length
float64 1.33
100
| max_line_length
int64 4
993
| alphanum_fraction
float64 0.27
0.93
|
|---|---|---|---|---|---|---|
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/AttachedCollisionObject.h | #ifndef _ROS_moveit_msgs_AttachedCollisionObject_h
#define _ROS_moveit_msgs_AttachedCollisionObject_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/CollisionObject.h"
#include "trajectory_msgs/JointTrajectory.h"
namespace moveit_msgs
{
class AttachedCollisionObject : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef moveit_msgs::CollisionObject _object_type;
_object_type object;
uint32_t touch_links_length;
typedef char* _touch_links_type;
_touch_links_type st_touch_links;
_touch_links_type * touch_links;
typedef trajectory_msgs::JointTrajectory _detach_posture_type;
_detach_posture_type detach_posture;
typedef double _weight_type;
_weight_type weight;
AttachedCollisionObject():
link_name(""),
object(),
touch_links_length(0), touch_links(NULL),
detach_posture(),
weight(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
offset += this->object.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->touch_links_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->touch_links_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->touch_links_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->touch_links_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->touch_links_length);
for( uint32_t i = 0; i < touch_links_length; i++){
uint32_t length_touch_linksi = strlen(this->touch_links[i]);
varToArr(outbuffer + offset, length_touch_linksi);
offset += 4;
memcpy(outbuffer + offset, this->touch_links[i], length_touch_linksi);
offset += length_touch_linksi;
}
offset += this->detach_posture.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_weight;
u_weight.real = this->weight;
*(outbuffer + offset + 0) = (u_weight.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_weight.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_weight.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_weight.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_weight.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_weight.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_weight.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_weight.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->weight);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
offset += this->object.deserialize(inbuffer + offset);
uint32_t touch_links_lengthT = ((uint32_t) (*(inbuffer + offset)));
touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
touch_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->touch_links_length);
if(touch_links_lengthT > touch_links_length)
this->touch_links = (char**)realloc(this->touch_links, touch_links_lengthT * sizeof(char*));
touch_links_length = touch_links_lengthT;
for( uint32_t i = 0; i < touch_links_length; i++){
uint32_t length_st_touch_links;
arrToVar(length_st_touch_links, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_touch_links; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_touch_links-1]=0;
this->st_touch_links = (char *)(inbuffer + offset-1);
offset += length_st_touch_links;
memcpy( &(this->touch_links[i]), &(this->st_touch_links), sizeof(char*));
}
offset += this->detach_posture.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_weight;
u_weight.base = 0;
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_weight.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->weight = u_weight.real;
offset += sizeof(this->weight);
return offset;
}
const char * getType(){ return "moveit_msgs/AttachedCollisionObject"; };
const char * getMD5(){ return "3ceac60b21e85bbd6c5b0ab9d476b752"; };
};
}
#endif
| 5,525 | C | 39.335766 | 100 | 0.5819 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/AllowedCollisionMatrix.h | #ifndef _ROS_moveit_msgs_AllowedCollisionMatrix_h
#define _ROS_moveit_msgs_AllowedCollisionMatrix_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/AllowedCollisionEntry.h"
namespace moveit_msgs
{
class AllowedCollisionMatrix : public ros::Msg
{
public:
uint32_t entry_names_length;
typedef char* _entry_names_type;
_entry_names_type st_entry_names;
_entry_names_type * entry_names;
uint32_t entry_values_length;
typedef moveit_msgs::AllowedCollisionEntry _entry_values_type;
_entry_values_type st_entry_values;
_entry_values_type * entry_values;
uint32_t default_entry_names_length;
typedef char* _default_entry_names_type;
_default_entry_names_type st_default_entry_names;
_default_entry_names_type * default_entry_names;
uint32_t default_entry_values_length;
typedef bool _default_entry_values_type;
_default_entry_values_type st_default_entry_values;
_default_entry_values_type * default_entry_values;
AllowedCollisionMatrix():
entry_names_length(0), entry_names(NULL),
entry_values_length(0), entry_values(NULL),
default_entry_names_length(0), default_entry_names(NULL),
default_entry_values_length(0), default_entry_values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->entry_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->entry_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->entry_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->entry_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->entry_names_length);
for( uint32_t i = 0; i < entry_names_length; i++){
uint32_t length_entry_namesi = strlen(this->entry_names[i]);
varToArr(outbuffer + offset, length_entry_namesi);
offset += 4;
memcpy(outbuffer + offset, this->entry_names[i], length_entry_namesi);
offset += length_entry_namesi;
}
*(outbuffer + offset + 0) = (this->entry_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->entry_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->entry_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->entry_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->entry_values_length);
for( uint32_t i = 0; i < entry_values_length; i++){
offset += this->entry_values[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->default_entry_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->default_entry_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->default_entry_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->default_entry_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->default_entry_names_length);
for( uint32_t i = 0; i < default_entry_names_length; i++){
uint32_t length_default_entry_namesi = strlen(this->default_entry_names[i]);
varToArr(outbuffer + offset, length_default_entry_namesi);
offset += 4;
memcpy(outbuffer + offset, this->default_entry_names[i], length_default_entry_namesi);
offset += length_default_entry_namesi;
}
*(outbuffer + offset + 0) = (this->default_entry_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->default_entry_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->default_entry_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->default_entry_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->default_entry_values_length);
for( uint32_t i = 0; i < default_entry_values_length; i++){
union {
bool real;
uint8_t base;
} u_default_entry_valuesi;
u_default_entry_valuesi.real = this->default_entry_values[i];
*(outbuffer + offset + 0) = (u_default_entry_valuesi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->default_entry_values[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t entry_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->entry_names_length);
if(entry_names_lengthT > entry_names_length)
this->entry_names = (char**)realloc(this->entry_names, entry_names_lengthT * sizeof(char*));
entry_names_length = entry_names_lengthT;
for( uint32_t i = 0; i < entry_names_length; i++){
uint32_t length_st_entry_names;
arrToVar(length_st_entry_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_entry_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_entry_names-1]=0;
this->st_entry_names = (char *)(inbuffer + offset-1);
offset += length_st_entry_names;
memcpy( &(this->entry_names[i]), &(this->st_entry_names), sizeof(char*));
}
uint32_t entry_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->entry_values_length);
if(entry_values_lengthT > entry_values_length)
this->entry_values = (moveit_msgs::AllowedCollisionEntry*)realloc(this->entry_values, entry_values_lengthT * sizeof(moveit_msgs::AllowedCollisionEntry));
entry_values_length = entry_values_lengthT;
for( uint32_t i = 0; i < entry_values_length; i++){
offset += this->st_entry_values.deserialize(inbuffer + offset);
memcpy( &(this->entry_values[i]), &(this->st_entry_values), sizeof(moveit_msgs::AllowedCollisionEntry));
}
uint32_t default_entry_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->default_entry_names_length);
if(default_entry_names_lengthT > default_entry_names_length)
this->default_entry_names = (char**)realloc(this->default_entry_names, default_entry_names_lengthT * sizeof(char*));
default_entry_names_length = default_entry_names_lengthT;
for( uint32_t i = 0; i < default_entry_names_length; i++){
uint32_t length_st_default_entry_names;
arrToVar(length_st_default_entry_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_default_entry_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_default_entry_names-1]=0;
this->st_default_entry_names = (char *)(inbuffer + offset-1);
offset += length_st_default_entry_names;
memcpy( &(this->default_entry_names[i]), &(this->st_default_entry_names), sizeof(char*));
}
uint32_t default_entry_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->default_entry_values_length);
if(default_entry_values_lengthT > default_entry_values_length)
this->default_entry_values = (bool*)realloc(this->default_entry_values, default_entry_values_lengthT * sizeof(bool));
default_entry_values_length = default_entry_values_lengthT;
for( uint32_t i = 0; i < default_entry_values_length; i++){
union {
bool real;
uint8_t base;
} u_st_default_entry_values;
u_st_default_entry_values.base = 0;
u_st_default_entry_values.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_default_entry_values = u_st_default_entry_values.real;
offset += sizeof(this->st_default_entry_values);
memcpy( &(this->default_entry_values[i]), &(this->st_default_entry_values), sizeof(bool));
}
return offset;
}
const char * getType(){ return "moveit_msgs/AllowedCollisionMatrix"; };
const char * getMD5(){ return "aedce13587eef0d79165a075659c1879"; };
};
}
#endif
| 8,960 | C | 49.627118 | 161 | 0.614844 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/DisplayTrajectory.h | #ifndef _ROS_moveit_msgs_DisplayTrajectory_h
#define _ROS_moveit_msgs_DisplayTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
class DisplayTrajectory : public ros::Msg
{
public:
typedef const char* _model_id_type;
_model_id_type model_id;
uint32_t trajectory_length;
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type st_trajectory;
_trajectory_type * trajectory;
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
DisplayTrajectory():
model_id(""),
trajectory_length(0), trajectory(NULL),
trajectory_start()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_id = strlen(this->model_id);
varToArr(outbuffer + offset, length_model_id);
offset += 4;
memcpy(outbuffer + offset, this->model_id, length_model_id);
offset += length_model_id;
*(outbuffer + offset + 0) = (this->trajectory_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_length);
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->trajectory[i].serialize(outbuffer + offset);
}
offset += this->trajectory_start.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_id;
arrToVar(length_model_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_id-1]=0;
this->model_id = (char *)(inbuffer + offset-1);
offset += length_model_id;
uint32_t trajectory_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_length);
if(trajectory_lengthT > trajectory_length)
this->trajectory = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory, trajectory_lengthT * sizeof(moveit_msgs::RobotTrajectory));
trajectory_length = trajectory_lengthT;
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->st_trajectory.deserialize(inbuffer + offset);
memcpy( &(this->trajectory[i]), &(this->st_trajectory), sizeof(moveit_msgs::RobotTrajectory));
}
offset += this->trajectory_start.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/DisplayTrajectory"; };
const char * getMD5(){ return "c3c039261ab9e8a11457dac56b6316c8"; };
};
}
#endif
| 3,253 | C | 35.977272 | 143 | 0.627421 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupActionGoal.h | #ifndef _ROS_moveit_msgs_PickupActionGoal_h
#define _ROS_moveit_msgs_PickupActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "moveit_msgs/PickupGoal.h"
namespace moveit_msgs
{
class PickupActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef moveit_msgs::PickupGoal _goal_type;
_goal_type goal;
PickupActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PickupActionGoal"; };
const char * getMD5(){ return "9e12196da542c9a26bbc43e9655a1906"; };
};
}
#endif
| 1,407 | C | 23.701754 | 72 | 0.649609 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupFeedback.h | #ifndef _ROS_moveit_msgs_PickupFeedback_h
#define _ROS_moveit_msgs_PickupFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class PickupFeedback : public ros::Msg
{
public:
typedef const char* _state_type;
_state_type state;
PickupFeedback():
state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
return offset;
}
const char * getType(){ return "moveit_msgs/PickupFeedback"; };
const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; };
};
}
#endif
| 1,285 | C | 21.964285 | 72 | 0.617121 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/LinkScale.h | #ifndef _ROS_moveit_msgs_LinkScale_h
#define _ROS_moveit_msgs_LinkScale_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class LinkScale : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef double _scale_type;
_scale_type scale;
LinkScale():
link_name(""),
scale(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_scale;
u_scale.real = this->scale;
*(outbuffer + offset + 0) = (u_scale.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_scale.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_scale.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_scale.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_scale.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_scale.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_scale.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_scale.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->scale);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
union {
double real;
uint64_t base;
} u_scale;
u_scale.base = 0;
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_scale.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->scale = u_scale.real;
offset += sizeof(this->scale);
return offset;
}
const char * getType(){ return "moveit_msgs/LinkScale"; };
const char * getMD5(){ return "19faf226446bfb2f645a4da6f2a56166"; };
};
}
#endif
| 2,851 | C | 31.409091 | 73 | 0.540512 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPositionIK.h | #ifndef _ROS_SERVICE_GetPositionIK_h
#define _ROS_SERVICE_GetPositionIK_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/PositionIKRequest.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
static const char GETPOSITIONIK[] = "moveit_msgs/GetPositionIK";
class GetPositionIKRequest : public ros::Msg
{
public:
typedef moveit_msgs::PositionIKRequest _ik_request_type;
_ik_request_type ik_request;
GetPositionIKRequest():
ik_request()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->ik_request.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->ik_request.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOSITIONIK; };
const char * getMD5(){ return "a67dc7e99d15c1dca32a77c22bc2d93b"; };
};
class GetPositionIKResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _solution_type;
_solution_type solution;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
GetPositionIKResponse():
solution(),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->solution.serialize(outbuffer + offset);
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->solution.deserialize(inbuffer + offset);
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOSITIONIK; };
const char * getMD5(){ return "ad50fe5fa0ddb482909be313121ea148"; };
};
class GetPositionIK {
public:
typedef GetPositionIKRequest Request;
typedef GetPositionIKResponse Response;
};
}
#endif
| 2,146 | C | 23.123595 | 72 | 0.664958 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupActionGoal.h | #ifndef _ROS_moveit_msgs_MoveGroupActionGoal_h
#define _ROS_moveit_msgs_MoveGroupActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "moveit_msgs/MoveGroupGoal.h"
namespace moveit_msgs
{
class MoveGroupActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef moveit_msgs::MoveGroupGoal _goal_type;
_goal_type goal;
MoveGroupActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupActionGoal"; };
const char * getMD5(){ return "df11ac1a643d87b6e6a6fe5af1823709"; };
};
}
#endif
| 1,428 | C | 24.070175 | 72 | 0.654762 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/WorkspaceParameters.h | #ifndef _ROS_moveit_msgs_WorkspaceParameters_h
#define _ROS_moveit_msgs_WorkspaceParameters_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Vector3.h"
namespace moveit_msgs
{
class WorkspaceParameters : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Vector3 _min_corner_type;
_min_corner_type min_corner;
typedef geometry_msgs::Vector3 _max_corner_type;
_max_corner_type max_corner;
WorkspaceParameters():
header(),
min_corner(),
max_corner()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->min_corner.serialize(outbuffer + offset);
offset += this->max_corner.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->min_corner.deserialize(inbuffer + offset);
offset += this->max_corner.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/WorkspaceParameters"; };
const char * getMD5(){ return "d639a834e7b1f927e9f1d6c30e920016"; };
};
}
#endif
| 1,439 | C | 24.714285 | 72 | 0.658791 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/LoadMap.h | #ifndef _ROS_SERVICE_LoadMap_h
#define _ROS_SERVICE_LoadMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char LOADMAP[] = "moveit_msgs/LoadMap";
class LoadMapRequest : public ros::Msg
{
public:
typedef const char* _filename_type;
_filename_type filename;
LoadMapRequest():
filename("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_filename = strlen(this->filename);
varToArr(outbuffer + offset, length_filename);
offset += 4;
memcpy(outbuffer + offset, this->filename, length_filename);
offset += length_filename;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_filename;
arrToVar(length_filename, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_filename; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_filename-1]=0;
this->filename = (char *)(inbuffer + offset-1);
offset += length_filename;
return offset;
}
const char * getType(){ return LOADMAP; };
const char * getMD5(){ return "030824f52a0628ead956fb9d67e66ae9"; };
};
class LoadMapResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
LoadMapResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return LOADMAP; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class LoadMap {
public:
typedef LoadMapRequest Request;
typedef LoadMapResponse Response;
};
}
#endif
| 2,450 | C | 22.122641 | 74 | 0.599184 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceGoal.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceGoal_h
#define _ROS_moveit_msgs_MoveGroupSequenceGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionSequenceRequest.h"
#include "moveit_msgs/PlanningOptions.h"
namespace moveit_msgs
{
class MoveGroupSequenceGoal : public ros::Msg
{
public:
typedef moveit_msgs::MotionSequenceRequest _request_type;
_request_type request;
typedef moveit_msgs::PlanningOptions _planning_options_type;
_planning_options_type planning_options;
MoveGroupSequenceGoal():
request(),
planning_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->request.serialize(outbuffer + offset);
offset += this->planning_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->request.deserialize(inbuffer + offset);
offset += this->planning_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceGoal"; };
const char * getMD5(){ return "12fc6281edcaf031de4783a58087ebf1"; };
};
}
#endif
| 1,300 | C | 24.509803 | 74 | 0.685385 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceResult.h | #ifndef _ROS_moveit_msgs_PlaceResult_h
#define _ROS_moveit_msgs_PlaceResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/PlaceLocation.h"
namespace moveit_msgs
{
class PlaceResult : public ros::Msg
{
public:
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
uint32_t trajectory_stages_length;
typedef moveit_msgs::RobotTrajectory _trajectory_stages_type;
_trajectory_stages_type st_trajectory_stages;
_trajectory_stages_type * trajectory_stages;
uint32_t trajectory_descriptions_length;
typedef char* _trajectory_descriptions_type;
_trajectory_descriptions_type st_trajectory_descriptions;
_trajectory_descriptions_type * trajectory_descriptions;
typedef moveit_msgs::PlaceLocation _place_location_type;
_place_location_type place_location;
typedef double _planning_time_type;
_planning_time_type planning_time;
PlaceResult():
error_code(),
trajectory_start(),
trajectory_stages_length(0), trajectory_stages(NULL),
trajectory_descriptions_length(0), trajectory_descriptions(NULL),
place_location(),
planning_time(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.serialize(outbuffer + offset);
offset += this->trajectory_start.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->trajectory_stages_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_stages_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_stages_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_stages_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_stages_length);
for( uint32_t i = 0; i < trajectory_stages_length; i++){
offset += this->trajectory_stages[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->trajectory_descriptions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_descriptions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_descriptions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_descriptions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_descriptions_length);
for( uint32_t i = 0; i < trajectory_descriptions_length; i++){
uint32_t length_trajectory_descriptionsi = strlen(this->trajectory_descriptions[i]);
varToArr(outbuffer + offset, length_trajectory_descriptionsi);
offset += 4;
memcpy(outbuffer + offset, this->trajectory_descriptions[i], length_trajectory_descriptionsi);
offset += length_trajectory_descriptionsi;
}
offset += this->place_location.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.real = this->planning_time;
*(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planning_time);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->error_code.deserialize(inbuffer + offset);
offset += this->trajectory_start.deserialize(inbuffer + offset);
uint32_t trajectory_stages_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_stages_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_stages_length);
if(trajectory_stages_lengthT > trajectory_stages_length)
this->trajectory_stages = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory_stages, trajectory_stages_lengthT * sizeof(moveit_msgs::RobotTrajectory));
trajectory_stages_length = trajectory_stages_lengthT;
for( uint32_t i = 0; i < trajectory_stages_length; i++){
offset += this->st_trajectory_stages.deserialize(inbuffer + offset);
memcpy( &(this->trajectory_stages[i]), &(this->st_trajectory_stages), sizeof(moveit_msgs::RobotTrajectory));
}
uint32_t trajectory_descriptions_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_descriptions_length);
if(trajectory_descriptions_lengthT > trajectory_descriptions_length)
this->trajectory_descriptions = (char**)realloc(this->trajectory_descriptions, trajectory_descriptions_lengthT * sizeof(char*));
trajectory_descriptions_length = trajectory_descriptions_lengthT;
for( uint32_t i = 0; i < trajectory_descriptions_length; i++){
uint32_t length_st_trajectory_descriptions;
arrToVar(length_st_trajectory_descriptions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_trajectory_descriptions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_trajectory_descriptions-1]=0;
this->st_trajectory_descriptions = (char *)(inbuffer + offset-1);
offset += length_st_trajectory_descriptions;
memcpy( &(this->trajectory_descriptions[i]), &(this->st_trajectory_descriptions), sizeof(char*));
}
offset += this->place_location.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.base = 0;
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planning_time = u_planning_time.real;
offset += sizeof(this->planning_time);
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceResult"; };
const char * getMD5(){ return "94bc2148a619282cbe09156013d6c4c9"; };
};
}
#endif
| 7,610 | C | 49.072368 | 164 | 0.631143 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetCartesianPath.h | #ifndef _ROS_SERVICE_GetCartesianPath_h
#define _ROS_SERVICE_GetCartesianPath_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/MoveItErrorCodes.h"
#include "geometry_msgs/Pose.h"
#include "moveit_msgs/Constraints.h"
namespace moveit_msgs
{
static const char GETCARTESIANPATH[] = "moveit_msgs/GetCartesianPath";
class GetCartesianPathRequest : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef moveit_msgs::RobotState _start_state_type;
_start_state_type start_state;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef const char* _link_name_type;
_link_name_type link_name;
uint32_t waypoints_length;
typedef geometry_msgs::Pose _waypoints_type;
_waypoints_type st_waypoints;
_waypoints_type * waypoints;
typedef double _max_step_type;
_max_step_type max_step;
typedef double _jump_threshold_type;
_jump_threshold_type jump_threshold;
typedef bool _avoid_collisions_type;
_avoid_collisions_type avoid_collisions;
typedef moveit_msgs::Constraints _path_constraints_type;
_path_constraints_type path_constraints;
GetCartesianPathRequest():
header(),
start_state(),
group_name(""),
link_name(""),
waypoints_length(0), waypoints(NULL),
max_step(0),
jump_threshold(0),
avoid_collisions(0),
path_constraints()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->start_state.serialize(outbuffer + offset);
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
*(outbuffer + offset + 0) = (this->waypoints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->waypoints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->waypoints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->waypoints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->waypoints_length);
for( uint32_t i = 0; i < waypoints_length; i++){
offset += this->waypoints[i].serialize(outbuffer + offset);
}
union {
double real;
uint64_t base;
} u_max_step;
u_max_step.real = this->max_step;
*(outbuffer + offset + 0) = (u_max_step.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_step.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_step.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_step.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_step.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_step.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_step.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_step.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_step);
union {
double real;
uint64_t base;
} u_jump_threshold;
u_jump_threshold.real = this->jump_threshold;
*(outbuffer + offset + 0) = (u_jump_threshold.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_jump_threshold.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_jump_threshold.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_jump_threshold.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_jump_threshold.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_jump_threshold.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_jump_threshold.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_jump_threshold.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->jump_threshold);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.real = this->avoid_collisions;
*(outbuffer + offset + 0) = (u_avoid_collisions.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->avoid_collisions);
offset += this->path_constraints.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->start_state.deserialize(inbuffer + offset);
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
uint32_t waypoints_lengthT = ((uint32_t) (*(inbuffer + offset)));
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
waypoints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->waypoints_length);
if(waypoints_lengthT > waypoints_length)
this->waypoints = (geometry_msgs::Pose*)realloc(this->waypoints, waypoints_lengthT * sizeof(geometry_msgs::Pose));
waypoints_length = waypoints_lengthT;
for( uint32_t i = 0; i < waypoints_length; i++){
offset += this->st_waypoints.deserialize(inbuffer + offset);
memcpy( &(this->waypoints[i]), &(this->st_waypoints), sizeof(geometry_msgs::Pose));
}
union {
double real;
uint64_t base;
} u_max_step;
u_max_step.base = 0;
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_step = u_max_step.real;
offset += sizeof(this->max_step);
union {
double real;
uint64_t base;
} u_jump_threshold;
u_jump_threshold.base = 0;
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_jump_threshold.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->jump_threshold = u_jump_threshold.real;
offset += sizeof(this->jump_threshold);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.base = 0;
u_avoid_collisions.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->avoid_collisions = u_avoid_collisions.real;
offset += sizeof(this->avoid_collisions);
offset += this->path_constraints.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETCARTESIANPATH; };
const char * getMD5(){ return "b37c16ad7ed838d811a270a8054276b6"; };
};
class GetCartesianPathResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _start_state_type;
_start_state_type start_state;
typedef moveit_msgs::RobotTrajectory _solution_type;
_solution_type solution;
typedef double _fraction_type;
_fraction_type fraction;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
GetCartesianPathResponse():
start_state(),
solution(),
fraction(0),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->start_state.serialize(outbuffer + offset);
offset += this->solution.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_fraction;
u_fraction.real = this->fraction;
*(outbuffer + offset + 0) = (u_fraction.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fraction.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fraction.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fraction.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_fraction.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_fraction.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_fraction.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_fraction.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->fraction);
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->start_state.deserialize(inbuffer + offset);
offset += this->solution.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_fraction;
u_fraction.base = 0;
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_fraction.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->fraction = u_fraction.real;
offset += sizeof(this->fraction);
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETCARTESIANPATH; };
const char * getMD5(){ return "45414110461a45eb0e273e013924ce59"; };
};
class GetCartesianPath {
public:
typedef GetCartesianPathRequest Request;
typedef GetCartesianPathResponse Response;
};
}
#endif
| 11,595 | C | 40.414286 | 122 | 0.578784 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GripperTranslation.h | #ifndef _ROS_moveit_msgs_GripperTranslation_h
#define _ROS_moveit_msgs_GripperTranslation_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3Stamped.h"
namespace moveit_msgs
{
class GripperTranslation : public ros::Msg
{
public:
typedef geometry_msgs::Vector3Stamped _direction_type;
_direction_type direction;
typedef float _desired_distance_type;
_desired_distance_type desired_distance;
typedef float _min_distance_type;
_min_distance_type min_distance;
GripperTranslation():
direction(),
desired_distance(0),
min_distance(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->direction.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_desired_distance;
u_desired_distance.real = this->desired_distance;
*(outbuffer + offset + 0) = (u_desired_distance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_desired_distance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_desired_distance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_desired_distance.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->desired_distance);
union {
float real;
uint32_t base;
} u_min_distance;
u_min_distance.real = this->min_distance;
*(outbuffer + offset + 0) = (u_min_distance.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_distance.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_distance.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_distance.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->min_distance);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->direction.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_desired_distance;
u_desired_distance.base = 0;
u_desired_distance.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_desired_distance.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_desired_distance.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_desired_distance.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->desired_distance = u_desired_distance.real;
offset += sizeof(this->desired_distance);
union {
float real;
uint32_t base;
} u_min_distance;
u_min_distance.base = 0;
u_min_distance.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_distance.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_distance.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_distance.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->min_distance = u_min_distance.real;
offset += sizeof(this->min_distance);
return offset;
}
const char * getType(){ return "moveit_msgs/GripperTranslation"; };
const char * getMD5(){ return "b53bc0ad0f717cdec3b0e42dec300121"; };
};
}
#endif
| 3,255 | C | 34.010752 | 84 | 0.583103 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceFeedback.h | #ifndef _ROS_moveit_msgs_PlaceFeedback_h
#define _ROS_moveit_msgs_PlaceFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class PlaceFeedback : public ros::Msg
{
public:
typedef const char* _state_type;
_state_type state;
PlaceFeedback():
state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceFeedback"; };
const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; };
};
}
#endif
| 1,280 | C | 21.875 | 72 | 0.615625 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/ListRobotStatesInWarehouse.h | #ifndef _ROS_SERVICE_ListRobotStatesInWarehouse_h
#define _ROS_SERVICE_ListRobotStatesInWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char LISTROBOTSTATESINWAREHOUSE[] = "moveit_msgs/ListRobotStatesInWarehouse";
class ListRobotStatesInWarehouseRequest : public ros::Msg
{
public:
typedef const char* _regex_type;
_regex_type regex;
typedef const char* _robot_type;
_robot_type robot;
ListRobotStatesInWarehouseRequest():
regex(""),
robot("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_regex = strlen(this->regex);
varToArr(outbuffer + offset, length_regex);
offset += 4;
memcpy(outbuffer + offset, this->regex, length_regex);
offset += length_regex;
uint32_t length_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_regex;
arrToVar(length_regex, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_regex; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_regex-1]=0;
this->regex = (char *)(inbuffer + offset-1);
offset += length_regex;
uint32_t length_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
return offset;
}
const char * getType(){ return LISTROBOTSTATESINWAREHOUSE; };
const char * getMD5(){ return "6f0970a3ca837e2fc3ed63e314b44b42"; };
};
class ListRobotStatesInWarehouseResponse : public ros::Msg
{
public:
uint32_t states_length;
typedef char* _states_type;
_states_type st_states;
_states_type * states;
ListRobotStatesInWarehouseResponse():
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
uint32_t length_statesi = strlen(this->states[i]);
varToArr(outbuffer + offset, length_statesi);
offset += 4;
memcpy(outbuffer + offset, this->states[i], length_statesi);
offset += length_statesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (char**)realloc(this->states, states_lengthT * sizeof(char*));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
uint32_t length_st_states;
arrToVar(length_st_states, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_states; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_states-1]=0;
this->st_states = (char *)(inbuffer + offset-1);
offset += length_st_states;
memcpy( &(this->states[i]), &(this->st_states), sizeof(char*));
}
return offset;
}
const char * getType(){ return LISTROBOTSTATESINWAREHOUSE; };
const char * getMD5(){ return "a8656b247c0429bb79afe0ddb88eb2f5"; };
};
class ListRobotStatesInWarehouse {
public:
typedef ListRobotStatesInWarehouseRequest Request;
typedef ListRobotStatesInWarehouseResponse Response;
};
}
#endif
| 4,507 | C | 30.746479 | 90 | 0.610828 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/DisplayRobotState.h | #ifndef _ROS_moveit_msgs_DisplayRobotState_h
#define _ROS_moveit_msgs_DisplayRobotState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/ObjectColor.h"
namespace moveit_msgs
{
class DisplayRobotState : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _state_type;
_state_type state;
uint32_t highlight_links_length;
typedef moveit_msgs::ObjectColor _highlight_links_type;
_highlight_links_type st_highlight_links;
_highlight_links_type * highlight_links;
DisplayRobotState():
state(),
highlight_links_length(0), highlight_links(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->state.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->highlight_links_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->highlight_links_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->highlight_links_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->highlight_links_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->highlight_links_length);
for( uint32_t i = 0; i < highlight_links_length; i++){
offset += this->highlight_links[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->state.deserialize(inbuffer + offset);
uint32_t highlight_links_lengthT = ((uint32_t) (*(inbuffer + offset)));
highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
highlight_links_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->highlight_links_length);
if(highlight_links_lengthT > highlight_links_length)
this->highlight_links = (moveit_msgs::ObjectColor*)realloc(this->highlight_links, highlight_links_lengthT * sizeof(moveit_msgs::ObjectColor));
highlight_links_length = highlight_links_lengthT;
for( uint32_t i = 0; i < highlight_links_length; i++){
offset += this->st_highlight_links.deserialize(inbuffer + offset);
memcpy( &(this->highlight_links[i]), &(this->st_highlight_links), sizeof(moveit_msgs::ObjectColor));
}
return offset;
}
const char * getType(){ return "moveit_msgs/DisplayRobotState"; };
const char * getMD5(){ return "6a3bab3a33a8c47aee24481a455a21aa"; };
};
}
#endif
| 2,652 | C | 36.366197 | 150 | 0.636501 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionSequenceItem.h | #ifndef _ROS_moveit_msgs_MotionSequenceItem_h
#define _ROS_moveit_msgs_MotionSequenceItem_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionPlanRequest.h"
namespace moveit_msgs
{
class MotionSequenceItem : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanRequest _req_type;
_req_type req;
typedef double _blend_radius_type;
_blend_radius_type blend_radius;
MotionSequenceItem():
req(),
blend_radius(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->req.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_blend_radius;
u_blend_radius.real = this->blend_radius;
*(outbuffer + offset + 0) = (u_blend_radius.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_blend_radius.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_blend_radius.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_blend_radius.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_blend_radius.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_blend_radius.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_blend_radius.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_blend_radius.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->blend_radius);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->req.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_blend_radius;
u_blend_radius.base = 0;
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_blend_radius.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->blend_radius = u_blend_radius.real;
offset += sizeof(this->blend_radius);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionSequenceItem"; };
const char * getMD5(){ return "932aef4280f479e42c693b8b285624bf"; };
};
}
#endif
| 2,661 | C | 33.571428 | 80 | 0.567832 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceActionResult.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceActionResult_h
#define _ROS_moveit_msgs_MoveGroupSequenceActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/MoveGroupSequenceResult.h"
namespace moveit_msgs
{
class MoveGroupSequenceActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::MoveGroupSequenceResult _result_type;
_result_type result;
MoveGroupSequenceActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceActionResult"; };
const char * getMD5(){ return "e995e5b2d6c322a0395df341caa51d8e"; };
};
}
#endif
| 1,512 | C | 25.543859 | 82 | 0.67791 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/CollisionObject.h | #ifndef _ROS_moveit_msgs_CollisionObject_h
#define _ROS_moveit_msgs_CollisionObject_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "object_recognition_msgs/ObjectType.h"
#include "shape_msgs/SolidPrimitive.h"
#include "geometry_msgs/Pose.h"
#include "shape_msgs/Mesh.h"
#include "shape_msgs/Plane.h"
namespace moveit_msgs
{
class CollisionObject : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _id_type;
_id_type id;
typedef object_recognition_msgs::ObjectType _type_type;
_type_type type;
uint32_t primitives_length;
typedef shape_msgs::SolidPrimitive _primitives_type;
_primitives_type st_primitives;
_primitives_type * primitives;
uint32_t primitive_poses_length;
typedef geometry_msgs::Pose _primitive_poses_type;
_primitive_poses_type st_primitive_poses;
_primitive_poses_type * primitive_poses;
uint32_t meshes_length;
typedef shape_msgs::Mesh _meshes_type;
_meshes_type st_meshes;
_meshes_type * meshes;
uint32_t mesh_poses_length;
typedef geometry_msgs::Pose _mesh_poses_type;
_mesh_poses_type st_mesh_poses;
_mesh_poses_type * mesh_poses;
uint32_t planes_length;
typedef shape_msgs::Plane _planes_type;
_planes_type st_planes;
_planes_type * planes;
uint32_t plane_poses_length;
typedef geometry_msgs::Pose _plane_poses_type;
_plane_poses_type st_plane_poses;
_plane_poses_type * plane_poses;
typedef int8_t _operation_type;
_operation_type operation;
enum { ADD = 0 };
enum { REMOVE = 1 };
enum { APPEND = 2 };
enum { MOVE = 3 };
CollisionObject():
header(),
id(""),
type(),
primitives_length(0), primitives(NULL),
primitive_poses_length(0), primitive_poses(NULL),
meshes_length(0), meshes(NULL),
mesh_poses_length(0), mesh_poses(NULL),
planes_length(0), planes(NULL),
plane_poses_length(0), plane_poses(NULL),
operation(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
offset += this->type.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->primitives_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitives_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitives_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitives_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitives_length);
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->primitives[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->primitive_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitive_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitive_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitive_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitive_poses_length);
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->primitive_poses[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->meshes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->meshes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->meshes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->meshes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->meshes_length);
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->meshes[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->mesh_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->mesh_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->mesh_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->mesh_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->mesh_poses_length);
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->mesh_poses[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->planes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->planes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->planes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->planes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->planes_length);
for( uint32_t i = 0; i < planes_length; i++){
offset += this->planes[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->plane_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->plane_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->plane_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->plane_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->plane_poses_length);
for( uint32_t i = 0; i < plane_poses_length; i++){
offset += this->plane_poses[i].serialize(outbuffer + offset);
}
union {
int8_t real;
uint8_t base;
} u_operation;
u_operation.real = this->operation;
*(outbuffer + offset + 0) = (u_operation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->operation);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_id;
arrToVar(length_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_id-1]=0;
this->id = (char *)(inbuffer + offset-1);
offset += length_id;
offset += this->type.deserialize(inbuffer + offset);
uint32_t primitives_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitives_length);
if(primitives_lengthT > primitives_length)
this->primitives = (shape_msgs::SolidPrimitive*)realloc(this->primitives, primitives_lengthT * sizeof(shape_msgs::SolidPrimitive));
primitives_length = primitives_lengthT;
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->st_primitives.deserialize(inbuffer + offset);
memcpy( &(this->primitives[i]), &(this->st_primitives), sizeof(shape_msgs::SolidPrimitive));
}
uint32_t primitive_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitive_poses_length);
if(primitive_poses_lengthT > primitive_poses_length)
this->primitive_poses = (geometry_msgs::Pose*)realloc(this->primitive_poses, primitive_poses_lengthT * sizeof(geometry_msgs::Pose));
primitive_poses_length = primitive_poses_lengthT;
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->st_primitive_poses.deserialize(inbuffer + offset);
memcpy( &(this->primitive_poses[i]), &(this->st_primitive_poses), sizeof(geometry_msgs::Pose));
}
uint32_t meshes_lengthT = ((uint32_t) (*(inbuffer + offset)));
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->meshes_length);
if(meshes_lengthT > meshes_length)
this->meshes = (shape_msgs::Mesh*)realloc(this->meshes, meshes_lengthT * sizeof(shape_msgs::Mesh));
meshes_length = meshes_lengthT;
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->st_meshes.deserialize(inbuffer + offset);
memcpy( &(this->meshes[i]), &(this->st_meshes), sizeof(shape_msgs::Mesh));
}
uint32_t mesh_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->mesh_poses_length);
if(mesh_poses_lengthT > mesh_poses_length)
this->mesh_poses = (geometry_msgs::Pose*)realloc(this->mesh_poses, mesh_poses_lengthT * sizeof(geometry_msgs::Pose));
mesh_poses_length = mesh_poses_lengthT;
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->st_mesh_poses.deserialize(inbuffer + offset);
memcpy( &(this->mesh_poses[i]), &(this->st_mesh_poses), sizeof(geometry_msgs::Pose));
}
uint32_t planes_lengthT = ((uint32_t) (*(inbuffer + offset)));
planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
planes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->planes_length);
if(planes_lengthT > planes_length)
this->planes = (shape_msgs::Plane*)realloc(this->planes, planes_lengthT * sizeof(shape_msgs::Plane));
planes_length = planes_lengthT;
for( uint32_t i = 0; i < planes_length; i++){
offset += this->st_planes.deserialize(inbuffer + offset);
memcpy( &(this->planes[i]), &(this->st_planes), sizeof(shape_msgs::Plane));
}
uint32_t plane_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
plane_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->plane_poses_length);
if(plane_poses_lengthT > plane_poses_length)
this->plane_poses = (geometry_msgs::Pose*)realloc(this->plane_poses, plane_poses_lengthT * sizeof(geometry_msgs::Pose));
plane_poses_length = plane_poses_lengthT;
for( uint32_t i = 0; i < plane_poses_length; i++){
offset += this->st_plane_poses.deserialize(inbuffer + offset);
memcpy( &(this->plane_poses[i]), &(this->st_plane_poses), sizeof(geometry_msgs::Pose));
}
union {
int8_t real;
uint8_t base;
} u_operation;
u_operation.base = 0;
u_operation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->operation = u_operation.real;
offset += sizeof(this->operation);
return offset;
}
const char * getType(){ return "moveit_msgs/CollisionObject"; };
const char * getMD5(){ return "568a161b26dc46c54a5a07621ce82cf3"; };
};
}
#endif
| 11,609 | C | 46.581967 | 140 | 0.589973 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetRobotStateFromWarehouse.h | #ifndef _ROS_SERVICE_GetRobotStateFromWarehouse_h
#define _ROS_SERVICE_GetRobotStateFromWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
static const char GETROBOTSTATEFROMWAREHOUSE[] = "moveit_msgs/GetRobotStateFromWarehouse";
class GetRobotStateFromWarehouseRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _robot_type;
_robot_type robot;
GetRobotStateFromWarehouseRequest():
name(""),
robot("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
return offset;
}
const char * getType(){ return GETROBOTSTATEFROMWAREHOUSE; };
const char * getMD5(){ return "dab44354403f811c40b84964e068219c"; };
};
class GetRobotStateFromWarehouseResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _state_type;
_state_type state;
GetRobotStateFromWarehouseResponse():
state()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->state.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->state.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETROBOTSTATEFROMWAREHOUSE; };
const char * getMD5(){ return "219fdfe7af6da3c7935fb948e6d5c637"; };
};
class GetRobotStateFromWarehouse {
public:
typedef GetRobotStateFromWarehouseRequest Request;
typedef GetRobotStateFromWarehouseResponse Response;
};
}
#endif
| 2,947 | C | 25.558558 | 90 | 0.642687 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceActionGoal.h | #ifndef _ROS_moveit_msgs_PlaceActionGoal_h
#define _ROS_moveit_msgs_PlaceActionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalID.h"
#include "moveit_msgs/PlaceGoal.h"
namespace moveit_msgs
{
class PlaceActionGoal : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef moveit_msgs::PlaceGoal _goal_type;
_goal_type goal;
PlaceActionGoal():
header(),
goal_id(),
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->goal_id.serialize(outbuffer + offset);
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->goal_id.deserialize(inbuffer + offset);
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceActionGoal"; };
const char * getMD5(){ return "facadaee390f685ed5e693ac12f5aa3d"; };
};
}
#endif
| 1,400 | C | 23.578947 | 72 | 0.647857 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlaceActionResult.h | #ifndef _ROS_moveit_msgs_PlaceActionResult_h
#define _ROS_moveit_msgs_PlaceActionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/PlaceResult.h"
namespace moveit_msgs
{
class PlaceActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::PlaceResult _result_type;
_result_type result;
PlaceActionResult():
header(),
status(),
result()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->result.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->result.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PlaceActionResult"; };
const char * getMD5(){ return "a93c9107fd23796469241f1d40422dfa"; };
};
}
#endif
| 1,428 | C | 24.070175 | 72 | 0.658964 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetPlannerParams.h | #ifndef _ROS_SERVICE_GetPlannerParams_h
#define _ROS_SERVICE_GetPlannerParams_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PlannerParams.h"
namespace moveit_msgs
{
static const char GETPLANNERPARAMS[] = "moveit_msgs/GetPlannerParams";
class GetPlannerParamsRequest : public ros::Msg
{
public:
typedef const char* _planner_config_type;
_planner_config_type planner_config;
typedef const char* _group_type;
_group_type group;
GetPlannerParamsRequest():
planner_config(""),
group("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_planner_config = strlen(this->planner_config);
varToArr(outbuffer + offset, length_planner_config);
offset += 4;
memcpy(outbuffer + offset, this->planner_config, length_planner_config);
offset += length_planner_config;
uint32_t length_group = strlen(this->group);
varToArr(outbuffer + offset, length_group);
offset += 4;
memcpy(outbuffer + offset, this->group, length_group);
offset += length_group;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_planner_config;
arrToVar(length_planner_config, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_planner_config; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_planner_config-1]=0;
this->planner_config = (char *)(inbuffer + offset-1);
offset += length_planner_config;
uint32_t length_group;
arrToVar(length_group, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group-1]=0;
this->group = (char *)(inbuffer + offset-1);
offset += length_group;
return offset;
}
const char * getType(){ return GETPLANNERPARAMS; };
const char * getMD5(){ return "f548a13784550d510d791867af53ef40"; };
};
class GetPlannerParamsResponse : public ros::Msg
{
public:
typedef moveit_msgs::PlannerParams _params_type;
_params_type params;
GetPlannerParamsResponse():
params()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->params.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->params.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPLANNERPARAMS; };
const char * getMD5(){ return "462b1bd59976ece800f6a48f2b0bf1a2"; };
};
class GetPlannerParams {
public:
typedef GetPlannerParamsRequest Request;
typedef GetPlannerParamsResponse Response;
};
}
#endif
| 2,989 | C | 25.936937 | 78 | 0.642355 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlanningScene.h | #ifndef _ROS_moveit_msgs_PlanningScene_h
#define _ROS_moveit_msgs_PlanningScene_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "geometry_msgs/TransformStamped.h"
#include "moveit_msgs/AllowedCollisionMatrix.h"
#include "moveit_msgs/LinkPadding.h"
#include "moveit_msgs/LinkScale.h"
#include "moveit_msgs/ObjectColor.h"
#include "moveit_msgs/PlanningSceneWorld.h"
namespace moveit_msgs
{
class PlanningScene : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef moveit_msgs::RobotState _robot_state_type;
_robot_state_type robot_state;
typedef const char* _robot_model_name_type;
_robot_model_name_type robot_model_name;
uint32_t fixed_frame_transforms_length;
typedef geometry_msgs::TransformStamped _fixed_frame_transforms_type;
_fixed_frame_transforms_type st_fixed_frame_transforms;
_fixed_frame_transforms_type * fixed_frame_transforms;
typedef moveit_msgs::AllowedCollisionMatrix _allowed_collision_matrix_type;
_allowed_collision_matrix_type allowed_collision_matrix;
uint32_t link_padding_length;
typedef moveit_msgs::LinkPadding _link_padding_type;
_link_padding_type st_link_padding;
_link_padding_type * link_padding;
uint32_t link_scale_length;
typedef moveit_msgs::LinkScale _link_scale_type;
_link_scale_type st_link_scale;
_link_scale_type * link_scale;
uint32_t object_colors_length;
typedef moveit_msgs::ObjectColor _object_colors_type;
_object_colors_type st_object_colors;
_object_colors_type * object_colors;
typedef moveit_msgs::PlanningSceneWorld _world_type;
_world_type world;
typedef bool _is_diff_type;
_is_diff_type is_diff;
PlanningScene():
name(""),
robot_state(),
robot_model_name(""),
fixed_frame_transforms_length(0), fixed_frame_transforms(NULL),
allowed_collision_matrix(),
link_padding_length(0), link_padding(NULL),
link_scale_length(0), link_scale(NULL),
object_colors_length(0), object_colors(NULL),
world(),
is_diff(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
offset += this->robot_state.serialize(outbuffer + offset);
uint32_t length_robot_model_name = strlen(this->robot_model_name);
varToArr(outbuffer + offset, length_robot_model_name);
offset += 4;
memcpy(outbuffer + offset, this->robot_model_name, length_robot_model_name);
offset += length_robot_model_name;
*(outbuffer + offset + 0) = (this->fixed_frame_transforms_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fixed_frame_transforms_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fixed_frame_transforms_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fixed_frame_transforms_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fixed_frame_transforms_length);
for( uint32_t i = 0; i < fixed_frame_transforms_length; i++){
offset += this->fixed_frame_transforms[i].serialize(outbuffer + offset);
}
offset += this->allowed_collision_matrix.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->link_padding_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->link_padding_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->link_padding_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->link_padding_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->link_padding_length);
for( uint32_t i = 0; i < link_padding_length; i++){
offset += this->link_padding[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->link_scale_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->link_scale_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->link_scale_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->link_scale_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->link_scale_length);
for( uint32_t i = 0; i < link_scale_length; i++){
offset += this->link_scale[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->object_colors_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->object_colors_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->object_colors_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->object_colors_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->object_colors_length);
for( uint32_t i = 0; i < object_colors_length; i++){
offset += this->object_colors[i].serialize(outbuffer + offset);
}
offset += this->world.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_is_diff;
u_is_diff.real = this->is_diff;
*(outbuffer + offset + 0) = (u_is_diff.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_diff);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
offset += this->robot_state.deserialize(inbuffer + offset);
uint32_t length_robot_model_name;
arrToVar(length_robot_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot_model_name-1]=0;
this->robot_model_name = (char *)(inbuffer + offset-1);
offset += length_robot_model_name;
uint32_t fixed_frame_transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fixed_frame_transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fixed_frame_transforms_length);
if(fixed_frame_transforms_lengthT > fixed_frame_transforms_length)
this->fixed_frame_transforms = (geometry_msgs::TransformStamped*)realloc(this->fixed_frame_transforms, fixed_frame_transforms_lengthT * sizeof(geometry_msgs::TransformStamped));
fixed_frame_transforms_length = fixed_frame_transforms_lengthT;
for( uint32_t i = 0; i < fixed_frame_transforms_length; i++){
offset += this->st_fixed_frame_transforms.deserialize(inbuffer + offset);
memcpy( &(this->fixed_frame_transforms[i]), &(this->st_fixed_frame_transforms), sizeof(geometry_msgs::TransformStamped));
}
offset += this->allowed_collision_matrix.deserialize(inbuffer + offset);
uint32_t link_padding_lengthT = ((uint32_t) (*(inbuffer + offset)));
link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
link_padding_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->link_padding_length);
if(link_padding_lengthT > link_padding_length)
this->link_padding = (moveit_msgs::LinkPadding*)realloc(this->link_padding, link_padding_lengthT * sizeof(moveit_msgs::LinkPadding));
link_padding_length = link_padding_lengthT;
for( uint32_t i = 0; i < link_padding_length; i++){
offset += this->st_link_padding.deserialize(inbuffer + offset);
memcpy( &(this->link_padding[i]), &(this->st_link_padding), sizeof(moveit_msgs::LinkPadding));
}
uint32_t link_scale_lengthT = ((uint32_t) (*(inbuffer + offset)));
link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
link_scale_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->link_scale_length);
if(link_scale_lengthT > link_scale_length)
this->link_scale = (moveit_msgs::LinkScale*)realloc(this->link_scale, link_scale_lengthT * sizeof(moveit_msgs::LinkScale));
link_scale_length = link_scale_lengthT;
for( uint32_t i = 0; i < link_scale_length; i++){
offset += this->st_link_scale.deserialize(inbuffer + offset);
memcpy( &(this->link_scale[i]), &(this->st_link_scale), sizeof(moveit_msgs::LinkScale));
}
uint32_t object_colors_lengthT = ((uint32_t) (*(inbuffer + offset)));
object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
object_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->object_colors_length);
if(object_colors_lengthT > object_colors_length)
this->object_colors = (moveit_msgs::ObjectColor*)realloc(this->object_colors, object_colors_lengthT * sizeof(moveit_msgs::ObjectColor));
object_colors_length = object_colors_lengthT;
for( uint32_t i = 0; i < object_colors_length; i++){
offset += this->st_object_colors.deserialize(inbuffer + offset);
memcpy( &(this->object_colors[i]), &(this->st_object_colors), sizeof(moveit_msgs::ObjectColor));
}
offset += this->world.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_is_diff;
u_is_diff.base = 0;
u_is_diff.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_diff = u_is_diff.real;
offset += sizeof(this->is_diff);
return offset;
}
const char * getType(){ return "moveit_msgs/PlanningScene"; };
const char * getMD5(){ return "89aac6d20db967ba716cba5a86b1b9d5"; };
};
}
#endif
| 10,388 | C | 47.774648 | 185 | 0.620042 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupGoal.h | #ifndef _ROS_moveit_msgs_MoveGroupGoal_h
#define _ROS_moveit_msgs_MoveGroupGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionPlanRequest.h"
#include "moveit_msgs/PlanningOptions.h"
namespace moveit_msgs
{
class MoveGroupGoal : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanRequest _request_type;
_request_type request;
typedef moveit_msgs::PlanningOptions _planning_options_type;
_planning_options_type planning_options;
MoveGroupGoal():
request(),
planning_options()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->request.serialize(outbuffer + offset);
offset += this->planning_options.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->request.deserialize(inbuffer + offset);
offset += this->planning_options.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupGoal"; };
const char * getMD5(){ return "a6de2db49c561a49babce1a8172e8906"; };
};
}
#endif
| 1,252 | C | 23.568627 | 72 | 0.673323 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/RenameRobotStateInWarehouse.h | #ifndef _ROS_SERVICE_RenameRobotStateInWarehouse_h
#define _ROS_SERVICE_RenameRobotStateInWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char RENAMEROBOTSTATEINWAREHOUSE[] = "moveit_msgs/RenameRobotStateInWarehouse";
class RenameRobotStateInWarehouseRequest : public ros::Msg
{
public:
typedef const char* _old_name_type;
_old_name_type old_name;
typedef const char* _new_name_type;
_new_name_type new_name;
typedef const char* _robot_type;
_robot_type robot;
RenameRobotStateInWarehouseRequest():
old_name(""),
new_name(""),
robot("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_old_name = strlen(this->old_name);
varToArr(outbuffer + offset, length_old_name);
offset += 4;
memcpy(outbuffer + offset, this->old_name, length_old_name);
offset += length_old_name;
uint32_t length_new_name = strlen(this->new_name);
varToArr(outbuffer + offset, length_new_name);
offset += 4;
memcpy(outbuffer + offset, this->new_name, length_new_name);
offset += length_new_name;
uint32_t length_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_old_name;
arrToVar(length_old_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_old_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_old_name-1]=0;
this->old_name = (char *)(inbuffer + offset-1);
offset += length_old_name;
uint32_t length_new_name;
arrToVar(length_new_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_new_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_new_name-1]=0;
this->new_name = (char *)(inbuffer + offset-1);
offset += length_new_name;
uint32_t length_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
return offset;
}
const char * getType(){ return RENAMEROBOTSTATEINWAREHOUSE; };
const char * getMD5(){ return "073dc05c3fd313b947cea483c25c46b0"; };
};
class RenameRobotStateInWarehouseResponse : public ros::Msg
{
public:
RenameRobotStateInWarehouseResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return RENAMEROBOTSTATEINWAREHOUSE; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class RenameRobotStateInWarehouse {
public:
typedef RenameRobotStateInWarehouseRequest Request;
typedef RenameRobotStateInWarehouseResponse Response;
};
}
#endif
| 3,448 | C | 27.270492 | 92 | 0.635151 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceFeedback.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceFeedback_h
#define _ROS_moveit_msgs_MoveGroupSequenceFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class MoveGroupSequenceFeedback : public ros::Msg
{
public:
typedef const char* _state_type;
_state_type state;
MoveGroupSequenceFeedback():
state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceFeedback"; };
const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; };
};
}
#endif
| 1,340 | C | 22.946428 | 78 | 0.632836 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/KinematicSolverInfo.h | #ifndef _ROS_moveit_msgs_KinematicSolverInfo_h
#define _ROS_moveit_msgs_KinematicSolverInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/JointLimits.h"
namespace moveit_msgs
{
class KinematicSolverInfo : public ros::Msg
{
public:
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t limits_length;
typedef moveit_msgs::JointLimits _limits_type;
_limits_type st_limits;
_limits_type * limits;
uint32_t link_names_length;
typedef char* _link_names_type;
_link_names_type st_link_names;
_link_names_type * link_names;
KinematicSolverInfo():
joint_names_length(0), joint_names(NULL),
limits_length(0), limits(NULL),
link_names_length(0), link_names(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
*(outbuffer + offset + 0) = (this->limits_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->limits_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->limits_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->limits_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->limits_length);
for( uint32_t i = 0; i < limits_length; i++){
offset += this->limits[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->link_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->link_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->link_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->link_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->link_names_length);
for( uint32_t i = 0; i < link_names_length; i++){
uint32_t length_link_namesi = strlen(this->link_names[i]);
varToArr(outbuffer + offset, length_link_namesi);
offset += 4;
memcpy(outbuffer + offset, this->link_names[i], length_link_namesi);
offset += length_link_namesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
uint32_t limits_lengthT = ((uint32_t) (*(inbuffer + offset)));
limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
limits_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->limits_length);
if(limits_lengthT > limits_length)
this->limits = (moveit_msgs::JointLimits*)realloc(this->limits, limits_lengthT * sizeof(moveit_msgs::JointLimits));
limits_length = limits_lengthT;
for( uint32_t i = 0; i < limits_length; i++){
offset += this->st_limits.deserialize(inbuffer + offset);
memcpy( &(this->limits[i]), &(this->st_limits), sizeof(moveit_msgs::JointLimits));
}
uint32_t link_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->link_names_length);
if(link_names_lengthT > link_names_length)
this->link_names = (char**)realloc(this->link_names, link_names_lengthT * sizeof(char*));
link_names_length = link_names_lengthT;
for( uint32_t i = 0; i < link_names_length; i++){
uint32_t length_st_link_names;
arrToVar(length_st_link_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_link_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_link_names-1]=0;
this->st_link_names = (char *)(inbuffer + offset-1);
offset += length_st_link_names;
memcpy( &(this->link_names[i]), &(this->st_link_names), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/KinematicSolverInfo"; };
const char * getMD5(){ return "cc048557c0f9795c392dd80f8bb00489"; };
};
}
#endif
| 6,086 | C | 42.791367 | 123 | 0.589057 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PositionIKRequest.h | #ifndef _ROS_moveit_msgs_PositionIKRequest_h
#define _ROS_moveit_msgs_PositionIKRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/Constraints.h"
#include "geometry_msgs/PoseStamped.h"
#include "ros/duration.h"
namespace moveit_msgs
{
class PositionIKRequest : public ros::Msg
{
public:
typedef const char* _group_name_type;
_group_name_type group_name;
typedef moveit_msgs::RobotState _robot_state_type;
_robot_state_type robot_state;
typedef moveit_msgs::Constraints _constraints_type;
_constraints_type constraints;
typedef bool _avoid_collisions_type;
_avoid_collisions_type avoid_collisions;
typedef const char* _ik_link_name_type;
_ik_link_name_type ik_link_name;
typedef geometry_msgs::PoseStamped _pose_stamped_type;
_pose_stamped_type pose_stamped;
uint32_t ik_link_names_length;
typedef char* _ik_link_names_type;
_ik_link_names_type st_ik_link_names;
_ik_link_names_type * ik_link_names;
uint32_t pose_stamped_vector_length;
typedef geometry_msgs::PoseStamped _pose_stamped_vector_type;
_pose_stamped_vector_type st_pose_stamped_vector;
_pose_stamped_vector_type * pose_stamped_vector;
typedef ros::Duration _timeout_type;
_timeout_type timeout;
typedef int32_t _attempts_type;
_attempts_type attempts;
PositionIKRequest():
group_name(""),
robot_state(),
constraints(),
avoid_collisions(0),
ik_link_name(""),
pose_stamped(),
ik_link_names_length(0), ik_link_names(NULL),
pose_stamped_vector_length(0), pose_stamped_vector(NULL),
timeout(),
attempts(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
offset += this->robot_state.serialize(outbuffer + offset);
offset += this->constraints.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.real = this->avoid_collisions;
*(outbuffer + offset + 0) = (u_avoid_collisions.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->avoid_collisions);
uint32_t length_ik_link_name = strlen(this->ik_link_name);
varToArr(outbuffer + offset, length_ik_link_name);
offset += 4;
memcpy(outbuffer + offset, this->ik_link_name, length_ik_link_name);
offset += length_ik_link_name;
offset += this->pose_stamped.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->ik_link_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->ik_link_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->ik_link_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->ik_link_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->ik_link_names_length);
for( uint32_t i = 0; i < ik_link_names_length; i++){
uint32_t length_ik_link_namesi = strlen(this->ik_link_names[i]);
varToArr(outbuffer + offset, length_ik_link_namesi);
offset += 4;
memcpy(outbuffer + offset, this->ik_link_names[i], length_ik_link_namesi);
offset += length_ik_link_namesi;
}
*(outbuffer + offset + 0) = (this->pose_stamped_vector_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_stamped_vector_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_stamped_vector_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_stamped_vector_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_stamped_vector_length);
for( uint32_t i = 0; i < pose_stamped_vector_length; i++){
offset += this->pose_stamped_vector[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->timeout.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.sec);
*(outbuffer + offset + 0) = (this->timeout.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->timeout.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->timeout.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->timeout.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->timeout.nsec);
union {
int32_t real;
uint32_t base;
} u_attempts;
u_attempts.real = this->attempts;
*(outbuffer + offset + 0) = (u_attempts.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attempts.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attempts.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attempts.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->attempts);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
offset += this->robot_state.deserialize(inbuffer + offset);
offset += this->constraints.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_avoid_collisions;
u_avoid_collisions.base = 0;
u_avoid_collisions.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->avoid_collisions = u_avoid_collisions.real;
offset += sizeof(this->avoid_collisions);
uint32_t length_ik_link_name;
arrToVar(length_ik_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_ik_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_ik_link_name-1]=0;
this->ik_link_name = (char *)(inbuffer + offset-1);
offset += length_ik_link_name;
offset += this->pose_stamped.deserialize(inbuffer + offset);
uint32_t ik_link_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
ik_link_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->ik_link_names_length);
if(ik_link_names_lengthT > ik_link_names_length)
this->ik_link_names = (char**)realloc(this->ik_link_names, ik_link_names_lengthT * sizeof(char*));
ik_link_names_length = ik_link_names_lengthT;
for( uint32_t i = 0; i < ik_link_names_length; i++){
uint32_t length_st_ik_link_names;
arrToVar(length_st_ik_link_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_ik_link_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_ik_link_names-1]=0;
this->st_ik_link_names = (char *)(inbuffer + offset-1);
offset += length_st_ik_link_names;
memcpy( &(this->ik_link_names[i]), &(this->st_ik_link_names), sizeof(char*));
}
uint32_t pose_stamped_vector_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_stamped_vector_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_stamped_vector_length);
if(pose_stamped_vector_lengthT > pose_stamped_vector_length)
this->pose_stamped_vector = (geometry_msgs::PoseStamped*)realloc(this->pose_stamped_vector, pose_stamped_vector_lengthT * sizeof(geometry_msgs::PoseStamped));
pose_stamped_vector_length = pose_stamped_vector_lengthT;
for( uint32_t i = 0; i < pose_stamped_vector_length; i++){
offset += this->st_pose_stamped_vector.deserialize(inbuffer + offset);
memcpy( &(this->pose_stamped_vector[i]), &(this->st_pose_stamped_vector), sizeof(geometry_msgs::PoseStamped));
}
this->timeout.sec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.sec);
this->timeout.nsec = ((uint32_t) (*(inbuffer + offset)));
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->timeout.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->timeout.nsec);
union {
int32_t real;
uint32_t base;
} u_attempts;
u_attempts.base = 0;
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attempts.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->attempts = u_attempts.real;
offset += sizeof(this->attempts);
return offset;
}
const char * getType(){ return "moveit_msgs/PositionIKRequest"; };
const char * getMD5(){ return "9936dc239c90af180ec94a51596c96f2"; };
};
}
#endif
| 10,071 | C | 44.990867 | 166 | 0.593685 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/SaveRobotStateToWarehouse.h | #ifndef _ROS_SERVICE_SaveRobotStateToWarehouse_h
#define _ROS_SERVICE_SaveRobotStateToWarehouse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
namespace moveit_msgs
{
static const char SAVEROBOTSTATETOWAREHOUSE[] = "moveit_msgs/SaveRobotStateToWarehouse";
class SaveRobotStateToWarehouseRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _robot_type;
_robot_type robot;
typedef moveit_msgs::RobotState _state_type;
_state_type state;
SaveRobotStateToWarehouseRequest():
name(""),
robot(""),
state()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_robot = strlen(this->robot);
varToArr(outbuffer + offset, length_robot);
offset += 4;
memcpy(outbuffer + offset, this->robot, length_robot);
offset += length_robot;
offset += this->state.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_robot;
arrToVar(length_robot, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot-1]=0;
this->robot = (char *)(inbuffer + offset-1);
offset += length_robot;
offset += this->state.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SAVEROBOTSTATETOWAREHOUSE; };
const char * getMD5(){ return "7937284880c511876f85988912ec5448"; };
};
class SaveRobotStateToWarehouseResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
SaveRobotStateToWarehouseResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return SAVEROBOTSTATETOWAREHOUSE; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class SaveRobotStateToWarehouse {
public:
typedef SaveRobotStateToWarehouseRequest Request;
typedef SaveRobotStateToWarehouseResponse Response;
};
}
#endif
| 3,488 | C | 26.046511 | 88 | 0.6207 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/GetMotionPlan.h | #ifndef _ROS_SERVICE_GetMotionPlan_h
#define _ROS_SERVICE_GetMotionPlan_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/MotionPlanRequest.h"
#include "moveit_msgs/MotionPlanResponse.h"
namespace moveit_msgs
{
static const char GETMOTIONPLAN[] = "moveit_msgs/GetMotionPlan";
class GetMotionPlanRequest : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanRequest _motion_plan_request_type;
_motion_plan_request_type motion_plan_request;
GetMotionPlanRequest():
motion_plan_request()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->motion_plan_request.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->motion_plan_request.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMOTIONPLAN; };
const char * getMD5(){ return "9dcb82c5daeb2ff8a7ab1a98b642871d"; };
};
class GetMotionPlanResponse : public ros::Msg
{
public:
typedef moveit_msgs::MotionPlanResponse _motion_plan_response_type;
_motion_plan_response_type motion_plan_response;
GetMotionPlanResponse():
motion_plan_response()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->motion_plan_response.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->motion_plan_response.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMOTIONPLAN; };
const char * getMD5(){ return "37fe7e8f0d4dfa55ccfa53d63c86ae15"; };
};
class GetMotionPlan {
public:
typedef GetMotionPlanRequest Request;
typedef GetMotionPlanResponse Response;
};
}
#endif
| 2,000 | C | 23.108433 | 74 | 0.6765 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/SaveMap.h | #ifndef _ROS_SERVICE_SaveMap_h
#define _ROS_SERVICE_SaveMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
static const char SAVEMAP[] = "moveit_msgs/SaveMap";
class SaveMapRequest : public ros::Msg
{
public:
typedef const char* _filename_type;
_filename_type filename;
SaveMapRequest():
filename("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_filename = strlen(this->filename);
varToArr(outbuffer + offset, length_filename);
offset += 4;
memcpy(outbuffer + offset, this->filename, length_filename);
offset += length_filename;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_filename;
arrToVar(length_filename, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_filename; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_filename-1]=0;
this->filename = (char *)(inbuffer + offset-1);
offset += length_filename;
return offset;
}
const char * getType(){ return SAVEMAP; };
const char * getMD5(){ return "030824f52a0628ead956fb9d67e66ae9"; };
};
class SaveMapResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
SaveMapResponse():
success(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
return offset;
}
const char * getType(){ return SAVEMAP; };
const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
};
class SaveMap {
public:
typedef SaveMapRequest Request;
typedef SaveMapResponse Response;
};
}
#endif
| 2,450 | C | 22.122641 | 74 | 0.599184 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupSequenceActionFeedback.h | #ifndef _ROS_moveit_msgs_MoveGroupSequenceActionFeedback_h
#define _ROS_moveit_msgs_MoveGroupSequenceActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/MoveGroupSequenceFeedback.h"
namespace moveit_msgs
{
class MoveGroupSequenceActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::MoveGroupSequenceFeedback _feedback_type;
_feedback_type feedback;
MoveGroupSequenceActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupSequenceActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
| 1,538 | C | 26 | 84 | 0.683355 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionPlanResponse.h | #ifndef _ROS_moveit_msgs_MotionPlanResponse_h
#define _ROS_moveit_msgs_MotionPlanResponse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/MoveItErrorCodes.h"
namespace moveit_msgs
{
class MotionPlanResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
typedef const char* _group_name_type;
_group_name_type group_name;
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type trajectory;
typedef double _planning_time_type;
_planning_time_type planning_time;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
MotionPlanResponse():
trajectory_start(),
group_name(""),
trajectory(),
planning_time(0),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory_start.serialize(outbuffer + offset);
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
offset += this->trajectory.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.real = this->planning_time;
*(outbuffer + offset + 0) = (u_planning_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_planning_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_planning_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_planning_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_planning_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_planning_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_planning_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_planning_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->planning_time);
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory_start.deserialize(inbuffer + offset);
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
offset += this->trajectory.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_planning_time;
u_planning_time.base = 0;
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_planning_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->planning_time = u_planning_time.real;
offset += sizeof(this->planning_time);
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionPlanResponse"; };
const char * getMD5(){ return "e493d20ab41424c48f671e152c70fc74"; };
};
}
#endif
| 4,030 | C | 37.028302 | 81 | 0.602233 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MotionPlanDetailedResponse.h | #ifndef _ROS_moveit_msgs_MotionPlanDetailedResponse_h
#define _ROS_moveit_msgs_MotionPlanDetailedResponse_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/RobotState.h"
#include "moveit_msgs/RobotTrajectory.h"
#include "moveit_msgs/MoveItErrorCodes.h"
namespace moveit_msgs
{
class MotionPlanDetailedResponse : public ros::Msg
{
public:
typedef moveit_msgs::RobotState _trajectory_start_type;
_trajectory_start_type trajectory_start;
typedef const char* _group_name_type;
_group_name_type group_name;
uint32_t trajectory_length;
typedef moveit_msgs::RobotTrajectory _trajectory_type;
_trajectory_type st_trajectory;
_trajectory_type * trajectory;
uint32_t description_length;
typedef char* _description_type;
_description_type st_description;
_description_type * description;
uint32_t processing_time_length;
typedef double _processing_time_type;
_processing_time_type st_processing_time;
_processing_time_type * processing_time;
typedef moveit_msgs::MoveItErrorCodes _error_code_type;
_error_code_type error_code;
MotionPlanDetailedResponse():
trajectory_start(),
group_name(""),
trajectory_length(0), trajectory(NULL),
description_length(0), description(NULL),
processing_time_length(0), processing_time(NULL),
error_code()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->trajectory_start.serialize(outbuffer + offset);
uint32_t length_group_name = strlen(this->group_name);
varToArr(outbuffer + offset, length_group_name);
offset += 4;
memcpy(outbuffer + offset, this->group_name, length_group_name);
offset += length_group_name;
*(outbuffer + offset + 0) = (this->trajectory_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->trajectory_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->trajectory_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->trajectory_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->trajectory_length);
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->trajectory[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->description_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->description_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->description_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->description_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->description_length);
for( uint32_t i = 0; i < description_length; i++){
uint32_t length_descriptioni = strlen(this->description[i]);
varToArr(outbuffer + offset, length_descriptioni);
offset += 4;
memcpy(outbuffer + offset, this->description[i], length_descriptioni);
offset += length_descriptioni;
}
*(outbuffer + offset + 0) = (this->processing_time_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->processing_time_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->processing_time_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->processing_time_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->processing_time_length);
for( uint32_t i = 0; i < processing_time_length; i++){
union {
double real;
uint64_t base;
} u_processing_timei;
u_processing_timei.real = this->processing_time[i];
*(outbuffer + offset + 0) = (u_processing_timei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_processing_timei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_processing_timei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_processing_timei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_processing_timei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_processing_timei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_processing_timei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_processing_timei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->processing_time[i]);
}
offset += this->error_code.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->trajectory_start.deserialize(inbuffer + offset);
uint32_t length_group_name;
arrToVar(length_group_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_group_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_group_name-1]=0;
this->group_name = (char *)(inbuffer + offset-1);
offset += length_group_name;
uint32_t trajectory_lengthT = ((uint32_t) (*(inbuffer + offset)));
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
trajectory_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->trajectory_length);
if(trajectory_lengthT > trajectory_length)
this->trajectory = (moveit_msgs::RobotTrajectory*)realloc(this->trajectory, trajectory_lengthT * sizeof(moveit_msgs::RobotTrajectory));
trajectory_length = trajectory_lengthT;
for( uint32_t i = 0; i < trajectory_length; i++){
offset += this->st_trajectory.deserialize(inbuffer + offset);
memcpy( &(this->trajectory[i]), &(this->st_trajectory), sizeof(moveit_msgs::RobotTrajectory));
}
uint32_t description_lengthT = ((uint32_t) (*(inbuffer + offset)));
description_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
description_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
description_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->description_length);
if(description_lengthT > description_length)
this->description = (char**)realloc(this->description, description_lengthT * sizeof(char*));
description_length = description_lengthT;
for( uint32_t i = 0; i < description_length; i++){
uint32_t length_st_description;
arrToVar(length_st_description, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_description; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_description-1]=0;
this->st_description = (char *)(inbuffer + offset-1);
offset += length_st_description;
memcpy( &(this->description[i]), &(this->st_description), sizeof(char*));
}
uint32_t processing_time_lengthT = ((uint32_t) (*(inbuffer + offset)));
processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
processing_time_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->processing_time_length);
if(processing_time_lengthT > processing_time_length)
this->processing_time = (double*)realloc(this->processing_time, processing_time_lengthT * sizeof(double));
processing_time_length = processing_time_lengthT;
for( uint32_t i = 0; i < processing_time_length; i++){
union {
double real;
uint64_t base;
} u_st_processing_time;
u_st_processing_time.base = 0;
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_processing_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_processing_time = u_st_processing_time.real;
offset += sizeof(this->st_processing_time);
memcpy( &(this->processing_time[i]), &(this->st_processing_time), sizeof(double));
}
offset += this->error_code.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MotionPlanDetailedResponse"; };
const char * getMD5(){ return "7b84c374bb2e37bdc0eba664f7636a8f"; };
};
}
#endif
| 8,844 | C | 47.333333 | 143 | 0.606739 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/TrajectoryConstraints.h | #ifndef _ROS_moveit_msgs_TrajectoryConstraints_h
#define _ROS_moveit_msgs_TrajectoryConstraints_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/Constraints.h"
namespace moveit_msgs
{
class TrajectoryConstraints : public ros::Msg
{
public:
uint32_t constraints_length;
typedef moveit_msgs::Constraints _constraints_type;
_constraints_type st_constraints;
_constraints_type * constraints;
TrajectoryConstraints():
constraints_length(0), constraints(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->constraints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->constraints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->constraints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->constraints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->constraints_length);
for( uint32_t i = 0; i < constraints_length; i++){
offset += this->constraints[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t constraints_lengthT = ((uint32_t) (*(inbuffer + offset)));
constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
constraints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->constraints_length);
if(constraints_lengthT > constraints_length)
this->constraints = (moveit_msgs::Constraints*)realloc(this->constraints, constraints_lengthT * sizeof(moveit_msgs::Constraints));
constraints_length = constraints_lengthT;
for( uint32_t i = 0; i < constraints_length; i++){
offset += this->st_constraints.deserialize(inbuffer + offset);
memcpy( &(this->constraints[i]), &(this->st_constraints), sizeof(moveit_msgs::Constraints));
}
return offset;
}
const char * getType(){ return "moveit_msgs/TrajectoryConstraints"; };
const char * getMD5(){ return "461e1a732dfebb01e7d6c75d51a51eac"; };
};
}
#endif
| 2,302 | C | 34.430769 | 138 | 0.63119 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupActionFeedback.h | #ifndef _ROS_moveit_msgs_MoveGroupActionFeedback_h
#define _ROS_moveit_msgs_MoveGroupActionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
#include "moveit_msgs/MoveGroupFeedback.h"
namespace moveit_msgs
{
class MoveGroupActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef moveit_msgs::MoveGroupFeedback _feedback_type;
_feedback_type feedback;
MoveGroupActionFeedback():
header(),
status(),
feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->status.serialize(outbuffer + offset);
offset += this->feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->status.deserialize(inbuffer + offset);
offset += this->feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
| 1,482 | C | 25.017543 | 76 | 0.67139 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PickupAction.h | #ifndef _ROS_moveit_msgs_PickupAction_h
#define _ROS_moveit_msgs_PickupAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "moveit_msgs/PickupActionGoal.h"
#include "moveit_msgs/PickupActionResult.h"
#include "moveit_msgs/PickupActionFeedback.h"
namespace moveit_msgs
{
class PickupAction : public ros::Msg
{
public:
typedef moveit_msgs::PickupActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef moveit_msgs::PickupActionResult _action_result_type;
_action_result_type action_result;
typedef moveit_msgs::PickupActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
PickupAction():
action_goal(),
action_result(),
action_feedback()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->action_goal.serialize(outbuffer + offset);
offset += this->action_result.serialize(outbuffer + offset);
offset += this->action_feedback.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->action_goal.deserialize(inbuffer + offset);
offset += this->action_result.deserialize(inbuffer + offset);
offset += this->action_feedback.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/PickupAction"; };
const char * getMD5(){ return "966c9238fcaad4ba8d20e116b676ccc1"; };
};
}
#endif
| 1,583 | C | 26.789473 | 72 | 0.680985 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/MoveGroupFeedback.h | #ifndef _ROS_moveit_msgs_MoveGroupFeedback_h
#define _ROS_moveit_msgs_MoveGroupFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class MoveGroupFeedback : public ros::Msg
{
public:
typedef const char* _state_type;
_state_type state;
MoveGroupFeedback():
state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state = strlen(this->state);
varToArr(outbuffer + offset, length_state);
offset += 4;
memcpy(outbuffer + offset, this->state, length_state);
offset += length_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state;
arrToVar(length_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state-1]=0;
this->state = (char *)(inbuffer + offset-1);
offset += length_state;
return offset;
}
const char * getType(){ return "moveit_msgs/MoveGroupFeedback"; };
const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; };
};
}
#endif
| 1,300 | C | 22.232142 | 72 | 0.621538 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlannerInterfaceDescription.h | #ifndef _ROS_moveit_msgs_PlannerInterfaceDescription_h
#define _ROS_moveit_msgs_PlannerInterfaceDescription_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class PlannerInterfaceDescription : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
uint32_t planner_ids_length;
typedef char* _planner_ids_type;
_planner_ids_type st_planner_ids;
_planner_ids_type * planner_ids;
PlannerInterfaceDescription():
name(""),
planner_ids_length(0), planner_ids(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
*(outbuffer + offset + 0) = (this->planner_ids_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->planner_ids_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->planner_ids_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->planner_ids_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->planner_ids_length);
for( uint32_t i = 0; i < planner_ids_length; i++){
uint32_t length_planner_idsi = strlen(this->planner_ids[i]);
varToArr(outbuffer + offset, length_planner_idsi);
offset += 4;
memcpy(outbuffer + offset, this->planner_ids[i], length_planner_idsi);
offset += length_planner_idsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t planner_ids_lengthT = ((uint32_t) (*(inbuffer + offset)));
planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
planner_ids_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->planner_ids_length);
if(planner_ids_lengthT > planner_ids_length)
this->planner_ids = (char**)realloc(this->planner_ids, planner_ids_lengthT * sizeof(char*));
planner_ids_length = planner_ids_lengthT;
for( uint32_t i = 0; i < planner_ids_length; i++){
uint32_t length_st_planner_ids;
arrToVar(length_st_planner_ids, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_planner_ids; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_planner_ids-1]=0;
this->st_planner_ids = (char *)(inbuffer + offset-1);
offset += length_st_planner_ids;
memcpy( &(this->planner_ids[i]), &(this->st_planner_ids), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/PlannerInterfaceDescription"; };
const char * getMD5(){ return "ea5f6e6129aa1b110ccda9900d2bf25e"; };
};
}
#endif
| 3,329 | C | 34.806451 | 100 | 0.604085 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/BoundingVolume.h | #ifndef _ROS_moveit_msgs_BoundingVolume_h
#define _ROS_moveit_msgs_BoundingVolume_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "shape_msgs/SolidPrimitive.h"
#include "geometry_msgs/Pose.h"
#include "shape_msgs/Mesh.h"
namespace moveit_msgs
{
class BoundingVolume : public ros::Msg
{
public:
uint32_t primitives_length;
typedef shape_msgs::SolidPrimitive _primitives_type;
_primitives_type st_primitives;
_primitives_type * primitives;
uint32_t primitive_poses_length;
typedef geometry_msgs::Pose _primitive_poses_type;
_primitive_poses_type st_primitive_poses;
_primitive_poses_type * primitive_poses;
uint32_t meshes_length;
typedef shape_msgs::Mesh _meshes_type;
_meshes_type st_meshes;
_meshes_type * meshes;
uint32_t mesh_poses_length;
typedef geometry_msgs::Pose _mesh_poses_type;
_mesh_poses_type st_mesh_poses;
_mesh_poses_type * mesh_poses;
BoundingVolume():
primitives_length(0), primitives(NULL),
primitive_poses_length(0), primitive_poses(NULL),
meshes_length(0), meshes(NULL),
mesh_poses_length(0), mesh_poses(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->primitives_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitives_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitives_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitives_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitives_length);
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->primitives[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->primitive_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->primitive_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->primitive_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->primitive_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->primitive_poses_length);
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->primitive_poses[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->meshes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->meshes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->meshes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->meshes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->meshes_length);
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->meshes[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->mesh_poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->mesh_poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->mesh_poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->mesh_poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->mesh_poses_length);
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->mesh_poses[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t primitives_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitives_length);
if(primitives_lengthT > primitives_length)
this->primitives = (shape_msgs::SolidPrimitive*)realloc(this->primitives, primitives_lengthT * sizeof(shape_msgs::SolidPrimitive));
primitives_length = primitives_lengthT;
for( uint32_t i = 0; i < primitives_length; i++){
offset += this->st_primitives.deserialize(inbuffer + offset);
memcpy( &(this->primitives[i]), &(this->st_primitives), sizeof(shape_msgs::SolidPrimitive));
}
uint32_t primitive_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->primitive_poses_length);
if(primitive_poses_lengthT > primitive_poses_length)
this->primitive_poses = (geometry_msgs::Pose*)realloc(this->primitive_poses, primitive_poses_lengthT * sizeof(geometry_msgs::Pose));
primitive_poses_length = primitive_poses_lengthT;
for( uint32_t i = 0; i < primitive_poses_length; i++){
offset += this->st_primitive_poses.deserialize(inbuffer + offset);
memcpy( &(this->primitive_poses[i]), &(this->st_primitive_poses), sizeof(geometry_msgs::Pose));
}
uint32_t meshes_lengthT = ((uint32_t) (*(inbuffer + offset)));
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->meshes_length);
if(meshes_lengthT > meshes_length)
this->meshes = (shape_msgs::Mesh*)realloc(this->meshes, meshes_lengthT * sizeof(shape_msgs::Mesh));
meshes_length = meshes_lengthT;
for( uint32_t i = 0; i < meshes_length; i++){
offset += this->st_meshes.deserialize(inbuffer + offset);
memcpy( &(this->meshes[i]), &(this->st_meshes), sizeof(shape_msgs::Mesh));
}
uint32_t mesh_poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->mesh_poses_length);
if(mesh_poses_lengthT > mesh_poses_length)
this->mesh_poses = (geometry_msgs::Pose*)realloc(this->mesh_poses, mesh_poses_lengthT * sizeof(geometry_msgs::Pose));
mesh_poses_length = mesh_poses_lengthT;
for( uint32_t i = 0; i < mesh_poses_length; i++){
offset += this->st_mesh_poses.deserialize(inbuffer + offset);
memcpy( &(this->mesh_poses[i]), &(this->st_mesh_poses), sizeof(geometry_msgs::Pose));
}
return offset;
}
const char * getType(){ return "moveit_msgs/BoundingVolume"; };
const char * getMD5(){ return "22db94010f39e9198032cb4a1aeda26e"; };
};
}
#endif
| 6,874 | C | 47.415493 | 140 | 0.600669 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/OrientedBoundingBox.h | #ifndef _ROS_moveit_msgs_OrientedBoundingBox_h
#define _ROS_moveit_msgs_OrientedBoundingBox_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Point32.h"
namespace moveit_msgs
{
class OrientedBoundingBox : public ros::Msg
{
public:
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Point32 _extents_type;
_extents_type extents;
OrientedBoundingBox():
pose(),
extents()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->pose.serialize(outbuffer + offset);
offset += this->extents.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->pose.deserialize(inbuffer + offset);
offset += this->extents.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/OrientedBoundingBox"; };
const char * getMD5(){ return "da3bd98e7cb14efa4141367a9d886ee7"; };
};
}
#endif
| 1,176 | C | 22.078431 | 72 | 0.657313 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/RobotTrajectory.h | #ifndef _ROS_moveit_msgs_RobotTrajectory_h
#define _ROS_moveit_msgs_RobotTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
#include "trajectory_msgs/MultiDOFJointTrajectory.h"
namespace moveit_msgs
{
class RobotTrajectory : public ros::Msg
{
public:
typedef trajectory_msgs::JointTrajectory _joint_trajectory_type;
_joint_trajectory_type joint_trajectory;
typedef trajectory_msgs::MultiDOFJointTrajectory _multi_dof_joint_trajectory_type;
_multi_dof_joint_trajectory_type multi_dof_joint_trajectory;
RobotTrajectory():
joint_trajectory(),
multi_dof_joint_trajectory()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->joint_trajectory.serialize(outbuffer + offset);
offset += this->multi_dof_joint_trajectory.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->joint_trajectory.deserialize(inbuffer + offset);
offset += this->multi_dof_joint_trajectory.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "moveit_msgs/RobotTrajectory"; };
const char * getMD5(){ return "dfa9556423d709a3729bcef664bddf67"; };
};
}
#endif
| 1,404 | C | 26.549019 | 88 | 0.695869 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/moveit_msgs/PlannerParams.h | #ifndef _ROS_moveit_msgs_PlannerParams_h
#define _ROS_moveit_msgs_PlannerParams_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace moveit_msgs
{
class PlannerParams : public ros::Msg
{
public:
uint32_t keys_length;
typedef char* _keys_type;
_keys_type st_keys;
_keys_type * keys;
uint32_t values_length;
typedef char* _values_type;
_values_type st_values;
_values_type * values;
uint32_t descriptions_length;
typedef char* _descriptions_type;
_descriptions_type st_descriptions;
_descriptions_type * descriptions;
PlannerParams():
keys_length(0), keys(NULL),
values_length(0), values(NULL),
descriptions_length(0), descriptions(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->keys_length);
for( uint32_t i = 0; i < keys_length; i++){
uint32_t length_keysi = strlen(this->keys[i]);
varToArr(outbuffer + offset, length_keysi);
offset += 4;
memcpy(outbuffer + offset, this->keys[i], length_keysi);
offset += length_keysi;
}
*(outbuffer + offset + 0) = (this->values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->values_length);
for( uint32_t i = 0; i < values_length; i++){
uint32_t length_valuesi = strlen(this->values[i]);
varToArr(outbuffer + offset, length_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->values[i], length_valuesi);
offset += length_valuesi;
}
*(outbuffer + offset + 0) = (this->descriptions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->descriptions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->descriptions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->descriptions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->descriptions_length);
for( uint32_t i = 0; i < descriptions_length; i++){
uint32_t length_descriptionsi = strlen(this->descriptions[i]);
varToArr(outbuffer + offset, length_descriptionsi);
offset += 4;
memcpy(outbuffer + offset, this->descriptions[i], length_descriptionsi);
offset += length_descriptionsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->keys_length);
if(keys_lengthT > keys_length)
this->keys = (char**)realloc(this->keys, keys_lengthT * sizeof(char*));
keys_length = keys_lengthT;
for( uint32_t i = 0; i < keys_length; i++){
uint32_t length_st_keys;
arrToVar(length_st_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_keys-1]=0;
this->st_keys = (char *)(inbuffer + offset-1);
offset += length_st_keys;
memcpy( &(this->keys[i]), &(this->st_keys), sizeof(char*));
}
uint32_t values_lengthT = ((uint32_t) (*(inbuffer + offset)));
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->values_length);
if(values_lengthT > values_length)
this->values = (char**)realloc(this->values, values_lengthT * sizeof(char*));
values_length = values_lengthT;
for( uint32_t i = 0; i < values_length; i++){
uint32_t length_st_values;
arrToVar(length_st_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_values-1]=0;
this->st_values = (char *)(inbuffer + offset-1);
offset += length_st_values;
memcpy( &(this->values[i]), &(this->st_values), sizeof(char*));
}
uint32_t descriptions_lengthT = ((uint32_t) (*(inbuffer + offset)));
descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->descriptions_length);
if(descriptions_lengthT > descriptions_length)
this->descriptions = (char**)realloc(this->descriptions, descriptions_lengthT * sizeof(char*));
descriptions_length = descriptions_lengthT;
for( uint32_t i = 0; i < descriptions_length; i++){
uint32_t length_st_descriptions;
arrToVar(length_st_descriptions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_descriptions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_descriptions-1]=0;
this->st_descriptions = (char *)(inbuffer + offset-1);
offset += length_st_descriptions;
memcpy( &(this->descriptions[i]), &(this->st_descriptions), sizeof(char*));
}
return offset;
}
const char * getType(){ return "moveit_msgs/PlannerParams"; };
const char * getMD5(){ return "cebdf4927996b9026bcf59a160d64145"; };
};
}
#endif
| 6,192 | C | 40.286666 | 103 | 0.581718 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/pcl_msgs/Vertices.h | #ifndef _ROS_pcl_msgs_Vertices_h
#define _ROS_pcl_msgs_Vertices_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace pcl_msgs
{
class Vertices : public ros::Msg
{
public:
uint32_t vertices_length;
typedef uint32_t _vertices_type;
_vertices_type st_vertices;
_vertices_type * vertices;
Vertices():
vertices_length(0), vertices(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->vertices_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->vertices_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->vertices_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->vertices_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->vertices_length);
for( uint32_t i = 0; i < vertices_length; i++){
*(outbuffer + offset + 0) = (this->vertices[i] >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->vertices[i] >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->vertices[i] >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->vertices[i] >> (8 * 3)) & 0xFF;
offset += sizeof(this->vertices[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t vertices_lengthT = ((uint32_t) (*(inbuffer + offset)));
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
vertices_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->vertices_length);
if(vertices_lengthT > vertices_length)
this->vertices = (uint32_t*)realloc(this->vertices, vertices_lengthT * sizeof(uint32_t));
vertices_length = vertices_lengthT;
for( uint32_t i = 0; i < vertices_length; i++){
this->st_vertices = ((uint32_t) (*(inbuffer + offset)));
this->st_vertices |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->st_vertices |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->st_vertices |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->st_vertices);
memcpy( &(this->vertices[i]), &(this->st_vertices), sizeof(uint32_t));
}
return offset;
}
const char * getType(){ return "pcl_msgs/Vertices"; };
const char * getMD5(){ return "39bd7b1c23763ddd1b882b97cb7cfe11"; };
};
}
#endif
| 2,579 | C | 34.833333 | 97 | 0.562233 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/pcl_msgs/PolygonMesh.h | #ifndef _ROS_pcl_msgs_PolygonMesh_h
#define _ROS_pcl_msgs_PolygonMesh_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/PointCloud2.h"
#include "pcl_msgs/Vertices.h"
namespace pcl_msgs
{
class PolygonMesh : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef sensor_msgs::PointCloud2 _cloud_type;
_cloud_type cloud;
uint32_t polygons_length;
typedef pcl_msgs::Vertices _polygons_type;
_polygons_type st_polygons;
_polygons_type * polygons;
PolygonMesh():
header(),
cloud(),
polygons_length(0), polygons(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->cloud.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->polygons_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->polygons_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->polygons_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->polygons_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->polygons_length);
for( uint32_t i = 0; i < polygons_length; i++){
offset += this->polygons[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->cloud.deserialize(inbuffer + offset);
uint32_t polygons_lengthT = ((uint32_t) (*(inbuffer + offset)));
polygons_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
polygons_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
polygons_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->polygons_length);
if(polygons_lengthT > polygons_length)
this->polygons = (pcl_msgs::Vertices*)realloc(this->polygons, polygons_lengthT * sizeof(pcl_msgs::Vertices));
polygons_length = polygons_lengthT;
for( uint32_t i = 0; i < polygons_length; i++){
offset += this->st_polygons.deserialize(inbuffer + offset);
memcpy( &(this->polygons[i]), &(this->st_polygons), sizeof(pcl_msgs::Vertices));
}
return offset;
}
const char * getType(){ return "pcl_msgs/PolygonMesh"; };
const char * getMD5(){ return "45a5fc6ad2cde8489600a790acc9a38a"; };
};
}
#endif
| 2,603 | C | 32.818181 | 117 | 0.609297 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/pcl_msgs/PointIndices.h | #ifndef _ROS_pcl_msgs_PointIndices_h
#define _ROS_pcl_msgs_PointIndices_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace pcl_msgs
{
class PointIndices : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t indices_length;
typedef int32_t _indices_type;
_indices_type st_indices;
_indices_type * indices;
PointIndices():
header(),
indices_length(0), indices(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->indices_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->indices_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->indices_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->indices_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->indices_length);
for( uint32_t i = 0; i < indices_length; i++){
union {
int32_t real;
uint32_t base;
} u_indicesi;
u_indicesi.real = this->indices[i];
*(outbuffer + offset + 0) = (u_indicesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_indicesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_indicesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_indicesi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->indices[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t indices_lengthT = ((uint32_t) (*(inbuffer + offset)));
indices_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
indices_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
indices_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->indices_length);
if(indices_lengthT > indices_length)
this->indices = (int32_t*)realloc(this->indices, indices_lengthT * sizeof(int32_t));
indices_length = indices_lengthT;
for( uint32_t i = 0; i < indices_length; i++){
union {
int32_t real;
uint32_t base;
} u_st_indices;
u_st_indices.base = 0;
u_st_indices.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_indices.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_indices.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_indices.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_indices = u_st_indices.real;
offset += sizeof(this->st_indices);
memcpy( &(this->indices[i]), &(this->st_indices), sizeof(int32_t));
}
return offset;
}
const char * getType(){ return "pcl_msgs/PointIndices"; };
const char * getMD5(){ return "458c7998b7eaf99908256472e273b3d4"; };
};
}
#endif
| 3,084 | C | 33.662921 | 92 | 0.56096 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/pcl_msgs/ModelCoefficients.h | #ifndef _ROS_pcl_msgs_ModelCoefficients_h
#define _ROS_pcl_msgs_ModelCoefficients_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace pcl_msgs
{
class ModelCoefficients : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t values_length;
typedef float _values_type;
_values_type st_values;
_values_type * values;
ModelCoefficients():
header(),
values_length(0), values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->values_length);
for( uint32_t i = 0; i < values_length; i++){
union {
float real;
uint32_t base;
} u_valuesi;
u_valuesi.real = this->values[i];
*(outbuffer + offset + 0) = (u_valuesi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_valuesi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_valuesi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_valuesi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->values[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t values_lengthT = ((uint32_t) (*(inbuffer + offset)));
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->values_length);
if(values_lengthT > values_length)
this->values = (float*)realloc(this->values, values_lengthT * sizeof(float));
values_length = values_lengthT;
for( uint32_t i = 0; i < values_length; i++){
union {
float real;
uint32_t base;
} u_st_values;
u_st_values.base = 0;
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_values.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_values = u_st_values.real;
offset += sizeof(this->st_values);
memcpy( &(this->values[i]), &(this->st_values), sizeof(float));
}
return offset;
}
const char * getType(){ return "pcl_msgs/ModelCoefficients"; };
const char * getMD5(){ return "ca27dea75e72cb894cd36f9e5005e93e"; };
};
}
#endif
| 3,051 | C | 33.292134 | 85 | 0.558178 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/roscpp/Logger.h | #ifndef _ROS_roscpp_Logger_h
#define _ROS_roscpp_Logger_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace roscpp
{
class Logger : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _level_type;
_level_type level;
Logger():
name(""),
level("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_level = strlen(this->level);
varToArr(outbuffer + offset, length_level);
offset += 4;
memcpy(outbuffer + offset, this->level, length_level);
offset += length_level;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_level;
arrToVar(length_level, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_level; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_level-1]=0;
this->level = (char *)(inbuffer + offset-1);
offset += length_level;
return offset;
}
const char * getType(){ return "roscpp/Logger"; };
const char * getMD5(){ return "a6069a2ff40db7bd32143dd66e1f408e"; };
};
}
#endif
| 1,831 | C | 24.09589 | 72 | 0.593119 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/roscpp/SetLoggerLevel.h | #ifndef _ROS_SERVICE_SetLoggerLevel_h
#define _ROS_SERVICE_SetLoggerLevel_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace roscpp
{
static const char SETLOGGERLEVEL[] = "roscpp/SetLoggerLevel";
class SetLoggerLevelRequest : public ros::Msg
{
public:
typedef const char* _logger_type;
_logger_type logger;
typedef const char* _level_type;
_level_type level;
SetLoggerLevelRequest():
logger(""),
level("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_logger = strlen(this->logger);
varToArr(outbuffer + offset, length_logger);
offset += 4;
memcpy(outbuffer + offset, this->logger, length_logger);
offset += length_logger;
uint32_t length_level = strlen(this->level);
varToArr(outbuffer + offset, length_level);
offset += 4;
memcpy(outbuffer + offset, this->level, length_level);
offset += length_level;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_logger;
arrToVar(length_logger, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_logger; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_logger-1]=0;
this->logger = (char *)(inbuffer + offset-1);
offset += length_logger;
uint32_t length_level;
arrToVar(length_level, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_level; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_level-1]=0;
this->level = (char *)(inbuffer + offset-1);
offset += length_level;
return offset;
}
const char * getType(){ return SETLOGGERLEVEL; };
const char * getMD5(){ return "51da076440d78ca1684d36c868df61ea"; };
};
class SetLoggerLevelResponse : public ros::Msg
{
public:
SetLoggerLevelResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return SETLOGGERLEVEL; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetLoggerLevel {
public:
typedef SetLoggerLevelRequest Request;
typedef SetLoggerLevelResponse Response;
};
}
#endif
| 2,567 | C | 23.457143 | 72 | 0.623296 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/roscpp/GetLoggers.h | #ifndef _ROS_SERVICE_GetLoggers_h
#define _ROS_SERVICE_GetLoggers_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "roscpp/Logger.h"
namespace roscpp
{
static const char GETLOGGERS[] = "roscpp/GetLoggers";
class GetLoggersRequest : public ros::Msg
{
public:
GetLoggersRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return GETLOGGERS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class GetLoggersResponse : public ros::Msg
{
public:
uint32_t loggers_length;
typedef roscpp::Logger _loggers_type;
_loggers_type st_loggers;
_loggers_type * loggers;
GetLoggersResponse():
loggers_length(0), loggers(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->loggers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->loggers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->loggers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->loggers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->loggers_length);
for( uint32_t i = 0; i < loggers_length; i++){
offset += this->loggers[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t loggers_lengthT = ((uint32_t) (*(inbuffer + offset)));
loggers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
loggers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
loggers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->loggers_length);
if(loggers_lengthT > loggers_length)
this->loggers = (roscpp::Logger*)realloc(this->loggers, loggers_lengthT * sizeof(roscpp::Logger));
loggers_length = loggers_lengthT;
for( uint32_t i = 0; i < loggers_length; i++){
offset += this->st_loggers.deserialize(inbuffer + offset);
memcpy( &(this->loggers[i]), &(this->st_loggers), sizeof(roscpp::Logger));
}
return offset;
}
const char * getType(){ return GETLOGGERS; };
const char * getMD5(){ return "32e97e85527d4678a8f9279894bb64b0"; };
};
class GetLoggers {
public:
typedef GetLoggersRequest Request;
typedef GetLoggersResponse Response;
};
}
#endif
| 2,685 | C | 26.690721 | 106 | 0.604469 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/roscpp/Empty.h | #ifndef _ROS_SERVICE_Empty_h
#define _ROS_SERVICE_Empty_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace roscpp
{
static const char EMPTY[] = "roscpp/Empty";
class EmptyRequest : public ros::Msg
{
public:
EmptyRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return EMPTY; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class EmptyResponse : public ros::Msg
{
public:
EmptyResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return EMPTY; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class Empty {
public:
typedef EmptyRequest Request;
typedef EmptyResponse Response;
};
}
#endif
| 1,190 | C | 15.774648 | 72 | 0.619328 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/smach_msgs/SmachContainerStructure.h | #ifndef _ROS_smach_msgs_SmachContainerStructure_h
#define _ROS_smach_msgs_SmachContainerStructure_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace smach_msgs
{
class SmachContainerStructure : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _path_type;
_path_type path;
uint32_t children_length;
typedef char* _children_type;
_children_type st_children;
_children_type * children;
uint32_t internal_outcomes_length;
typedef char* _internal_outcomes_type;
_internal_outcomes_type st_internal_outcomes;
_internal_outcomes_type * internal_outcomes;
uint32_t outcomes_from_length;
typedef char* _outcomes_from_type;
_outcomes_from_type st_outcomes_from;
_outcomes_from_type * outcomes_from;
uint32_t outcomes_to_length;
typedef char* _outcomes_to_type;
_outcomes_to_type st_outcomes_to;
_outcomes_to_type * outcomes_to;
uint32_t container_outcomes_length;
typedef char* _container_outcomes_type;
_container_outcomes_type st_container_outcomes;
_container_outcomes_type * container_outcomes;
SmachContainerStructure():
header(),
path(""),
children_length(0), children(NULL),
internal_outcomes_length(0), internal_outcomes(NULL),
outcomes_from_length(0), outcomes_from(NULL),
outcomes_to_length(0), outcomes_to(NULL),
container_outcomes_length(0), container_outcomes(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_path = strlen(this->path);
varToArr(outbuffer + offset, length_path);
offset += 4;
memcpy(outbuffer + offset, this->path, length_path);
offset += length_path;
*(outbuffer + offset + 0) = (this->children_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->children_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->children_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->children_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->children_length);
for( uint32_t i = 0; i < children_length; i++){
uint32_t length_childreni = strlen(this->children[i]);
varToArr(outbuffer + offset, length_childreni);
offset += 4;
memcpy(outbuffer + offset, this->children[i], length_childreni);
offset += length_childreni;
}
*(outbuffer + offset + 0) = (this->internal_outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->internal_outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->internal_outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->internal_outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->internal_outcomes_length);
for( uint32_t i = 0; i < internal_outcomes_length; i++){
uint32_t length_internal_outcomesi = strlen(this->internal_outcomes[i]);
varToArr(outbuffer + offset, length_internal_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->internal_outcomes[i], length_internal_outcomesi);
offset += length_internal_outcomesi;
}
*(outbuffer + offset + 0) = (this->outcomes_from_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outcomes_from_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outcomes_from_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outcomes_from_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outcomes_from_length);
for( uint32_t i = 0; i < outcomes_from_length; i++){
uint32_t length_outcomes_fromi = strlen(this->outcomes_from[i]);
varToArr(outbuffer + offset, length_outcomes_fromi);
offset += 4;
memcpy(outbuffer + offset, this->outcomes_from[i], length_outcomes_fromi);
offset += length_outcomes_fromi;
}
*(outbuffer + offset + 0) = (this->outcomes_to_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outcomes_to_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outcomes_to_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outcomes_to_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outcomes_to_length);
for( uint32_t i = 0; i < outcomes_to_length; i++){
uint32_t length_outcomes_toi = strlen(this->outcomes_to[i]);
varToArr(outbuffer + offset, length_outcomes_toi);
offset += 4;
memcpy(outbuffer + offset, this->outcomes_to[i], length_outcomes_toi);
offset += length_outcomes_toi;
}
*(outbuffer + offset + 0) = (this->container_outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->container_outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->container_outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->container_outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->container_outcomes_length);
for( uint32_t i = 0; i < container_outcomes_length; i++){
uint32_t length_container_outcomesi = strlen(this->container_outcomes[i]);
varToArr(outbuffer + offset, length_container_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->container_outcomes[i], length_container_outcomesi);
offset += length_container_outcomesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_path;
arrToVar(length_path, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_path; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_path-1]=0;
this->path = (char *)(inbuffer + offset-1);
offset += length_path;
uint32_t children_lengthT = ((uint32_t) (*(inbuffer + offset)));
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
children_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->children_length);
if(children_lengthT > children_length)
this->children = (char**)realloc(this->children, children_lengthT * sizeof(char*));
children_length = children_lengthT;
for( uint32_t i = 0; i < children_length; i++){
uint32_t length_st_children;
arrToVar(length_st_children, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_children; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_children-1]=0;
this->st_children = (char *)(inbuffer + offset-1);
offset += length_st_children;
memcpy( &(this->children[i]), &(this->st_children), sizeof(char*));
}
uint32_t internal_outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
internal_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
internal_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
internal_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->internal_outcomes_length);
if(internal_outcomes_lengthT > internal_outcomes_length)
this->internal_outcomes = (char**)realloc(this->internal_outcomes, internal_outcomes_lengthT * sizeof(char*));
internal_outcomes_length = internal_outcomes_lengthT;
for( uint32_t i = 0; i < internal_outcomes_length; i++){
uint32_t length_st_internal_outcomes;
arrToVar(length_st_internal_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_internal_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_internal_outcomes-1]=0;
this->st_internal_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_internal_outcomes;
memcpy( &(this->internal_outcomes[i]), &(this->st_internal_outcomes), sizeof(char*));
}
uint32_t outcomes_from_lengthT = ((uint32_t) (*(inbuffer + offset)));
outcomes_from_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outcomes_from_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outcomes_from_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outcomes_from_length);
if(outcomes_from_lengthT > outcomes_from_length)
this->outcomes_from = (char**)realloc(this->outcomes_from, outcomes_from_lengthT * sizeof(char*));
outcomes_from_length = outcomes_from_lengthT;
for( uint32_t i = 0; i < outcomes_from_length; i++){
uint32_t length_st_outcomes_from;
arrToVar(length_st_outcomes_from, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_outcomes_from; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_outcomes_from-1]=0;
this->st_outcomes_from = (char *)(inbuffer + offset-1);
offset += length_st_outcomes_from;
memcpy( &(this->outcomes_from[i]), &(this->st_outcomes_from), sizeof(char*));
}
uint32_t outcomes_to_lengthT = ((uint32_t) (*(inbuffer + offset)));
outcomes_to_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outcomes_to_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outcomes_to_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outcomes_to_length);
if(outcomes_to_lengthT > outcomes_to_length)
this->outcomes_to = (char**)realloc(this->outcomes_to, outcomes_to_lengthT * sizeof(char*));
outcomes_to_length = outcomes_to_lengthT;
for( uint32_t i = 0; i < outcomes_to_length; i++){
uint32_t length_st_outcomes_to;
arrToVar(length_st_outcomes_to, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_outcomes_to; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_outcomes_to-1]=0;
this->st_outcomes_to = (char *)(inbuffer + offset-1);
offset += length_st_outcomes_to;
memcpy( &(this->outcomes_to[i]), &(this->st_outcomes_to), sizeof(char*));
}
uint32_t container_outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
container_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
container_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
container_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->container_outcomes_length);
if(container_outcomes_lengthT > container_outcomes_length)
this->container_outcomes = (char**)realloc(this->container_outcomes, container_outcomes_lengthT * sizeof(char*));
container_outcomes_length = container_outcomes_lengthT;
for( uint32_t i = 0; i < container_outcomes_length; i++){
uint32_t length_st_container_outcomes;
arrToVar(length_st_container_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_container_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_container_outcomes-1]=0;
this->st_container_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_container_outcomes;
memcpy( &(this->container_outcomes[i]), &(this->st_container_outcomes), sizeof(char*));
}
return offset;
}
const char * getType(){ return "smach_msgs/SmachContainerStructure"; };
const char * getMD5(){ return "3d3d1e0d0f99779ee9e58101a5dcf7ea"; };
};
}
#endif
| 12,015 | C | 47.647773 | 121 | 0.611735 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/smach_msgs/SmachContainerInitialStatusCmd.h | #ifndef _ROS_smach_msgs_SmachContainerInitialStatusCmd_h
#define _ROS_smach_msgs_SmachContainerInitialStatusCmd_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace smach_msgs
{
class SmachContainerInitialStatusCmd : public ros::Msg
{
public:
typedef const char* _path_type;
_path_type path;
uint32_t initial_states_length;
typedef char* _initial_states_type;
_initial_states_type st_initial_states;
_initial_states_type * initial_states;
typedef const char* _local_data_type;
_local_data_type local_data;
SmachContainerInitialStatusCmd():
path(""),
initial_states_length(0), initial_states(NULL),
local_data("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_path = strlen(this->path);
varToArr(outbuffer + offset, length_path);
offset += 4;
memcpy(outbuffer + offset, this->path, length_path);
offset += length_path;
*(outbuffer + offset + 0) = (this->initial_states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->initial_states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->initial_states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->initial_states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->initial_states_length);
for( uint32_t i = 0; i < initial_states_length; i++){
uint32_t length_initial_statesi = strlen(this->initial_states[i]);
varToArr(outbuffer + offset, length_initial_statesi);
offset += 4;
memcpy(outbuffer + offset, this->initial_states[i], length_initial_statesi);
offset += length_initial_statesi;
}
uint32_t length_local_data = strlen(this->local_data);
varToArr(outbuffer + offset, length_local_data);
offset += 4;
memcpy(outbuffer + offset, this->local_data, length_local_data);
offset += length_local_data;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_path;
arrToVar(length_path, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_path; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_path-1]=0;
this->path = (char *)(inbuffer + offset-1);
offset += length_path;
uint32_t initial_states_lengthT = ((uint32_t) (*(inbuffer + offset)));
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->initial_states_length);
if(initial_states_lengthT > initial_states_length)
this->initial_states = (char**)realloc(this->initial_states, initial_states_lengthT * sizeof(char*));
initial_states_length = initial_states_lengthT;
for( uint32_t i = 0; i < initial_states_length; i++){
uint32_t length_st_initial_states;
arrToVar(length_st_initial_states, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_initial_states; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_initial_states-1]=0;
this->st_initial_states = (char *)(inbuffer + offset-1);
offset += length_st_initial_states;
memcpy( &(this->initial_states[i]), &(this->st_initial_states), sizeof(char*));
}
uint32_t length_local_data;
arrToVar(length_local_data, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_local_data; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_local_data-1]=0;
this->local_data = (char *)(inbuffer + offset-1);
offset += length_local_data;
return offset;
}
const char * getType(){ return "smach_msgs/SmachContainerInitialStatusCmd"; };
const char * getMD5(){ return "45f8cf31fc29b829db77f23001f788d6"; };
};
}
#endif
| 4,165 | C | 36.872727 | 109 | 0.618007 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/smach_msgs/SmachContainerStatus.h | #ifndef _ROS_smach_msgs_SmachContainerStatus_h
#define _ROS_smach_msgs_SmachContainerStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace smach_msgs
{
class SmachContainerStatus : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _path_type;
_path_type path;
uint32_t initial_states_length;
typedef char* _initial_states_type;
_initial_states_type st_initial_states;
_initial_states_type * initial_states;
uint32_t active_states_length;
typedef char* _active_states_type;
_active_states_type st_active_states;
_active_states_type * active_states;
typedef const char* _local_data_type;
_local_data_type local_data;
typedef const char* _info_type;
_info_type info;
SmachContainerStatus():
header(),
path(""),
initial_states_length(0), initial_states(NULL),
active_states_length(0), active_states(NULL),
local_data(""),
info("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_path = strlen(this->path);
varToArr(outbuffer + offset, length_path);
offset += 4;
memcpy(outbuffer + offset, this->path, length_path);
offset += length_path;
*(outbuffer + offset + 0) = (this->initial_states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->initial_states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->initial_states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->initial_states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->initial_states_length);
for( uint32_t i = 0; i < initial_states_length; i++){
uint32_t length_initial_statesi = strlen(this->initial_states[i]);
varToArr(outbuffer + offset, length_initial_statesi);
offset += 4;
memcpy(outbuffer + offset, this->initial_states[i], length_initial_statesi);
offset += length_initial_statesi;
}
*(outbuffer + offset + 0) = (this->active_states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->active_states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->active_states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->active_states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->active_states_length);
for( uint32_t i = 0; i < active_states_length; i++){
uint32_t length_active_statesi = strlen(this->active_states[i]);
varToArr(outbuffer + offset, length_active_statesi);
offset += 4;
memcpy(outbuffer + offset, this->active_states[i], length_active_statesi);
offset += length_active_statesi;
}
uint32_t length_local_data = strlen(this->local_data);
varToArr(outbuffer + offset, length_local_data);
offset += 4;
memcpy(outbuffer + offset, this->local_data, length_local_data);
offset += length_local_data;
uint32_t length_info = strlen(this->info);
varToArr(outbuffer + offset, length_info);
offset += 4;
memcpy(outbuffer + offset, this->info, length_info);
offset += length_info;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_path;
arrToVar(length_path, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_path; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_path-1]=0;
this->path = (char *)(inbuffer + offset-1);
offset += length_path;
uint32_t initial_states_lengthT = ((uint32_t) (*(inbuffer + offset)));
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
initial_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->initial_states_length);
if(initial_states_lengthT > initial_states_length)
this->initial_states = (char**)realloc(this->initial_states, initial_states_lengthT * sizeof(char*));
initial_states_length = initial_states_lengthT;
for( uint32_t i = 0; i < initial_states_length; i++){
uint32_t length_st_initial_states;
arrToVar(length_st_initial_states, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_initial_states; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_initial_states-1]=0;
this->st_initial_states = (char *)(inbuffer + offset-1);
offset += length_st_initial_states;
memcpy( &(this->initial_states[i]), &(this->st_initial_states), sizeof(char*));
}
uint32_t active_states_lengthT = ((uint32_t) (*(inbuffer + offset)));
active_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
active_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
active_states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->active_states_length);
if(active_states_lengthT > active_states_length)
this->active_states = (char**)realloc(this->active_states, active_states_lengthT * sizeof(char*));
active_states_length = active_states_lengthT;
for( uint32_t i = 0; i < active_states_length; i++){
uint32_t length_st_active_states;
arrToVar(length_st_active_states, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_active_states; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_active_states-1]=0;
this->st_active_states = (char *)(inbuffer + offset-1);
offset += length_st_active_states;
memcpy( &(this->active_states[i]), &(this->st_active_states), sizeof(char*));
}
uint32_t length_local_data;
arrToVar(length_local_data, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_local_data; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_local_data-1]=0;
this->local_data = (char *)(inbuffer + offset-1);
offset += length_local_data;
uint32_t length_info;
arrToVar(length_info, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_info; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_info-1]=0;
this->info = (char *)(inbuffer + offset-1);
offset += length_info;
return offset;
}
const char * getType(){ return "smach_msgs/SmachContainerStatus"; };
const char * getMD5(){ return "5ba2bb79ac19e3842d562a191f2a675b"; };
};
}
#endif
| 7,036 | C | 40.394117 | 109 | 0.608016 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/theora_image_transport/Packet.h | #ifndef _ROS_theora_image_transport_Packet_h
#define _ROS_theora_image_transport_Packet_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace theora_image_transport
{
class Packet : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t data_length;
typedef uint8_t _data_type;
_data_type st_data;
_data_type * data;
typedef int32_t _b_o_s_type;
_b_o_s_type b_o_s;
typedef int32_t _e_o_s_type;
_e_o_s_type e_o_s;
typedef int64_t _granulepos_type;
_granulepos_type granulepos;
typedef int64_t _packetno_type;
_packetno_type packetno;
Packet():
header(),
data_length(0), data(NULL),
b_o_s(0),
e_o_s(0),
granulepos(0),
packetno(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->data_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->data_length);
for( uint32_t i = 0; i < data_length; i++){
*(outbuffer + offset + 0) = (this->data[i] >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
union {
int32_t real;
uint32_t base;
} u_b_o_s;
u_b_o_s.real = this->b_o_s;
*(outbuffer + offset + 0) = (u_b_o_s.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_b_o_s.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_b_o_s.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_b_o_s.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->b_o_s);
union {
int32_t real;
uint32_t base;
} u_e_o_s;
u_e_o_s.real = this->e_o_s;
*(outbuffer + offset + 0) = (u_e_o_s.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_e_o_s.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_e_o_s.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_e_o_s.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->e_o_s);
union {
int64_t real;
uint64_t base;
} u_granulepos;
u_granulepos.real = this->granulepos;
*(outbuffer + offset + 0) = (u_granulepos.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_granulepos.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_granulepos.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_granulepos.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_granulepos.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_granulepos.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_granulepos.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_granulepos.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->granulepos);
union {
int64_t real;
uint64_t base;
} u_packetno;
u_packetno.real = this->packetno;
*(outbuffer + offset + 0) = (u_packetno.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_packetno.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_packetno.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_packetno.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_packetno.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_packetno.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_packetno.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_packetno.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->packetno);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t data_lengthT = ((uint32_t) (*(inbuffer + offset)));
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data_length);
if(data_lengthT > data_length)
this->data = (uint8_t*)realloc(this->data, data_lengthT * sizeof(uint8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint8_t));
}
union {
int32_t real;
uint32_t base;
} u_b_o_s;
u_b_o_s.base = 0;
u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_b_o_s.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->b_o_s = u_b_o_s.real;
offset += sizeof(this->b_o_s);
union {
int32_t real;
uint32_t base;
} u_e_o_s;
u_e_o_s.base = 0;
u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_e_o_s.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->e_o_s = u_e_o_s.real;
offset += sizeof(this->e_o_s);
union {
int64_t real;
uint64_t base;
} u_granulepos;
u_granulepos.base = 0;
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_granulepos.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->granulepos = u_granulepos.real;
offset += sizeof(this->granulepos);
union {
int64_t real;
uint64_t base;
} u_packetno;
u_packetno.base = 0;
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_packetno.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->packetno = u_packetno.real;
offset += sizeof(this->packetno);
return offset;
}
const char * getType(){ return "theora_image_transport/Packet"; };
const char * getMD5(){ return "33ac4e14a7cff32e7e0d65f18bb410f3"; };
};
}
#endif
| 7,486 | C | 39.690217 | 83 | 0.50895 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetPhysicsProperties.h | #ifndef _ROS_SERVICE_SetPhysicsProperties_h
#define _ROS_SERVICE_SetPhysicsProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
#include "gazebo_msgs/ODEPhysics.h"
namespace gazebo_msgs
{
static const char SETPHYSICSPROPERTIES[] = "gazebo_msgs/SetPhysicsProperties";
class SetPhysicsPropertiesRequest : public ros::Msg
{
public:
typedef double _time_step_type;
_time_step_type time_step;
typedef double _max_update_rate_type;
_max_update_rate_type max_update_rate;
typedef geometry_msgs::Vector3 _gravity_type;
_gravity_type gravity;
typedef gazebo_msgs::ODEPhysics _ode_config_type;
_ode_config_type ode_config;
SetPhysicsPropertiesRequest():
time_step(0),
max_update_rate(0),
gravity(),
ode_config()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.real = this->time_step;
*(outbuffer + offset + 0) = (u_time_step.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_time_step.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_time_step.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_time_step.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_time_step.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_time_step.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_time_step.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_time_step.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->time_step);
union {
double real;
uint64_t base;
} u_max_update_rate;
u_max_update_rate.real = this->max_update_rate;
*(outbuffer + offset + 0) = (u_max_update_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_update_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_update_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_update_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_update_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_update_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_update_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_update_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_update_rate);
offset += this->gravity.serialize(outbuffer + offset);
offset += this->ode_config.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.base = 0;
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->time_step = u_time_step.real;
offset += sizeof(this->time_step);
union {
double real;
uint64_t base;
} u_max_update_rate;
u_max_update_rate.base = 0;
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_update_rate = u_max_update_rate.real;
offset += sizeof(this->max_update_rate);
offset += this->gravity.deserialize(inbuffer + offset);
offset += this->ode_config.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SETPHYSICSPROPERTIES; };
const char * getMD5(){ return "abd9f82732b52b92e9d6bb36e6a82452"; };
};
class SetPhysicsPropertiesResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetPhysicsPropertiesResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETPHYSICSPROPERTIES; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetPhysicsProperties {
public:
typedef SetPhysicsPropertiesRequest Request;
typedef SetPhysicsPropertiesResponse Response;
};
}
#endif
| 6,707 | C | 35.857143 | 83 | 0.573133 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetModelState.h | #ifndef _ROS_SERVICE_GetModelState_h
#define _ROS_SERVICE_GetModelState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
#include "std_msgs/Header.h"
namespace gazebo_msgs
{
static const char GETMODELSTATE[] = "gazebo_msgs/GetModelState";
class GetModelStateRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
typedef const char* _relative_entity_name_type;
_relative_entity_name_type relative_entity_name;
GetModelStateRequest():
model_name(""),
relative_entity_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
uint32_t length_relative_entity_name = strlen(this->relative_entity_name);
varToArr(outbuffer + offset, length_relative_entity_name);
offset += 4;
memcpy(outbuffer + offset, this->relative_entity_name, length_relative_entity_name);
offset += length_relative_entity_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
uint32_t length_relative_entity_name;
arrToVar(length_relative_entity_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_relative_entity_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_relative_entity_name-1]=0;
this->relative_entity_name = (char *)(inbuffer + offset-1);
offset += length_relative_entity_name;
return offset;
}
const char * getType(){ return GETMODELSTATE; };
const char * getMD5(){ return "19d412713cefe4a67437e17a951e759e"; };
};
class GetModelStateResponse : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Twist _twist_type;
_twist_type twist;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetModelStateResponse():
header(),
pose(),
twist(),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->pose.serialize(outbuffer + offset);
offset += this->twist.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->pose.deserialize(inbuffer + offset);
offset += this->twist.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETMODELSTATE; };
const char * getMD5(){ return "ccd51739bb00f0141629e87b792e92b9"; };
};
class GetModelState {
public:
typedef GetModelStateRequest Request;
typedef GetModelStateResponse Response;
};
}
#endif
| 4,898 | C | 30.006329 | 90 | 0.630053 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ModelStates.h | #ifndef _ROS_gazebo_msgs_ModelStates_h
#define _ROS_gazebo_msgs_ModelStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
namespace gazebo_msgs
{
class ModelStates : public ros::Msg
{
public:
uint32_t name_length;
typedef char* _name_type;
_name_type st_name;
_name_type * name;
uint32_t pose_length;
typedef geometry_msgs::Pose _pose_type;
_pose_type st_pose;
_pose_type * pose;
uint32_t twist_length;
typedef geometry_msgs::Twist _twist_type;
_twist_type st_twist;
_twist_type * twist;
ModelStates():
name_length(0), name(NULL),
pose_length(0), pose(NULL),
twist_length(0), twist(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->name_length);
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_namei = strlen(this->name[i]);
varToArr(outbuffer + offset, length_namei);
offset += 4;
memcpy(outbuffer + offset, this->name[i], length_namei);
offset += length_namei;
}
*(outbuffer + offset + 0) = (this->pose_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_length);
for( uint32_t i = 0; i < pose_length; i++){
offset += this->pose[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->twist_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->twist_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->twist_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->twist_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->twist_length);
for( uint32_t i = 0; i < twist_length; i++){
offset += this->twist[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->name_length);
if(name_lengthT > name_length)
this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
name_length = name_lengthT;
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_st_name;
arrToVar(length_st_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_name-1]=0;
this->st_name = (char *)(inbuffer + offset-1);
offset += length_st_name;
memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
}
uint32_t pose_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_length);
if(pose_lengthT > pose_length)
this->pose = (geometry_msgs::Pose*)realloc(this->pose, pose_lengthT * sizeof(geometry_msgs::Pose));
pose_length = pose_lengthT;
for( uint32_t i = 0; i < pose_length; i++){
offset += this->st_pose.deserialize(inbuffer + offset);
memcpy( &(this->pose[i]), &(this->st_pose), sizeof(geometry_msgs::Pose));
}
uint32_t twist_lengthT = ((uint32_t) (*(inbuffer + offset)));
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->twist_length);
if(twist_lengthT > twist_length)
this->twist = (geometry_msgs::Twist*)realloc(this->twist, twist_lengthT * sizeof(geometry_msgs::Twist));
twist_length = twist_lengthT;
for( uint32_t i = 0; i < twist_length; i++){
offset += this->st_twist.deserialize(inbuffer + offset);
memcpy( &(this->twist[i]), &(this->st_twist), sizeof(geometry_msgs::Twist));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/ModelStates"; };
const char * getMD5(){ return "48c080191eb15c41858319b4d8a609c2"; };
};
}
#endif
| 5,116 | C | 38.976562 | 112 | 0.560594 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetWorldProperties.h | #ifndef _ROS_SERVICE_GetWorldProperties_h
#define _ROS_SERVICE_GetWorldProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char GETWORLDPROPERTIES[] = "gazebo_msgs/GetWorldProperties";
class GetWorldPropertiesRequest : public ros::Msg
{
public:
GetWorldPropertiesRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return GETWORLDPROPERTIES; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class GetWorldPropertiesResponse : public ros::Msg
{
public:
typedef double _sim_time_type;
_sim_time_type sim_time;
uint32_t model_names_length;
typedef char* _model_names_type;
_model_names_type st_model_names;
_model_names_type * model_names;
typedef bool _rendering_enabled_type;
_rendering_enabled_type rendering_enabled;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetWorldPropertiesResponse():
sim_time(0),
model_names_length(0), model_names(NULL),
rendering_enabled(0),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_sim_time;
u_sim_time.real = this->sim_time;
*(outbuffer + offset + 0) = (u_sim_time.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sim_time.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sim_time.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sim_time.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_sim_time.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_sim_time.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_sim_time.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_sim_time.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->sim_time);
*(outbuffer + offset + 0) = (this->model_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->model_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->model_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->model_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->model_names_length);
for( uint32_t i = 0; i < model_names_length; i++){
uint32_t length_model_namesi = strlen(this->model_names[i]);
varToArr(outbuffer + offset, length_model_namesi);
offset += 4;
memcpy(outbuffer + offset, this->model_names[i], length_model_namesi);
offset += length_model_namesi;
}
union {
bool real;
uint8_t base;
} u_rendering_enabled;
u_rendering_enabled.real = this->rendering_enabled;
*(outbuffer + offset + 0) = (u_rendering_enabled.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->rendering_enabled);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_sim_time;
u_sim_time.base = 0;
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_sim_time.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->sim_time = u_sim_time.real;
offset += sizeof(this->sim_time);
uint32_t model_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->model_names_length);
if(model_names_lengthT > model_names_length)
this->model_names = (char**)realloc(this->model_names, model_names_lengthT * sizeof(char*));
model_names_length = model_names_lengthT;
for( uint32_t i = 0; i < model_names_length; i++){
uint32_t length_st_model_names;
arrToVar(length_st_model_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_model_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_model_names-1]=0;
this->st_model_names = (char *)(inbuffer + offset-1);
offset += length_st_model_names;
memcpy( &(this->model_names[i]), &(this->st_model_names), sizeof(char*));
}
union {
bool real;
uint8_t base;
} u_rendering_enabled;
u_rendering_enabled.base = 0;
u_rendering_enabled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->rendering_enabled = u_rendering_enabled.real;
offset += sizeof(this->rendering_enabled);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETWORLDPROPERTIES; };
const char * getMD5(){ return "36bb0f2eccf4d8be971410c22818ba3f"; };
};
class GetWorldProperties {
public:
typedef GetWorldPropertiesRequest Request;
typedef GetWorldPropertiesResponse Response;
};
}
#endif
| 7,002 | C | 35.284974 | 100 | 0.58012 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ApplyBodyWrench.h | #ifndef _ROS_SERVICE_ApplyBodyWrench_h
#define _ROS_SERVICE_ApplyBodyWrench_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/duration.h"
#include "geometry_msgs/Wrench.h"
#include "ros/time.h"
#include "geometry_msgs/Point.h"
namespace gazebo_msgs
{
static const char APPLYBODYWRENCH[] = "gazebo_msgs/ApplyBodyWrench";
class ApplyBodyWrenchRequest : public ros::Msg
{
public:
typedef const char* _body_name_type;
_body_name_type body_name;
typedef const char* _reference_frame_type;
_reference_frame_type reference_frame;
typedef geometry_msgs::Point _reference_point_type;
_reference_point_type reference_point;
typedef geometry_msgs::Wrench _wrench_type;
_wrench_type wrench;
typedef ros::Time _start_time_type;
_start_time_type start_time;
typedef ros::Duration _duration_type;
_duration_type duration;
ApplyBodyWrenchRequest():
body_name(""),
reference_frame(""),
reference_point(),
wrench(),
start_time(),
duration()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_body_name = strlen(this->body_name);
varToArr(outbuffer + offset, length_body_name);
offset += 4;
memcpy(outbuffer + offset, this->body_name, length_body_name);
offset += length_body_name;
uint32_t length_reference_frame = strlen(this->reference_frame);
varToArr(outbuffer + offset, length_reference_frame);
offset += 4;
memcpy(outbuffer + offset, this->reference_frame, length_reference_frame);
offset += length_reference_frame;
offset += this->reference_point.serialize(outbuffer + offset);
offset += this->wrench.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->start_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->start_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->start_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->start_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->start_time.sec);
*(outbuffer + offset + 0) = (this->start_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->start_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->start_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->start_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->start_time.nsec);
*(outbuffer + offset + 0) = (this->duration.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->duration.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->duration.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->duration.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->duration.sec);
*(outbuffer + offset + 0) = (this->duration.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->duration.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->duration.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->duration.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->duration.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_body_name;
arrToVar(length_body_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_body_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_body_name-1]=0;
this->body_name = (char *)(inbuffer + offset-1);
offset += length_body_name;
uint32_t length_reference_frame;
arrToVar(length_reference_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_reference_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_reference_frame-1]=0;
this->reference_frame = (char *)(inbuffer + offset-1);
offset += length_reference_frame;
offset += this->reference_point.deserialize(inbuffer + offset);
offset += this->wrench.deserialize(inbuffer + offset);
this->start_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->start_time.sec);
this->start_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->start_time.nsec);
this->duration.sec = ((uint32_t) (*(inbuffer + offset)));
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->duration.sec);
this->duration.nsec = ((uint32_t) (*(inbuffer + offset)));
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->duration.nsec);
return offset;
}
const char * getType(){ return APPLYBODYWRENCH; };
const char * getMD5(){ return "e37e6adf97eba5095baa77dffb71e5bd"; };
};
class ApplyBodyWrenchResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
ApplyBodyWrenchResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return APPLYBODYWRENCH; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class ApplyBodyWrench {
public:
typedef ApplyBodyWrenchRequest Request;
typedef ApplyBodyWrenchResponse Response;
};
}
#endif
| 7,720 | C | 37.605 | 82 | 0.590415 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetModelState.h | #ifndef _ROS_SERVICE_SetModelState_h
#define _ROS_SERVICE_SetModelState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "gazebo_msgs/ModelState.h"
namespace gazebo_msgs
{
static const char SETMODELSTATE[] = "gazebo_msgs/SetModelState";
class SetModelStateRequest : public ros::Msg
{
public:
typedef gazebo_msgs::ModelState _model_state_type;
_model_state_type model_state;
SetModelStateRequest():
model_state()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->model_state.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->model_state.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SETMODELSTATE; };
const char * getMD5(){ return "cb042b0e91880f4661b29ea5b6234350"; };
};
class SetModelStateResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetModelStateResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETMODELSTATE; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetModelState {
public:
typedef SetModelStateRequest Request;
typedef SetModelStateResponse Response;
};
}
#endif
| 2,906 | C | 24.955357 | 78 | 0.625602 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetJointTrajectory.h | #ifndef _ROS_SERVICE_SetJointTrajectory_h
#define _ROS_SERVICE_SetJointTrajectory_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "trajectory_msgs/JointTrajectory.h"
#include "geometry_msgs/Pose.h"
namespace gazebo_msgs
{
static const char SETJOINTTRAJECTORY[] = "gazebo_msgs/SetJointTrajectory";
class SetJointTrajectoryRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
typedef trajectory_msgs::JointTrajectory _joint_trajectory_type;
_joint_trajectory_type joint_trajectory;
typedef geometry_msgs::Pose _model_pose_type;
_model_pose_type model_pose;
typedef bool _set_model_pose_type;
_set_model_pose_type set_model_pose;
typedef bool _disable_physics_updates_type;
_disable_physics_updates_type disable_physics_updates;
SetJointTrajectoryRequest():
model_name(""),
joint_trajectory(),
model_pose(),
set_model_pose(0),
disable_physics_updates(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
offset += this->joint_trajectory.serialize(outbuffer + offset);
offset += this->model_pose.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_set_model_pose;
u_set_model_pose.real = this->set_model_pose;
*(outbuffer + offset + 0) = (u_set_model_pose.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->set_model_pose);
union {
bool real;
uint8_t base;
} u_disable_physics_updates;
u_disable_physics_updates.real = this->disable_physics_updates;
*(outbuffer + offset + 0) = (u_disable_physics_updates.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->disable_physics_updates);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
offset += this->joint_trajectory.deserialize(inbuffer + offset);
offset += this->model_pose.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_set_model_pose;
u_set_model_pose.base = 0;
u_set_model_pose.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->set_model_pose = u_set_model_pose.real;
offset += sizeof(this->set_model_pose);
union {
bool real;
uint8_t base;
} u_disable_physics_updates;
u_disable_physics_updates.base = 0;
u_disable_physics_updates.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->disable_physics_updates = u_disable_physics_updates.real;
offset += sizeof(this->disable_physics_updates);
return offset;
}
const char * getType(){ return SETJOINTTRAJECTORY; };
const char * getMD5(){ return "649dd2eba5ffd358069238825f9f85ab"; };
};
class SetJointTrajectoryResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetJointTrajectoryResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETJOINTTRAJECTORY; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetJointTrajectory {
public:
typedef SetJointTrajectoryRequest Request;
typedef SetJointTrajectoryResponse Response;
};
}
#endif
| 5,442 | C | 30.830409 | 90 | 0.623117 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/BodyRequest.h | #ifndef _ROS_SERVICE_BodyRequest_h
#define _ROS_SERVICE_BodyRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char BODYREQUEST[] = "gazebo_msgs/BodyRequest";
class BodyRequestRequest : public ros::Msg
{
public:
typedef const char* _body_name_type;
_body_name_type body_name;
BodyRequestRequest():
body_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_body_name = strlen(this->body_name);
varToArr(outbuffer + offset, length_body_name);
offset += 4;
memcpy(outbuffer + offset, this->body_name, length_body_name);
offset += length_body_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_body_name;
arrToVar(length_body_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_body_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_body_name-1]=0;
this->body_name = (char *)(inbuffer + offset-1);
offset += length_body_name;
return offset;
}
const char * getType(){ return BODYREQUEST; };
const char * getMD5(){ return "5eade9afe7f232d78005bd0cafeab755"; };
};
class BodyRequestResponse : public ros::Msg
{
public:
BodyRequestResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return BODYREQUEST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class BodyRequest {
public:
typedef BodyRequestRequest Request;
typedef BodyRequestResponse Response;
};
}
#endif
| 1,964 | C | 21.329545 | 72 | 0.629328 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetLightProperties.h | #ifndef _ROS_SERVICE_GetLightProperties_h
#define _ROS_SERVICE_GetLightProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/ColorRGBA.h"
namespace gazebo_msgs
{
static const char GETLIGHTPROPERTIES[] = "gazebo_msgs/GetLightProperties";
class GetLightPropertiesRequest : public ros::Msg
{
public:
typedef const char* _light_name_type;
_light_name_type light_name;
GetLightPropertiesRequest():
light_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_light_name = strlen(this->light_name);
varToArr(outbuffer + offset, length_light_name);
offset += 4;
memcpy(outbuffer + offset, this->light_name, length_light_name);
offset += length_light_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_light_name;
arrToVar(length_light_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_light_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_light_name-1]=0;
this->light_name = (char *)(inbuffer + offset-1);
offset += length_light_name;
return offset;
}
const char * getType(){ return GETLIGHTPROPERTIES; };
const char * getMD5(){ return "4fb676dfb4741fc866365702a859441c"; };
};
class GetLightPropertiesResponse : public ros::Msg
{
public:
typedef std_msgs::ColorRGBA _diffuse_type;
_diffuse_type diffuse;
typedef double _attenuation_constant_type;
_attenuation_constant_type attenuation_constant;
typedef double _attenuation_linear_type;
_attenuation_linear_type attenuation_linear;
typedef double _attenuation_quadratic_type;
_attenuation_quadratic_type attenuation_quadratic;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetLightPropertiesResponse():
diffuse(),
attenuation_constant(0),
attenuation_linear(0),
attenuation_quadratic(0),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->diffuse.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_attenuation_constant;
u_attenuation_constant.real = this->attenuation_constant;
*(outbuffer + offset + 0) = (u_attenuation_constant.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_constant.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_constant.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_constant.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_constant.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_constant.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_constant.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_constant.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_constant);
union {
double real;
uint64_t base;
} u_attenuation_linear;
u_attenuation_linear.real = this->attenuation_linear;
*(outbuffer + offset + 0) = (u_attenuation_linear.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_linear.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_linear.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_linear.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_linear.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_linear.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_linear.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_linear.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_linear);
union {
double real;
uint64_t base;
} u_attenuation_quadratic;
u_attenuation_quadratic.real = this->attenuation_quadratic;
*(outbuffer + offset + 0) = (u_attenuation_quadratic.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_quadratic.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_quadratic.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_quadratic.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_quadratic.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_quadratic.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_quadratic.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_quadratic.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_quadratic);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->diffuse.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_attenuation_constant;
u_attenuation_constant.base = 0;
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_constant = u_attenuation_constant.real;
offset += sizeof(this->attenuation_constant);
union {
double real;
uint64_t base;
} u_attenuation_linear;
u_attenuation_linear.base = 0;
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_linear = u_attenuation_linear.real;
offset += sizeof(this->attenuation_linear);
union {
double real;
uint64_t base;
} u_attenuation_quadratic;
u_attenuation_quadratic.base = 0;
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_quadratic = u_attenuation_quadratic.real;
offset += sizeof(this->attenuation_quadratic);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETLIGHTPROPERTIES; };
const char * getMD5(){ return "9a19ddd5aab4c13b7643d1722c709f1f"; };
};
class GetLightProperties {
public:
typedef GetLightPropertiesRequest Request;
typedef GetLightPropertiesResponse Response;
};
}
#endif
| 9,498 | C | 41.217778 | 89 | 0.594862 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetLinkState.h | #ifndef _ROS_SERVICE_SetLinkState_h
#define _ROS_SERVICE_SetLinkState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "gazebo_msgs/LinkState.h"
namespace gazebo_msgs
{
static const char SETLINKSTATE[] = "gazebo_msgs/SetLinkState";
class SetLinkStateRequest : public ros::Msg
{
public:
typedef gazebo_msgs::LinkState _link_state_type;
_link_state_type link_state;
SetLinkStateRequest():
link_state()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->link_state.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->link_state.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SETLINKSTATE; };
const char * getMD5(){ return "22a2c757d56911b6f27868159e9a872d"; };
};
class SetLinkStateResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetLinkStateResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETLINKSTATE; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetLinkState {
public:
typedef SetLinkStateRequest Request;
typedef SetLinkStateResponse Response;
};
}
#endif
| 2,885 | C | 24.767857 | 78 | 0.622877 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ModelState.h | #ifndef _ROS_gazebo_msgs_ModelState_h
#define _ROS_gazebo_msgs_ModelState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
namespace gazebo_msgs
{
class ModelState : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Twist _twist_type;
_twist_type twist;
typedef const char* _reference_frame_type;
_reference_frame_type reference_frame;
ModelState():
model_name(""),
pose(),
twist(),
reference_frame("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
offset += this->pose.serialize(outbuffer + offset);
offset += this->twist.serialize(outbuffer + offset);
uint32_t length_reference_frame = strlen(this->reference_frame);
varToArr(outbuffer + offset, length_reference_frame);
offset += 4;
memcpy(outbuffer + offset, this->reference_frame, length_reference_frame);
offset += length_reference_frame;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
offset += this->pose.deserialize(inbuffer + offset);
offset += this->twist.deserialize(inbuffer + offset);
uint32_t length_reference_frame;
arrToVar(length_reference_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_reference_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_reference_frame-1]=0;
this->reference_frame = (char *)(inbuffer + offset-1);
offset += length_reference_frame;
return offset;
}
const char * getType(){ return "gazebo_msgs/ModelState"; };
const char * getMD5(){ return "9330fd35f2fcd82d457e54bd54e10593"; };
};
}
#endif
| 2,599 | C | 29.588235 | 80 | 0.63486 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetModelProperties.h | #ifndef _ROS_SERVICE_GetModelProperties_h
#define _ROS_SERVICE_GetModelProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char GETMODELPROPERTIES[] = "gazebo_msgs/GetModelProperties";
class GetModelPropertiesRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
GetModelPropertiesRequest():
model_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
return offset;
}
const char * getType(){ return GETMODELPROPERTIES; };
const char * getMD5(){ return "ea31c8eab6fc401383cf528a7c0984ba"; };
};
class GetModelPropertiesResponse : public ros::Msg
{
public:
typedef const char* _parent_model_name_type;
_parent_model_name_type parent_model_name;
typedef const char* _canonical_body_name_type;
_canonical_body_name_type canonical_body_name;
uint32_t body_names_length;
typedef char* _body_names_type;
_body_names_type st_body_names;
_body_names_type * body_names;
uint32_t geom_names_length;
typedef char* _geom_names_type;
_geom_names_type st_geom_names;
_geom_names_type * geom_names;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t child_model_names_length;
typedef char* _child_model_names_type;
_child_model_names_type st_child_model_names;
_child_model_names_type * child_model_names;
typedef bool _is_static_type;
_is_static_type is_static;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetModelPropertiesResponse():
parent_model_name(""),
canonical_body_name(""),
body_names_length(0), body_names(NULL),
geom_names_length(0), geom_names(NULL),
joint_names_length(0), joint_names(NULL),
child_model_names_length(0), child_model_names(NULL),
is_static(0),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_parent_model_name = strlen(this->parent_model_name);
varToArr(outbuffer + offset, length_parent_model_name);
offset += 4;
memcpy(outbuffer + offset, this->parent_model_name, length_parent_model_name);
offset += length_parent_model_name;
uint32_t length_canonical_body_name = strlen(this->canonical_body_name);
varToArr(outbuffer + offset, length_canonical_body_name);
offset += 4;
memcpy(outbuffer + offset, this->canonical_body_name, length_canonical_body_name);
offset += length_canonical_body_name;
*(outbuffer + offset + 0) = (this->body_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->body_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->body_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->body_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->body_names_length);
for( uint32_t i = 0; i < body_names_length; i++){
uint32_t length_body_namesi = strlen(this->body_names[i]);
varToArr(outbuffer + offset, length_body_namesi);
offset += 4;
memcpy(outbuffer + offset, this->body_names[i], length_body_namesi);
offset += length_body_namesi;
}
*(outbuffer + offset + 0) = (this->geom_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->geom_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->geom_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->geom_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->geom_names_length);
for( uint32_t i = 0; i < geom_names_length; i++){
uint32_t length_geom_namesi = strlen(this->geom_names[i]);
varToArr(outbuffer + offset, length_geom_namesi);
offset += 4;
memcpy(outbuffer + offset, this->geom_names[i], length_geom_namesi);
offset += length_geom_namesi;
}
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
*(outbuffer + offset + 0) = (this->child_model_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->child_model_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->child_model_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->child_model_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->child_model_names_length);
for( uint32_t i = 0; i < child_model_names_length; i++){
uint32_t length_child_model_namesi = strlen(this->child_model_names[i]);
varToArr(outbuffer + offset, length_child_model_namesi);
offset += 4;
memcpy(outbuffer + offset, this->child_model_names[i], length_child_model_namesi);
offset += length_child_model_namesi;
}
union {
bool real;
uint8_t base;
} u_is_static;
u_is_static.real = this->is_static;
*(outbuffer + offset + 0) = (u_is_static.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->is_static);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_parent_model_name;
arrToVar(length_parent_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_parent_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_parent_model_name-1]=0;
this->parent_model_name = (char *)(inbuffer + offset-1);
offset += length_parent_model_name;
uint32_t length_canonical_body_name;
arrToVar(length_canonical_body_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_canonical_body_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_canonical_body_name-1]=0;
this->canonical_body_name = (char *)(inbuffer + offset-1);
offset += length_canonical_body_name;
uint32_t body_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
body_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
body_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
body_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->body_names_length);
if(body_names_lengthT > body_names_length)
this->body_names = (char**)realloc(this->body_names, body_names_lengthT * sizeof(char*));
body_names_length = body_names_lengthT;
for( uint32_t i = 0; i < body_names_length; i++){
uint32_t length_st_body_names;
arrToVar(length_st_body_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_body_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_body_names-1]=0;
this->st_body_names = (char *)(inbuffer + offset-1);
offset += length_st_body_names;
memcpy( &(this->body_names[i]), &(this->st_body_names), sizeof(char*));
}
uint32_t geom_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
geom_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
geom_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
geom_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->geom_names_length);
if(geom_names_lengthT > geom_names_length)
this->geom_names = (char**)realloc(this->geom_names, geom_names_lengthT * sizeof(char*));
geom_names_length = geom_names_lengthT;
for( uint32_t i = 0; i < geom_names_length; i++){
uint32_t length_st_geom_names;
arrToVar(length_st_geom_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_geom_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_geom_names-1]=0;
this->st_geom_names = (char *)(inbuffer + offset-1);
offset += length_st_geom_names;
memcpy( &(this->geom_names[i]), &(this->st_geom_names), sizeof(char*));
}
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
uint32_t child_model_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
child_model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
child_model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
child_model_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->child_model_names_length);
if(child_model_names_lengthT > child_model_names_length)
this->child_model_names = (char**)realloc(this->child_model_names, child_model_names_lengthT * sizeof(char*));
child_model_names_length = child_model_names_lengthT;
for( uint32_t i = 0; i < child_model_names_length; i++){
uint32_t length_st_child_model_names;
arrToVar(length_st_child_model_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_child_model_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_child_model_names-1]=0;
this->st_child_model_names = (char *)(inbuffer + offset-1);
offset += length_st_child_model_names;
memcpy( &(this->child_model_names[i]), &(this->st_child_model_names), sizeof(char*));
}
union {
bool real;
uint8_t base;
} u_is_static;
u_is_static.base = 0;
u_is_static.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->is_static = u_is_static.real;
offset += sizeof(this->is_static);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETMODELPROPERTIES; };
const char * getMD5(){ return "b7f370938ef77b464b95f1bab3ec5028"; };
};
class GetModelProperties {
public:
typedef GetModelPropertiesRequest Request;
typedef GetModelPropertiesResponse Response;
};
}
#endif
| 13,779 | C | 41.662539 | 118 | 0.602366 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ODEPhysics.h | #ifndef _ROS_gazebo_msgs_ODEPhysics_h
#define _ROS_gazebo_msgs_ODEPhysics_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
class ODEPhysics : public ros::Msg
{
public:
typedef bool _auto_disable_bodies_type;
_auto_disable_bodies_type auto_disable_bodies;
typedef uint32_t _sor_pgs_precon_iters_type;
_sor_pgs_precon_iters_type sor_pgs_precon_iters;
typedef uint32_t _sor_pgs_iters_type;
_sor_pgs_iters_type sor_pgs_iters;
typedef double _sor_pgs_w_type;
_sor_pgs_w_type sor_pgs_w;
typedef double _sor_pgs_rms_error_tol_type;
_sor_pgs_rms_error_tol_type sor_pgs_rms_error_tol;
typedef double _contact_surface_layer_type;
_contact_surface_layer_type contact_surface_layer;
typedef double _contact_max_correcting_vel_type;
_contact_max_correcting_vel_type contact_max_correcting_vel;
typedef double _cfm_type;
_cfm_type cfm;
typedef double _erp_type;
_erp_type erp;
typedef uint32_t _max_contacts_type;
_max_contacts_type max_contacts;
ODEPhysics():
auto_disable_bodies(0),
sor_pgs_precon_iters(0),
sor_pgs_iters(0),
sor_pgs_w(0),
sor_pgs_rms_error_tol(0),
contact_surface_layer(0),
contact_max_correcting_vel(0),
cfm(0),
erp(0),
max_contacts(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_auto_disable_bodies;
u_auto_disable_bodies.real = this->auto_disable_bodies;
*(outbuffer + offset + 0) = (u_auto_disable_bodies.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->auto_disable_bodies);
*(outbuffer + offset + 0) = (this->sor_pgs_precon_iters >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sor_pgs_precon_iters >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sor_pgs_precon_iters >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sor_pgs_precon_iters >> (8 * 3)) & 0xFF;
offset += sizeof(this->sor_pgs_precon_iters);
*(outbuffer + offset + 0) = (this->sor_pgs_iters >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sor_pgs_iters >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sor_pgs_iters >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sor_pgs_iters >> (8 * 3)) & 0xFF;
offset += sizeof(this->sor_pgs_iters);
union {
double real;
uint64_t base;
} u_sor_pgs_w;
u_sor_pgs_w.real = this->sor_pgs_w;
*(outbuffer + offset + 0) = (u_sor_pgs_w.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sor_pgs_w.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sor_pgs_w.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sor_pgs_w.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_sor_pgs_w.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_sor_pgs_w.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_sor_pgs_w.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_sor_pgs_w.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->sor_pgs_w);
union {
double real;
uint64_t base;
} u_sor_pgs_rms_error_tol;
u_sor_pgs_rms_error_tol.real = this->sor_pgs_rms_error_tol;
*(outbuffer + offset + 0) = (u_sor_pgs_rms_error_tol.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sor_pgs_rms_error_tol.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sor_pgs_rms_error_tol.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sor_pgs_rms_error_tol.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_sor_pgs_rms_error_tol.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_sor_pgs_rms_error_tol.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_sor_pgs_rms_error_tol.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_sor_pgs_rms_error_tol.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->sor_pgs_rms_error_tol);
union {
double real;
uint64_t base;
} u_contact_surface_layer;
u_contact_surface_layer.real = this->contact_surface_layer;
*(outbuffer + offset + 0) = (u_contact_surface_layer.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_contact_surface_layer.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_contact_surface_layer.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_contact_surface_layer.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_contact_surface_layer.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_contact_surface_layer.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_contact_surface_layer.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_contact_surface_layer.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->contact_surface_layer);
union {
double real;
uint64_t base;
} u_contact_max_correcting_vel;
u_contact_max_correcting_vel.real = this->contact_max_correcting_vel;
*(outbuffer + offset + 0) = (u_contact_max_correcting_vel.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_contact_max_correcting_vel.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_contact_max_correcting_vel.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_contact_max_correcting_vel.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_contact_max_correcting_vel.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_contact_max_correcting_vel.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_contact_max_correcting_vel.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_contact_max_correcting_vel.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->contact_max_correcting_vel);
union {
double real;
uint64_t base;
} u_cfm;
u_cfm.real = this->cfm;
*(outbuffer + offset + 0) = (u_cfm.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cfm.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cfm.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cfm.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_cfm.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_cfm.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_cfm.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_cfm.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->cfm);
union {
double real;
uint64_t base;
} u_erp;
u_erp.real = this->erp;
*(outbuffer + offset + 0) = (u_erp.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_erp.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_erp.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_erp.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_erp.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_erp.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_erp.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_erp.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->erp);
*(outbuffer + offset + 0) = (this->max_contacts >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->max_contacts >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->max_contacts >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->max_contacts >> (8 * 3)) & 0xFF;
offset += sizeof(this->max_contacts);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_auto_disable_bodies;
u_auto_disable_bodies.base = 0;
u_auto_disable_bodies.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->auto_disable_bodies = u_auto_disable_bodies.real;
offset += sizeof(this->auto_disable_bodies);
this->sor_pgs_precon_iters = ((uint32_t) (*(inbuffer + offset)));
this->sor_pgs_precon_iters |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->sor_pgs_precon_iters |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->sor_pgs_precon_iters |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sor_pgs_precon_iters);
this->sor_pgs_iters = ((uint32_t) (*(inbuffer + offset)));
this->sor_pgs_iters |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->sor_pgs_iters |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->sor_pgs_iters |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sor_pgs_iters);
union {
double real;
uint64_t base;
} u_sor_pgs_w;
u_sor_pgs_w.base = 0;
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_sor_pgs_w.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->sor_pgs_w = u_sor_pgs_w.real;
offset += sizeof(this->sor_pgs_w);
union {
double real;
uint64_t base;
} u_sor_pgs_rms_error_tol;
u_sor_pgs_rms_error_tol.base = 0;
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_sor_pgs_rms_error_tol.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->sor_pgs_rms_error_tol = u_sor_pgs_rms_error_tol.real;
offset += sizeof(this->sor_pgs_rms_error_tol);
union {
double real;
uint64_t base;
} u_contact_surface_layer;
u_contact_surface_layer.base = 0;
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_contact_surface_layer.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->contact_surface_layer = u_contact_surface_layer.real;
offset += sizeof(this->contact_surface_layer);
union {
double real;
uint64_t base;
} u_contact_max_correcting_vel;
u_contact_max_correcting_vel.base = 0;
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_contact_max_correcting_vel.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->contact_max_correcting_vel = u_contact_max_correcting_vel.real;
offset += sizeof(this->contact_max_correcting_vel);
union {
double real;
uint64_t base;
} u_cfm;
u_cfm.base = 0;
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_cfm.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->cfm = u_cfm.real;
offset += sizeof(this->cfm);
union {
double real;
uint64_t base;
} u_erp;
u_erp.base = 0;
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_erp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->erp = u_erp.real;
offset += sizeof(this->erp);
this->max_contacts = ((uint32_t) (*(inbuffer + offset)));
this->max_contacts |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->max_contacts |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->max_contacts |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->max_contacts);
return offset;
}
const char * getType(){ return "gazebo_msgs/ODEPhysics"; };
const char * getMD5(){ return "667d56ddbd547918c32d1934503dc335"; };
};
}
#endif
| 14,584 | C | 49.642361 | 94 | 0.53209 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetPhysicsProperties.h | #ifndef _ROS_SERVICE_GetPhysicsProperties_h
#define _ROS_SERVICE_GetPhysicsProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
#include "gazebo_msgs/ODEPhysics.h"
namespace gazebo_msgs
{
static const char GETPHYSICSPROPERTIES[] = "gazebo_msgs/GetPhysicsProperties";
class GetPhysicsPropertiesRequest : public ros::Msg
{
public:
GetPhysicsPropertiesRequest()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return GETPHYSICSPROPERTIES; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class GetPhysicsPropertiesResponse : public ros::Msg
{
public:
typedef double _time_step_type;
_time_step_type time_step;
typedef bool _pause_type;
_pause_type pause;
typedef double _max_update_rate_type;
_max_update_rate_type max_update_rate;
typedef geometry_msgs::Vector3 _gravity_type;
_gravity_type gravity;
typedef gazebo_msgs::ODEPhysics _ode_config_type;
_ode_config_type ode_config;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetPhysicsPropertiesResponse():
time_step(0),
pause(0),
max_update_rate(0),
gravity(),
ode_config(),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.real = this->time_step;
*(outbuffer + offset + 0) = (u_time_step.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_time_step.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_time_step.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_time_step.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_time_step.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_time_step.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_time_step.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_time_step.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->time_step);
union {
bool real;
uint8_t base;
} u_pause;
u_pause.real = this->pause;
*(outbuffer + offset + 0) = (u_pause.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->pause);
union {
double real;
uint64_t base;
} u_max_update_rate;
u_max_update_rate.real = this->max_update_rate;
*(outbuffer + offset + 0) = (u_max_update_rate.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_update_rate.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_update_rate.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_update_rate.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_update_rate.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_update_rate.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_update_rate.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_update_rate.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_update_rate);
offset += this->gravity.serialize(outbuffer + offset);
offset += this->ode_config.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_time_step;
u_time_step.base = 0;
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_time_step.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->time_step = u_time_step.real;
offset += sizeof(this->time_step);
union {
bool real;
uint8_t base;
} u_pause;
u_pause.base = 0;
u_pause.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->pause = u_pause.real;
offset += sizeof(this->pause);
union {
double real;
uint64_t base;
} u_max_update_rate;
u_max_update_rate.base = 0;
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_update_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_update_rate = u_max_update_rate.real;
offset += sizeof(this->max_update_rate);
offset += this->gravity.deserialize(inbuffer + offset);
offset += this->ode_config.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETPHYSICSPROPERTIES; };
const char * getMD5(){ return "575a5e74786981b7df2e3afc567693a6"; };
};
class GetPhysicsProperties {
public:
typedef GetPhysicsPropertiesRequest Request;
typedef GetPhysicsPropertiesResponse Response;
};
}
#endif
| 7,231 | C | 35.16 | 83 | 0.566727 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetLinkProperties.h | #ifndef _ROS_SERVICE_SetLinkProperties_h
#define _ROS_SERVICE_SetLinkProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
namespace gazebo_msgs
{
static const char SETLINKPROPERTIES[] = "gazebo_msgs/SetLinkProperties";
class SetLinkPropertiesRequest : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef geometry_msgs::Pose _com_type;
_com_type com;
typedef bool _gravity_mode_type;
_gravity_mode_type gravity_mode;
typedef double _mass_type;
_mass_type mass;
typedef double _ixx_type;
_ixx_type ixx;
typedef double _ixy_type;
_ixy_type ixy;
typedef double _ixz_type;
_ixz_type ixz;
typedef double _iyy_type;
_iyy_type iyy;
typedef double _iyz_type;
_iyz_type iyz;
typedef double _izz_type;
_izz_type izz;
SetLinkPropertiesRequest():
link_name(""),
com(),
gravity_mode(0),
mass(0),
ixx(0),
ixy(0),
ixz(0),
iyy(0),
iyz(0),
izz(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
offset += this->com.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_gravity_mode;
u_gravity_mode.real = this->gravity_mode;
*(outbuffer + offset + 0) = (u_gravity_mode.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->gravity_mode);
union {
double real;
uint64_t base;
} u_mass;
u_mass.real = this->mass;
*(outbuffer + offset + 0) = (u_mass.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_mass.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_mass.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_mass.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_mass.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_mass.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_mass.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_mass.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->mass);
union {
double real;
uint64_t base;
} u_ixx;
u_ixx.real = this->ixx;
*(outbuffer + offset + 0) = (u_ixx.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixx.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixx.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixx.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixx.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixx.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixx.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixx.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixx);
union {
double real;
uint64_t base;
} u_ixy;
u_ixy.real = this->ixy;
*(outbuffer + offset + 0) = (u_ixy.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixy.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixy.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixy.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixy.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixy.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixy.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixy.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixy);
union {
double real;
uint64_t base;
} u_ixz;
u_ixz.real = this->ixz;
*(outbuffer + offset + 0) = (u_ixz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixz);
union {
double real;
uint64_t base;
} u_iyy;
u_iyy.real = this->iyy;
*(outbuffer + offset + 0) = (u_iyy.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_iyy.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_iyy.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_iyy.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_iyy.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_iyy.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_iyy.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_iyy.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->iyy);
union {
double real;
uint64_t base;
} u_iyz;
u_iyz.real = this->iyz;
*(outbuffer + offset + 0) = (u_iyz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_iyz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_iyz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_iyz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_iyz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_iyz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_iyz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_iyz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->iyz);
union {
double real;
uint64_t base;
} u_izz;
u_izz.real = this->izz;
*(outbuffer + offset + 0) = (u_izz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_izz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_izz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_izz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_izz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_izz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_izz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_izz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->izz);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
offset += this->com.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_gravity_mode;
u_gravity_mode.base = 0;
u_gravity_mode.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->gravity_mode = u_gravity_mode.real;
offset += sizeof(this->gravity_mode);
union {
double real;
uint64_t base;
} u_mass;
u_mass.base = 0;
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->mass = u_mass.real;
offset += sizeof(this->mass);
union {
double real;
uint64_t base;
} u_ixx;
u_ixx.base = 0;
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixx = u_ixx.real;
offset += sizeof(this->ixx);
union {
double real;
uint64_t base;
} u_ixy;
u_ixy.base = 0;
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixy = u_ixy.real;
offset += sizeof(this->ixy);
union {
double real;
uint64_t base;
} u_ixz;
u_ixz.base = 0;
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixz = u_ixz.real;
offset += sizeof(this->ixz);
union {
double real;
uint64_t base;
} u_iyy;
u_iyy.base = 0;
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->iyy = u_iyy.real;
offset += sizeof(this->iyy);
union {
double real;
uint64_t base;
} u_iyz;
u_iyz.base = 0;
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->iyz = u_iyz.real;
offset += sizeof(this->iyz);
union {
double real;
uint64_t base;
} u_izz;
u_izz.base = 0;
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->izz = u_izz.real;
offset += sizeof(this->izz);
return offset;
}
const char * getType(){ return SETLINKPROPERTIES; };
const char * getMD5(){ return "68ac74a4be01b165bc305b5ccdc45e91"; };
};
class SetLinkPropertiesResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetLinkPropertiesResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETLINKPROPERTIES; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetLinkProperties {
public:
typedef SetLinkPropertiesRequest Request;
typedef SetLinkPropertiesResponse Response;
};
}
#endif
| 14,529 | C | 38.16442 | 79 | 0.500723 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetJointProperties.h | #ifndef _ROS_SERVICE_GetJointProperties_h
#define _ROS_SERVICE_GetJointProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char GETJOINTPROPERTIES[] = "gazebo_msgs/GetJointProperties";
class GetJointPropertiesRequest : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
GetJointPropertiesRequest():
joint_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_joint_name = strlen(this->joint_name);
varToArr(outbuffer + offset, length_joint_name);
offset += 4;
memcpy(outbuffer + offset, this->joint_name, length_joint_name);
offset += length_joint_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_joint_name;
arrToVar(length_joint_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_joint_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_joint_name-1]=0;
this->joint_name = (char *)(inbuffer + offset-1);
offset += length_joint_name;
return offset;
}
const char * getType(){ return GETJOINTPROPERTIES; };
const char * getMD5(){ return "0be1351618e1dc030eb7959d9a4902de"; };
};
class GetJointPropertiesResponse : public ros::Msg
{
public:
typedef uint8_t _type_type;
_type_type type;
uint32_t damping_length;
typedef double _damping_type;
_damping_type st_damping;
_damping_type * damping;
uint32_t position_length;
typedef double _position_type;
_position_type st_position;
_position_type * position;
uint32_t rate_length;
typedef double _rate_type;
_rate_type st_rate;
_rate_type * rate;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
enum { REVOLUTE = 0 };
enum { CONTINUOUS = 1 };
enum { PRISMATIC = 2 };
enum { FIXED = 3 };
enum { BALL = 4 };
enum { UNIVERSAL = 5 };
GetJointPropertiesResponse():
type(0),
damping_length(0), damping(NULL),
position_length(0), position(NULL),
rate_length(0), rate(NULL),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
offset += sizeof(this->type);
*(outbuffer + offset + 0) = (this->damping_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->damping_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->damping_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->damping_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->damping_length);
for( uint32_t i = 0; i < damping_length; i++){
union {
double real;
uint64_t base;
} u_dampingi;
u_dampingi.real = this->damping[i];
*(outbuffer + offset + 0) = (u_dampingi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_dampingi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_dampingi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_dampingi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_dampingi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_dampingi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_dampingi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_dampingi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->damping[i]);
}
*(outbuffer + offset + 0) = (this->position_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->position_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->position_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->position_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->position_length);
for( uint32_t i = 0; i < position_length; i++){
union {
double real;
uint64_t base;
} u_positioni;
u_positioni.real = this->position[i];
*(outbuffer + offset + 0) = (u_positioni.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_positioni.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_positioni.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_positioni.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_positioni.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_positioni.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_positioni.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_positioni.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->position[i]);
}
*(outbuffer + offset + 0) = (this->rate_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->rate_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->rate_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->rate_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->rate_length);
for( uint32_t i = 0; i < rate_length; i++){
union {
double real;
uint64_t base;
} u_ratei;
u_ratei.real = this->rate[i];
*(outbuffer + offset + 0) = (u_ratei.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ratei.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ratei.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ratei.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ratei.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ratei.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ratei.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ratei.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->rate[i]);
}
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->type);
uint32_t damping_lengthT = ((uint32_t) (*(inbuffer + offset)));
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->damping_length);
if(damping_lengthT > damping_length)
this->damping = (double*)realloc(this->damping, damping_lengthT * sizeof(double));
damping_length = damping_lengthT;
for( uint32_t i = 0; i < damping_length; i++){
union {
double real;
uint64_t base;
} u_st_damping;
u_st_damping.base = 0;
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_damping = u_st_damping.real;
offset += sizeof(this->st_damping);
memcpy( &(this->damping[i]), &(this->st_damping), sizeof(double));
}
uint32_t position_lengthT = ((uint32_t) (*(inbuffer + offset)));
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
position_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->position_length);
if(position_lengthT > position_length)
this->position = (double*)realloc(this->position, position_lengthT * sizeof(double));
position_length = position_lengthT;
for( uint32_t i = 0; i < position_length; i++){
union {
double real;
uint64_t base;
} u_st_position;
u_st_position.base = 0;
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_position = u_st_position.real;
offset += sizeof(this->st_position);
memcpy( &(this->position[i]), &(this->st_position), sizeof(double));
}
uint32_t rate_lengthT = ((uint32_t) (*(inbuffer + offset)));
rate_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
rate_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
rate_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->rate_length);
if(rate_lengthT > rate_length)
this->rate = (double*)realloc(this->rate, rate_lengthT * sizeof(double));
rate_length = rate_lengthT;
for( uint32_t i = 0; i < rate_length; i++){
union {
double real;
uint64_t base;
} u_st_rate;
u_st_rate.base = 0;
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_rate.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_rate = u_st_rate.real;
offset += sizeof(this->st_rate);
memcpy( &(this->rate[i]), &(this->st_rate), sizeof(double));
}
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETJOINTPROPERTIES; };
const char * getMD5(){ return "cd7b30a39faa372283dc94c5f6457f82"; };
};
class GetJointProperties {
public:
typedef GetJointPropertiesRequest Request;
typedef GetJointPropertiesResponse Response;
};
}
#endif
| 12,219 | C | 40.849315 | 93 | 0.540879 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/LinkState.h | #ifndef _ROS_gazebo_msgs_LinkState_h
#define _ROS_gazebo_msgs_LinkState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
namespace gazebo_msgs
{
class LinkState : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Twist _twist_type;
_twist_type twist;
typedef const char* _reference_frame_type;
_reference_frame_type reference_frame;
LinkState():
link_name(""),
pose(),
twist(),
reference_frame("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
offset += this->pose.serialize(outbuffer + offset);
offset += this->twist.serialize(outbuffer + offset);
uint32_t length_reference_frame = strlen(this->reference_frame);
varToArr(outbuffer + offset, length_reference_frame);
offset += 4;
memcpy(outbuffer + offset, this->reference_frame, length_reference_frame);
offset += length_reference_frame;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
offset += this->pose.deserialize(inbuffer + offset);
offset += this->twist.deserialize(inbuffer + offset);
uint32_t length_reference_frame;
arrToVar(length_reference_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_reference_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_reference_frame-1]=0;
this->reference_frame = (char *)(inbuffer + offset-1);
offset += length_reference_frame;
return offset;
}
const char * getType(){ return "gazebo_msgs/LinkState"; };
const char * getMD5(){ return "0818ebbf28ce3a08d48ab1eaa7309ebe"; };
};
}
#endif
| 2,578 | C | 29.341176 | 80 | 0.631885 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/DeleteModel.h | #ifndef _ROS_SERVICE_DeleteModel_h
#define _ROS_SERVICE_DeleteModel_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char DELETEMODEL[] = "gazebo_msgs/DeleteModel";
class DeleteModelRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
DeleteModelRequest():
model_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
return offset;
}
const char * getType(){ return DELETEMODEL; };
const char * getMD5(){ return "ea31c8eab6fc401383cf528a7c0984ba"; };
};
class DeleteModelResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
DeleteModelResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return DELETEMODEL; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class DeleteModel {
public:
typedef DeleteModelRequest Request;
typedef DeleteModelResponse Response;
};
}
#endif
| 3,300 | C | 25.837398 | 78 | 0.614848 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetLinkState.h | #ifndef _ROS_SERVICE_GetLinkState_h
#define _ROS_SERVICE_GetLinkState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "gazebo_msgs/LinkState.h"
namespace gazebo_msgs
{
static const char GETLINKSTATE[] = "gazebo_msgs/GetLinkState";
class GetLinkStateRequest : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
typedef const char* _reference_frame_type;
_reference_frame_type reference_frame;
GetLinkStateRequest():
link_name(""),
reference_frame("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
uint32_t length_reference_frame = strlen(this->reference_frame);
varToArr(outbuffer + offset, length_reference_frame);
offset += 4;
memcpy(outbuffer + offset, this->reference_frame, length_reference_frame);
offset += length_reference_frame;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
uint32_t length_reference_frame;
arrToVar(length_reference_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_reference_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_reference_frame-1]=0;
this->reference_frame = (char *)(inbuffer + offset-1);
offset += length_reference_frame;
return offset;
}
const char * getType(){ return GETLINKSTATE; };
const char * getMD5(){ return "7551675c30aaa71f7c288d4864552001"; };
};
class GetLinkStateResponse : public ros::Msg
{
public:
typedef gazebo_msgs::LinkState _link_state_type;
_link_state_type link_state;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetLinkStateResponse():
link_state(),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->link_state.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->link_state.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETLINKSTATE; };
const char * getMD5(){ return "8ba55ad34f9c072e75c0de57b089753b"; };
};
class GetLinkState {
public:
typedef GetLinkStateRequest Request;
typedef GetLinkStateResponse Response;
};
}
#endif
| 4,353 | C | 28.821918 | 80 | 0.624627 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/LinkStates.h | #ifndef _ROS_gazebo_msgs_LinkStates_h
#define _ROS_gazebo_msgs_LinkStates_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
namespace gazebo_msgs
{
class LinkStates : public ros::Msg
{
public:
uint32_t name_length;
typedef char* _name_type;
_name_type st_name;
_name_type * name;
uint32_t pose_length;
typedef geometry_msgs::Pose _pose_type;
_pose_type st_pose;
_pose_type * pose;
uint32_t twist_length;
typedef geometry_msgs::Twist _twist_type;
_twist_type st_twist;
_twist_type * twist;
LinkStates():
name_length(0), name(NULL),
pose_length(0), pose(NULL),
twist_length(0), twist(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->name_length);
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_namei = strlen(this->name[i]);
varToArr(outbuffer + offset, length_namei);
offset += 4;
memcpy(outbuffer + offset, this->name[i], length_namei);
offset += length_namei;
}
*(outbuffer + offset + 0) = (this->pose_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_length);
for( uint32_t i = 0; i < pose_length; i++){
offset += this->pose[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->twist_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->twist_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->twist_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->twist_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->twist_length);
for( uint32_t i = 0; i < twist_length; i++){
offset += this->twist[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->name_length);
if(name_lengthT > name_length)
this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
name_length = name_lengthT;
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_st_name;
arrToVar(length_st_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_name-1]=0;
this->st_name = (char *)(inbuffer + offset-1);
offset += length_st_name;
memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
}
uint32_t pose_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_length);
if(pose_lengthT > pose_length)
this->pose = (geometry_msgs::Pose*)realloc(this->pose, pose_lengthT * sizeof(geometry_msgs::Pose));
pose_length = pose_lengthT;
for( uint32_t i = 0; i < pose_length; i++){
offset += this->st_pose.deserialize(inbuffer + offset);
memcpy( &(this->pose[i]), &(this->st_pose), sizeof(geometry_msgs::Pose));
}
uint32_t twist_lengthT = ((uint32_t) (*(inbuffer + offset)));
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->twist_length);
if(twist_lengthT > twist_length)
this->twist = (geometry_msgs::Twist*)realloc(this->twist, twist_lengthT * sizeof(geometry_msgs::Twist));
twist_length = twist_lengthT;
for( uint32_t i = 0; i < twist_length; i++){
offset += this->st_twist.deserialize(inbuffer + offset);
memcpy( &(this->twist[i]), &(this->st_twist), sizeof(geometry_msgs::Twist));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/LinkStates"; };
const char * getMD5(){ return "48c080191eb15c41858319b4d8a609c2"; };
};
}
#endif
| 5,111 | C | 38.9375 | 112 | 0.560164 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ContactsState.h | #ifndef _ROS_gazebo_msgs_ContactsState_h
#define _ROS_gazebo_msgs_ContactsState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "gazebo_msgs/ContactState.h"
namespace gazebo_msgs
{
class ContactsState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t states_length;
typedef gazebo_msgs::ContactState _states_type;
_states_type st_states;
_states_type * states;
ContactsState():
header(),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->states_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->states_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->states_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->states_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->states_length);
for( uint32_t i = 0; i < states_length; i++){
offset += this->states[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t states_lengthT = ((uint32_t) (*(inbuffer + offset)));
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
states_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->states_length);
if(states_lengthT > states_length)
this->states = (gazebo_msgs::ContactState*)realloc(this->states, states_lengthT * sizeof(gazebo_msgs::ContactState));
states_length = states_lengthT;
for( uint32_t i = 0; i < states_length; i++){
offset += this->st_states.deserialize(inbuffer + offset);
memcpy( &(this->states[i]), &(this->st_states), sizeof(gazebo_msgs::ContactState));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/ContactsState"; };
const char * getMD5(){ return "acbcb1601a8e525bf72509f18e6f668d"; };
};
}
#endif
| 2,350 | C | 32.112676 | 125 | 0.602979 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetModelConfiguration.h | #ifndef _ROS_SERVICE_SetModelConfiguration_h
#define _ROS_SERVICE_SetModelConfiguration_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char SETMODELCONFIGURATION[] = "gazebo_msgs/SetModelConfiguration";
class SetModelConfigurationRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
typedef const char* _urdf_param_name_type;
_urdf_param_name_type urdf_param_name;
uint32_t joint_names_length;
typedef char* _joint_names_type;
_joint_names_type st_joint_names;
_joint_names_type * joint_names;
uint32_t joint_positions_length;
typedef double _joint_positions_type;
_joint_positions_type st_joint_positions;
_joint_positions_type * joint_positions;
SetModelConfigurationRequest():
model_name(""),
urdf_param_name(""),
joint_names_length(0), joint_names(NULL),
joint_positions_length(0), joint_positions(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
uint32_t length_urdf_param_name = strlen(this->urdf_param_name);
varToArr(outbuffer + offset, length_urdf_param_name);
offset += 4;
memcpy(outbuffer + offset, this->urdf_param_name, length_urdf_param_name);
offset += length_urdf_param_name;
*(outbuffer + offset + 0) = (this->joint_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_names_length);
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_joint_namesi = strlen(this->joint_names[i]);
varToArr(outbuffer + offset, length_joint_namesi);
offset += 4;
memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
offset += length_joint_namesi;
}
*(outbuffer + offset + 0) = (this->joint_positions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->joint_positions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->joint_positions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->joint_positions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->joint_positions_length);
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_joint_positionsi;
u_joint_positionsi.real = this->joint_positions[i];
*(outbuffer + offset + 0) = (u_joint_positionsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_joint_positionsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_joint_positionsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_joint_positionsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_joint_positionsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_joint_positionsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_joint_positionsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_joint_positionsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->joint_positions[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
uint32_t length_urdf_param_name;
arrToVar(length_urdf_param_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_urdf_param_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_urdf_param_name-1]=0;
this->urdf_param_name = (char *)(inbuffer + offset-1);
offset += length_urdf_param_name;
uint32_t joint_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_names_length);
if(joint_names_lengthT > joint_names_length)
this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
joint_names_length = joint_names_lengthT;
for( uint32_t i = 0; i < joint_names_length; i++){
uint32_t length_st_joint_names;
arrToVar(length_st_joint_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_joint_names-1]=0;
this->st_joint_names = (char *)(inbuffer + offset-1);
offset += length_st_joint_names;
memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
}
uint32_t joint_positions_lengthT = ((uint32_t) (*(inbuffer + offset)));
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
joint_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->joint_positions_length);
if(joint_positions_lengthT > joint_positions_length)
this->joint_positions = (double*)realloc(this->joint_positions, joint_positions_lengthT * sizeof(double));
joint_positions_length = joint_positions_lengthT;
for( uint32_t i = 0; i < joint_positions_length; i++){
union {
double real;
uint64_t base;
} u_st_joint_positions;
u_st_joint_positions.base = 0;
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_joint_positions.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_joint_positions = u_st_joint_positions.real;
offset += sizeof(this->st_joint_positions);
memcpy( &(this->joint_positions[i]), &(this->st_joint_positions), sizeof(double));
}
return offset;
}
const char * getType(){ return SETMODELCONFIGURATION; };
const char * getMD5(){ return "160eae60f51fabff255480c70afa289f"; };
};
class SetModelConfigurationResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetModelConfigurationResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETMODELCONFIGURATION; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetModelConfiguration {
public:
typedef SetModelConfigurationRequest Request;
typedef SetModelConfigurationResponse Response;
};
}
#endif
| 9,438 | C | 40.21834 | 114 | 0.599809 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetLightProperties.h | #ifndef _ROS_SERVICE_SetLightProperties_h
#define _ROS_SERVICE_SetLightProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/ColorRGBA.h"
namespace gazebo_msgs
{
static const char SETLIGHTPROPERTIES[] = "gazebo_msgs/SetLightProperties";
class SetLightPropertiesRequest : public ros::Msg
{
public:
typedef const char* _light_name_type;
_light_name_type light_name;
typedef std_msgs::ColorRGBA _diffuse_type;
_diffuse_type diffuse;
typedef double _attenuation_constant_type;
_attenuation_constant_type attenuation_constant;
typedef double _attenuation_linear_type;
_attenuation_linear_type attenuation_linear;
typedef double _attenuation_quadratic_type;
_attenuation_quadratic_type attenuation_quadratic;
SetLightPropertiesRequest():
light_name(""),
diffuse(),
attenuation_constant(0),
attenuation_linear(0),
attenuation_quadratic(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_light_name = strlen(this->light_name);
varToArr(outbuffer + offset, length_light_name);
offset += 4;
memcpy(outbuffer + offset, this->light_name, length_light_name);
offset += length_light_name;
offset += this->diffuse.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_attenuation_constant;
u_attenuation_constant.real = this->attenuation_constant;
*(outbuffer + offset + 0) = (u_attenuation_constant.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_constant.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_constant.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_constant.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_constant.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_constant.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_constant.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_constant.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_constant);
union {
double real;
uint64_t base;
} u_attenuation_linear;
u_attenuation_linear.real = this->attenuation_linear;
*(outbuffer + offset + 0) = (u_attenuation_linear.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_linear.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_linear.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_linear.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_linear.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_linear.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_linear.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_linear.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_linear);
union {
double real;
uint64_t base;
} u_attenuation_quadratic;
u_attenuation_quadratic.real = this->attenuation_quadratic;
*(outbuffer + offset + 0) = (u_attenuation_quadratic.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_attenuation_quadratic.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_attenuation_quadratic.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_attenuation_quadratic.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_attenuation_quadratic.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_attenuation_quadratic.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_attenuation_quadratic.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_attenuation_quadratic.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->attenuation_quadratic);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_light_name;
arrToVar(length_light_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_light_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_light_name-1]=0;
this->light_name = (char *)(inbuffer + offset-1);
offset += length_light_name;
offset += this->diffuse.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_attenuation_constant;
u_attenuation_constant.base = 0;
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_constant.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_constant = u_attenuation_constant.real;
offset += sizeof(this->attenuation_constant);
union {
double real;
uint64_t base;
} u_attenuation_linear;
u_attenuation_linear.base = 0;
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_linear.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_linear = u_attenuation_linear.real;
offset += sizeof(this->attenuation_linear);
union {
double real;
uint64_t base;
} u_attenuation_quadratic;
u_attenuation_quadratic.base = 0;
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_attenuation_quadratic.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->attenuation_quadratic = u_attenuation_quadratic.real;
offset += sizeof(this->attenuation_quadratic);
return offset;
}
const char * getType(){ return SETLIGHTPROPERTIES; };
const char * getMD5(){ return "73ad1ac5e9e312ddf7c74f38ad843f34"; };
};
class SetLightPropertiesResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetLightPropertiesResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETLIGHTPROPERTIES; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetLightProperties {
public:
typedef SetLightPropertiesRequest Request;
typedef SetLightPropertiesResponse Response;
};
}
#endif
| 9,498 | C | 41.217778 | 89 | 0.594862 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/WorldState.h | #ifndef _ROS_gazebo_msgs_WorldState_h
#define _ROS_gazebo_msgs_WorldState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Twist.h"
#include "geometry_msgs/Wrench.h"
namespace gazebo_msgs
{
class WorldState : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t name_length;
typedef char* _name_type;
_name_type st_name;
_name_type * name;
uint32_t pose_length;
typedef geometry_msgs::Pose _pose_type;
_pose_type st_pose;
_pose_type * pose;
uint32_t twist_length;
typedef geometry_msgs::Twist _twist_type;
_twist_type st_twist;
_twist_type * twist;
uint32_t wrench_length;
typedef geometry_msgs::Wrench _wrench_type;
_wrench_type st_wrench;
_wrench_type * wrench;
WorldState():
header(),
name_length(0), name(NULL),
pose_length(0), pose(NULL),
twist_length(0), twist(NULL),
wrench_length(0), wrench(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->name_length);
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_namei = strlen(this->name[i]);
varToArr(outbuffer + offset, length_namei);
offset += 4;
memcpy(outbuffer + offset, this->name[i], length_namei);
offset += length_namei;
}
*(outbuffer + offset + 0) = (this->pose_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->pose_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->pose_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->pose_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->pose_length);
for( uint32_t i = 0; i < pose_length; i++){
offset += this->pose[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->twist_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->twist_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->twist_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->twist_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->twist_length);
for( uint32_t i = 0; i < twist_length; i++){
offset += this->twist[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->wrench_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->wrench_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->wrench_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->wrench_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->wrench_length);
for( uint32_t i = 0; i < wrench_length; i++){
offset += this->wrench[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t name_lengthT = ((uint32_t) (*(inbuffer + offset)));
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->name_length);
if(name_lengthT > name_length)
this->name = (char**)realloc(this->name, name_lengthT * sizeof(char*));
name_length = name_lengthT;
for( uint32_t i = 0; i < name_length; i++){
uint32_t length_st_name;
arrToVar(length_st_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_name-1]=0;
this->st_name = (char *)(inbuffer + offset-1);
offset += length_st_name;
memcpy( &(this->name[i]), &(this->st_name), sizeof(char*));
}
uint32_t pose_lengthT = ((uint32_t) (*(inbuffer + offset)));
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
pose_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->pose_length);
if(pose_lengthT > pose_length)
this->pose = (geometry_msgs::Pose*)realloc(this->pose, pose_lengthT * sizeof(geometry_msgs::Pose));
pose_length = pose_lengthT;
for( uint32_t i = 0; i < pose_length; i++){
offset += this->st_pose.deserialize(inbuffer + offset);
memcpy( &(this->pose[i]), &(this->st_pose), sizeof(geometry_msgs::Pose));
}
uint32_t twist_lengthT = ((uint32_t) (*(inbuffer + offset)));
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
twist_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->twist_length);
if(twist_lengthT > twist_length)
this->twist = (geometry_msgs::Twist*)realloc(this->twist, twist_lengthT * sizeof(geometry_msgs::Twist));
twist_length = twist_lengthT;
for( uint32_t i = 0; i < twist_length; i++){
offset += this->st_twist.deserialize(inbuffer + offset);
memcpy( &(this->twist[i]), &(this->st_twist), sizeof(geometry_msgs::Twist));
}
uint32_t wrench_lengthT = ((uint32_t) (*(inbuffer + offset)));
wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
wrench_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->wrench_length);
if(wrench_lengthT > wrench_length)
this->wrench = (geometry_msgs::Wrench*)realloc(this->wrench, wrench_lengthT * sizeof(geometry_msgs::Wrench));
wrench_length = wrench_lengthT;
for( uint32_t i = 0; i < wrench_length; i++){
offset += this->st_wrench.deserialize(inbuffer + offset);
memcpy( &(this->wrench[i]), &(this->st_wrench), sizeof(geometry_msgs::Wrench));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/WorldState"; };
const char * getMD5(){ return "de1a9de3ab7ba97ac0e9ec01a4eb481e"; };
};
}
#endif
| 6,783 | C | 41.4 | 117 | 0.565679 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/GetLinkProperties.h | #ifndef _ROS_SERVICE_GetLinkProperties_h
#define _ROS_SERVICE_GetLinkProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
namespace gazebo_msgs
{
static const char GETLINKPROPERTIES[] = "gazebo_msgs/GetLinkProperties";
class GetLinkPropertiesRequest : public ros::Msg
{
public:
typedef const char* _link_name_type;
_link_name_type link_name;
GetLinkPropertiesRequest():
link_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_link_name = strlen(this->link_name);
varToArr(outbuffer + offset, length_link_name);
offset += 4;
memcpy(outbuffer + offset, this->link_name, length_link_name);
offset += length_link_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_link_name;
arrToVar(length_link_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_link_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_link_name-1]=0;
this->link_name = (char *)(inbuffer + offset-1);
offset += length_link_name;
return offset;
}
const char * getType(){ return GETLINKPROPERTIES; };
const char * getMD5(){ return "7d82d60381f1b66a30f2157f60884345"; };
};
class GetLinkPropertiesResponse : public ros::Msg
{
public:
typedef geometry_msgs::Pose _com_type;
_com_type com;
typedef bool _gravity_mode_type;
_gravity_mode_type gravity_mode;
typedef double _mass_type;
_mass_type mass;
typedef double _ixx_type;
_ixx_type ixx;
typedef double _ixy_type;
_ixy_type ixy;
typedef double _ixz_type;
_ixz_type ixz;
typedef double _iyy_type;
_iyy_type iyy;
typedef double _iyz_type;
_iyz_type iyz;
typedef double _izz_type;
_izz_type izz;
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
GetLinkPropertiesResponse():
com(),
gravity_mode(0),
mass(0),
ixx(0),
ixy(0),
ixz(0),
iyy(0),
iyz(0),
izz(0),
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->com.serialize(outbuffer + offset);
union {
bool real;
uint8_t base;
} u_gravity_mode;
u_gravity_mode.real = this->gravity_mode;
*(outbuffer + offset + 0) = (u_gravity_mode.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->gravity_mode);
union {
double real;
uint64_t base;
} u_mass;
u_mass.real = this->mass;
*(outbuffer + offset + 0) = (u_mass.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_mass.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_mass.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_mass.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_mass.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_mass.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_mass.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_mass.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->mass);
union {
double real;
uint64_t base;
} u_ixx;
u_ixx.real = this->ixx;
*(outbuffer + offset + 0) = (u_ixx.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixx.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixx.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixx.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixx.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixx.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixx.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixx.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixx);
union {
double real;
uint64_t base;
} u_ixy;
u_ixy.real = this->ixy;
*(outbuffer + offset + 0) = (u_ixy.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixy.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixy.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixy.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixy.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixy.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixy.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixy.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixy);
union {
double real;
uint64_t base;
} u_ixz;
u_ixz.real = this->ixz;
*(outbuffer + offset + 0) = (u_ixz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ixz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ixz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ixz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_ixz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_ixz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_ixz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_ixz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->ixz);
union {
double real;
uint64_t base;
} u_iyy;
u_iyy.real = this->iyy;
*(outbuffer + offset + 0) = (u_iyy.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_iyy.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_iyy.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_iyy.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_iyy.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_iyy.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_iyy.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_iyy.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->iyy);
union {
double real;
uint64_t base;
} u_iyz;
u_iyz.real = this->iyz;
*(outbuffer + offset + 0) = (u_iyz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_iyz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_iyz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_iyz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_iyz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_iyz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_iyz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_iyz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->iyz);
union {
double real;
uint64_t base;
} u_izz;
u_izz.real = this->izz;
*(outbuffer + offset + 0) = (u_izz.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_izz.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_izz.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_izz.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_izz.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_izz.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_izz.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_izz.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->izz);
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->com.deserialize(inbuffer + offset);
union {
bool real;
uint8_t base;
} u_gravity_mode;
u_gravity_mode.base = 0;
u_gravity_mode.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->gravity_mode = u_gravity_mode.real;
offset += sizeof(this->gravity_mode);
union {
double real;
uint64_t base;
} u_mass;
u_mass.base = 0;
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_mass.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->mass = u_mass.real;
offset += sizeof(this->mass);
union {
double real;
uint64_t base;
} u_ixx;
u_ixx.base = 0;
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixx = u_ixx.real;
offset += sizeof(this->ixx);
union {
double real;
uint64_t base;
} u_ixy;
u_ixy.base = 0;
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixy = u_ixy.real;
offset += sizeof(this->ixy);
union {
double real;
uint64_t base;
} u_ixz;
u_ixz.base = 0;
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->ixz = u_ixz.real;
offset += sizeof(this->ixz);
union {
double real;
uint64_t base;
} u_iyy;
u_iyy.base = 0;
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->iyy = u_iyy.real;
offset += sizeof(this->iyy);
union {
double real;
uint64_t base;
} u_iyz;
u_iyz.base = 0;
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->iyz = u_iyz.real;
offset += sizeof(this->iyz);
union {
double real;
uint64_t base;
} u_izz;
u_izz.base = 0;
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_izz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->izz = u_izz.real;
offset += sizeof(this->izz);
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return GETLINKPROPERTIES; };
const char * getMD5(){ return "a8619f92d17cfcc3958c0fd13299443d"; };
};
class GetLinkProperties {
public:
typedef GetLinkPropertiesRequest Request;
typedef GetLinkPropertiesResponse Response;
};
}
#endif
| 14,529 | C | 38.16442 | 79 | 0.500723 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SetJointProperties.h | #ifndef _ROS_SERVICE_SetJointProperties_h
#define _ROS_SERVICE_SetJointProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "gazebo_msgs/ODEJointProperties.h"
namespace gazebo_msgs
{
static const char SETJOINTPROPERTIES[] = "gazebo_msgs/SetJointProperties";
class SetJointPropertiesRequest : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
typedef gazebo_msgs::ODEJointProperties _ode_joint_config_type;
_ode_joint_config_type ode_joint_config;
SetJointPropertiesRequest():
joint_name(""),
ode_joint_config()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_joint_name = strlen(this->joint_name);
varToArr(outbuffer + offset, length_joint_name);
offset += 4;
memcpy(outbuffer + offset, this->joint_name, length_joint_name);
offset += length_joint_name;
offset += this->ode_joint_config.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_joint_name;
arrToVar(length_joint_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_joint_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_joint_name-1]=0;
this->joint_name = (char *)(inbuffer + offset-1);
offset += length_joint_name;
offset += this->ode_joint_config.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SETJOINTPROPERTIES; };
const char * getMD5(){ return "331fd8f35fd27e3c1421175590258e26"; };
};
class SetJointPropertiesResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SetJointPropertiesResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SETJOINTPROPERTIES; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SetJointProperties {
public:
typedef SetJointPropertiesRequest Request;
typedef SetJointPropertiesResponse Response;
};
}
#endif
| 3,719 | C | 27.837209 | 78 | 0.632428 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ODEJointProperties.h | #ifndef _ROS_gazebo_msgs_ODEJointProperties_h
#define _ROS_gazebo_msgs_ODEJointProperties_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
class ODEJointProperties : public ros::Msg
{
public:
uint32_t damping_length;
typedef double _damping_type;
_damping_type st_damping;
_damping_type * damping;
uint32_t hiStop_length;
typedef double _hiStop_type;
_hiStop_type st_hiStop;
_hiStop_type * hiStop;
uint32_t loStop_length;
typedef double _loStop_type;
_loStop_type st_loStop;
_loStop_type * loStop;
uint32_t erp_length;
typedef double _erp_type;
_erp_type st_erp;
_erp_type * erp;
uint32_t cfm_length;
typedef double _cfm_type;
_cfm_type st_cfm;
_cfm_type * cfm;
uint32_t stop_erp_length;
typedef double _stop_erp_type;
_stop_erp_type st_stop_erp;
_stop_erp_type * stop_erp;
uint32_t stop_cfm_length;
typedef double _stop_cfm_type;
_stop_cfm_type st_stop_cfm;
_stop_cfm_type * stop_cfm;
uint32_t fudge_factor_length;
typedef double _fudge_factor_type;
_fudge_factor_type st_fudge_factor;
_fudge_factor_type * fudge_factor;
uint32_t fmax_length;
typedef double _fmax_type;
_fmax_type st_fmax;
_fmax_type * fmax;
uint32_t vel_length;
typedef double _vel_type;
_vel_type st_vel;
_vel_type * vel;
ODEJointProperties():
damping_length(0), damping(NULL),
hiStop_length(0), hiStop(NULL),
loStop_length(0), loStop(NULL),
erp_length(0), erp(NULL),
cfm_length(0), cfm(NULL),
stop_erp_length(0), stop_erp(NULL),
stop_cfm_length(0), stop_cfm(NULL),
fudge_factor_length(0), fudge_factor(NULL),
fmax_length(0), fmax(NULL),
vel_length(0), vel(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->damping_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->damping_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->damping_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->damping_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->damping_length);
for( uint32_t i = 0; i < damping_length; i++){
union {
double real;
uint64_t base;
} u_dampingi;
u_dampingi.real = this->damping[i];
*(outbuffer + offset + 0) = (u_dampingi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_dampingi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_dampingi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_dampingi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_dampingi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_dampingi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_dampingi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_dampingi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->damping[i]);
}
*(outbuffer + offset + 0) = (this->hiStop_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->hiStop_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->hiStop_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->hiStop_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->hiStop_length);
for( uint32_t i = 0; i < hiStop_length; i++){
union {
double real;
uint64_t base;
} u_hiStopi;
u_hiStopi.real = this->hiStop[i];
*(outbuffer + offset + 0) = (u_hiStopi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_hiStopi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_hiStopi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_hiStopi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_hiStopi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_hiStopi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_hiStopi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_hiStopi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->hiStop[i]);
}
*(outbuffer + offset + 0) = (this->loStop_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->loStop_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->loStop_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->loStop_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->loStop_length);
for( uint32_t i = 0; i < loStop_length; i++){
union {
double real;
uint64_t base;
} u_loStopi;
u_loStopi.real = this->loStop[i];
*(outbuffer + offset + 0) = (u_loStopi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_loStopi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_loStopi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_loStopi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_loStopi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_loStopi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_loStopi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_loStopi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->loStop[i]);
}
*(outbuffer + offset + 0) = (this->erp_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->erp_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->erp_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->erp_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->erp_length);
for( uint32_t i = 0; i < erp_length; i++){
union {
double real;
uint64_t base;
} u_erpi;
u_erpi.real = this->erp[i];
*(outbuffer + offset + 0) = (u_erpi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_erpi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_erpi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_erpi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_erpi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_erpi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_erpi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_erpi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->erp[i]);
}
*(outbuffer + offset + 0) = (this->cfm_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cfm_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cfm_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cfm_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cfm_length);
for( uint32_t i = 0; i < cfm_length; i++){
union {
double real;
uint64_t base;
} u_cfmi;
u_cfmi.real = this->cfm[i];
*(outbuffer + offset + 0) = (u_cfmi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_cfmi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_cfmi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_cfmi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_cfmi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_cfmi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_cfmi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_cfmi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->cfm[i]);
}
*(outbuffer + offset + 0) = (this->stop_erp_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stop_erp_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stop_erp_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stop_erp_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->stop_erp_length);
for( uint32_t i = 0; i < stop_erp_length; i++){
union {
double real;
uint64_t base;
} u_stop_erpi;
u_stop_erpi.real = this->stop_erp[i];
*(outbuffer + offset + 0) = (u_stop_erpi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_stop_erpi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_stop_erpi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_stop_erpi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_stop_erpi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_stop_erpi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_stop_erpi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_stop_erpi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->stop_erp[i]);
}
*(outbuffer + offset + 0) = (this->stop_cfm_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stop_cfm_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stop_cfm_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stop_cfm_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->stop_cfm_length);
for( uint32_t i = 0; i < stop_cfm_length; i++){
union {
double real;
uint64_t base;
} u_stop_cfmi;
u_stop_cfmi.real = this->stop_cfm[i];
*(outbuffer + offset + 0) = (u_stop_cfmi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_stop_cfmi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_stop_cfmi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_stop_cfmi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_stop_cfmi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_stop_cfmi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_stop_cfmi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_stop_cfmi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->stop_cfm[i]);
}
*(outbuffer + offset + 0) = (this->fudge_factor_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fudge_factor_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fudge_factor_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fudge_factor_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fudge_factor_length);
for( uint32_t i = 0; i < fudge_factor_length; i++){
union {
double real;
uint64_t base;
} u_fudge_factori;
u_fudge_factori.real = this->fudge_factor[i];
*(outbuffer + offset + 0) = (u_fudge_factori.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fudge_factori.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fudge_factori.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fudge_factori.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_fudge_factori.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_fudge_factori.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_fudge_factori.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_fudge_factori.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->fudge_factor[i]);
}
*(outbuffer + offset + 0) = (this->fmax_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->fmax_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->fmax_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->fmax_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->fmax_length);
for( uint32_t i = 0; i < fmax_length; i++){
union {
double real;
uint64_t base;
} u_fmaxi;
u_fmaxi.real = this->fmax[i];
*(outbuffer + offset + 0) = (u_fmaxi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_fmaxi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_fmaxi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_fmaxi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_fmaxi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_fmaxi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_fmaxi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_fmaxi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->fmax[i]);
}
*(outbuffer + offset + 0) = (this->vel_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->vel_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->vel_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->vel_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->vel_length);
for( uint32_t i = 0; i < vel_length; i++){
union {
double real;
uint64_t base;
} u_veli;
u_veli.real = this->vel[i];
*(outbuffer + offset + 0) = (u_veli.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_veli.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_veli.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_veli.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_veli.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_veli.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_veli.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_veli.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->vel[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t damping_lengthT = ((uint32_t) (*(inbuffer + offset)));
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
damping_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->damping_length);
if(damping_lengthT > damping_length)
this->damping = (double*)realloc(this->damping, damping_lengthT * sizeof(double));
damping_length = damping_lengthT;
for( uint32_t i = 0; i < damping_length; i++){
union {
double real;
uint64_t base;
} u_st_damping;
u_st_damping.base = 0;
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_damping.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_damping = u_st_damping.real;
offset += sizeof(this->st_damping);
memcpy( &(this->damping[i]), &(this->st_damping), sizeof(double));
}
uint32_t hiStop_lengthT = ((uint32_t) (*(inbuffer + offset)));
hiStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
hiStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
hiStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->hiStop_length);
if(hiStop_lengthT > hiStop_length)
this->hiStop = (double*)realloc(this->hiStop, hiStop_lengthT * sizeof(double));
hiStop_length = hiStop_lengthT;
for( uint32_t i = 0; i < hiStop_length; i++){
union {
double real;
uint64_t base;
} u_st_hiStop;
u_st_hiStop.base = 0;
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_hiStop.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_hiStop = u_st_hiStop.real;
offset += sizeof(this->st_hiStop);
memcpy( &(this->hiStop[i]), &(this->st_hiStop), sizeof(double));
}
uint32_t loStop_lengthT = ((uint32_t) (*(inbuffer + offset)));
loStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
loStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
loStop_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->loStop_length);
if(loStop_lengthT > loStop_length)
this->loStop = (double*)realloc(this->loStop, loStop_lengthT * sizeof(double));
loStop_length = loStop_lengthT;
for( uint32_t i = 0; i < loStop_length; i++){
union {
double real;
uint64_t base;
} u_st_loStop;
u_st_loStop.base = 0;
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_loStop.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_loStop = u_st_loStop.real;
offset += sizeof(this->st_loStop);
memcpy( &(this->loStop[i]), &(this->st_loStop), sizeof(double));
}
uint32_t erp_lengthT = ((uint32_t) (*(inbuffer + offset)));
erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->erp_length);
if(erp_lengthT > erp_length)
this->erp = (double*)realloc(this->erp, erp_lengthT * sizeof(double));
erp_length = erp_lengthT;
for( uint32_t i = 0; i < erp_length; i++){
union {
double real;
uint64_t base;
} u_st_erp;
u_st_erp.base = 0;
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_erp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_erp = u_st_erp.real;
offset += sizeof(this->st_erp);
memcpy( &(this->erp[i]), &(this->st_erp), sizeof(double));
}
uint32_t cfm_lengthT = ((uint32_t) (*(inbuffer + offset)));
cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cfm_length);
if(cfm_lengthT > cfm_length)
this->cfm = (double*)realloc(this->cfm, cfm_lengthT * sizeof(double));
cfm_length = cfm_lengthT;
for( uint32_t i = 0; i < cfm_length; i++){
union {
double real;
uint64_t base;
} u_st_cfm;
u_st_cfm.base = 0;
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_cfm.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_cfm = u_st_cfm.real;
offset += sizeof(this->st_cfm);
memcpy( &(this->cfm[i]), &(this->st_cfm), sizeof(double));
}
uint32_t stop_erp_lengthT = ((uint32_t) (*(inbuffer + offset)));
stop_erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
stop_erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
stop_erp_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stop_erp_length);
if(stop_erp_lengthT > stop_erp_length)
this->stop_erp = (double*)realloc(this->stop_erp, stop_erp_lengthT * sizeof(double));
stop_erp_length = stop_erp_lengthT;
for( uint32_t i = 0; i < stop_erp_length; i++){
union {
double real;
uint64_t base;
} u_st_stop_erp;
u_st_stop_erp.base = 0;
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_stop_erp.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_stop_erp = u_st_stop_erp.real;
offset += sizeof(this->st_stop_erp);
memcpy( &(this->stop_erp[i]), &(this->st_stop_erp), sizeof(double));
}
uint32_t stop_cfm_lengthT = ((uint32_t) (*(inbuffer + offset)));
stop_cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
stop_cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
stop_cfm_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stop_cfm_length);
if(stop_cfm_lengthT > stop_cfm_length)
this->stop_cfm = (double*)realloc(this->stop_cfm, stop_cfm_lengthT * sizeof(double));
stop_cfm_length = stop_cfm_lengthT;
for( uint32_t i = 0; i < stop_cfm_length; i++){
union {
double real;
uint64_t base;
} u_st_stop_cfm;
u_st_stop_cfm.base = 0;
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_stop_cfm.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_stop_cfm = u_st_stop_cfm.real;
offset += sizeof(this->st_stop_cfm);
memcpy( &(this->stop_cfm[i]), &(this->st_stop_cfm), sizeof(double));
}
uint32_t fudge_factor_lengthT = ((uint32_t) (*(inbuffer + offset)));
fudge_factor_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fudge_factor_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fudge_factor_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fudge_factor_length);
if(fudge_factor_lengthT > fudge_factor_length)
this->fudge_factor = (double*)realloc(this->fudge_factor, fudge_factor_lengthT * sizeof(double));
fudge_factor_length = fudge_factor_lengthT;
for( uint32_t i = 0; i < fudge_factor_length; i++){
union {
double real;
uint64_t base;
} u_st_fudge_factor;
u_st_fudge_factor.base = 0;
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_fudge_factor.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_fudge_factor = u_st_fudge_factor.real;
offset += sizeof(this->st_fudge_factor);
memcpy( &(this->fudge_factor[i]), &(this->st_fudge_factor), sizeof(double));
}
uint32_t fmax_lengthT = ((uint32_t) (*(inbuffer + offset)));
fmax_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
fmax_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
fmax_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->fmax_length);
if(fmax_lengthT > fmax_length)
this->fmax = (double*)realloc(this->fmax, fmax_lengthT * sizeof(double));
fmax_length = fmax_lengthT;
for( uint32_t i = 0; i < fmax_length; i++){
union {
double real;
uint64_t base;
} u_st_fmax;
u_st_fmax.base = 0;
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_fmax.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_fmax = u_st_fmax.real;
offset += sizeof(this->st_fmax);
memcpy( &(this->fmax[i]), &(this->st_fmax), sizeof(double));
}
uint32_t vel_lengthT = ((uint32_t) (*(inbuffer + offset)));
vel_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
vel_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
vel_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->vel_length);
if(vel_lengthT > vel_length)
this->vel = (double*)realloc(this->vel, vel_lengthT * sizeof(double));
vel_length = vel_lengthT;
for( uint32_t i = 0; i < vel_length; i++){
union {
double real;
uint64_t base;
} u_st_vel;
u_st_vel.base = 0;
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_vel.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_vel = u_st_vel.real;
offset += sizeof(this->st_vel);
memcpy( &(this->vel[i]), &(this->st_vel), sizeof(double));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/ODEJointProperties"; };
const char * getMD5(){ return "1b744c32a920af979f53afe2f9c3511f"; };
};
}
#endif
| 28,133 | C | 49.329159 | 105 | 0.510646 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ApplyJointEffort.h | #ifndef _ROS_SERVICE_ApplyJointEffort_h
#define _ROS_SERVICE_ApplyJointEffort_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/duration.h"
#include "ros/time.h"
namespace gazebo_msgs
{
static const char APPLYJOINTEFFORT[] = "gazebo_msgs/ApplyJointEffort";
class ApplyJointEffortRequest : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
typedef double _effort_type;
_effort_type effort;
typedef ros::Time _start_time_type;
_start_time_type start_time;
typedef ros::Duration _duration_type;
_duration_type duration;
ApplyJointEffortRequest():
joint_name(""),
effort(0),
start_time(),
duration()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_joint_name = strlen(this->joint_name);
varToArr(outbuffer + offset, length_joint_name);
offset += 4;
memcpy(outbuffer + offset, this->joint_name, length_joint_name);
offset += length_joint_name;
union {
double real;
uint64_t base;
} u_effort;
u_effort.real = this->effort;
*(outbuffer + offset + 0) = (u_effort.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_effort.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_effort.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_effort.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_effort.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_effort.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_effort.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_effort.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->effort);
*(outbuffer + offset + 0) = (this->start_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->start_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->start_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->start_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->start_time.sec);
*(outbuffer + offset + 0) = (this->start_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->start_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->start_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->start_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->start_time.nsec);
*(outbuffer + offset + 0) = (this->duration.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->duration.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->duration.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->duration.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->duration.sec);
*(outbuffer + offset + 0) = (this->duration.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->duration.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->duration.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->duration.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->duration.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_joint_name;
arrToVar(length_joint_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_joint_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_joint_name-1]=0;
this->joint_name = (char *)(inbuffer + offset-1);
offset += length_joint_name;
union {
double real;
uint64_t base;
} u_effort;
u_effort.base = 0;
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->effort = u_effort.real;
offset += sizeof(this->effort);
this->start_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->start_time.sec);
this->start_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->start_time.nsec);
this->duration.sec = ((uint32_t) (*(inbuffer + offset)));
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->duration.sec);
this->duration.nsec = ((uint32_t) (*(inbuffer + offset)));
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->duration.nsec);
return offset;
}
const char * getType(){ return APPLYJOINTEFFORT; };
const char * getMD5(){ return "2c3396ab9af67a509ecd2167a8fe41a2"; };
};
class ApplyJointEffortResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
ApplyJointEffortResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return APPLYJOINTEFFORT; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class ApplyJointEffort {
public:
typedef ApplyJointEffortRequest Request;
typedef ApplyJointEffortResponse Response;
};
}
#endif
| 7,975 | C | 38.29064 | 82 | 0.558997 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/ContactState.h | #ifndef _ROS_gazebo_msgs_ContactState_h
#define _ROS_gazebo_msgs_ContactState_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Wrench.h"
#include "geometry_msgs/Vector3.h"
namespace gazebo_msgs
{
class ContactState : public ros::Msg
{
public:
typedef const char* _info_type;
_info_type info;
typedef const char* _collision1_name_type;
_collision1_name_type collision1_name;
typedef const char* _collision2_name_type;
_collision2_name_type collision2_name;
uint32_t wrenches_length;
typedef geometry_msgs::Wrench _wrenches_type;
_wrenches_type st_wrenches;
_wrenches_type * wrenches;
typedef geometry_msgs::Wrench _total_wrench_type;
_total_wrench_type total_wrench;
uint32_t contact_positions_length;
typedef geometry_msgs::Vector3 _contact_positions_type;
_contact_positions_type st_contact_positions;
_contact_positions_type * contact_positions;
uint32_t contact_normals_length;
typedef geometry_msgs::Vector3 _contact_normals_type;
_contact_normals_type st_contact_normals;
_contact_normals_type * contact_normals;
uint32_t depths_length;
typedef double _depths_type;
_depths_type st_depths;
_depths_type * depths;
ContactState():
info(""),
collision1_name(""),
collision2_name(""),
wrenches_length(0), wrenches(NULL),
total_wrench(),
contact_positions_length(0), contact_positions(NULL),
contact_normals_length(0), contact_normals(NULL),
depths_length(0), depths(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_info = strlen(this->info);
varToArr(outbuffer + offset, length_info);
offset += 4;
memcpy(outbuffer + offset, this->info, length_info);
offset += length_info;
uint32_t length_collision1_name = strlen(this->collision1_name);
varToArr(outbuffer + offset, length_collision1_name);
offset += 4;
memcpy(outbuffer + offset, this->collision1_name, length_collision1_name);
offset += length_collision1_name;
uint32_t length_collision2_name = strlen(this->collision2_name);
varToArr(outbuffer + offset, length_collision2_name);
offset += 4;
memcpy(outbuffer + offset, this->collision2_name, length_collision2_name);
offset += length_collision2_name;
*(outbuffer + offset + 0) = (this->wrenches_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->wrenches_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->wrenches_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->wrenches_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->wrenches_length);
for( uint32_t i = 0; i < wrenches_length; i++){
offset += this->wrenches[i].serialize(outbuffer + offset);
}
offset += this->total_wrench.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->contact_positions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->contact_positions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->contact_positions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->contact_positions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->contact_positions_length);
for( uint32_t i = 0; i < contact_positions_length; i++){
offset += this->contact_positions[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->contact_normals_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->contact_normals_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->contact_normals_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->contact_normals_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->contact_normals_length);
for( uint32_t i = 0; i < contact_normals_length; i++){
offset += this->contact_normals[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->depths_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->depths_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->depths_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->depths_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->depths_length);
for( uint32_t i = 0; i < depths_length; i++){
union {
double real;
uint64_t base;
} u_depthsi;
u_depthsi.real = this->depths[i];
*(outbuffer + offset + 0) = (u_depthsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_depthsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_depthsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_depthsi.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_depthsi.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_depthsi.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_depthsi.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_depthsi.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->depths[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_info;
arrToVar(length_info, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_info; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_info-1]=0;
this->info = (char *)(inbuffer + offset-1);
offset += length_info;
uint32_t length_collision1_name;
arrToVar(length_collision1_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_collision1_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_collision1_name-1]=0;
this->collision1_name = (char *)(inbuffer + offset-1);
offset += length_collision1_name;
uint32_t length_collision2_name;
arrToVar(length_collision2_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_collision2_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_collision2_name-1]=0;
this->collision2_name = (char *)(inbuffer + offset-1);
offset += length_collision2_name;
uint32_t wrenches_lengthT = ((uint32_t) (*(inbuffer + offset)));
wrenches_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
wrenches_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
wrenches_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->wrenches_length);
if(wrenches_lengthT > wrenches_length)
this->wrenches = (geometry_msgs::Wrench*)realloc(this->wrenches, wrenches_lengthT * sizeof(geometry_msgs::Wrench));
wrenches_length = wrenches_lengthT;
for( uint32_t i = 0; i < wrenches_length; i++){
offset += this->st_wrenches.deserialize(inbuffer + offset);
memcpy( &(this->wrenches[i]), &(this->st_wrenches), sizeof(geometry_msgs::Wrench));
}
offset += this->total_wrench.deserialize(inbuffer + offset);
uint32_t contact_positions_lengthT = ((uint32_t) (*(inbuffer + offset)));
contact_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
contact_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
contact_positions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->contact_positions_length);
if(contact_positions_lengthT > contact_positions_length)
this->contact_positions = (geometry_msgs::Vector3*)realloc(this->contact_positions, contact_positions_lengthT * sizeof(geometry_msgs::Vector3));
contact_positions_length = contact_positions_lengthT;
for( uint32_t i = 0; i < contact_positions_length; i++){
offset += this->st_contact_positions.deserialize(inbuffer + offset);
memcpy( &(this->contact_positions[i]), &(this->st_contact_positions), sizeof(geometry_msgs::Vector3));
}
uint32_t contact_normals_lengthT = ((uint32_t) (*(inbuffer + offset)));
contact_normals_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
contact_normals_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
contact_normals_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->contact_normals_length);
if(contact_normals_lengthT > contact_normals_length)
this->contact_normals = (geometry_msgs::Vector3*)realloc(this->contact_normals, contact_normals_lengthT * sizeof(geometry_msgs::Vector3));
contact_normals_length = contact_normals_lengthT;
for( uint32_t i = 0; i < contact_normals_length; i++){
offset += this->st_contact_normals.deserialize(inbuffer + offset);
memcpy( &(this->contact_normals[i]), &(this->st_contact_normals), sizeof(geometry_msgs::Vector3));
}
uint32_t depths_lengthT = ((uint32_t) (*(inbuffer + offset)));
depths_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
depths_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
depths_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->depths_length);
if(depths_lengthT > depths_length)
this->depths = (double*)realloc(this->depths, depths_lengthT * sizeof(double));
depths_length = depths_lengthT;
for( uint32_t i = 0; i < depths_length; i++){
union {
double real;
uint64_t base;
} u_st_depths;
u_st_depths.base = 0;
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_depths.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_depths = u_st_depths.real;
offset += sizeof(this->st_depths);
memcpy( &(this->depths[i]), &(this->st_depths), sizeof(double));
}
return offset;
}
const char * getType(){ return "gazebo_msgs/ContactState"; };
const char * getMD5(){ return "48c0ffb054b8c444f870cecea1ee50d9"; };
};
}
#endif
| 10,777 | C | 47.116071 | 152 | 0.596084 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/SpawnModel.h | #ifndef _ROS_SERVICE_SpawnModel_h
#define _ROS_SERVICE_SpawnModel_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Pose.h"
namespace gazebo_msgs
{
static const char SPAWNMODEL[] = "gazebo_msgs/SpawnModel";
class SpawnModelRequest : public ros::Msg
{
public:
typedef const char* _model_name_type;
_model_name_type model_name;
typedef const char* _model_xml_type;
_model_xml_type model_xml;
typedef const char* _robot_namespace_type;
_robot_namespace_type robot_namespace;
typedef geometry_msgs::Pose _initial_pose_type;
_initial_pose_type initial_pose;
typedef const char* _reference_frame_type;
_reference_frame_type reference_frame;
SpawnModelRequest():
model_name(""),
model_xml(""),
robot_namespace(""),
initial_pose(),
reference_frame("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_model_name = strlen(this->model_name);
varToArr(outbuffer + offset, length_model_name);
offset += 4;
memcpy(outbuffer + offset, this->model_name, length_model_name);
offset += length_model_name;
uint32_t length_model_xml = strlen(this->model_xml);
varToArr(outbuffer + offset, length_model_xml);
offset += 4;
memcpy(outbuffer + offset, this->model_xml, length_model_xml);
offset += length_model_xml;
uint32_t length_robot_namespace = strlen(this->robot_namespace);
varToArr(outbuffer + offset, length_robot_namespace);
offset += 4;
memcpy(outbuffer + offset, this->robot_namespace, length_robot_namespace);
offset += length_robot_namespace;
offset += this->initial_pose.serialize(outbuffer + offset);
uint32_t length_reference_frame = strlen(this->reference_frame);
varToArr(outbuffer + offset, length_reference_frame);
offset += 4;
memcpy(outbuffer + offset, this->reference_frame, length_reference_frame);
offset += length_reference_frame;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_model_name;
arrToVar(length_model_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_name-1]=0;
this->model_name = (char *)(inbuffer + offset-1);
offset += length_model_name;
uint32_t length_model_xml;
arrToVar(length_model_xml, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_model_xml; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_model_xml-1]=0;
this->model_xml = (char *)(inbuffer + offset-1);
offset += length_model_xml;
uint32_t length_robot_namespace;
arrToVar(length_robot_namespace, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_robot_namespace; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_robot_namespace-1]=0;
this->robot_namespace = (char *)(inbuffer + offset-1);
offset += length_robot_namespace;
offset += this->initial_pose.deserialize(inbuffer + offset);
uint32_t length_reference_frame;
arrToVar(length_reference_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_reference_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_reference_frame-1]=0;
this->reference_frame = (char *)(inbuffer + offset-1);
offset += length_reference_frame;
return offset;
}
const char * getType(){ return SPAWNMODEL; };
const char * getMD5(){ return "6d0eba5753761cd57e6263a056b79930"; };
};
class SpawnModelResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
SpawnModelResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return SPAWNMODEL; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class SpawnModel {
public:
typedef SpawnModelRequest Request;
typedef SpawnModelResponse Response;
};
}
#endif
| 5,817 | C | 31.322222 | 80 | 0.625236 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/DeleteLight.h | #ifndef _ROS_SERVICE_DeleteLight_h
#define _ROS_SERVICE_DeleteLight_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char DELETELIGHT[] = "gazebo_msgs/DeleteLight";
class DeleteLightRequest : public ros::Msg
{
public:
typedef const char* _light_name_type;
_light_name_type light_name;
DeleteLightRequest():
light_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_light_name = strlen(this->light_name);
varToArr(outbuffer + offset, length_light_name);
offset += 4;
memcpy(outbuffer + offset, this->light_name, length_light_name);
offset += length_light_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_light_name;
arrToVar(length_light_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_light_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_light_name-1]=0;
this->light_name = (char *)(inbuffer + offset-1);
offset += length_light_name;
return offset;
}
const char * getType(){ return DELETELIGHT; };
const char * getMD5(){ return "4fb676dfb4741fc866365702a859441c"; };
};
class DeleteLightResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _status_message_type;
_status_message_type status_message;
DeleteLightResponse():
success(0),
status_message("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.real = this->success;
*(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->success);
uint32_t length_status_message = strlen(this->status_message);
varToArr(outbuffer + offset, length_status_message);
offset += 4;
memcpy(outbuffer + offset, this->status_message, length_status_message);
offset += length_status_message;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
bool real;
uint8_t base;
} u_success;
u_success.base = 0;
u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->success = u_success.real;
offset += sizeof(this->success);
uint32_t length_status_message;
arrToVar(length_status_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status_message-1]=0;
this->status_message = (char *)(inbuffer + offset-1);
offset += length_status_message;
return offset;
}
const char * getType(){ return DELETELIGHT; };
const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
};
class DeleteLight {
public:
typedef DeleteLightRequest Request;
typedef DeleteLightResponse Response;
};
}
#endif
| 3,300 | C | 25.837398 | 78 | 0.614848 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/gazebo_msgs/JointRequest.h | #ifndef _ROS_SERVICE_JointRequest_h
#define _ROS_SERVICE_JointRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace gazebo_msgs
{
static const char JOINTREQUEST[] = "gazebo_msgs/JointRequest";
class JointRequestRequest : public ros::Msg
{
public:
typedef const char* _joint_name_type;
_joint_name_type joint_name;
JointRequestRequest():
joint_name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_joint_name = strlen(this->joint_name);
varToArr(outbuffer + offset, length_joint_name);
offset += 4;
memcpy(outbuffer + offset, this->joint_name, length_joint_name);
offset += length_joint_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_joint_name;
arrToVar(length_joint_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_joint_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_joint_name-1]=0;
this->joint_name = (char *)(inbuffer + offset-1);
offset += length_joint_name;
return offset;
}
const char * getType(){ return JOINTREQUEST; };
const char * getMD5(){ return "0be1351618e1dc030eb7959d9a4902de"; };
};
class JointRequestResponse : public ros::Msg
{
public:
JointRequestResponse()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
return offset;
}
const char * getType(){ return JOINTREQUEST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class JointRequest {
public:
typedef JointRequestRequest Request;
typedef JointRequestResponse Response;
};
}
#endif
| 1,993 | C | 21.659091 | 72 | 0.634722 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosgraph_msgs/TopicStatistics.h | #ifndef _ROS_rosgraph_msgs_TopicStatistics_h
#define _ROS_rosgraph_msgs_TopicStatistics_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
#include "ros/duration.h"
namespace rosgraph_msgs
{
class TopicStatistics : public ros::Msg
{
public:
typedef const char* _topic_type;
_topic_type topic;
typedef const char* _node_pub_type;
_node_pub_type node_pub;
typedef const char* _node_sub_type;
_node_sub_type node_sub;
typedef ros::Time _window_start_type;
_window_start_type window_start;
typedef ros::Time _window_stop_type;
_window_stop_type window_stop;
typedef int32_t _delivered_msgs_type;
_delivered_msgs_type delivered_msgs;
typedef int32_t _dropped_msgs_type;
_dropped_msgs_type dropped_msgs;
typedef int32_t _traffic_type;
_traffic_type traffic;
typedef ros::Duration _period_mean_type;
_period_mean_type period_mean;
typedef ros::Duration _period_stddev_type;
_period_stddev_type period_stddev;
typedef ros::Duration _period_max_type;
_period_max_type period_max;
typedef ros::Duration _stamp_age_mean_type;
_stamp_age_mean_type stamp_age_mean;
typedef ros::Duration _stamp_age_stddev_type;
_stamp_age_stddev_type stamp_age_stddev;
typedef ros::Duration _stamp_age_max_type;
_stamp_age_max_type stamp_age_max;
TopicStatistics():
topic(""),
node_pub(""),
node_sub(""),
window_start(),
window_stop(),
delivered_msgs(0),
dropped_msgs(0),
traffic(0),
period_mean(),
period_stddev(),
period_max(),
stamp_age_mean(),
stamp_age_stddev(),
stamp_age_max()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_topic = strlen(this->topic);
varToArr(outbuffer + offset, length_topic);
offset += 4;
memcpy(outbuffer + offset, this->topic, length_topic);
offset += length_topic;
uint32_t length_node_pub = strlen(this->node_pub);
varToArr(outbuffer + offset, length_node_pub);
offset += 4;
memcpy(outbuffer + offset, this->node_pub, length_node_pub);
offset += length_node_pub;
uint32_t length_node_sub = strlen(this->node_sub);
varToArr(outbuffer + offset, length_node_sub);
offset += 4;
memcpy(outbuffer + offset, this->node_sub, length_node_sub);
offset += length_node_sub;
*(outbuffer + offset + 0) = (this->window_start.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->window_start.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->window_start.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->window_start.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->window_start.sec);
*(outbuffer + offset + 0) = (this->window_start.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->window_start.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->window_start.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->window_start.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->window_start.nsec);
*(outbuffer + offset + 0) = (this->window_stop.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->window_stop.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->window_stop.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->window_stop.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->window_stop.sec);
*(outbuffer + offset + 0) = (this->window_stop.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->window_stop.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->window_stop.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->window_stop.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->window_stop.nsec);
union {
int32_t real;
uint32_t base;
} u_delivered_msgs;
u_delivered_msgs.real = this->delivered_msgs;
*(outbuffer + offset + 0) = (u_delivered_msgs.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_delivered_msgs.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_delivered_msgs.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_delivered_msgs.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->delivered_msgs);
union {
int32_t real;
uint32_t base;
} u_dropped_msgs;
u_dropped_msgs.real = this->dropped_msgs;
*(outbuffer + offset + 0) = (u_dropped_msgs.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_dropped_msgs.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_dropped_msgs.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_dropped_msgs.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->dropped_msgs);
union {
int32_t real;
uint32_t base;
} u_traffic;
u_traffic.real = this->traffic;
*(outbuffer + offset + 0) = (u_traffic.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_traffic.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_traffic.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_traffic.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->traffic);
*(outbuffer + offset + 0) = (this->period_mean.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_mean.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_mean.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_mean.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_mean.sec);
*(outbuffer + offset + 0) = (this->period_mean.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_mean.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_mean.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_mean.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_mean.nsec);
*(outbuffer + offset + 0) = (this->period_stddev.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_stddev.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_stddev.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_stddev.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_stddev.sec);
*(outbuffer + offset + 0) = (this->period_stddev.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_stddev.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_stddev.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_stddev.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_stddev.nsec);
*(outbuffer + offset + 0) = (this->period_max.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_max.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_max.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_max.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_max.sec);
*(outbuffer + offset + 0) = (this->period_max.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->period_max.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->period_max.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->period_max.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->period_max.nsec);
*(outbuffer + offset + 0) = (this->stamp_age_mean.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_mean.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_mean.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_mean.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_mean.sec);
*(outbuffer + offset + 0) = (this->stamp_age_mean.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_mean.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_mean.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_mean.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_mean.nsec);
*(outbuffer + offset + 0) = (this->stamp_age_stddev.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_stddev.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_stddev.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_stddev.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_stddev.sec);
*(outbuffer + offset + 0) = (this->stamp_age_stddev.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_stddev.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_stddev.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_stddev.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_stddev.nsec);
*(outbuffer + offset + 0) = (this->stamp_age_max.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_max.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_max.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_max.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_max.sec);
*(outbuffer + offset + 0) = (this->stamp_age_max.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp_age_max.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp_age_max.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp_age_max.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp_age_max.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_topic;
arrToVar(length_topic, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic-1]=0;
this->topic = (char *)(inbuffer + offset-1);
offset += length_topic;
uint32_t length_node_pub;
arrToVar(length_node_pub, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_node_pub; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_node_pub-1]=0;
this->node_pub = (char *)(inbuffer + offset-1);
offset += length_node_pub;
uint32_t length_node_sub;
arrToVar(length_node_sub, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_node_sub; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_node_sub-1]=0;
this->node_sub = (char *)(inbuffer + offset-1);
offset += length_node_sub;
this->window_start.sec = ((uint32_t) (*(inbuffer + offset)));
this->window_start.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->window_start.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->window_start.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->window_start.sec);
this->window_start.nsec = ((uint32_t) (*(inbuffer + offset)));
this->window_start.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->window_start.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->window_start.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->window_start.nsec);
this->window_stop.sec = ((uint32_t) (*(inbuffer + offset)));
this->window_stop.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->window_stop.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->window_stop.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->window_stop.sec);
this->window_stop.nsec = ((uint32_t) (*(inbuffer + offset)));
this->window_stop.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->window_stop.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->window_stop.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->window_stop.nsec);
union {
int32_t real;
uint32_t base;
} u_delivered_msgs;
u_delivered_msgs.base = 0;
u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_delivered_msgs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->delivered_msgs = u_delivered_msgs.real;
offset += sizeof(this->delivered_msgs);
union {
int32_t real;
uint32_t base;
} u_dropped_msgs;
u_dropped_msgs.base = 0;
u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_dropped_msgs.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->dropped_msgs = u_dropped_msgs.real;
offset += sizeof(this->dropped_msgs);
union {
int32_t real;
uint32_t base;
} u_traffic;
u_traffic.base = 0;
u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_traffic.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->traffic = u_traffic.real;
offset += sizeof(this->traffic);
this->period_mean.sec = ((uint32_t) (*(inbuffer + offset)));
this->period_mean.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_mean.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_mean.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_mean.sec);
this->period_mean.nsec = ((uint32_t) (*(inbuffer + offset)));
this->period_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_mean.nsec);
this->period_stddev.sec = ((uint32_t) (*(inbuffer + offset)));
this->period_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_stddev.sec);
this->period_stddev.nsec = ((uint32_t) (*(inbuffer + offset)));
this->period_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_stddev.nsec);
this->period_max.sec = ((uint32_t) (*(inbuffer + offset)));
this->period_max.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_max.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_max.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_max.sec);
this->period_max.nsec = ((uint32_t) (*(inbuffer + offset)));
this->period_max.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->period_max.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->period_max.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->period_max.nsec);
this->stamp_age_mean.sec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_mean.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_mean.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_mean.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_mean.sec);
this->stamp_age_mean.nsec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_mean.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_mean.nsec);
this->stamp_age_stddev.sec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_stddev.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_stddev.sec);
this->stamp_age_stddev.nsec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_stddev.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_stddev.nsec);
this->stamp_age_max.sec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_max.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_max.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_max.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_max.sec);
this->stamp_age_max.nsec = ((uint32_t) (*(inbuffer + offset)));
this->stamp_age_max.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp_age_max.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp_age_max.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp_age_max.nsec);
return offset;
}
const char * getType(){ return "rosgraph_msgs/TopicStatistics"; };
const char * getMD5(){ return "10152ed868c5097a5e2e4a89d7daa710"; };
};
}
#endif
| 18,654 | C | 52.606322 | 88 | 0.545138 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosgraph_msgs/Log.h | #ifndef _ROS_rosgraph_msgs_Log_h
#define _ROS_rosgraph_msgs_Log_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace rosgraph_msgs
{
class Log : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef int8_t _level_type;
_level_type level;
typedef const char* _name_type;
_name_type name;
typedef const char* _msg_type;
_msg_type msg;
typedef const char* _file_type;
_file_type file;
typedef const char* _function_type;
_function_type function;
typedef uint32_t _line_type;
_line_type line;
uint32_t topics_length;
typedef char* _topics_type;
_topics_type st_topics;
_topics_type * topics;
enum { DEBUG = 1 };
enum { INFO = 2 };
enum { WARN = 4 };
enum { ERROR = 8 };
enum { FATAL = 16 };
Log():
header(),
level(0),
name(""),
msg(""),
file(""),
function(""),
line(0),
topics_length(0), topics(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
int8_t real;
uint8_t base;
} u_level;
u_level.real = this->level;
*(outbuffer + offset + 0) = (u_level.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->level);
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
uint32_t length_msg = strlen(this->msg);
varToArr(outbuffer + offset, length_msg);
offset += 4;
memcpy(outbuffer + offset, this->msg, length_msg);
offset += length_msg;
uint32_t length_file = strlen(this->file);
varToArr(outbuffer + offset, length_file);
offset += 4;
memcpy(outbuffer + offset, this->file, length_file);
offset += length_file;
uint32_t length_function = strlen(this->function);
varToArr(outbuffer + offset, length_function);
offset += 4;
memcpy(outbuffer + offset, this->function, length_function);
offset += length_function;
*(outbuffer + offset + 0) = (this->line >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->line >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->line >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->line >> (8 * 3)) & 0xFF;
offset += sizeof(this->line);
*(outbuffer + offset + 0) = (this->topics_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->topics_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->topics_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->topics_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->topics_length);
for( uint32_t i = 0; i < topics_length; i++){
uint32_t length_topicsi = strlen(this->topics[i]);
varToArr(outbuffer + offset, length_topicsi);
offset += 4;
memcpy(outbuffer + offset, this->topics[i], length_topicsi);
offset += length_topicsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
int8_t real;
uint8_t base;
} u_level;
u_level.base = 0;
u_level.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->level = u_level.real;
offset += sizeof(this->level);
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
uint32_t length_msg;
arrToVar(length_msg, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_msg; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_msg-1]=0;
this->msg = (char *)(inbuffer + offset-1);
offset += length_msg;
uint32_t length_file;
arrToVar(length_file, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_file; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_file-1]=0;
this->file = (char *)(inbuffer + offset-1);
offset += length_file;
uint32_t length_function;
arrToVar(length_function, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_function; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_function-1]=0;
this->function = (char *)(inbuffer + offset-1);
offset += length_function;
this->line = ((uint32_t) (*(inbuffer + offset)));
this->line |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->line |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->line |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->line);
uint32_t topics_lengthT = ((uint32_t) (*(inbuffer + offset)));
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
topics_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->topics_length);
if(topics_lengthT > topics_length)
this->topics = (char**)realloc(this->topics, topics_lengthT * sizeof(char*));
topics_length = topics_lengthT;
for( uint32_t i = 0; i < topics_length; i++){
uint32_t length_st_topics;
arrToVar(length_st_topics, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_topics; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_topics-1]=0;
this->st_topics = (char *)(inbuffer + offset-1);
offset += length_st_topics;
memcpy( &(this->topics[i]), &(this->st_topics), sizeof(char*));
}
return offset;
}
const char * getType(){ return "rosgraph_msgs/Log"; };
const char * getMD5(){ return "acffd30cd6b6de30f120938c17c593fb"; };
};
}
#endif
| 6,464 | C | 33.758064 | 85 | 0.559097 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosgraph_msgs/Clock.h | #ifndef _ROS_rosgraph_msgs_Clock_h
#define _ROS_rosgraph_msgs_Clock_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace rosgraph_msgs
{
class Clock : public ros::Msg
{
public:
typedef ros::Time _clock_type;
_clock_type clock;
Clock():
clock()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->clock.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->clock.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->clock.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->clock.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->clock.sec);
*(outbuffer + offset + 0) = (this->clock.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->clock.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->clock.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->clock.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->clock.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->clock.sec = ((uint32_t) (*(inbuffer + offset)));
this->clock.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->clock.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->clock.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->clock.sec);
this->clock.nsec = ((uint32_t) (*(inbuffer + offset)));
this->clock.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->clock.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->clock.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->clock.nsec);
return offset;
}
const char * getType(){ return "rosgraph_msgs/Clock"; };
const char * getMD5(){ return "a9c97c1d230cfc112e270351a944ee47"; };
};
}
#endif
| 2,053 | C | 31.603174 | 77 | 0.539698 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarkerInit.h | #ifndef _ROS_visualization_msgs_InteractiveMarkerInit_h
#define _ROS_visualization_msgs_InteractiveMarkerInit_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "visualization_msgs/InteractiveMarker.h"
namespace visualization_msgs
{
class InteractiveMarkerInit : public ros::Msg
{
public:
typedef const char* _server_id_type;
_server_id_type server_id;
typedef uint64_t _seq_num_type;
_seq_num_type seq_num;
uint32_t markers_length;
typedef visualization_msgs::InteractiveMarker _markers_type;
_markers_type st_markers;
_markers_type * markers;
InteractiveMarkerInit():
server_id(""),
seq_num(0),
markers_length(0), markers(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_server_id = strlen(this->server_id);
varToArr(outbuffer + offset, length_server_id);
offset += 4;
memcpy(outbuffer + offset, this->server_id, length_server_id);
offset += length_server_id;
*(outbuffer + offset + 0) = (this->seq_num >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->seq_num >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->seq_num >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->seq_num >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (this->seq_num >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (this->seq_num >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (this->seq_num >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (this->seq_num >> (8 * 7)) & 0xFF;
offset += sizeof(this->seq_num);
*(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->markers_length);
for( uint32_t i = 0; i < markers_length; i++){
offset += this->markers[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_server_id;
arrToVar(length_server_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_server_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_server_id-1]=0;
this->server_id = (char *)(inbuffer + offset-1);
offset += length_server_id;
this->seq_num = ((uint64_t) (*(inbuffer + offset)));
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
offset += sizeof(this->seq_num);
uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->markers_length);
if(markers_lengthT > markers_length)
this->markers = (visualization_msgs::InteractiveMarker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::InteractiveMarker));
markers_length = markers_lengthT;
for( uint32_t i = 0; i < markers_length; i++){
offset += this->st_markers.deserialize(inbuffer + offset);
memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::InteractiveMarker));
}
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarkerInit"; };
const char * getMD5(){ return "d5f2c5045a72456d228676ab91048734"; };
};
}
#endif
| 4,257 | C | 40.339805 | 152 | 0.575758 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/Marker.h | #ifndef _ROS_visualization_msgs_Marker_h
#define _ROS_visualization_msgs_Marker_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
#include "geometry_msgs/Vector3.h"
#include "std_msgs/ColorRGBA.h"
#include "ros/duration.h"
#include "geometry_msgs/Point.h"
namespace visualization_msgs
{
class Marker : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _ns_type;
_ns_type ns;
typedef int32_t _id_type;
_id_type id;
typedef int32_t _type_type;
_type_type type;
typedef int32_t _action_type;
_action_type action;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef geometry_msgs::Vector3 _scale_type;
_scale_type scale;
typedef std_msgs::ColorRGBA _color_type;
_color_type color;
typedef ros::Duration _lifetime_type;
_lifetime_type lifetime;
typedef bool _frame_locked_type;
_frame_locked_type frame_locked;
uint32_t points_length;
typedef geometry_msgs::Point _points_type;
_points_type st_points;
_points_type * points;
uint32_t colors_length;
typedef std_msgs::ColorRGBA _colors_type;
_colors_type st_colors;
_colors_type * colors;
typedef const char* _text_type;
_text_type text;
typedef const char* _mesh_resource_type;
_mesh_resource_type mesh_resource;
typedef bool _mesh_use_embedded_materials_type;
_mesh_use_embedded_materials_type mesh_use_embedded_materials;
enum { ARROW = 0 };
enum { CUBE = 1 };
enum { SPHERE = 2 };
enum { CYLINDER = 3 };
enum { LINE_STRIP = 4 };
enum { LINE_LIST = 5 };
enum { CUBE_LIST = 6 };
enum { SPHERE_LIST = 7 };
enum { POINTS = 8 };
enum { TEXT_VIEW_FACING = 9 };
enum { MESH_RESOURCE = 10 };
enum { TRIANGLE_LIST = 11 };
enum { ADD = 0 };
enum { MODIFY = 0 };
enum { DELETE = 2 };
enum { DELETEALL = 3 };
Marker():
header(),
ns(""),
id(0),
type(0),
action(0),
pose(),
scale(),
color(),
lifetime(),
frame_locked(0),
points_length(0), points(NULL),
colors_length(0), colors(NULL),
text(""),
mesh_resource(""),
mesh_use_embedded_materials(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_ns = strlen(this->ns);
varToArr(outbuffer + offset, length_ns);
offset += 4;
memcpy(outbuffer + offset, this->ns, length_ns);
offset += length_ns;
union {
int32_t real;
uint32_t base;
} u_id;
u_id.real = this->id;
*(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_type;
u_type.real = this->type;
*(outbuffer + offset + 0) = (u_type.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_type.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_type.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_type.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->type);
union {
int32_t real;
uint32_t base;
} u_action;
u_action.real = this->action;
*(outbuffer + offset + 0) = (u_action.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_action.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_action.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_action.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->action);
offset += this->pose.serialize(outbuffer + offset);
offset += this->scale.serialize(outbuffer + offset);
offset += this->color.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->lifetime.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->lifetime.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->lifetime.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->lifetime.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->lifetime.sec);
*(outbuffer + offset + 0) = (this->lifetime.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->lifetime.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->lifetime.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->lifetime.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->lifetime.nsec);
union {
bool real;
uint8_t base;
} u_frame_locked;
u_frame_locked.real = this->frame_locked;
*(outbuffer + offset + 0) = (u_frame_locked.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->frame_locked);
*(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->points_length);
for( uint32_t i = 0; i < points_length; i++){
offset += this->points[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->colors_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->colors_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->colors_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->colors_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->colors_length);
for( uint32_t i = 0; i < colors_length; i++){
offset += this->colors[i].serialize(outbuffer + offset);
}
uint32_t length_text = strlen(this->text);
varToArr(outbuffer + offset, length_text);
offset += 4;
memcpy(outbuffer + offset, this->text, length_text);
offset += length_text;
uint32_t length_mesh_resource = strlen(this->mesh_resource);
varToArr(outbuffer + offset, length_mesh_resource);
offset += 4;
memcpy(outbuffer + offset, this->mesh_resource, length_mesh_resource);
offset += length_mesh_resource;
union {
bool real;
uint8_t base;
} u_mesh_use_embedded_materials;
u_mesh_use_embedded_materials.real = this->mesh_use_embedded_materials;
*(outbuffer + offset + 0) = (u_mesh_use_embedded_materials.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->mesh_use_embedded_materials);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_ns;
arrToVar(length_ns, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_ns; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_ns-1]=0;
this->ns = (char *)(inbuffer + offset-1);
offset += length_ns;
union {
int32_t real;
uint32_t base;
} u_id;
u_id.base = 0;
u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->id = u_id.real;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_type;
u_type.base = 0;
u_type.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->type = u_type.real;
offset += sizeof(this->type);
union {
int32_t real;
uint32_t base;
} u_action;
u_action.base = 0;
u_action.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->action = u_action.real;
offset += sizeof(this->action);
offset += this->pose.deserialize(inbuffer + offset);
offset += this->scale.deserialize(inbuffer + offset);
offset += this->color.deserialize(inbuffer + offset);
this->lifetime.sec = ((uint32_t) (*(inbuffer + offset)));
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->lifetime.sec);
this->lifetime.nsec = ((uint32_t) (*(inbuffer + offset)));
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->lifetime.nsec);
union {
bool real;
uint8_t base;
} u_frame_locked;
u_frame_locked.base = 0;
u_frame_locked.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->frame_locked = u_frame_locked.real;
offset += sizeof(this->frame_locked);
uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->points_length);
if(points_lengthT > points_length)
this->points = (geometry_msgs::Point*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point));
points_length = points_lengthT;
for( uint32_t i = 0; i < points_length; i++){
offset += this->st_points.deserialize(inbuffer + offset);
memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point));
}
uint32_t colors_lengthT = ((uint32_t) (*(inbuffer + offset)));
colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->colors_length);
if(colors_lengthT > colors_length)
this->colors = (std_msgs::ColorRGBA*)realloc(this->colors, colors_lengthT * sizeof(std_msgs::ColorRGBA));
colors_length = colors_lengthT;
for( uint32_t i = 0; i < colors_length; i++){
offset += this->st_colors.deserialize(inbuffer + offset);
memcpy( &(this->colors[i]), &(this->st_colors), sizeof(std_msgs::ColorRGBA));
}
uint32_t length_text;
arrToVar(length_text, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_text; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_text-1]=0;
this->text = (char *)(inbuffer + offset-1);
offset += length_text;
uint32_t length_mesh_resource;
arrToVar(length_mesh_resource, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_mesh_resource; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_mesh_resource-1]=0;
this->mesh_resource = (char *)(inbuffer + offset-1);
offset += length_mesh_resource;
union {
bool real;
uint8_t base;
} u_mesh_use_embedded_materials;
u_mesh_use_embedded_materials.base = 0;
u_mesh_use_embedded_materials.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->mesh_use_embedded_materials = u_mesh_use_embedded_materials.real;
offset += sizeof(this->mesh_use_embedded_materials);
return offset;
}
const char * getType(){ return "visualization_msgs/Marker"; };
const char * getMD5(){ return "4048c9de2a16f4ae8e0538085ebf1b97"; };
};
}
#endif
| 12,639 | C | 39.383386 | 115 | 0.552575 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/MarkerArray.h | #ifndef _ROS_visualization_msgs_MarkerArray_h
#define _ROS_visualization_msgs_MarkerArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "visualization_msgs/Marker.h"
namespace visualization_msgs
{
class MarkerArray : public ros::Msg
{
public:
uint32_t markers_length;
typedef visualization_msgs::Marker _markers_type;
_markers_type st_markers;
_markers_type * markers;
MarkerArray():
markers_length(0), markers(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->markers_length);
for( uint32_t i = 0; i < markers_length; i++){
offset += this->markers[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->markers_length);
if(markers_lengthT > markers_length)
this->markers = (visualization_msgs::Marker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::Marker));
markers_length = markers_lengthT;
for( uint32_t i = 0; i < markers_length; i++){
offset += this->st_markers.deserialize(inbuffer + offset);
memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::Marker));
}
return offset;
}
const char * getType(){ return "visualization_msgs/MarkerArray"; };
const char * getMD5(){ return "d155b9ce5188fbaf89745847fd5882d7"; };
};
}
#endif
| 2,166 | C | 32.338461 | 130 | 0.608033 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarkerUpdate.h | #ifndef _ROS_visualization_msgs_InteractiveMarkerUpdate_h
#define _ROS_visualization_msgs_InteractiveMarkerUpdate_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "visualization_msgs/InteractiveMarker.h"
#include "visualization_msgs/InteractiveMarkerPose.h"
namespace visualization_msgs
{
class InteractiveMarkerUpdate : public ros::Msg
{
public:
typedef const char* _server_id_type;
_server_id_type server_id;
typedef uint64_t _seq_num_type;
_seq_num_type seq_num;
typedef uint8_t _type_type;
_type_type type;
uint32_t markers_length;
typedef visualization_msgs::InteractiveMarker _markers_type;
_markers_type st_markers;
_markers_type * markers;
uint32_t poses_length;
typedef visualization_msgs::InteractiveMarkerPose _poses_type;
_poses_type st_poses;
_poses_type * poses;
uint32_t erases_length;
typedef char* _erases_type;
_erases_type st_erases;
_erases_type * erases;
enum { KEEP_ALIVE = 0 };
enum { UPDATE = 1 };
InteractiveMarkerUpdate():
server_id(""),
seq_num(0),
type(0),
markers_length(0), markers(NULL),
poses_length(0), poses(NULL),
erases_length(0), erases(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_server_id = strlen(this->server_id);
varToArr(outbuffer + offset, length_server_id);
offset += 4;
memcpy(outbuffer + offset, this->server_id, length_server_id);
offset += length_server_id;
*(outbuffer + offset + 0) = (this->seq_num >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->seq_num >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->seq_num >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->seq_num >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (this->seq_num >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (this->seq_num >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (this->seq_num >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (this->seq_num >> (8 * 7)) & 0xFF;
offset += sizeof(this->seq_num);
*(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
offset += sizeof(this->type);
*(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->markers_length);
for( uint32_t i = 0; i < markers_length; i++){
offset += this->markers[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->poses_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->poses_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->poses_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->poses_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->poses_length);
for( uint32_t i = 0; i < poses_length; i++){
offset += this->poses[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->erases_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->erases_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->erases_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->erases_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->erases_length);
for( uint32_t i = 0; i < erases_length; i++){
uint32_t length_erasesi = strlen(this->erases[i]);
varToArr(outbuffer + offset, length_erasesi);
offset += 4;
memcpy(outbuffer + offset, this->erases[i], length_erasesi);
offset += length_erasesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_server_id;
arrToVar(length_server_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_server_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_server_id-1]=0;
this->server_id = (char *)(inbuffer + offset-1);
offset += length_server_id;
this->seq_num = ((uint64_t) (*(inbuffer + offset)));
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
this->seq_num |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
offset += sizeof(this->seq_num);
this->type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->type);
uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->markers_length);
if(markers_lengthT > markers_length)
this->markers = (visualization_msgs::InteractiveMarker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::InteractiveMarker));
markers_length = markers_lengthT;
for( uint32_t i = 0; i < markers_length; i++){
offset += this->st_markers.deserialize(inbuffer + offset);
memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::InteractiveMarker));
}
uint32_t poses_lengthT = ((uint32_t) (*(inbuffer + offset)));
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->poses_length);
if(poses_lengthT > poses_length)
this->poses = (visualization_msgs::InteractiveMarkerPose*)realloc(this->poses, poses_lengthT * sizeof(visualization_msgs::InteractiveMarkerPose));
poses_length = poses_lengthT;
for( uint32_t i = 0; i < poses_length; i++){
offset += this->st_poses.deserialize(inbuffer + offset);
memcpy( &(this->poses[i]), &(this->st_poses), sizeof(visualization_msgs::InteractiveMarkerPose));
}
uint32_t erases_lengthT = ((uint32_t) (*(inbuffer + offset)));
erases_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
erases_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
erases_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->erases_length);
if(erases_lengthT > erases_length)
this->erases = (char**)realloc(this->erases, erases_lengthT * sizeof(char*));
erases_length = erases_lengthT;
for( uint32_t i = 0; i < erases_length; i++){
uint32_t length_st_erases;
arrToVar(length_st_erases, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_erases; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_erases-1]=0;
this->st_erases = (char *)(inbuffer + offset-1);
offset += length_st_erases;
memcpy( &(this->erases[i]), &(this->st_erases), sizeof(char*));
}
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarkerUpdate"; };
const char * getMD5(){ return "710d308d0a9276d65945e92dd30b3946"; };
};
}
#endif
| 7,886 | C | 44.068571 | 154 | 0.57266 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/MenuEntry.h | #ifndef _ROS_visualization_msgs_MenuEntry_h
#define _ROS_visualization_msgs_MenuEntry_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace visualization_msgs
{
class MenuEntry : public ros::Msg
{
public:
typedef uint32_t _id_type;
_id_type id;
typedef uint32_t _parent_id_type;
_parent_id_type parent_id;
typedef const char* _title_type;
_title_type title;
typedef const char* _command_type;
_command_type command;
typedef uint8_t _command_type_type;
_command_type_type command_type;
enum { FEEDBACK = 0 };
enum { ROSRUN = 1 };
enum { ROSLAUNCH = 2 };
MenuEntry():
id(0),
parent_id(0),
title(""),
command(""),
command_type(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->id >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
*(outbuffer + offset + 0) = (this->parent_id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->parent_id >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->parent_id >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->parent_id >> (8 * 3)) & 0xFF;
offset += sizeof(this->parent_id);
uint32_t length_title = strlen(this->title);
varToArr(outbuffer + offset, length_title);
offset += 4;
memcpy(outbuffer + offset, this->title, length_title);
offset += length_title;
uint32_t length_command = strlen(this->command);
varToArr(outbuffer + offset, length_command);
offset += 4;
memcpy(outbuffer + offset, this->command, length_command);
offset += length_command;
*(outbuffer + offset + 0) = (this->command_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->command_type);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->id = ((uint32_t) (*(inbuffer + offset)));
this->id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->id);
this->parent_id = ((uint32_t) (*(inbuffer + offset)));
this->parent_id |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->parent_id |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->parent_id |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->parent_id);
uint32_t length_title;
arrToVar(length_title, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_title; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_title-1]=0;
this->title = (char *)(inbuffer + offset-1);
offset += length_title;
uint32_t length_command;
arrToVar(length_command, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_command; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_command-1]=0;
this->command = (char *)(inbuffer + offset-1);
offset += length_command;
this->command_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->command_type);
return offset;
}
const char * getType(){ return "visualization_msgs/MenuEntry"; };
const char * getMD5(){ return "b90ec63024573de83b57aa93eb39be2d"; };
};
}
#endif
| 3,764 | C | 33.541284 | 76 | 0.557651 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarkerPose.h | #ifndef _ROS_visualization_msgs_InteractiveMarkerPose_h
#define _ROS_visualization_msgs_InteractiveMarkerPose_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Pose.h"
namespace visualization_msgs
{
class InteractiveMarkerPose : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Pose _pose_type;
_pose_type pose;
typedef const char* _name_type;
_name_type name;
InteractiveMarkerPose():
header(),
pose(),
name("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->pose.serialize(outbuffer + offset);
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->pose.deserialize(inbuffer + offset);
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarkerPose"; };
const char * getMD5(){ return "a6e6833209a196a38d798dadb02c81f8"; };
};
}
#endif
| 1,802 | C | 25.514706 | 81 | 0.63374 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/InteractiveMarkerControl.h | #ifndef _ROS_visualization_msgs_InteractiveMarkerControl_h
#define _ROS_visualization_msgs_InteractiveMarkerControl_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Quaternion.h"
#include "visualization_msgs/Marker.h"
namespace visualization_msgs
{
class InteractiveMarkerControl : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef geometry_msgs::Quaternion _orientation_type;
_orientation_type orientation;
typedef uint8_t _orientation_mode_type;
_orientation_mode_type orientation_mode;
typedef uint8_t _interaction_mode_type;
_interaction_mode_type interaction_mode;
typedef bool _always_visible_type;
_always_visible_type always_visible;
uint32_t markers_length;
typedef visualization_msgs::Marker _markers_type;
_markers_type st_markers;
_markers_type * markers;
typedef bool _independent_marker_orientation_type;
_independent_marker_orientation_type independent_marker_orientation;
typedef const char* _description_type;
_description_type description;
enum { INHERIT = 0 };
enum { FIXED = 1 };
enum { VIEW_FACING = 2 };
enum { NONE = 0 };
enum { MENU = 1 };
enum { BUTTON = 2 };
enum { MOVE_AXIS = 3 };
enum { MOVE_PLANE = 4 };
enum { ROTATE_AXIS = 5 };
enum { MOVE_ROTATE = 6 };
enum { MOVE_3D = 7 };
enum { ROTATE_3D = 8 };
enum { MOVE_ROTATE_3D = 9 };
InteractiveMarkerControl():
name(""),
orientation(),
orientation_mode(0),
interaction_mode(0),
always_visible(0),
markers_length(0), markers(NULL),
independent_marker_orientation(0),
description("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_name = strlen(this->name);
varToArr(outbuffer + offset, length_name);
offset += 4;
memcpy(outbuffer + offset, this->name, length_name);
offset += length_name;
offset += this->orientation.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->orientation_mode >> (8 * 0)) & 0xFF;
offset += sizeof(this->orientation_mode);
*(outbuffer + offset + 0) = (this->interaction_mode >> (8 * 0)) & 0xFF;
offset += sizeof(this->interaction_mode);
union {
bool real;
uint8_t base;
} u_always_visible;
u_always_visible.real = this->always_visible;
*(outbuffer + offset + 0) = (u_always_visible.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->always_visible);
*(outbuffer + offset + 0) = (this->markers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->markers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->markers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->markers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->markers_length);
for( uint32_t i = 0; i < markers_length; i++){
offset += this->markers[i].serialize(outbuffer + offset);
}
union {
bool real;
uint8_t base;
} u_independent_marker_orientation;
u_independent_marker_orientation.real = this->independent_marker_orientation;
*(outbuffer + offset + 0) = (u_independent_marker_orientation.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->independent_marker_orientation);
uint32_t length_description = strlen(this->description);
varToArr(outbuffer + offset, length_description);
offset += 4;
memcpy(outbuffer + offset, this->description, length_description);
offset += length_description;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_name;
arrToVar(length_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_name-1]=0;
this->name = (char *)(inbuffer + offset-1);
offset += length_name;
offset += this->orientation.deserialize(inbuffer + offset);
this->orientation_mode = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->orientation_mode);
this->interaction_mode = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->interaction_mode);
union {
bool real;
uint8_t base;
} u_always_visible;
u_always_visible.base = 0;
u_always_visible.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->always_visible = u_always_visible.real;
offset += sizeof(this->always_visible);
uint32_t markers_lengthT = ((uint32_t) (*(inbuffer + offset)));
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
markers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->markers_length);
if(markers_lengthT > markers_length)
this->markers = (visualization_msgs::Marker*)realloc(this->markers, markers_lengthT * sizeof(visualization_msgs::Marker));
markers_length = markers_lengthT;
for( uint32_t i = 0; i < markers_length; i++){
offset += this->st_markers.deserialize(inbuffer + offset);
memcpy( &(this->markers[i]), &(this->st_markers), sizeof(visualization_msgs::Marker));
}
union {
bool real;
uint8_t base;
} u_independent_marker_orientation;
u_independent_marker_orientation.base = 0;
u_independent_marker_orientation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->independent_marker_orientation = u_independent_marker_orientation.real;
offset += sizeof(this->independent_marker_orientation);
uint32_t length_description;
arrToVar(length_description, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_description; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_description-1]=0;
this->description = (char *)(inbuffer + offset-1);
offset += length_description;
return offset;
}
const char * getType(){ return "visualization_msgs/InteractiveMarkerControl"; };
const char * getMD5(){ return "b3c81e785788195d1840b86c28da1aac"; };
};
}
#endif
| 6,517 | C | 37.797619 | 130 | 0.610557 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/visualization_msgs/ImageMarker.h | #ifndef _ROS_visualization_msgs_ImageMarker_h
#define _ROS_visualization_msgs_ImageMarker_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Point.h"
#include "std_msgs/ColorRGBA.h"
#include "ros/duration.h"
namespace visualization_msgs
{
class ImageMarker : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _ns_type;
_ns_type ns;
typedef int32_t _id_type;
_id_type id;
typedef int32_t _type_type;
_type_type type;
typedef int32_t _action_type;
_action_type action;
typedef geometry_msgs::Point _position_type;
_position_type position;
typedef float _scale_type;
_scale_type scale;
typedef std_msgs::ColorRGBA _outline_color_type;
_outline_color_type outline_color;
typedef uint8_t _filled_type;
_filled_type filled;
typedef std_msgs::ColorRGBA _fill_color_type;
_fill_color_type fill_color;
typedef ros::Duration _lifetime_type;
_lifetime_type lifetime;
uint32_t points_length;
typedef geometry_msgs::Point _points_type;
_points_type st_points;
_points_type * points;
uint32_t outline_colors_length;
typedef std_msgs::ColorRGBA _outline_colors_type;
_outline_colors_type st_outline_colors;
_outline_colors_type * outline_colors;
enum { CIRCLE = 0 };
enum { LINE_STRIP = 1 };
enum { LINE_LIST = 2 };
enum { POLYGON = 3 };
enum { POINTS = 4 };
enum { ADD = 0 };
enum { REMOVE = 1 };
ImageMarker():
header(),
ns(""),
id(0),
type(0),
action(0),
position(),
scale(0),
outline_color(),
filled(0),
fill_color(),
lifetime(),
points_length(0), points(NULL),
outline_colors_length(0), outline_colors(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_ns = strlen(this->ns);
varToArr(outbuffer + offset, length_ns);
offset += 4;
memcpy(outbuffer + offset, this->ns, length_ns);
offset += length_ns;
union {
int32_t real;
uint32_t base;
} u_id;
u_id.real = this->id;
*(outbuffer + offset + 0) = (u_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_type;
u_type.real = this->type;
*(outbuffer + offset + 0) = (u_type.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_type.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_type.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_type.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->type);
union {
int32_t real;
uint32_t base;
} u_action;
u_action.real = this->action;
*(outbuffer + offset + 0) = (u_action.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_action.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_action.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_action.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->action);
offset += this->position.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_scale;
u_scale.real = this->scale;
*(outbuffer + offset + 0) = (u_scale.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_scale.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_scale.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_scale.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->scale);
offset += this->outline_color.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->filled >> (8 * 0)) & 0xFF;
offset += sizeof(this->filled);
offset += this->fill_color.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->lifetime.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->lifetime.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->lifetime.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->lifetime.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->lifetime.sec);
*(outbuffer + offset + 0) = (this->lifetime.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->lifetime.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->lifetime.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->lifetime.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->lifetime.nsec);
*(outbuffer + offset + 0) = (this->points_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->points_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->points_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->points_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->points_length);
for( uint32_t i = 0; i < points_length; i++){
offset += this->points[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->outline_colors_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outline_colors_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outline_colors_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outline_colors_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outline_colors_length);
for( uint32_t i = 0; i < outline_colors_length; i++){
offset += this->outline_colors[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_ns;
arrToVar(length_ns, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_ns; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_ns-1]=0;
this->ns = (char *)(inbuffer + offset-1);
offset += length_ns;
union {
int32_t real;
uint32_t base;
} u_id;
u_id.base = 0;
u_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->id = u_id.real;
offset += sizeof(this->id);
union {
int32_t real;
uint32_t base;
} u_type;
u_type.base = 0;
u_type.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_type.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->type = u_type.real;
offset += sizeof(this->type);
union {
int32_t real;
uint32_t base;
} u_action;
u_action.base = 0;
u_action.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_action.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->action = u_action.real;
offset += sizeof(this->action);
offset += this->position.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_scale;
u_scale.base = 0;
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_scale.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->scale = u_scale.real;
offset += sizeof(this->scale);
offset += this->outline_color.deserialize(inbuffer + offset);
this->filled = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->filled);
offset += this->fill_color.deserialize(inbuffer + offset);
this->lifetime.sec = ((uint32_t) (*(inbuffer + offset)));
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->lifetime.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->lifetime.sec);
this->lifetime.nsec = ((uint32_t) (*(inbuffer + offset)));
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->lifetime.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->lifetime.nsec);
uint32_t points_lengthT = ((uint32_t) (*(inbuffer + offset)));
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
points_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->points_length);
if(points_lengthT > points_length)
this->points = (geometry_msgs::Point*)realloc(this->points, points_lengthT * sizeof(geometry_msgs::Point));
points_length = points_lengthT;
for( uint32_t i = 0; i < points_length; i++){
offset += this->st_points.deserialize(inbuffer + offset);
memcpy( &(this->points[i]), &(this->st_points), sizeof(geometry_msgs::Point));
}
uint32_t outline_colors_lengthT = ((uint32_t) (*(inbuffer + offset)));
outline_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outline_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outline_colors_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outline_colors_length);
if(outline_colors_lengthT > outline_colors_length)
this->outline_colors = (std_msgs::ColorRGBA*)realloc(this->outline_colors, outline_colors_lengthT * sizeof(std_msgs::ColorRGBA));
outline_colors_length = outline_colors_lengthT;
for( uint32_t i = 0; i < outline_colors_length; i++){
offset += this->st_outline_colors.deserialize(inbuffer + offset);
memcpy( &(this->outline_colors[i]), &(this->st_outline_colors), sizeof(std_msgs::ColorRGBA));
}
return offset;
}
const char * getType(){ return "visualization_msgs/ImageMarker"; };
const char * getMD5(){ return "1de93c67ec8858b831025a08fbf1b35c"; };
};
}
#endif
| 11,066 | C | 41.079848 | 137 | 0.545455 |
Subsets and Splits