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/std_msgs/Float64.h | #ifndef _ROS_std_msgs_Float64_h
#define _ROS_std_msgs_Float64_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Float64 : public ros::Msg
{
public:
typedef double _data_type;
_data_type data;
Float64():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_data;
u_data.real = this->data;
*(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_data.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_data.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_data.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_data.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_data.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_data.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_data.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_data;
u_data.base = 0;
u_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->data = u_data.real;
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return "std_msgs/Float64"; };
const char * getMD5(){ return "fdb28210bfa9d7c91146260178d9a584"; };
};
}
#endif
| 2,114 | C | 28.788732 | 72 | 0.509461 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/UInt32MultiArray.h | #ifndef _ROS_std_msgs_UInt32MultiArray_h
#define _ROS_std_msgs_UInt32MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class UInt32MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef uint32_t _data_type;
_data_type st_data;
_data_type * data;
UInt32MultiArray():
layout(),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->layout.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;
*(outbuffer + offset + 1) = (this->data[i] >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data[i] >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data[i] >> (8 * 3)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->layout.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 = (uint32_t*)realloc(this->data, data_lengthT * sizeof(uint32_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint32_t) (*(inbuffer + offset)));
this->st_data |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->st_data |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->st_data |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint32_t));
}
return offset;
}
const char * getType(){ return "std_msgs/UInt32MultiArray"; };
const char * getMD5(){ return "4d6a180abc9be191b96a7eda6c8a233d"; };
};
}
#endif
| 2,721 | C | 33.897435 | 85 | 0.554208 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/UInt8.h | #ifndef _ROS_std_msgs_UInt8_h
#define _ROS_std_msgs_UInt8_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class UInt8 : public ros::Msg
{
public:
typedef uint8_t _data_type;
_data_type data;
UInt8():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->data = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return "std_msgs/UInt8"; };
const char * getMD5(){ return "7c8164229e7d2c17eb95e9231617fdee"; };
};
}
#endif
| 872 | C | 17.97826 | 72 | 0.581422 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Byte.h | #ifndef _ROS_std_msgs_Byte_h
#define _ROS_std_msgs_Byte_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Byte : public ros::Msg
{
public:
typedef int8_t _data_type;
_data_type data;
Byte():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_data;
u_data.real = this->data;
*(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_data;
u_data.base = 0;
u_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->data = u_data.real;
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return "std_msgs/Byte"; };
const char * getMD5(){ return "ad736a2e8818154c487bb80fe42ce43b"; };
};
}
#endif
| 1,116 | C | 18.596491 | 72 | 0.544803 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/String.h | #ifndef _ROS_std_msgs_String_h
#define _ROS_std_msgs_String_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class String : public ros::Msg
{
public:
typedef const char* _data_type;
_data_type data;
String():
data("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_data = strlen(this->data);
varToArr(outbuffer + offset, length_data);
offset += 4;
memcpy(outbuffer + offset, this->data, length_data);
offset += length_data;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_data;
arrToVar(length_data, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_data; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_data-1]=0;
this->data = (char *)(inbuffer + offset-1);
offset += length_data;
return offset;
}
const char * getType(){ return "std_msgs/String"; };
const char * getMD5(){ return "992ce8a1687cec8c8bd883ec73ca41d1"; };
};
}
#endif
| 1,217 | C | 20.75 | 72 | 0.595727 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/MultiArrayLayout.h | #ifndef _ROS_std_msgs_MultiArrayLayout_h
#define _ROS_std_msgs_MultiArrayLayout_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayDimension.h"
namespace std_msgs
{
class MultiArrayLayout : public ros::Msg
{
public:
uint32_t dim_length;
typedef std_msgs::MultiArrayDimension _dim_type;
_dim_type st_dim;
_dim_type * dim;
typedef uint32_t _data_offset_type;
_data_offset_type data_offset;
MultiArrayLayout():
dim_length(0), dim(NULL),
data_offset(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->dim_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->dim_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->dim_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->dim_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->dim_length);
for( uint32_t i = 0; i < dim_length; i++){
offset += this->dim[i].serialize(outbuffer + offset);
}
*(outbuffer + offset + 0) = (this->data_offset >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data_offset >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data_offset >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data_offset >> (8 * 3)) & 0xFF;
offset += sizeof(this->data_offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t dim_lengthT = ((uint32_t) (*(inbuffer + offset)));
dim_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
dim_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
dim_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->dim_length);
if(dim_lengthT > dim_length)
this->dim = (std_msgs::MultiArrayDimension*)realloc(this->dim, dim_lengthT * sizeof(std_msgs::MultiArrayDimension));
dim_length = dim_lengthT;
for( uint32_t i = 0; i < dim_length; i++){
offset += this->st_dim.deserialize(inbuffer + offset);
memcpy( &(this->dim[i]), &(this->st_dim), sizeof(std_msgs::MultiArrayDimension));
}
this->data_offset = ((uint32_t) (*(inbuffer + offset)));
this->data_offset |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->data_offset |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->data_offset |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data_offset);
return offset;
}
const char * getType(){ return "std_msgs/MultiArrayLayout"; };
const char * getMD5(){ return "0fed2a11c13e11c5571b4e2a995a91a3"; };
};
}
#endif
| 2,822 | C | 35.192307 | 124 | 0.567328 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Duration.h | #ifndef _ROS_std_msgs_Duration_h
#define _ROS_std_msgs_Duration_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/duration.h"
namespace std_msgs
{
class Duration : public ros::Msg
{
public:
typedef ros::Duration _data_type;
_data_type data;
Duration():
data()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->data.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->data.sec);
*(outbuffer + offset + 0) = (this->data.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->data.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->data.sec = ((uint32_t) (*(inbuffer + offset)));
this->data.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->data.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->data.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data.sec);
this->data.nsec = ((uint32_t) (*(inbuffer + offset)));
this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data.nsec);
return offset;
}
const char * getType(){ return "std_msgs/Duration"; };
const char * getMD5(){ return "3e286caf4241d664e55f3ad380e2ae46"; };
};
}
#endif
| 2,032 | C | 31.269841 | 76 | 0.534941 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/UInt8MultiArray.h | #ifndef _ROS_std_msgs_UInt8MultiArray_h
#define _ROS_std_msgs_UInt8MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class UInt8MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef uint8_t _data_type;
_data_type st_data;
_data_type * data;
UInt8MultiArray():
layout(),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->layout.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]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->layout.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));
}
return offset;
}
const char * getType(){ return "std_msgs/UInt8MultiArray"; };
const char * getMD5(){ return "82373f1612381bb6ee473b5cd6f5d89c"; };
};
}
#endif
| 2,279 | C | 30.666666 | 83 | 0.571742 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Int16MultiArray.h | #ifndef _ROS_std_msgs_Int16MultiArray_h
#define _ROS_std_msgs_Int16MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class Int16MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef int16_t _data_type;
_data_type st_data;
_data_type * data;
Int16MultiArray():
layout(),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->layout.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++){
union {
int16_t real;
uint16_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->layout.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 = (int16_t*)realloc(this->data, data_lengthT * sizeof(int16_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
int16_t real;
uint16_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_data.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(int16_t));
}
return offset;
}
const char * getType(){ return "std_msgs/Int16MultiArray"; };
const char * getMD5(){ return "d9338d7f523fcb692fae9d0a0e9f067c"; };
};
}
#endif
| 2,693 | C | 30.694117 | 83 | 0.5544 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/MultiArrayDimension.h | #ifndef _ROS_std_msgs_MultiArrayDimension_h
#define _ROS_std_msgs_MultiArrayDimension_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class MultiArrayDimension : public ros::Msg
{
public:
typedef const char* _label_type;
_label_type label;
typedef uint32_t _size_type;
_size_type size;
typedef uint32_t _stride_type;
_stride_type stride;
MultiArrayDimension():
label(""),
size(0),
stride(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_label = strlen(this->label);
varToArr(outbuffer + offset, length_label);
offset += 4;
memcpy(outbuffer + offset, this->label, length_label);
offset += length_label;
*(outbuffer + offset + 0) = (this->size >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->size >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->size >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->size >> (8 * 3)) & 0xFF;
offset += sizeof(this->size);
*(outbuffer + offset + 0) = (this->stride >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stride >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stride >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stride >> (8 * 3)) & 0xFF;
offset += sizeof(this->stride);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_label;
arrToVar(length_label, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_label; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_label-1]=0;
this->label = (char *)(inbuffer + offset-1);
offset += length_label;
this->size = ((uint32_t) (*(inbuffer + offset)));
this->size |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->size |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->size |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->size);
this->stride = ((uint32_t) (*(inbuffer + offset)));
this->stride |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stride |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stride |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stride);
return offset;
}
const char * getType(){ return "std_msgs/MultiArrayDimension"; };
const char * getMD5(){ return "4cd0c83a8683deae40ecdac60e53bfa8"; };
};
}
#endif
| 2,690 | C | 31.817073 | 73 | 0.550929 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/UInt64MultiArray.h | #ifndef _ROS_std_msgs_UInt64MultiArray_h
#define _ROS_std_msgs_UInt64MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class UInt64MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef uint64_t _data_type;
_data_type st_data;
_data_type * data;
UInt64MultiArray():
layout(),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->layout.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;
*(outbuffer + offset + 1) = (this->data[i] >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data[i] >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data[i] >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (this->data[i] >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (this->data[i] >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (this->data[i] >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (this->data[i] >> (8 * 7)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->layout.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 = (uint64_t*)realloc(this->data, data_lengthT * sizeof(uint64_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
this->st_data = ((uint64_t) (*(inbuffer + offset)));
this->st_data |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
this->st_data |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(uint64_t));
}
return offset;
}
const char * getType(){ return "std_msgs/UInt64MultiArray"; };
const char * getMD5(){ return "6088f127afb1d6c72927aa1247e945af"; };
};
}
#endif
| 3,297 | C | 37.348837 | 85 | 0.536245 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/ColorRGBA.h | #ifndef _ROS_std_msgs_ColorRGBA_h
#define _ROS_std_msgs_ColorRGBA_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class ColorRGBA : public ros::Msg
{
public:
typedef float _r_type;
_r_type r;
typedef float _g_type;
_g_type g;
typedef float _b_type;
_b_type b;
typedef float _a_type;
_a_type a;
ColorRGBA():
r(0),
g(0),
b(0),
a(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
float real;
uint32_t base;
} u_r;
u_r.real = this->r;
*(outbuffer + offset + 0) = (u_r.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_r.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_r.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_r.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->r);
union {
float real;
uint32_t base;
} u_g;
u_g.real = this->g;
*(outbuffer + offset + 0) = (u_g.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_g.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_g.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_g.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->g);
union {
float real;
uint32_t base;
} u_b;
u_b.real = this->b;
*(outbuffer + offset + 0) = (u_b.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_b.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_b.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_b.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->b);
union {
float real;
uint32_t base;
} u_a;
u_a.real = this->a;
*(outbuffer + offset + 0) = (u_a.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_a.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_a.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_a.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->a);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
float real;
uint32_t base;
} u_r;
u_r.base = 0;
u_r.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_r.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_r.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_r.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->r = u_r.real;
offset += sizeof(this->r);
union {
float real;
uint32_t base;
} u_g;
u_g.base = 0;
u_g.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_g.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_g.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_g.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->g = u_g.real;
offset += sizeof(this->g);
union {
float real;
uint32_t base;
} u_b;
u_b.base = 0;
u_b.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_b.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_b.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_b.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->b = u_b.real;
offset += sizeof(this->b);
union {
float real;
uint32_t base;
} u_a;
u_a.base = 0;
u_a.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_a.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_a.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_a.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->a = u_a.real;
offset += sizeof(this->a);
return offset;
}
const char * getType(){ return "std_msgs/ColorRGBA"; };
const char * getMD5(){ return "a29a96539573343b1310c73607334b00"; };
};
}
#endif
| 4,114 | C | 29.481481 | 72 | 0.458678 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Float64MultiArray.h | #ifndef _ROS_std_msgs_Float64MultiArray_h
#define _ROS_std_msgs_Float64MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class Float64MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef double _data_type;
_data_type st_data;
_data_type * data;
Float64MultiArray():
layout(),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->layout.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++){
union {
double real;
uint64_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_datai.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_datai.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_datai.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_datai.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->layout.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 = (double*)realloc(this->data, data_lengthT * sizeof(double));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
double real;
uint64_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_st_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(double));
}
return offset;
}
const char * getType(){ return "std_msgs/Float64MultiArray"; };
const char * getMD5(){ return "4b7d974086d4060e7db4613a7e6c3ba4"; };
};
}
#endif
| 3,561 | C | 35.721649 | 81 | 0.534962 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Time.h | #ifndef _ROS_std_msgs_Time_h
#define _ROS_std_msgs_Time_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace std_msgs
{
class Time : public ros::Msg
{
public:
typedef ros::Time _data_type;
_data_type data;
Time():
data()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->data.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->data.sec);
*(outbuffer + offset + 0) = (this->data.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->data.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->data.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->data.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->data.nsec);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->data.sec = ((uint32_t) (*(inbuffer + offset)));
this->data.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->data.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->data.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data.sec);
this->data.nsec = ((uint32_t) (*(inbuffer + offset)));
this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->data.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->data.nsec);
return offset;
}
const char * getType(){ return "std_msgs/Time"; };
const char * getMD5(){ return "cd7166c74c552c311fbcc2fe5a7bc289"; };
};
}
#endif
| 2,004 | C | 30.825396 | 76 | 0.528443 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Char.h | #ifndef _ROS_std_msgs_Char_h
#define _ROS_std_msgs_Char_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Char : public ros::Msg
{
public:
typedef uint8_t _data_type;
_data_type data;
Char():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->data = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return "std_msgs/Char"; };
const char * getMD5(){ return "1bf77f25acecdedba0e224b162199717"; };
};
}
#endif
| 867 | C | 17.869565 | 72 | 0.579008 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Float32MultiArray.h | #ifndef _ROS_std_msgs_Float32MultiArray_h
#define _ROS_std_msgs_Float32MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class Float32MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef float _data_type;
_data_type st_data;
_data_type * data;
Float32MultiArray():
layout(),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->layout.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++){
union {
float real;
uint32_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->layout.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 = (float*)realloc(this->data, data_lengthT * sizeof(float));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
float real;
uint32_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(float));
}
return offset;
}
const char * getType(){ return "std_msgs/Float32MultiArray"; };
const char * getMD5(){ return "6a40e0ffa6a17a503ac3f8616991b1f6"; };
};
}
#endif
| 2,979 | C | 32.483146 | 79 | 0.547499 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Int8MultiArray.h | #ifndef _ROS_std_msgs_Int8MultiArray_h
#define _ROS_std_msgs_Int8MultiArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/MultiArrayLayout.h"
namespace std_msgs
{
class Int8MultiArray : public ros::Msg
{
public:
typedef std_msgs::MultiArrayLayout _layout_type;
_layout_type layout;
uint32_t data_length;
typedef int8_t _data_type;
_data_type st_data;
_data_type * data;
Int8MultiArray():
layout(),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->layout.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++){
union {
int8_t real;
uint8_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->layout.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 = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t));
}
return offset;
}
const char * getType(){ return "std_msgs/Int8MultiArray"; };
const char * getMD5(){ return "d7c1af35a1b4781bbe79e03dd94b7c13"; };
};
}
#endif
| 2,535 | C | 29.554217 | 81 | 0.557002 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Int8.h | #ifndef _ROS_std_msgs_Int8_h
#define _ROS_std_msgs_Int8_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Int8 : public ros::Msg
{
public:
typedef int8_t _data_type;
_data_type data;
Int8():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_data;
u_data.real = this->data;
*(outbuffer + offset + 0) = (u_data.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->data);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int8_t real;
uint8_t base;
} u_data;
u_data.base = 0;
u_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->data = u_data.real;
offset += sizeof(this->data);
return offset;
}
const char * getType(){ return "std_msgs/Int8"; };
const char * getMD5(){ return "27ffa0c9c4b8fb8492252bcad9e5c57b"; };
};
}
#endif
| 1,116 | C | 18.596491 | 72 | 0.544803 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/std_msgs/Empty.h | #ifndef _ROS_std_msgs_Empty_h
#define _ROS_std_msgs_Empty_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Empty : public ros::Msg
{
public:
Empty()
{
}
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 "std_msgs/Empty"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 606 | C | 14.564102 | 72 | 0.612211 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_msgs/GoalStatus.h | #ifndef _ROS_actionlib_msgs_GoalStatus_h
#define _ROS_actionlib_msgs_GoalStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "actionlib_msgs/GoalID.h"
namespace actionlib_msgs
{
class GoalStatus : public ros::Msg
{
public:
typedef actionlib_msgs::GoalID _goal_id_type;
_goal_id_type goal_id;
typedef uint8_t _status_type;
_status_type status;
typedef const char* _text_type;
_text_type text;
enum { PENDING = 0 };
enum { ACTIVE = 1 };
enum { PREEMPTED = 2 };
enum { SUCCEEDED = 3 };
enum { ABORTED = 4 };
enum { REJECTED = 5 };
enum { PREEMPTING = 6 };
enum { RECALLING = 7 };
enum { RECALLED = 8 };
enum { LOST = 9 };
GoalStatus():
goal_id(),
status(0),
text("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->goal_id.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->status >> (8 * 0)) & 0xFF;
offset += sizeof(this->status);
uint32_t length_text = strlen(this->text);
varToArr(outbuffer + offset, length_text);
offset += 4;
memcpy(outbuffer + offset, this->text, length_text);
offset += length_text;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->goal_id.deserialize(inbuffer + offset);
this->status = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->status);
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;
return offset;
}
const char * getType(){ return "actionlib_msgs/GoalStatus"; };
const char * getMD5(){ return "d388f9b87b3c471f784434d671988d4a"; };
};
}
#endif
| 2,126 | C | 25.92405 | 72 | 0.571025 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_msgs/GoalStatusArray.h | #ifndef _ROS_actionlib_msgs_GoalStatusArray_h
#define _ROS_actionlib_msgs_GoalStatusArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "actionlib_msgs/GoalStatus.h"
namespace actionlib_msgs
{
class GoalStatusArray : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t status_list_length;
typedef actionlib_msgs::GoalStatus _status_list_type;
_status_list_type st_status_list;
_status_list_type * status_list;
GoalStatusArray():
header(),
status_list_length(0), status_list(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->status_list_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->status_list_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->status_list_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->status_list_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->status_list_length);
for( uint32_t i = 0; i < status_list_length; i++){
offset += this->status_list[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t status_list_lengthT = ((uint32_t) (*(inbuffer + offset)));
status_list_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
status_list_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
status_list_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->status_list_length);
if(status_list_lengthT > status_list_length)
this->status_list = (actionlib_msgs::GoalStatus*)realloc(this->status_list, status_list_lengthT * sizeof(actionlib_msgs::GoalStatus));
status_list_length = status_list_lengthT;
for( uint32_t i = 0; i < status_list_length; i++){
offset += this->st_status_list.deserialize(inbuffer + offset);
memcpy( &(this->status_list[i]), &(this->st_status_list), sizeof(actionlib_msgs::GoalStatus));
}
return offset;
}
const char * getType(){ return "actionlib_msgs/GoalStatusArray"; };
const char * getMD5(){ return "8b2b82f13216d0a8ea88bd3af735e619"; };
};
}
#endif
| 2,532 | C | 34.676056 | 142 | 0.619273 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/actionlib_msgs/GoalID.h | #ifndef _ROS_actionlib_msgs_GoalID_h
#define _ROS_actionlib_msgs_GoalID_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace actionlib_msgs
{
class GoalID : public ros::Msg
{
public:
typedef ros::Time _stamp_type;
_stamp_type stamp;
typedef const char* _id_type;
_id_type id;
GoalID():
stamp(),
id("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->stamp.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp.sec);
*(outbuffer + offset + 0) = (this->stamp.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp.nsec);
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->stamp.sec = ((uint32_t) (*(inbuffer + offset)));
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp.sec);
this->stamp.nsec = ((uint32_t) (*(inbuffer + offset)));
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp.nsec);
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;
return offset;
}
const char * getType(){ return "actionlib_msgs/GoalID"; };
const char * getMD5(){ return "302881f31927c1df708a2dbab0e80ee8"; };
};
}
#endif
| 2,636 | C | 31.9625 | 77 | 0.544006 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_example/Turtlebot3Result.h | #ifndef _ROS_turtlebot3_example_Turtlebot3Result_h
#define _ROS_turtlebot3_example_Turtlebot3Result_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlebot3_example
{
class Turtlebot3Result : public ros::Msg
{
public:
typedef const char* _result_type;
_result_type result;
Turtlebot3Result():
result("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_result = strlen(this->result);
varToArr(outbuffer + offset, length_result);
offset += 4;
memcpy(outbuffer + offset, this->result, length_result);
offset += length_result;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_result;
arrToVar(length_result, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_result; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_result-1]=0;
this->result = (char *)(inbuffer + offset-1);
offset += length_result;
return offset;
}
const char * getType(){ return "turtlebot3_example/Turtlebot3Result"; };
const char * getMD5(){ return "c22f2a1ed8654a0b365f1bb3f7ff2c0f"; };
};
}
#endif
| 1,339 | C | 22.928571 | 76 | 0.632562 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_example/Turtlebot3Goal.h | #ifndef _ROS_turtlebot3_example_Turtlebot3Goal_h
#define _ROS_turtlebot3_example_Turtlebot3Goal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/Vector3.h"
namespace turtlebot3_example
{
class Turtlebot3Goal : public ros::Msg
{
public:
typedef geometry_msgs::Vector3 _goal_type;
_goal_type goal;
Turtlebot3Goal():
goal()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->goal.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->goal.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "turtlebot3_example/Turtlebot3Goal"; };
const char * getMD5(){ return "8ad3bd0e46ff6777ce7cd2fdd945cb9e"; };
};
}
#endif
| 929 | C | 19.666666 | 74 | 0.65662 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_example/Turtlebot3ActionGoal.h | #ifndef _ROS_turtlebot3_example_Turtlebot3ActionGoal_h
#define _ROS_turtlebot3_example_Turtlebot3ActionGoal_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 "turtlebot3_example/Turtlebot3Goal.h"
namespace turtlebot3_example
{
class Turtlebot3ActionGoal : 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 turtlebot3_example::Turtlebot3Goal _goal_type;
_goal_type goal;
Turtlebot3ActionGoal():
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 "turtlebot3_example/Turtlebot3ActionGoal"; };
const char * getMD5(){ return "629663823fea578d64180162f10bec87"; };
};
}
#endif
| 1,477 | C | 24.929824 | 80 | 0.666215 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_example/Turtlebot3Feedback.h | #ifndef _ROS_turtlebot3_example_Turtlebot3Feedback_h
#define _ROS_turtlebot3_example_Turtlebot3Feedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace turtlebot3_example
{
class Turtlebot3Feedback : public ros::Msg
{
public:
typedef const char* _state_type;
_state_type state;
Turtlebot3Feedback():
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 "turtlebot3_example/Turtlebot3Feedback"; };
const char * getMD5(){ return "af6d3a99f0fbeb66d3248fa4b3e675fb"; };
};
}
#endif
| 1,333 | C | 22.821428 | 78 | 0.630908 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_example/Turtlebot3ActionFeedback.h | #ifndef _ROS_turtlebot3_example_Turtlebot3ActionFeedback_h
#define _ROS_turtlebot3_example_Turtlebot3ActionFeedback_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 "turtlebot3_example/Turtlebot3Feedback.h"
namespace turtlebot3_example
{
class Turtlebot3ActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef turtlebot3_example::Turtlebot3Feedback _feedback_type;
_feedback_type feedback;
Turtlebot3ActionFeedback():
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 "turtlebot3_example/Turtlebot3ActionFeedback"; };
const char * getMD5(){ return "12232ef97486c7962f264c105aae2958"; };
};
}
#endif
| 1,531 | C | 25.877193 | 84 | 0.681907 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_example/Turtlebot3Action.h | #ifndef _ROS_turtlebot3_example_Turtlebot3Action_h
#define _ROS_turtlebot3_example_Turtlebot3Action_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "turtlebot3_example/Turtlebot3ActionGoal.h"
#include "turtlebot3_example/Turtlebot3ActionResult.h"
#include "turtlebot3_example/Turtlebot3ActionFeedback.h"
namespace turtlebot3_example
{
class Turtlebot3Action : public ros::Msg
{
public:
typedef turtlebot3_example::Turtlebot3ActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef turtlebot3_example::Turtlebot3ActionResult _action_result_type;
_action_result_type action_result;
typedef turtlebot3_example::Turtlebot3ActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
Turtlebot3Action():
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 "turtlebot3_example/Turtlebot3Action"; };
const char * getMD5(){ return "86a69578ab4eb5bb3e55984730f14503"; };
};
}
#endif
| 1,697 | C | 28.789473 | 81 | 0.702416 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/turtlebot3_example/Turtlebot3ActionResult.h | #ifndef _ROS_turtlebot3_example_Turtlebot3ActionResult_h
#define _ROS_turtlebot3_example_Turtlebot3ActionResult_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 "turtlebot3_example/Turtlebot3Result.h"
namespace turtlebot3_example
{
class Turtlebot3ActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef turtlebot3_example::Turtlebot3Result _result_type;
_result_type result;
Turtlebot3ActionResult():
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 "turtlebot3_example/Turtlebot3ActionResult"; };
const char * getMD5(){ return "5489bcfa93e36e07a0b801f3ac4c7c97"; };
};
}
#endif
| 1,505 | C | 25.421052 | 82 | 0.676412 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/ProjectedMapsInfo.h | #ifndef _ROS_SERVICE_ProjectedMapsInfo_h
#define _ROS_SERVICE_ProjectedMapsInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "map_msgs/ProjectedMapInfo.h"
namespace map_msgs
{
static const char PROJECTEDMAPSINFO[] = "map_msgs/ProjectedMapsInfo";
class ProjectedMapsInfoRequest : public ros::Msg
{
public:
uint32_t projected_maps_info_length;
typedef map_msgs::ProjectedMapInfo _projected_maps_info_type;
_projected_maps_info_type st_projected_maps_info;
_projected_maps_info_type * projected_maps_info;
ProjectedMapsInfoRequest():
projected_maps_info_length(0), projected_maps_info(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->projected_maps_info_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->projected_maps_info_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->projected_maps_info_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->projected_maps_info_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->projected_maps_info_length);
for( uint32_t i = 0; i < projected_maps_info_length; i++){
offset += this->projected_maps_info[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t projected_maps_info_lengthT = ((uint32_t) (*(inbuffer + offset)));
projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->projected_maps_info_length);
if(projected_maps_info_lengthT > projected_maps_info_length)
this->projected_maps_info = (map_msgs::ProjectedMapInfo*)realloc(this->projected_maps_info, projected_maps_info_lengthT * sizeof(map_msgs::ProjectedMapInfo));
projected_maps_info_length = projected_maps_info_lengthT;
for( uint32_t i = 0; i < projected_maps_info_length; i++){
offset += this->st_projected_maps_info.deserialize(inbuffer + offset);
memcpy( &(this->projected_maps_info[i]), &(this->st_projected_maps_info), sizeof(map_msgs::ProjectedMapInfo));
}
return offset;
}
const char * getType(){ return PROJECTEDMAPSINFO; };
const char * getMD5(){ return "d7980a33202421c8cd74565e57a4d229"; };
};
class ProjectedMapsInfoResponse : public ros::Msg
{
public:
ProjectedMapsInfoResponse()
{
}
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 PROJECTEDMAPSINFO; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class ProjectedMapsInfo {
public:
typedef ProjectedMapsInfoRequest Request;
typedef ProjectedMapsInfoResponse Response;
};
}
#endif
| 3,212 | C | 32.123711 | 166 | 0.647883 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/GetMapROI.h | #ifndef _ROS_SERVICE_GetMapROI_h
#define _ROS_SERVICE_GetMapROI_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/OccupancyGrid.h"
namespace map_msgs
{
static const char GETMAPROI[] = "map_msgs/GetMapROI";
class GetMapROIRequest : public ros::Msg
{
public:
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _l_x_type;
_l_x_type l_x;
typedef double _l_y_type;
_l_y_type l_y;
GetMapROIRequest():
x(0),
y(0),
l_x(0),
l_y(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_l_x;
u_l_x.real = this->l_x;
*(outbuffer + offset + 0) = (u_l_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_l_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_l_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_l_x.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_l_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_l_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_l_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_l_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->l_x);
union {
double real;
uint64_t base;
} u_l_y;
u_l_y.real = this->l_y;
*(outbuffer + offset + 0) = (u_l_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_l_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_l_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_l_y.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_l_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_l_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_l_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_l_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->l_y);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->x = u_x.real;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->y = u_y.real;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_l_x;
u_l_x.base = 0;
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->l_x = u_l_x.real;
offset += sizeof(this->l_x);
union {
double real;
uint64_t base;
} u_l_y;
u_l_y.base = 0;
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->l_y = u_l_y.real;
offset += sizeof(this->l_y);
return offset;
}
const char * getType(){ return GETMAPROI; };
const char * getMD5(){ return "43c2ff8f45af555c0eaf070c401e9a47"; };
};
class GetMapROIResponse : public ros::Msg
{
public:
typedef nav_msgs::OccupancyGrid _sub_map_type;
_sub_map_type sub_map;
GetMapROIResponse():
sub_map()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->sub_map.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->sub_map.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETMAPROI; };
const char * getMD5(){ return "4d1986519c00d81967d2891a606b234c"; };
};
class GetMapROI {
public:
typedef GetMapROIRequest Request;
typedef GetMapROIResponse Response;
};
}
#endif
| 7,264 | C | 34.439024 | 72 | 0.475358 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/GetPointMap.h | #ifndef _ROS_SERVICE_GetPointMap_h
#define _ROS_SERVICE_GetPointMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "sensor_msgs/PointCloud2.h"
namespace map_msgs
{
static const char GETPOINTMAP[] = "map_msgs/GetPointMap";
class GetPointMapRequest : public ros::Msg
{
public:
GetPointMapRequest()
{
}
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 GETPOINTMAP; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class GetPointMapResponse : public ros::Msg
{
public:
typedef sensor_msgs::PointCloud2 _map_type;
_map_type map;
GetPointMapResponse():
map()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOINTMAP; };
const char * getMD5(){ return "b84fbb39505086eb6a62d933c75cb7b4"; };
};
class GetPointMap {
public:
typedef GetPointMapRequest Request;
typedef GetPointMapResponse Response;
};
}
#endif
| 1,508 | C | 18.597402 | 72 | 0.642573 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/OccupancyGridUpdate.h | #ifndef _ROS_map_msgs_OccupancyGridUpdate_h
#define _ROS_map_msgs_OccupancyGridUpdate_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace map_msgs
{
class OccupancyGridUpdate : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef int32_t _x_type;
_x_type x;
typedef int32_t _y_type;
_y_type y;
typedef uint32_t _width_type;
_width_type width;
typedef uint32_t _height_type;
_height_type height;
uint32_t data_length;
typedef int8_t _data_type;
_data_type st_data;
_data_type * data;
OccupancyGridUpdate():
header(),
x(0),
y(0),
width(0),
height(0),
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
union {
int32_t real;
uint32_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->x);
union {
int32_t real;
uint32_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->y);
*(outbuffer + offset + 0) = (this->width >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->width >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->width >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->width >> (8 * 3)) & 0xFF;
offset += sizeof(this->width);
*(outbuffer + offset + 0) = (this->height >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->height >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->height >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->height >> (8 * 3)) & 0xFF;
offset += sizeof(this->height);
*(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++){
union {
int8_t real;
uint8_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
union {
int32_t real;
uint32_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->x = u_x.real;
offset += sizeof(this->x);
union {
int32_t real;
uint32_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->y = u_y.real;
offset += sizeof(this->y);
this->width = ((uint32_t) (*(inbuffer + offset)));
this->width |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->width |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->width |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->width);
this->height = ((uint32_t) (*(inbuffer + offset)));
this->height |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->height |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->height |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->height);
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 = (int8_t*)realloc(this->data, data_lengthT * sizeof(int8_t));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(int8_t));
}
return offset;
}
const char * getType(){ return "map_msgs/OccupancyGridUpdate"; };
const char * getMD5(){ return "b295be292b335c34718bd939deebe1c9"; };
};
}
#endif
| 5,702 | C | 35.324841 | 81 | 0.501754 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/GetPointMapROI.h | #ifndef _ROS_SERVICE_GetPointMapROI_h
#define _ROS_SERVICE_GetPointMapROI_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "sensor_msgs/PointCloud2.h"
namespace map_msgs
{
static const char GETPOINTMAPROI[] = "map_msgs/GetPointMapROI";
class GetPointMapROIRequest : public ros::Msg
{
public:
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _z_type;
_z_type z;
typedef double _r_type;
_r_type r;
typedef double _l_x_type;
_l_x_type l_x;
typedef double _l_y_type;
_l_y_type l_y;
typedef double _l_z_type;
_l_z_type l_z;
GetPointMapROIRequest():
x(0),
y(0),
z(0),
r(0),
l_x(0),
l_y(0),
l_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_z;
u_z.real = this->z;
*(outbuffer + offset + 0) = (u_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->z);
union {
double real;
uint64_t base;
} u_r;
u_r.real = this->r;
*(outbuffer + offset + 0) = (u_r.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_r.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_r.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_r.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_r.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_r.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_r.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_r.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->r);
union {
double real;
uint64_t base;
} u_l_x;
u_l_x.real = this->l_x;
*(outbuffer + offset + 0) = (u_l_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_l_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_l_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_l_x.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_l_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_l_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_l_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_l_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->l_x);
union {
double real;
uint64_t base;
} u_l_y;
u_l_y.real = this->l_y;
*(outbuffer + offset + 0) = (u_l_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_l_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_l_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_l_y.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_l_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_l_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_l_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_l_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->l_y);
union {
double real;
uint64_t base;
} u_l_z;
u_l_z.real = this->l_z;
*(outbuffer + offset + 0) = (u_l_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_l_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_l_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_l_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_l_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_l_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_l_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_l_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->l_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
double real;
uint64_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->x = u_x.real;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->y = u_y.real;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_z;
u_z.base = 0;
u_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->z = u_z.real;
offset += sizeof(this->z);
union {
double real;
uint64_t base;
} u_r;
u_r.base = 0;
u_r.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_r.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->r = u_r.real;
offset += sizeof(this->r);
union {
double real;
uint64_t base;
} u_l_x;
u_l_x.base = 0;
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_l_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->l_x = u_l_x.real;
offset += sizeof(this->l_x);
union {
double real;
uint64_t base;
} u_l_y;
u_l_y.base = 0;
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_l_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->l_y = u_l_y.real;
offset += sizeof(this->l_y);
union {
double real;
uint64_t base;
} u_l_z;
u_l_z.base = 0;
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_l_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->l_z = u_l_z.real;
offset += sizeof(this->l_z);
return offset;
}
const char * getType(){ return GETPOINTMAPROI; };
const char * getMD5(){ return "895f7e437a9a6dd225316872b187a303"; };
};
class GetPointMapROIResponse : public ros::Msg
{
public:
typedef sensor_msgs::PointCloud2 _sub_map_type;
_sub_map_type sub_map;
GetPointMapROIResponse():
sub_map()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->sub_map.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->sub_map.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return GETPOINTMAPROI; };
const char * getMD5(){ return "313769f8b0e724525c6463336cbccd63"; };
};
class GetPointMapROI {
public:
typedef GetPointMapROIRequest Request;
typedef GetPointMapROIResponse Response;
};
}
#endif
| 11,622 | C | 37.614618 | 72 | 0.462571 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/SetMapProjections.h | #ifndef _ROS_SERVICE_SetMapProjections_h
#define _ROS_SERVICE_SetMapProjections_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "map_msgs/ProjectedMapInfo.h"
namespace map_msgs
{
static const char SETMAPPROJECTIONS[] = "map_msgs/SetMapProjections";
class SetMapProjectionsRequest : public ros::Msg
{
public:
SetMapProjectionsRequest()
{
}
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 SETMAPPROJECTIONS; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SetMapProjectionsResponse : public ros::Msg
{
public:
uint32_t projected_maps_info_length;
typedef map_msgs::ProjectedMapInfo _projected_maps_info_type;
_projected_maps_info_type st_projected_maps_info;
_projected_maps_info_type * projected_maps_info;
SetMapProjectionsResponse():
projected_maps_info_length(0), projected_maps_info(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->projected_maps_info_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->projected_maps_info_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->projected_maps_info_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->projected_maps_info_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->projected_maps_info_length);
for( uint32_t i = 0; i < projected_maps_info_length; i++){
offset += this->projected_maps_info[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t projected_maps_info_lengthT = ((uint32_t) (*(inbuffer + offset)));
projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
projected_maps_info_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->projected_maps_info_length);
if(projected_maps_info_lengthT > projected_maps_info_length)
this->projected_maps_info = (map_msgs::ProjectedMapInfo*)realloc(this->projected_maps_info, projected_maps_info_lengthT * sizeof(map_msgs::ProjectedMapInfo));
projected_maps_info_length = projected_maps_info_lengthT;
for( uint32_t i = 0; i < projected_maps_info_length; i++){
offset += this->st_projected_maps_info.deserialize(inbuffer + offset);
memcpy( &(this->projected_maps_info[i]), &(this->st_projected_maps_info), sizeof(map_msgs::ProjectedMapInfo));
}
return offset;
}
const char * getType(){ return SETMAPPROJECTIONS; };
const char * getMD5(){ return "d7980a33202421c8cd74565e57a4d229"; };
};
class SetMapProjections {
public:
typedef SetMapProjectionsRequest Request;
typedef SetMapProjectionsResponse Response;
};
}
#endif
| 3,212 | C | 32.123711 | 166 | 0.647883 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_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"
#include "std_msgs/String.h"
namespace map_msgs
{
static const char SAVEMAP[] = "map_msgs/SaveMap";
class SaveMapRequest : public ros::Msg
{
public:
typedef std_msgs::String _filename_type;
_filename_type filename;
SaveMapRequest():
filename()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->filename.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->filename.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return SAVEMAP; };
const char * getMD5(){ return "716e25f9d9dc76ceba197f93cbf05dc7"; };
};
class SaveMapResponse : public ros::Msg
{
public:
SaveMapResponse()
{
}
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 SAVEMAP; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SaveMap {
public:
typedef SaveMapRequest Request;
typedef SaveMapResponse Response;
};
}
#endif
| 1,470 | C | 18.103896 | 72 | 0.633333 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/ProjectedMapInfo.h | #ifndef _ROS_map_msgs_ProjectedMapInfo_h
#define _ROS_map_msgs_ProjectedMapInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace map_msgs
{
class ProjectedMapInfo : public ros::Msg
{
public:
typedef const char* _frame_id_type;
_frame_id_type frame_id;
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _width_type;
_width_type width;
typedef double _height_type;
_height_type height;
typedef double _min_z_type;
_min_z_type min_z;
typedef double _max_z_type;
_max_z_type max_z;
ProjectedMapInfo():
frame_id(""),
x(0),
y(0),
width(0),
height(0),
min_z(0),
max_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_frame_id = strlen(this->frame_id);
varToArr(outbuffer + offset, length_frame_id);
offset += 4;
memcpy(outbuffer + offset, this->frame_id, length_frame_id);
offset += length_frame_id;
union {
double real;
uint64_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_width;
u_width.real = this->width;
*(outbuffer + offset + 0) = (u_width.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_width.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_width.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_width.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_width.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_width.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_width.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_width.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->width);
union {
double real;
uint64_t base;
} u_height;
u_height.real = this->height;
*(outbuffer + offset + 0) = (u_height.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_height.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_height.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_height.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_height.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_height.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_height.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_height.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->height);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.real = this->min_z;
*(outbuffer + offset + 0) = (u_min_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.real = this->max_z;
*(outbuffer + offset + 0) = (u_max_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_frame_id;
arrToVar(length_frame_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_frame_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_frame_id-1]=0;
this->frame_id = (char *)(inbuffer + offset-1);
offset += length_frame_id;
union {
double real;
uint64_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->x = u_x.real;
offset += sizeof(this->x);
union {
double real;
uint64_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->y = u_y.real;
offset += sizeof(this->y);
union {
double real;
uint64_t base;
} u_width;
u_width.base = 0;
u_width.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_width.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->width = u_width.real;
offset += sizeof(this->width);
union {
double real;
uint64_t base;
} u_height;
u_height.base = 0;
u_height.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_height.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->height = u_height.real;
offset += sizeof(this->height);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.base = 0;
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_z = u_min_z.real;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.base = 0;
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_z = u_max_z.real;
offset += sizeof(this->max_z);
return offset;
}
const char * getType(){ return "map_msgs/ProjectedMapInfo"; };
const char * getMD5(){ return "2dc10595ae94de23f22f8a6d2a0eef7a"; };
};
}
#endif
| 10,290 | C | 40.495968 | 74 | 0.477357 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/PointCloud2Update.h | #ifndef _ROS_map_msgs_PointCloud2Update_h
#define _ROS_map_msgs_PointCloud2Update_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "sensor_msgs/PointCloud2.h"
namespace map_msgs
{
class PointCloud2Update : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef uint32_t _type_type;
_type_type type;
typedef sensor_msgs::PointCloud2 _points_type;
_points_type points;
enum { ADD = 0 };
enum { DELETE = 1 };
PointCloud2Update():
header(),
type(0),
points()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->type >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->type >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->type >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->type >> (8 * 3)) & 0xFF;
offset += sizeof(this->type);
offset += this->points.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
this->type = ((uint32_t) (*(inbuffer + offset)));
this->type |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->type |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->type |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->type);
offset += this->points.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "map_msgs/PointCloud2Update"; };
const char * getMD5(){ return "6c58e4f249ae9cd2b24fb1ee0f99195e"; };
};
}
#endif
| 1,891 | C | 27.666666 | 72 | 0.580645 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/map_msgs/ProjectedMap.h | #ifndef _ROS_map_msgs_ProjectedMap_h
#define _ROS_map_msgs_ProjectedMap_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "nav_msgs/OccupancyGrid.h"
namespace map_msgs
{
class ProjectedMap : public ros::Msg
{
public:
typedef nav_msgs::OccupancyGrid _map_type;
_map_type map;
typedef double _min_z_type;
_min_z_type min_z;
typedef double _max_z_type;
_max_z_type max_z;
ProjectedMap():
map(),
min_z(0),
max_z(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->map.serialize(outbuffer + offset);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.real = this->min_z;
*(outbuffer + offset + 0) = (u_min_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_min_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_min_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_min_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_min_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_min_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_min_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_min_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.real = this->max_z;
*(outbuffer + offset + 0) = (u_max_z.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_max_z.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_max_z.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_max_z.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_max_z.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_max_z.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_max_z.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_max_z.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->max_z);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->map.deserialize(inbuffer + offset);
union {
double real;
uint64_t base;
} u_min_z;
u_min_z.base = 0;
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_min_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->min_z = u_min_z.real;
offset += sizeof(this->min_z);
union {
double real;
uint64_t base;
} u_max_z;
u_max_z.base = 0;
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_max_z.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->max_z = u_max_z.real;
offset += sizeof(this->max_z);
return offset;
}
const char * getType(){ return "map_msgs/ProjectedMap"; };
const char * getMD5(){ return "7bbe8f96e45089681dc1ea7d023cbfca"; };
};
}
#endif
| 3,929 | C | 35.055046 | 73 | 0.4958 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/base_local_planner/Position2DInt.h | #ifndef _ROS_base_local_planner_Position2DInt_h
#define _ROS_base_local_planner_Position2DInt_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace base_local_planner
{
class Position2DInt : public ros::Msg
{
public:
typedef int64_t _x_type;
_x_type x;
typedef int64_t _y_type;
_y_type y;
Position2DInt():
x(0),
y(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_x;
u_x.real = this->x;
*(outbuffer + offset + 0) = (u_x.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_x.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_x.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_x.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_x.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_x.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_x.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_x.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->x);
union {
int64_t real;
uint64_t base;
} u_y;
u_y.real = this->y;
*(outbuffer + offset + 0) = (u_y.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_y.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_y.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_y.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_y.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_y.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_y.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_y.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->y);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_x;
u_x.base = 0;
u_x.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_x.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->x = u_x.real;
offset += sizeof(this->x);
union {
int64_t real;
uint64_t base;
} u_y;
u_y.base = 0;
u_y.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_y.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->y = u_y.real;
offset += sizeof(this->y);
return offset;
}
const char * getType(){ return "base_local_planner/Position2DInt"; };
const char * getMD5(){ return "3b834ede922a0fff22c43585c533b49f"; };
};
}
#endif
| 3,514 | C | 33.126213 | 73 | 0.473819 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/KeyValue.h | #ifndef _ROS_diagnostic_msgs_KeyValue_h
#define _ROS_diagnostic_msgs_KeyValue_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace diagnostic_msgs
{
class KeyValue : public ros::Msg
{
public:
typedef const char* _key_type;
_key_type key;
typedef const char* _value_type;
_value_type value;
KeyValue():
key(""),
value("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_key = strlen(this->key);
varToArr(outbuffer + offset, length_key);
offset += 4;
memcpy(outbuffer + offset, this->key, length_key);
offset += length_key;
uint32_t length_value = strlen(this->value);
varToArr(outbuffer + offset, length_value);
offset += 4;
memcpy(outbuffer + offset, this->value, length_value);
offset += length_value;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_key;
arrToVar(length_key, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_key; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_key-1]=0;
this->key = (char *)(inbuffer + offset-1);
offset += length_key;
uint32_t length_value;
arrToVar(length_value, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_value; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_value-1]=0;
this->value = (char *)(inbuffer + offset-1);
offset += length_value;
return offset;
}
const char * getType(){ return "diagnostic_msgs/KeyValue"; };
const char * getMD5(){ return "cf57fdc6617a881a88c16e768132149c"; };
};
}
#endif
| 1,861 | C | 24.506849 | 72 | 0.597528 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/DiagnosticArray.h | #ifndef _ROS_diagnostic_msgs_DiagnosticArray_h
#define _ROS_diagnostic_msgs_DiagnosticArray_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "diagnostic_msgs/DiagnosticStatus.h"
namespace diagnostic_msgs
{
class DiagnosticArray : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
uint32_t status_length;
typedef diagnostic_msgs::DiagnosticStatus _status_type;
_status_type st_status;
_status_type * status;
DiagnosticArray():
header(),
status_length(0), status(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
*(outbuffer + offset + 0) = (this->status_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->status_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->status_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->status_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->status_length);
for( uint32_t i = 0; i < status_length; i++){
offset += this->status[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t status_lengthT = ((uint32_t) (*(inbuffer + offset)));
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->status_length);
if(status_lengthT > status_length)
this->status = (diagnostic_msgs::DiagnosticStatus*)realloc(this->status, status_lengthT * sizeof(diagnostic_msgs::DiagnosticStatus));
status_length = status_lengthT;
for( uint32_t i = 0; i < status_length; i++){
offset += this->st_status.deserialize(inbuffer + offset);
memcpy( &(this->status[i]), &(this->st_status), sizeof(diagnostic_msgs::DiagnosticStatus));
}
return offset;
}
const char * getType(){ return "diagnostic_msgs/DiagnosticArray"; };
const char * getMD5(){ return "60810da900de1dd6ddd437c3503511da"; };
};
}
#endif
| 2,416 | C | 33.042253 | 141 | 0.613825 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/DiagnosticStatus.h | #ifndef _ROS_diagnostic_msgs_DiagnosticStatus_h
#define _ROS_diagnostic_msgs_DiagnosticStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "diagnostic_msgs/KeyValue.h"
namespace diagnostic_msgs
{
class DiagnosticStatus : public ros::Msg
{
public:
typedef int8_t _level_type;
_level_type level;
typedef const char* _name_type;
_name_type name;
typedef const char* _message_type;
_message_type message;
typedef const char* _hardware_id_type;
_hardware_id_type hardware_id;
uint32_t values_length;
typedef diagnostic_msgs::KeyValue _values_type;
_values_type st_values;
_values_type * values;
enum { OK = 0 };
enum { WARN = 1 };
enum { ERROR = 2 };
enum { STALE = 3 };
DiagnosticStatus():
level(0),
name(""),
message(""),
hardware_id(""),
values_length(0), values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
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_message = strlen(this->message);
varToArr(outbuffer + offset, length_message);
offset += 4;
memcpy(outbuffer + offset, this->message, length_message);
offset += length_message;
uint32_t length_hardware_id = strlen(this->hardware_id);
varToArr(outbuffer + offset, length_hardware_id);
offset += 4;
memcpy(outbuffer + offset, this->hardware_id, length_hardware_id);
offset += length_hardware_id;
*(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++){
offset += this->values[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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_message;
arrToVar(length_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message-1]=0;
this->message = (char *)(inbuffer + offset-1);
offset += length_message;
uint32_t length_hardware_id;
arrToVar(length_hardware_id, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_hardware_id; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_hardware_id-1]=0;
this->hardware_id = (char *)(inbuffer + offset-1);
offset += length_hardware_id;
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 = (diagnostic_msgs::KeyValue*)realloc(this->values, values_lengthT * sizeof(diagnostic_msgs::KeyValue));
values_length = values_lengthT;
for( uint32_t i = 0; i < values_length; i++){
offset += this->st_values.deserialize(inbuffer + offset);
memcpy( &(this->values[i]), &(this->st_values), sizeof(diagnostic_msgs::KeyValue));
}
return offset;
}
const char * getType(){ return "diagnostic_msgs/DiagnosticStatus"; };
const char * getMD5(){ return "d0ce08bc6e5ba34c7754f563a9cabaf1"; };
};
}
#endif
| 4,751 | C | 33.434782 | 125 | 0.584719 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/AddDiagnostics.h | #ifndef _ROS_SERVICE_AddDiagnostics_h
#define _ROS_SERVICE_AddDiagnostics_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace diagnostic_msgs
{
static const char ADDDIAGNOSTICS[] = "diagnostic_msgs/AddDiagnostics";
class AddDiagnosticsRequest : public ros::Msg
{
public:
typedef const char* _load_namespace_type;
_load_namespace_type load_namespace;
AddDiagnosticsRequest():
load_namespace("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_load_namespace = strlen(this->load_namespace);
varToArr(outbuffer + offset, length_load_namespace);
offset += 4;
memcpy(outbuffer + offset, this->load_namespace, length_load_namespace);
offset += length_load_namespace;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_load_namespace;
arrToVar(length_load_namespace, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_load_namespace; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_load_namespace-1]=0;
this->load_namespace = (char *)(inbuffer + offset-1);
offset += length_load_namespace;
return offset;
}
const char * getType(){ return ADDDIAGNOSTICS; };
const char * getMD5(){ return "c26cf6e164288fbc6050d74f838bcdf0"; };
};
class AddDiagnosticsResponse : public ros::Msg
{
public:
typedef bool _success_type;
_success_type success;
typedef const char* _message_type;
_message_type message;
AddDiagnosticsResponse():
success(0),
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_message = strlen(this->message);
varToArr(outbuffer + offset, length_message);
offset += 4;
memcpy(outbuffer + offset, this->message, length_message);
offset += length_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_message;
arrToVar(length_message, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message-1]=0;
this->message = (char *)(inbuffer + offset-1);
offset += length_message;
return offset;
}
const char * getType(){ return ADDDIAGNOSTICS; };
const char * getMD5(){ return "937c9679a518e3a18d831e57125ea522"; };
};
class AddDiagnostics {
public:
typedef AddDiagnosticsRequest Request;
typedef AddDiagnosticsResponse Response;
};
}
#endif
| 3,299 | C | 25.829268 | 78 | 0.619582 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/diagnostic_msgs/SelfTest.h | #ifndef _ROS_SERVICE_SelfTest_h
#define _ROS_SERVICE_SelfTest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "diagnostic_msgs/DiagnosticStatus.h"
namespace diagnostic_msgs
{
static const char SELFTEST[] = "diagnostic_msgs/SelfTest";
class SelfTestRequest : public ros::Msg
{
public:
SelfTestRequest()
{
}
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 SELFTEST; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class SelfTestResponse : public ros::Msg
{
public:
typedef const char* _id_type;
_id_type id;
typedef int8_t _passed_type;
_passed_type passed;
uint32_t status_length;
typedef diagnostic_msgs::DiagnosticStatus _status_type;
_status_type st_status;
_status_type * status;
SelfTestResponse():
id(""),
passed(0),
status_length(0), status(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_id = strlen(this->id);
varToArr(outbuffer + offset, length_id);
offset += 4;
memcpy(outbuffer + offset, this->id, length_id);
offset += length_id;
union {
int8_t real;
uint8_t base;
} u_passed;
u_passed.real = this->passed;
*(outbuffer + offset + 0) = (u_passed.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->passed);
*(outbuffer + offset + 0) = (this->status_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->status_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->status_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->status_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->status_length);
for( uint32_t i = 0; i < status_length; i++){
offset += this->status[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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;
union {
int8_t real;
uint8_t base;
} u_passed;
u_passed.base = 0;
u_passed.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->passed = u_passed.real;
offset += sizeof(this->passed);
uint32_t status_lengthT = ((uint32_t) (*(inbuffer + offset)));
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
status_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->status_length);
if(status_lengthT > status_length)
this->status = (diagnostic_msgs::DiagnosticStatus*)realloc(this->status, status_lengthT * sizeof(diagnostic_msgs::DiagnosticStatus));
status_length = status_lengthT;
for( uint32_t i = 0; i < status_length; i++){
offset += this->st_status.deserialize(inbuffer + offset);
memcpy( &(this->status[i]), &(this->st_status), sizeof(diagnostic_msgs::DiagnosticStatus));
}
return offset;
}
const char * getType(){ return SELFTEST; };
const char * getMD5(){ return "ac21b1bab7ab17546986536c22eb34e9"; };
};
class SelfTest {
public:
typedef SelfTestRequest Request;
typedef SelfTestResponse Response;
};
}
#endif
| 3,860 | C | 28.25 | 141 | 0.585751 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/RequestMessageInfo.h | #ifndef _ROS_SERVICE_RequestMessageInfo_h
#define _ROS_SERVICE_RequestMessageInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
static const char REQUESTMESSAGEINFO[] = "rosserial_msgs/RequestMessageInfo";
class RequestMessageInfoRequest : public ros::Msg
{
public:
typedef const char* _type_type;
_type_type type;
RequestMessageInfoRequest():
type("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_type = strlen(this->type);
varToArr(outbuffer + offset, length_type);
offset += 4;
memcpy(outbuffer + offset, this->type, length_type);
offset += length_type;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_type;
arrToVar(length_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_type-1]=0;
this->type = (char *)(inbuffer + offset-1);
offset += length_type;
return offset;
}
const char * getType(){ return REQUESTMESSAGEINFO; };
const char * getMD5(){ return "dc67331de85cf97091b7d45e5c64ab75"; };
};
class RequestMessageInfoResponse : public ros::Msg
{
public:
typedef const char* _md5_type;
_md5_type md5;
typedef const char* _definition_type;
_definition_type definition;
RequestMessageInfoResponse():
md5(""),
definition("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_md5 = strlen(this->md5);
varToArr(outbuffer + offset, length_md5);
offset += 4;
memcpy(outbuffer + offset, this->md5, length_md5);
offset += length_md5;
uint32_t length_definition = strlen(this->definition);
varToArr(outbuffer + offset, length_definition);
offset += 4;
memcpy(outbuffer + offset, this->definition, length_definition);
offset += length_definition;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_md5;
arrToVar(length_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_md5-1]=0;
this->md5 = (char *)(inbuffer + offset-1);
offset += length_md5;
uint32_t length_definition;
arrToVar(length_definition, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_definition; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_definition-1]=0;
this->definition = (char *)(inbuffer + offset-1);
offset += length_definition;
return offset;
}
const char * getType(){ return REQUESTMESSAGEINFO; };
const char * getMD5(){ return "fe452186a069bed40f09b8628fe5eac8"; };
};
class RequestMessageInfo {
public:
typedef RequestMessageInfoRequest Request;
typedef RequestMessageInfoResponse Response;
};
}
#endif
| 3,273 | C | 25.836065 | 77 | 0.62542 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/TopicInfo.h | #ifndef _ROS_rosserial_msgs_TopicInfo_h
#define _ROS_rosserial_msgs_TopicInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
class TopicInfo : public ros::Msg
{
public:
typedef uint16_t _topic_id_type;
_topic_id_type topic_id;
typedef const char* _topic_name_type;
_topic_name_type topic_name;
typedef const char* _message_type_type;
_message_type_type message_type;
typedef const char* _md5sum_type;
_md5sum_type md5sum;
typedef int32_t _buffer_size_type;
_buffer_size_type buffer_size;
enum { ID_PUBLISHER = 0 };
enum { ID_SUBSCRIBER = 1 };
enum { ID_SERVICE_SERVER = 2 };
enum { ID_SERVICE_CLIENT = 4 };
enum { ID_PARAMETER_REQUEST = 6 };
enum { ID_LOG = 7 };
enum { ID_TIME = 10 };
enum { ID_TX_STOP = 11 };
TopicInfo():
topic_id(0),
topic_name(""),
message_type(""),
md5sum(""),
buffer_size(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->topic_id >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->topic_id >> (8 * 1)) & 0xFF;
offset += sizeof(this->topic_id);
uint32_t length_topic_name = strlen(this->topic_name);
varToArr(outbuffer + offset, length_topic_name);
offset += 4;
memcpy(outbuffer + offset, this->topic_name, length_topic_name);
offset += length_topic_name;
uint32_t length_message_type = strlen(this->message_type);
varToArr(outbuffer + offset, length_message_type);
offset += 4;
memcpy(outbuffer + offset, this->message_type, length_message_type);
offset += length_message_type;
uint32_t length_md5sum = strlen(this->md5sum);
varToArr(outbuffer + offset, length_md5sum);
offset += 4;
memcpy(outbuffer + offset, this->md5sum, length_md5sum);
offset += length_md5sum;
union {
int32_t real;
uint32_t base;
} u_buffer_size;
u_buffer_size.real = this->buffer_size;
*(outbuffer + offset + 0) = (u_buffer_size.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_buffer_size.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_buffer_size.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_buffer_size.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->buffer_size);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->topic_id = ((uint16_t) (*(inbuffer + offset)));
this->topic_id |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
offset += sizeof(this->topic_id);
uint32_t length_topic_name;
arrToVar(length_topic_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_topic_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_topic_name-1]=0;
this->topic_name = (char *)(inbuffer + offset-1);
offset += length_topic_name;
uint32_t length_message_type;
arrToVar(length_message_type, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_message_type; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_message_type-1]=0;
this->message_type = (char *)(inbuffer + offset-1);
offset += length_message_type;
uint32_t length_md5sum;
arrToVar(length_md5sum, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_md5sum; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_md5sum-1]=0;
this->md5sum = (char *)(inbuffer + offset-1);
offset += length_md5sum;
union {
int32_t real;
uint32_t base;
} u_buffer_size;
u_buffer_size.base = 0;
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_buffer_size.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->buffer_size = u_buffer_size.real;
offset += sizeof(this->buffer_size);
return offset;
}
const char * getType(){ return "rosserial_msgs/TopicInfo"; };
const char * getMD5(){ return "0ad51f88fc44892f8c10684077646005"; };
};
}
#endif
| 4,530 | C | 33.587786 | 79 | 0.577042 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/RequestParam.h | #ifndef _ROS_SERVICE_RequestParam_h
#define _ROS_SERVICE_RequestParam_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
static const char REQUESTPARAM[] = "rosserial_msgs/RequestParam";
class RequestParamRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
RequestParamRequest():
name("")
{
}
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;
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;
return offset;
}
const char * getType(){ return REQUESTPARAM; };
const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
};
class RequestParamResponse : public ros::Msg
{
public:
uint32_t ints_length;
typedef int32_t _ints_type;
_ints_type st_ints;
_ints_type * ints;
uint32_t floats_length;
typedef float _floats_type;
_floats_type st_floats;
_floats_type * floats;
uint32_t strings_length;
typedef char* _strings_type;
_strings_type st_strings;
_strings_type * strings;
RequestParamResponse():
ints_length(0), ints(NULL),
floats_length(0), floats(NULL),
strings_length(0), strings(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->ints_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->ints_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->ints_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->ints_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->ints_length);
for( uint32_t i = 0; i < ints_length; i++){
union {
int32_t real;
uint32_t base;
} u_intsi;
u_intsi.real = this->ints[i];
*(outbuffer + offset + 0) = (u_intsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_intsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_intsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_intsi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->ints[i]);
}
*(outbuffer + offset + 0) = (this->floats_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->floats_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->floats_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->floats_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->floats_length);
for( uint32_t i = 0; i < floats_length; i++){
union {
float real;
uint32_t base;
} u_floatsi;
u_floatsi.real = this->floats[i];
*(outbuffer + offset + 0) = (u_floatsi.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_floatsi.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_floatsi.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_floatsi.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->floats[i]);
}
*(outbuffer + offset + 0) = (this->strings_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->strings_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->strings_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->strings_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->strings_length);
for( uint32_t i = 0; i < strings_length; i++){
uint32_t length_stringsi = strlen(this->strings[i]);
varToArr(outbuffer + offset, length_stringsi);
offset += 4;
memcpy(outbuffer + offset, this->strings[i], length_stringsi);
offset += length_stringsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t ints_lengthT = ((uint32_t) (*(inbuffer + offset)));
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
ints_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->ints_length);
if(ints_lengthT > ints_length)
this->ints = (int32_t*)realloc(this->ints, ints_lengthT * sizeof(int32_t));
ints_length = ints_lengthT;
for( uint32_t i = 0; i < ints_length; i++){
union {
int32_t real;
uint32_t base;
} u_st_ints;
u_st_ints.base = 0;
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_ints = u_st_ints.real;
offset += sizeof(this->st_ints);
memcpy( &(this->ints[i]), &(this->st_ints), sizeof(int32_t));
}
uint32_t floats_lengthT = ((uint32_t) (*(inbuffer + offset)));
floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
floats_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->floats_length);
if(floats_lengthT > floats_length)
this->floats = (float*)realloc(this->floats, floats_lengthT * sizeof(float));
floats_length = floats_lengthT;
for( uint32_t i = 0; i < floats_length; i++){
union {
float real;
uint32_t base;
} u_st_floats;
u_st_floats.base = 0;
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_floats = u_st_floats.real;
offset += sizeof(this->st_floats);
memcpy( &(this->floats[i]), &(this->st_floats), sizeof(float));
}
uint32_t strings_lengthT = ((uint32_t) (*(inbuffer + offset)));
strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
strings_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->strings_length);
if(strings_lengthT > strings_length)
this->strings = (char**)realloc(this->strings, strings_lengthT * sizeof(char*));
strings_length = strings_lengthT;
for( uint32_t i = 0; i < strings_length; i++){
uint32_t length_st_strings;
arrToVar(length_st_strings, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_strings; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_strings-1]=0;
this->st_strings = (char *)(inbuffer + offset-1);
offset += length_st_strings;
memcpy( &(this->strings[i]), &(this->st_strings), sizeof(char*));
}
return offset;
}
const char * getType(){ return REQUESTPARAM; };
const char * getMD5(){ return "9f0e98bda65981986ddf53afa7a40e49"; };
};
class RequestParam {
public:
typedef RequestParamRequest Request;
typedef RequestParamResponse Response;
};
}
#endif
| 7,948 | C | 36.319249 | 88 | 0.551963 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/Log.h | #ifndef _ROS_rosserial_msgs_Log_h
#define _ROS_rosserial_msgs_Log_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
class Log : public ros::Msg
{
public:
typedef uint8_t _level_type;
_level_type level;
typedef const char* _msg_type;
_msg_type msg;
enum { ROSDEBUG = 0 };
enum { INFO = 1 };
enum { WARN = 2 };
enum { ERROR = 3 };
enum { FATAL = 4 };
Log():
level(0),
msg("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->level >> (8 * 0)) & 0xFF;
offset += sizeof(this->level);
uint32_t length_msg = strlen(this->msg);
varToArr(outbuffer + offset, length_msg);
offset += 4;
memcpy(outbuffer + offset, this->msg, length_msg);
offset += length_msg;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->level = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->level);
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;
return offset;
}
const char * getType(){ return "rosserial_msgs/Log"; };
const char * getMD5(){ return "11abd731c25933261cd6183bd12d6295"; };
};
}
#endif
| 1,615 | C | 22.764706 | 72 | 0.565325 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rosserial_msgs/RequestServiceInfo.h | #ifndef _ROS_SERVICE_RequestServiceInfo_h
#define _ROS_SERVICE_RequestServiceInfo_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rosserial_msgs
{
static const char REQUESTSERVICEINFO[] = "rosserial_msgs/RequestServiceInfo";
class RequestServiceInfoRequest : public ros::Msg
{
public:
typedef const char* _service_type;
_service_type service;
RequestServiceInfoRequest():
service("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_service = strlen(this->service);
varToArr(outbuffer + offset, length_service);
offset += 4;
memcpy(outbuffer + offset, this->service, length_service);
offset += length_service;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_service;
arrToVar(length_service, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_service; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_service-1]=0;
this->service = (char *)(inbuffer + offset-1);
offset += length_service;
return offset;
}
const char * getType(){ return REQUESTSERVICEINFO; };
const char * getMD5(){ return "1cbcfa13b08f6d36710b9af8741e6112"; };
};
class RequestServiceInfoResponse : public ros::Msg
{
public:
typedef const char* _service_md5_type;
_service_md5_type service_md5;
typedef const char* _request_md5_type;
_request_md5_type request_md5;
typedef const char* _response_md5_type;
_response_md5_type response_md5;
RequestServiceInfoResponse():
service_md5(""),
request_md5(""),
response_md5("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_service_md5 = strlen(this->service_md5);
varToArr(outbuffer + offset, length_service_md5);
offset += 4;
memcpy(outbuffer + offset, this->service_md5, length_service_md5);
offset += length_service_md5;
uint32_t length_request_md5 = strlen(this->request_md5);
varToArr(outbuffer + offset, length_request_md5);
offset += 4;
memcpy(outbuffer + offset, this->request_md5, length_request_md5);
offset += length_request_md5;
uint32_t length_response_md5 = strlen(this->response_md5);
varToArr(outbuffer + offset, length_response_md5);
offset += 4;
memcpy(outbuffer + offset, this->response_md5, length_response_md5);
offset += length_response_md5;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_service_md5;
arrToVar(length_service_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_service_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_service_md5-1]=0;
this->service_md5 = (char *)(inbuffer + offset-1);
offset += length_service_md5;
uint32_t length_request_md5;
arrToVar(length_request_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_request_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_request_md5-1]=0;
this->request_md5 = (char *)(inbuffer + offset-1);
offset += length_request_md5;
uint32_t length_response_md5;
arrToVar(length_response_md5, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_response_md5; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_response_md5-1]=0;
this->response_md5 = (char *)(inbuffer + offset-1);
offset += length_response_md5;
return offset;
}
const char * getType(){ return REQUESTSERVICEINFO; };
const char * getMD5(){ return "c3d6dd25b909596479fbbc6559fa6874"; };
};
class RequestServiceInfo {
public:
typedef RequestServiceInfoRequest Request;
typedef RequestServiceInfoResponse Response;
};
}
#endif
| 4,199 | C | 29.215827 | 77 | 0.635389 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisGoal_h
#define _ROS_flexbe_msgs_BehaviorSynthesisGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/SynthesisRequest.h"
namespace flexbe_msgs
{
class BehaviorSynthesisGoal : public ros::Msg
{
public:
typedef flexbe_msgs::SynthesisRequest _request_type;
_request_type request;
BehaviorSynthesisGoal():
request()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->request.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->request.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisGoal"; };
const char * getMD5(){ return "64ccf8fdad6091a950ca099bc67e6595"; };
};
}
#endif
| 968 | C | 20.533333 | 74 | 0.670455 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputActionResult.h | #ifndef _ROS_flexbe_msgs_BehaviorInputActionResult_h
#define _ROS_flexbe_msgs_BehaviorInputActionResult_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 "flexbe_msgs/BehaviorInputResult.h"
namespace flexbe_msgs
{
class BehaviorInputActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorInputResult _result_type;
_result_type result;
BehaviorInputActionResult():
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 "flexbe_msgs/BehaviorInputActionResult"; };
const char * getMD5(){ return "fbfb06b1b74139caf57e6c1834fe58bc"; };
};
}
#endif
| 1,484 | C | 25.052631 | 78 | 0.671833 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisFeedback_h
#define _ROS_flexbe_msgs_BehaviorSynthesisFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorSynthesisFeedback : public ros::Msg
{
public:
typedef const char* _status_type;
_status_type status;
typedef float _progress_type;
_progress_type progress;
BehaviorSynthesisFeedback():
status(""),
progress(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_status = strlen(this->status);
varToArr(outbuffer + offset, length_status);
offset += 4;
memcpy(outbuffer + offset, this->status, length_status);
offset += length_status;
union {
float real;
uint32_t base;
} u_progress;
u_progress.real = this->progress;
*(outbuffer + offset + 0) = (u_progress.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_progress.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_progress.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_progress.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->progress);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_status;
arrToVar(length_status, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_status; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_status-1]=0;
this->status = (char *)(inbuffer + offset-1);
offset += length_status;
union {
float real;
uint32_t base;
} u_progress;
u_progress.base = 0;
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_progress.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->progress = u_progress.real;
offset += sizeof(this->progress);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisFeedback"; };
const char * getMD5(){ return "ce404b6cabcba81b67a4c8bac81c05d3"; };
};
}
#endif
| 2,375 | C | 28.7 | 78 | 0.583158 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputActionFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorInputActionFeedback_h
#define _ROS_flexbe_msgs_BehaviorInputActionFeedback_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 "flexbe_msgs/BehaviorInputFeedback.h"
namespace flexbe_msgs
{
class BehaviorInputActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorInputFeedback _feedback_type;
_feedback_type feedback;
BehaviorInputActionFeedback():
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 "flexbe_msgs/BehaviorInputActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
| 1,510 | C | 25.508771 | 80 | 0.677483 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionGoal_h
#define _ROS_flexbe_msgs_BehaviorExecutionGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorExecutionGoal : public ros::Msg
{
public:
typedef const char* _behavior_name_type;
_behavior_name_type behavior_name;
uint32_t arg_keys_length;
typedef char* _arg_keys_type;
_arg_keys_type st_arg_keys;
_arg_keys_type * arg_keys;
uint32_t arg_values_length;
typedef char* _arg_values_type;
_arg_values_type st_arg_values;
_arg_values_type * arg_values;
uint32_t input_keys_length;
typedef char* _input_keys_type;
_input_keys_type st_input_keys;
_input_keys_type * input_keys;
uint32_t input_values_length;
typedef char* _input_values_type;
_input_values_type st_input_values;
_input_values_type * input_values;
BehaviorExecutionGoal():
behavior_name(""),
arg_keys_length(0), arg_keys(NULL),
arg_values_length(0), arg_values(NULL),
input_keys_length(0), input_keys(NULL),
input_values_length(0), input_values(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_behavior_name = strlen(this->behavior_name);
varToArr(outbuffer + offset, length_behavior_name);
offset += 4;
memcpy(outbuffer + offset, this->behavior_name, length_behavior_name);
offset += length_behavior_name;
*(outbuffer + offset + 0) = (this->arg_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_keys_length);
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_arg_keysi = strlen(this->arg_keys[i]);
varToArr(outbuffer + offset, length_arg_keysi);
offset += 4;
memcpy(outbuffer + offset, this->arg_keys[i], length_arg_keysi);
offset += length_arg_keysi;
}
*(outbuffer + offset + 0) = (this->arg_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_values_length);
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_arg_valuesi = strlen(this->arg_values[i]);
varToArr(outbuffer + offset, length_arg_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->arg_values[i], length_arg_valuesi);
offset += length_arg_valuesi;
}
*(outbuffer + offset + 0) = (this->input_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_keys_length);
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_input_keysi = strlen(this->input_keys[i]);
varToArr(outbuffer + offset, length_input_keysi);
offset += 4;
memcpy(outbuffer + offset, this->input_keys[i], length_input_keysi);
offset += length_input_keysi;
}
*(outbuffer + offset + 0) = (this->input_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_values_length);
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_input_valuesi = strlen(this->input_values[i]);
varToArr(outbuffer + offset, length_input_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->input_values[i], length_input_valuesi);
offset += length_input_valuesi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_behavior_name;
arrToVar(length_behavior_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_behavior_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_behavior_name-1]=0;
this->behavior_name = (char *)(inbuffer + offset-1);
offset += length_behavior_name;
uint32_t arg_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_keys_length);
if(arg_keys_lengthT > arg_keys_length)
this->arg_keys = (char**)realloc(this->arg_keys, arg_keys_lengthT * sizeof(char*));
arg_keys_length = arg_keys_lengthT;
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_st_arg_keys;
arrToVar(length_st_arg_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_keys-1]=0;
this->st_arg_keys = (char *)(inbuffer + offset-1);
offset += length_st_arg_keys;
memcpy( &(this->arg_keys[i]), &(this->st_arg_keys), sizeof(char*));
}
uint32_t arg_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_values_length);
if(arg_values_lengthT > arg_values_length)
this->arg_values = (char**)realloc(this->arg_values, arg_values_lengthT * sizeof(char*));
arg_values_length = arg_values_lengthT;
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_st_arg_values;
arrToVar(length_st_arg_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_values-1]=0;
this->st_arg_values = (char *)(inbuffer + offset-1);
offset += length_st_arg_values;
memcpy( &(this->arg_values[i]), &(this->st_arg_values), sizeof(char*));
}
uint32_t input_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_keys_length);
if(input_keys_lengthT > input_keys_length)
this->input_keys = (char**)realloc(this->input_keys, input_keys_lengthT * sizeof(char*));
input_keys_length = input_keys_lengthT;
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_st_input_keys;
arrToVar(length_st_input_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_keys-1]=0;
this->st_input_keys = (char *)(inbuffer + offset-1);
offset += length_st_input_keys;
memcpy( &(this->input_keys[i]), &(this->st_input_keys), sizeof(char*));
}
uint32_t input_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_values_length);
if(input_values_lengthT > input_values_length)
this->input_values = (char**)realloc(this->input_values, input_values_lengthT * sizeof(char*));
input_values_length = input_values_lengthT;
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_st_input_values;
arrToVar(length_st_input_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_values-1]=0;
this->st_input_values = (char *)(inbuffer + offset-1);
offset += length_st_input_values;
memcpy( &(this->input_values[i]), &(this->st_input_values), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionGoal"; };
const char * getMD5(){ return "448c2298fe3c13b6fd73cfc07e865a14"; };
};
}
#endif
| 9,264 | C | 44.416666 | 103 | 0.588515 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/SynthesisRequest.h | #ifndef _ROS_flexbe_msgs_SynthesisRequest_h
#define _ROS_flexbe_msgs_SynthesisRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class SynthesisRequest : public ros::Msg
{
public:
typedef const char* _name_type;
_name_type name;
typedef const char* _system_type;
_system_type system;
typedef const char* _goal_type;
_goal_type goal;
typedef const char* _initial_condition_type;
_initial_condition_type initial_condition;
uint32_t sm_outcomes_length;
typedef char* _sm_outcomes_type;
_sm_outcomes_type st_sm_outcomes;
_sm_outcomes_type * sm_outcomes;
SynthesisRequest():
name(""),
system(""),
goal(""),
initial_condition(""),
sm_outcomes_length(0), sm_outcomes(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;
uint32_t length_system = strlen(this->system);
varToArr(outbuffer + offset, length_system);
offset += 4;
memcpy(outbuffer + offset, this->system, length_system);
offset += length_system;
uint32_t length_goal = strlen(this->goal);
varToArr(outbuffer + offset, length_goal);
offset += 4;
memcpy(outbuffer + offset, this->goal, length_goal);
offset += length_goal;
uint32_t length_initial_condition = strlen(this->initial_condition);
varToArr(outbuffer + offset, length_initial_condition);
offset += 4;
memcpy(outbuffer + offset, this->initial_condition, length_initial_condition);
offset += length_initial_condition;
*(outbuffer + offset + 0) = (this->sm_outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->sm_outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->sm_outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->sm_outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->sm_outcomes_length);
for( uint32_t i = 0; i < sm_outcomes_length; i++){
uint32_t length_sm_outcomesi = strlen(this->sm_outcomes[i]);
varToArr(outbuffer + offset, length_sm_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->sm_outcomes[i], length_sm_outcomesi);
offset += length_sm_outcomesi;
}
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_system;
arrToVar(length_system, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_system; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_system-1]=0;
this->system = (char *)(inbuffer + offset-1);
offset += length_system;
uint32_t length_goal;
arrToVar(length_goal, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_goal; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_goal-1]=0;
this->goal = (char *)(inbuffer + offset-1);
offset += length_goal;
uint32_t length_initial_condition;
arrToVar(length_initial_condition, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_initial_condition; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_initial_condition-1]=0;
this->initial_condition = (char *)(inbuffer + offset-1);
offset += length_initial_condition;
uint32_t sm_outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
sm_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
sm_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
sm_outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->sm_outcomes_length);
if(sm_outcomes_lengthT > sm_outcomes_length)
this->sm_outcomes = (char**)realloc(this->sm_outcomes, sm_outcomes_lengthT * sizeof(char*));
sm_outcomes_length = sm_outcomes_lengthT;
for( uint32_t i = 0; i < sm_outcomes_length; i++){
uint32_t length_st_sm_outcomes;
arrToVar(length_st_sm_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_sm_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_sm_outcomes-1]=0;
this->st_sm_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_sm_outcomes;
memcpy( &(this->sm_outcomes[i]), &(this->st_sm_outcomes), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/SynthesisRequest"; };
const char * getMD5(){ return "99257dbfe8a196d006a75837dcabf3f6"; };
};
}
#endif
| 5,332 | C | 36.034722 | 100 | 0.605214 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/SynthesisErrorCodes.h | #ifndef _ROS_flexbe_msgs_SynthesisErrorCodes_h
#define _ROS_flexbe_msgs_SynthesisErrorCodes_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class SynthesisErrorCodes : public ros::Msg
{
public:
typedef int32_t _value_type;
_value_type value;
enum { SUCCESS = 1 };
SynthesisErrorCodes():
value(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_value;
u_value.real = this->value;
*(outbuffer + offset + 0) = (u_value.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_value.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_value.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_value.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->value);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_value;
u_value.base = 0;
u_value.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_value.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->value = u_value.real;
offset += sizeof(this->value);
return offset;
}
const char * getType(){ return "flexbe_msgs/SynthesisErrorCodes"; };
const char * getMD5(){ return "64e05da1f86a12ce44b1cca74395bd4e"; };
};
}
#endif
| 1,679 | C | 25.25 | 73 | 0.551519 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorInputGoal_h
#define _ROS_flexbe_msgs_BehaviorInputGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorInputGoal : public ros::Msg
{
public:
typedef uint8_t _request_type_type;
_request_type_type request_type;
typedef const char* _msg_type;
_msg_type msg;
BehaviorInputGoal():
request_type(0),
msg("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->request_type >> (8 * 0)) & 0xFF;
offset += sizeof(this->request_type);
uint32_t length_msg = strlen(this->msg);
varToArr(outbuffer + offset, length_msg);
offset += 4;
memcpy(outbuffer + offset, this->msg, length_msg);
offset += length_msg;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->request_type = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->request_type);
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;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputGoal"; };
const char * getMD5(){ return "724150348fd57a5ebc07765871d3f316"; };
};
}
#endif
| 1,598 | C | 24.380952 | 73 | 0.605757 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorModification.h | #ifndef _ROS_flexbe_msgs_BehaviorModification_h
#define _ROS_flexbe_msgs_BehaviorModification_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorModification : public ros::Msg
{
public:
typedef int32_t _index_begin_type;
_index_begin_type index_begin;
typedef int32_t _index_end_type;
_index_end_type index_end;
typedef const char* _new_content_type;
_new_content_type new_content;
BehaviorModification():
index_begin(0),
index_end(0),
new_content("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_index_begin;
u_index_begin.real = this->index_begin;
*(outbuffer + offset + 0) = (u_index_begin.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_index_begin.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_index_begin.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_index_begin.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->index_begin);
union {
int32_t real;
uint32_t base;
} u_index_end;
u_index_end.real = this->index_end;
*(outbuffer + offset + 0) = (u_index_end.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_index_end.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_index_end.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_index_end.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->index_end);
uint32_t length_new_content = strlen(this->new_content);
varToArr(outbuffer + offset, length_new_content);
offset += 4;
memcpy(outbuffer + offset, this->new_content, length_new_content);
offset += length_new_content;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_index_begin;
u_index_begin.base = 0;
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_index_begin.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->index_begin = u_index_begin.real;
offset += sizeof(this->index_begin);
union {
int32_t real;
uint32_t base;
} u_index_end;
u_index_end.base = 0;
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_index_end.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->index_end = u_index_end.real;
offset += sizeof(this->index_end);
uint32_t length_new_content;
arrToVar(length_new_content, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_new_content; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_new_content-1]=0;
this->new_content = (char *)(inbuffer + offset-1);
offset += length_new_content;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorModification"; };
const char * getMD5(){ return "ac997193d826b145a432b8e3e528f6b4"; };
};
}
#endif
| 3,545 | C | 33.096154 | 79 | 0.5622 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisActionGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisActionGoal_h
#define _ROS_flexbe_msgs_BehaviorSynthesisActionGoal_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 "flexbe_msgs/BehaviorSynthesisGoal.h"
namespace flexbe_msgs
{
class BehaviorSynthesisActionGoal : 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 flexbe_msgs::BehaviorSynthesisGoal _goal_type;
_goal_type goal;
BehaviorSynthesisActionGoal():
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 "flexbe_msgs/BehaviorSynthesisActionGoal"; };
const char * getMD5(){ return "ef3bccd0f7dc68c4fe76a2cb791126b0"; };
};
}
#endif
| 1,484 | C | 25.052631 | 80 | 0.66779 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionActionFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionActionFeedback_h
#define _ROS_flexbe_msgs_BehaviorExecutionActionFeedback_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 "flexbe_msgs/BehaviorExecutionFeedback.h"
namespace flexbe_msgs
{
class BehaviorExecutionActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorExecutionFeedback _feedback_type;
_feedback_type feedback;
BehaviorExecutionActionFeedback():
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 "flexbe_msgs/BehaviorExecutionActionFeedback"; };
const char * getMD5(){ return "b767b030e0462dae1168f66f2dd64853"; };
};
}
#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/flexbe_msgs/StateInstantiation.h | #ifndef _ROS_flexbe_msgs_StateInstantiation_h
#define _ROS_flexbe_msgs_StateInstantiation_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/OutcomeCondition.h"
namespace flexbe_msgs
{
class StateInstantiation : public ros::Msg
{
public:
typedef const char* _state_path_type;
_state_path_type state_path;
typedef const char* _state_class_type;
_state_class_type state_class;
typedef const char* _initial_state_name_type;
_initial_state_name_type initial_state_name;
uint32_t input_keys_length;
typedef char* _input_keys_type;
_input_keys_type st_input_keys;
_input_keys_type * input_keys;
uint32_t output_keys_length;
typedef char* _output_keys_type;
_output_keys_type st_output_keys;
_output_keys_type * output_keys;
uint32_t cond_outcome_length;
typedef char* _cond_outcome_type;
_cond_outcome_type st_cond_outcome;
_cond_outcome_type * cond_outcome;
uint32_t cond_transition_length;
typedef flexbe_msgs::OutcomeCondition _cond_transition_type;
_cond_transition_type st_cond_transition;
_cond_transition_type * cond_transition;
typedef const char* _behavior_class_type;
_behavior_class_type behavior_class;
uint32_t parameter_names_length;
typedef char* _parameter_names_type;
_parameter_names_type st_parameter_names;
_parameter_names_type * parameter_names;
uint32_t parameter_values_length;
typedef char* _parameter_values_type;
_parameter_values_type st_parameter_values;
_parameter_values_type * parameter_values;
float position[2];
uint32_t outcomes_length;
typedef char* _outcomes_type;
_outcomes_type st_outcomes;
_outcomes_type * outcomes;
uint32_t transitions_length;
typedef char* _transitions_type;
_transitions_type st_transitions;
_transitions_type * transitions;
uint32_t autonomy_length;
typedef int8_t _autonomy_type;
_autonomy_type st_autonomy;
_autonomy_type * autonomy;
uint32_t userdata_keys_length;
typedef char* _userdata_keys_type;
_userdata_keys_type st_userdata_keys;
_userdata_keys_type * userdata_keys;
uint32_t userdata_remapping_length;
typedef char* _userdata_remapping_type;
_userdata_remapping_type st_userdata_remapping;
_userdata_remapping_type * userdata_remapping;
enum { CLASS_STATEMACHINE = :STATEMACHINE };
enum { CLASS_CONCURRENCY = :CONCURRENCY };
enum { CLASS_PRIORITY = :PRIORITY };
enum { CLASS_BEHAVIOR = :BEHAVIOR };
StateInstantiation():
state_path(""),
state_class(""),
initial_state_name(""),
input_keys_length(0), input_keys(NULL),
output_keys_length(0), output_keys(NULL),
cond_outcome_length(0), cond_outcome(NULL),
cond_transition_length(0), cond_transition(NULL),
behavior_class(""),
parameter_names_length(0), parameter_names(NULL),
parameter_values_length(0), parameter_values(NULL),
position(),
outcomes_length(0), outcomes(NULL),
transitions_length(0), transitions(NULL),
autonomy_length(0), autonomy(NULL),
userdata_keys_length(0), userdata_keys(NULL),
userdata_remapping_length(0), userdata_remapping(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_state_path = strlen(this->state_path);
varToArr(outbuffer + offset, length_state_path);
offset += 4;
memcpy(outbuffer + offset, this->state_path, length_state_path);
offset += length_state_path;
uint32_t length_state_class = strlen(this->state_class);
varToArr(outbuffer + offset, length_state_class);
offset += 4;
memcpy(outbuffer + offset, this->state_class, length_state_class);
offset += length_state_class;
uint32_t length_initial_state_name = strlen(this->initial_state_name);
varToArr(outbuffer + offset, length_initial_state_name);
offset += 4;
memcpy(outbuffer + offset, this->initial_state_name, length_initial_state_name);
offset += length_initial_state_name;
*(outbuffer + offset + 0) = (this->input_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_keys_length);
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_input_keysi = strlen(this->input_keys[i]);
varToArr(outbuffer + offset, length_input_keysi);
offset += 4;
memcpy(outbuffer + offset, this->input_keys[i], length_input_keysi);
offset += length_input_keysi;
}
*(outbuffer + offset + 0) = (this->output_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->output_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->output_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->output_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->output_keys_length);
for( uint32_t i = 0; i < output_keys_length; i++){
uint32_t length_output_keysi = strlen(this->output_keys[i]);
varToArr(outbuffer + offset, length_output_keysi);
offset += 4;
memcpy(outbuffer + offset, this->output_keys[i], length_output_keysi);
offset += length_output_keysi;
}
*(outbuffer + offset + 0) = (this->cond_outcome_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cond_outcome_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cond_outcome_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cond_outcome_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cond_outcome_length);
for( uint32_t i = 0; i < cond_outcome_length; i++){
uint32_t length_cond_outcomei = strlen(this->cond_outcome[i]);
varToArr(outbuffer + offset, length_cond_outcomei);
offset += 4;
memcpy(outbuffer + offset, this->cond_outcome[i], length_cond_outcomei);
offset += length_cond_outcomei;
}
*(outbuffer + offset + 0) = (this->cond_transition_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->cond_transition_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->cond_transition_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->cond_transition_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->cond_transition_length);
for( uint32_t i = 0; i < cond_transition_length; i++){
offset += this->cond_transition[i].serialize(outbuffer + offset);
}
uint32_t length_behavior_class = strlen(this->behavior_class);
varToArr(outbuffer + offset, length_behavior_class);
offset += 4;
memcpy(outbuffer + offset, this->behavior_class, length_behavior_class);
offset += length_behavior_class;
*(outbuffer + offset + 0) = (this->parameter_names_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->parameter_names_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->parameter_names_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->parameter_names_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->parameter_names_length);
for( uint32_t i = 0; i < parameter_names_length; i++){
uint32_t length_parameter_namesi = strlen(this->parameter_names[i]);
varToArr(outbuffer + offset, length_parameter_namesi);
offset += 4;
memcpy(outbuffer + offset, this->parameter_names[i], length_parameter_namesi);
offset += length_parameter_namesi;
}
*(outbuffer + offset + 0) = (this->parameter_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->parameter_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->parameter_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->parameter_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->parameter_values_length);
for( uint32_t i = 0; i < parameter_values_length; i++){
uint32_t length_parameter_valuesi = strlen(this->parameter_values[i]);
varToArr(outbuffer + offset, length_parameter_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->parameter_values[i], length_parameter_valuesi);
offset += length_parameter_valuesi;
}
for( uint32_t i = 0; i < 2; i++){
union {
float real;
uint32_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;
offset += sizeof(this->position[i]);
}
*(outbuffer + offset + 0) = (this->outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outcomes_length);
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_outcomesi = strlen(this->outcomes[i]);
varToArr(outbuffer + offset, length_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->outcomes[i], length_outcomesi);
offset += length_outcomesi;
}
*(outbuffer + offset + 0) = (this->transitions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->transitions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->transitions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->transitions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->transitions_length);
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_transitionsi = strlen(this->transitions[i]);
varToArr(outbuffer + offset, length_transitionsi);
offset += 4;
memcpy(outbuffer + offset, this->transitions[i], length_transitionsi);
offset += length_transitionsi;
}
*(outbuffer + offset + 0) = (this->autonomy_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->autonomy_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->autonomy_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->autonomy_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->autonomy_length);
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_autonomyi;
u_autonomyi.real = this->autonomy[i];
*(outbuffer + offset + 0) = (u_autonomyi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy[i]);
}
*(outbuffer + offset + 0) = (this->userdata_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->userdata_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->userdata_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->userdata_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->userdata_keys_length);
for( uint32_t i = 0; i < userdata_keys_length; i++){
uint32_t length_userdata_keysi = strlen(this->userdata_keys[i]);
varToArr(outbuffer + offset, length_userdata_keysi);
offset += 4;
memcpy(outbuffer + offset, this->userdata_keys[i], length_userdata_keysi);
offset += length_userdata_keysi;
}
*(outbuffer + offset + 0) = (this->userdata_remapping_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->userdata_remapping_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->userdata_remapping_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->userdata_remapping_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->userdata_remapping_length);
for( uint32_t i = 0; i < userdata_remapping_length; i++){
uint32_t length_userdata_remappingi = strlen(this->userdata_remapping[i]);
varToArr(outbuffer + offset, length_userdata_remappingi);
offset += 4;
memcpy(outbuffer + offset, this->userdata_remapping[i], length_userdata_remappingi);
offset += length_userdata_remappingi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_state_path;
arrToVar(length_state_path, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state_path; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state_path-1]=0;
this->state_path = (char *)(inbuffer + offset-1);
offset += length_state_path;
uint32_t length_state_class;
arrToVar(length_state_class, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_state_class; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_state_class-1]=0;
this->state_class = (char *)(inbuffer + offset-1);
offset += length_state_class;
uint32_t length_initial_state_name;
arrToVar(length_initial_state_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_initial_state_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_initial_state_name-1]=0;
this->initial_state_name = (char *)(inbuffer + offset-1);
offset += length_initial_state_name;
uint32_t input_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_keys_length);
if(input_keys_lengthT > input_keys_length)
this->input_keys = (char**)realloc(this->input_keys, input_keys_lengthT * sizeof(char*));
input_keys_length = input_keys_lengthT;
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_st_input_keys;
arrToVar(length_st_input_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_keys-1]=0;
this->st_input_keys = (char *)(inbuffer + offset-1);
offset += length_st_input_keys;
memcpy( &(this->input_keys[i]), &(this->st_input_keys), sizeof(char*));
}
uint32_t output_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
output_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
output_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
output_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->output_keys_length);
if(output_keys_lengthT > output_keys_length)
this->output_keys = (char**)realloc(this->output_keys, output_keys_lengthT * sizeof(char*));
output_keys_length = output_keys_lengthT;
for( uint32_t i = 0; i < output_keys_length; i++){
uint32_t length_st_output_keys;
arrToVar(length_st_output_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_output_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_output_keys-1]=0;
this->st_output_keys = (char *)(inbuffer + offset-1);
offset += length_st_output_keys;
memcpy( &(this->output_keys[i]), &(this->st_output_keys), sizeof(char*));
}
uint32_t cond_outcome_lengthT = ((uint32_t) (*(inbuffer + offset)));
cond_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cond_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cond_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cond_outcome_length);
if(cond_outcome_lengthT > cond_outcome_length)
this->cond_outcome = (char**)realloc(this->cond_outcome, cond_outcome_lengthT * sizeof(char*));
cond_outcome_length = cond_outcome_lengthT;
for( uint32_t i = 0; i < cond_outcome_length; i++){
uint32_t length_st_cond_outcome;
arrToVar(length_st_cond_outcome, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_cond_outcome; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_cond_outcome-1]=0;
this->st_cond_outcome = (char *)(inbuffer + offset-1);
offset += length_st_cond_outcome;
memcpy( &(this->cond_outcome[i]), &(this->st_cond_outcome), sizeof(char*));
}
uint32_t cond_transition_lengthT = ((uint32_t) (*(inbuffer + offset)));
cond_transition_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
cond_transition_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
cond_transition_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->cond_transition_length);
if(cond_transition_lengthT > cond_transition_length)
this->cond_transition = (flexbe_msgs::OutcomeCondition*)realloc(this->cond_transition, cond_transition_lengthT * sizeof(flexbe_msgs::OutcomeCondition));
cond_transition_length = cond_transition_lengthT;
for( uint32_t i = 0; i < cond_transition_length; i++){
offset += this->st_cond_transition.deserialize(inbuffer + offset);
memcpy( &(this->cond_transition[i]), &(this->st_cond_transition), sizeof(flexbe_msgs::OutcomeCondition));
}
uint32_t length_behavior_class;
arrToVar(length_behavior_class, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_behavior_class; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_behavior_class-1]=0;
this->behavior_class = (char *)(inbuffer + offset-1);
offset += length_behavior_class;
uint32_t parameter_names_lengthT = ((uint32_t) (*(inbuffer + offset)));
parameter_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
parameter_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
parameter_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->parameter_names_length);
if(parameter_names_lengthT > parameter_names_length)
this->parameter_names = (char**)realloc(this->parameter_names, parameter_names_lengthT * sizeof(char*));
parameter_names_length = parameter_names_lengthT;
for( uint32_t i = 0; i < parameter_names_length; i++){
uint32_t length_st_parameter_names;
arrToVar(length_st_parameter_names, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_parameter_names; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_parameter_names-1]=0;
this->st_parameter_names = (char *)(inbuffer + offset-1);
offset += length_st_parameter_names;
memcpy( &(this->parameter_names[i]), &(this->st_parameter_names), sizeof(char*));
}
uint32_t parameter_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
parameter_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
parameter_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
parameter_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->parameter_values_length);
if(parameter_values_lengthT > parameter_values_length)
this->parameter_values = (char**)realloc(this->parameter_values, parameter_values_lengthT * sizeof(char*));
parameter_values_length = parameter_values_lengthT;
for( uint32_t i = 0; i < parameter_values_length; i++){
uint32_t length_st_parameter_values;
arrToVar(length_st_parameter_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_parameter_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_parameter_values-1]=0;
this->st_parameter_values = (char *)(inbuffer + offset-1);
offset += length_st_parameter_values;
memcpy( &(this->parameter_values[i]), &(this->st_parameter_values), sizeof(char*));
}
for( uint32_t i = 0; i < 2; i++){
union {
float real;
uint32_t base;
} u_positioni;
u_positioni.base = 0;
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_positioni.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->position[i] = u_positioni.real;
offset += sizeof(this->position[i]);
}
uint32_t outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outcomes_length);
if(outcomes_lengthT > outcomes_length)
this->outcomes = (char**)realloc(this->outcomes, outcomes_lengthT * sizeof(char*));
outcomes_length = outcomes_lengthT;
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_st_outcomes;
arrToVar(length_st_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_outcomes-1]=0;
this->st_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_outcomes;
memcpy( &(this->outcomes[i]), &(this->st_outcomes), sizeof(char*));
}
uint32_t transitions_lengthT = ((uint32_t) (*(inbuffer + offset)));
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->transitions_length);
if(transitions_lengthT > transitions_length)
this->transitions = (char**)realloc(this->transitions, transitions_lengthT * sizeof(char*));
transitions_length = transitions_lengthT;
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_st_transitions;
arrToVar(length_st_transitions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_transitions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_transitions-1]=0;
this->st_transitions = (char *)(inbuffer + offset-1);
offset += length_st_transitions;
memcpy( &(this->transitions[i]), &(this->st_transitions), sizeof(char*));
}
uint32_t autonomy_lengthT = ((uint32_t) (*(inbuffer + offset)));
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->autonomy_length);
if(autonomy_lengthT > autonomy_length)
this->autonomy = (int8_t*)realloc(this->autonomy, autonomy_lengthT * sizeof(int8_t));
autonomy_length = autonomy_lengthT;
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_autonomy;
u_st_autonomy.base = 0;
u_st_autonomy.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_autonomy = u_st_autonomy.real;
offset += sizeof(this->st_autonomy);
memcpy( &(this->autonomy[i]), &(this->st_autonomy), sizeof(int8_t));
}
uint32_t userdata_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
userdata_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
userdata_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
userdata_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->userdata_keys_length);
if(userdata_keys_lengthT > userdata_keys_length)
this->userdata_keys = (char**)realloc(this->userdata_keys, userdata_keys_lengthT * sizeof(char*));
userdata_keys_length = userdata_keys_lengthT;
for( uint32_t i = 0; i < userdata_keys_length; i++){
uint32_t length_st_userdata_keys;
arrToVar(length_st_userdata_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_userdata_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_userdata_keys-1]=0;
this->st_userdata_keys = (char *)(inbuffer + offset-1);
offset += length_st_userdata_keys;
memcpy( &(this->userdata_keys[i]), &(this->st_userdata_keys), sizeof(char*));
}
uint32_t userdata_remapping_lengthT = ((uint32_t) (*(inbuffer + offset)));
userdata_remapping_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
userdata_remapping_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
userdata_remapping_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->userdata_remapping_length);
if(userdata_remapping_lengthT > userdata_remapping_length)
this->userdata_remapping = (char**)realloc(this->userdata_remapping, userdata_remapping_lengthT * sizeof(char*));
userdata_remapping_length = userdata_remapping_lengthT;
for( uint32_t i = 0; i < userdata_remapping_length; i++){
uint32_t length_st_userdata_remapping;
arrToVar(length_st_userdata_remapping, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_userdata_remapping; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_userdata_remapping-1]=0;
this->st_userdata_remapping = (char *)(inbuffer + offset-1);
offset += length_st_userdata_remapping;
memcpy( &(this->userdata_remapping[i]), &(this->st_userdata_remapping), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/StateInstantiation"; };
const char * getMD5(){ return "1c6026e288cfff7ab6c8308ee1db66f1"; };
};
}
#endif
| 27,095 | C | 49.646729 | 160 | 0.602141 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputResult.h | #ifndef _ROS_flexbe_msgs_BehaviorInputResult_h
#define _ROS_flexbe_msgs_BehaviorInputResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorInputResult : public ros::Msg
{
public:
typedef uint8_t _result_code_type;
_result_code_type result_code;
typedef const char* _data_type;
_data_type data;
enum { RESULT_OK = 0 };
enum { RESULT_FAILED = 1 };
enum { RESULT_ABORTED = 2 };
BehaviorInputResult():
result_code(0),
data("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->result_code >> (8 * 0)) & 0xFF;
offset += sizeof(this->result_code);
uint32_t length_data = strlen(this->data);
varToArr(outbuffer + offset, length_data);
offset += 4;
memcpy(outbuffer + offset, this->data, length_data);
offset += length_data;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->result_code = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->result_code);
uint32_t length_data;
arrToVar(length_data, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_data; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_data-1]=0;
this->data = (char *)(inbuffer + offset-1);
offset += length_data;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorInputResult"; };
const char * getMD5(){ return "e0509f159e7c7bb2268efbc625f63b3f"; };
};
}
#endif
| 1,718 | C | 25.045454 | 72 | 0.601863 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisActionResult.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisActionResult_h
#define _ROS_flexbe_msgs_BehaviorSynthesisActionResult_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 "flexbe_msgs/BehaviorSynthesisResult.h"
namespace flexbe_msgs
{
class BehaviorSynthesisActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorSynthesisResult _result_type;
_result_type result;
BehaviorSynthesisActionResult():
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 "flexbe_msgs/BehaviorSynthesisActionResult"; };
const char * getMD5(){ return "d13a1c24e611f3c8aae59d09829d044b"; };
};
}
#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/flexbe_msgs/BehaviorExecutionFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionFeedback_h
#define _ROS_flexbe_msgs_BehaviorExecutionFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorExecutionFeedback : public ros::Msg
{
public:
typedef const char* _current_state_type;
_current_state_type current_state;
BehaviorExecutionFeedback():
current_state("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_current_state = strlen(this->current_state);
varToArr(outbuffer + offset, length_current_state);
offset += 4;
memcpy(outbuffer + offset, this->current_state, length_current_state);
offset += length_current_state;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_current_state;
arrToVar(length_current_state, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_current_state; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_current_state-1]=0;
this->current_state = (char *)(inbuffer + offset-1);
offset += length_current_state;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionFeedback"; };
const char * getMD5(){ return "6b3c1b68b57cc9263bf79fc4ad6ec8c7"; };
};
}
#endif
| 1,468 | C | 25.232142 | 78 | 0.653951 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/Container.h | #ifndef _ROS_flexbe_msgs_Container_h
#define _ROS_flexbe_msgs_Container_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class Container : public ros::Msg
{
public:
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 outcomes_length;
typedef char* _outcomes_type;
_outcomes_type st_outcomes;
_outcomes_type * outcomes;
uint32_t transitions_length;
typedef char* _transitions_type;
_transitions_type st_transitions;
_transitions_type * transitions;
uint32_t autonomy_length;
typedef int8_t _autonomy_type;
_autonomy_type st_autonomy;
_autonomy_type * autonomy;
Container():
path(""),
children_length(0), children(NULL),
outcomes_length(0), outcomes(NULL),
transitions_length(0), transitions(NULL),
autonomy_length(0), autonomy(NULL)
{
}
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->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->outcomes_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->outcomes_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->outcomes_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->outcomes_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->outcomes_length);
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_outcomesi = strlen(this->outcomes[i]);
varToArr(outbuffer + offset, length_outcomesi);
offset += 4;
memcpy(outbuffer + offset, this->outcomes[i], length_outcomesi);
offset += length_outcomesi;
}
*(outbuffer + offset + 0) = (this->transitions_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->transitions_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->transitions_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->transitions_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->transitions_length);
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_transitionsi = strlen(this->transitions[i]);
varToArr(outbuffer + offset, length_transitionsi);
offset += 4;
memcpy(outbuffer + offset, this->transitions[i], length_transitionsi);
offset += length_transitionsi;
}
*(outbuffer + offset + 0) = (this->autonomy_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->autonomy_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->autonomy_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->autonomy_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->autonomy_length);
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_autonomyi;
u_autonomyi.real = this->autonomy[i];
*(outbuffer + offset + 0) = (u_autonomyi.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy[i]);
}
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 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 outcomes_lengthT = ((uint32_t) (*(inbuffer + offset)));
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
outcomes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->outcomes_length);
if(outcomes_lengthT > outcomes_length)
this->outcomes = (char**)realloc(this->outcomes, outcomes_lengthT * sizeof(char*));
outcomes_length = outcomes_lengthT;
for( uint32_t i = 0; i < outcomes_length; i++){
uint32_t length_st_outcomes;
arrToVar(length_st_outcomes, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_outcomes; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_outcomes-1]=0;
this->st_outcomes = (char *)(inbuffer + offset-1);
offset += length_st_outcomes;
memcpy( &(this->outcomes[i]), &(this->st_outcomes), sizeof(char*));
}
uint32_t transitions_lengthT = ((uint32_t) (*(inbuffer + offset)));
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
transitions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->transitions_length);
if(transitions_lengthT > transitions_length)
this->transitions = (char**)realloc(this->transitions, transitions_lengthT * sizeof(char*));
transitions_length = transitions_lengthT;
for( uint32_t i = 0; i < transitions_length; i++){
uint32_t length_st_transitions;
arrToVar(length_st_transitions, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_transitions; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_transitions-1]=0;
this->st_transitions = (char *)(inbuffer + offset-1);
offset += length_st_transitions;
memcpy( &(this->transitions[i]), &(this->st_transitions), sizeof(char*));
}
uint32_t autonomy_lengthT = ((uint32_t) (*(inbuffer + offset)));
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
autonomy_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->autonomy_length);
if(autonomy_lengthT > autonomy_length)
this->autonomy = (int8_t*)realloc(this->autonomy, autonomy_lengthT * sizeof(int8_t));
autonomy_length = autonomy_lengthT;
for( uint32_t i = 0; i < autonomy_length; i++){
union {
int8_t real;
uint8_t base;
} u_st_autonomy;
u_st_autonomy.base = 0;
u_st_autonomy.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->st_autonomy = u_st_autonomy.real;
offset += sizeof(this->st_autonomy);
memcpy( &(this->autonomy[i]), &(this->st_autonomy), sizeof(int8_t));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/Container"; };
const char * getMD5(){ return "627eacc0f462c8ee83d7105e17cf4119"; };
};
}
#endif
| 8,769 | C | 41.780488 | 100 | 0.583647 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/OutcomeRequest.h | #ifndef _ROS_flexbe_msgs_OutcomeRequest_h
#define _ROS_flexbe_msgs_OutcomeRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class OutcomeRequest : public ros::Msg
{
public:
typedef uint8_t _outcome_type;
_outcome_type outcome;
typedef const char* _target_type;
_target_type target;
OutcomeRequest():
outcome(0),
target("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->outcome >> (8 * 0)) & 0xFF;
offset += sizeof(this->outcome);
uint32_t length_target = strlen(this->target);
varToArr(outbuffer + offset, length_target);
offset += 4;
memcpy(outbuffer + offset, this->target, length_target);
offset += length_target;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->outcome = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->outcome);
uint32_t length_target;
arrToVar(length_target, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_target; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_target-1]=0;
this->target = (char *)(inbuffer + offset-1);
offset += length_target;
return offset;
}
const char * getType(){ return "flexbe_msgs/OutcomeRequest"; };
const char * getMD5(){ return "b057cf075cb943bf0dbb3443419a61ed"; };
};
}
#endif
| 1,591 | C | 24.269841 | 72 | 0.609051 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorRequest.h | #ifndef _ROS_flexbe_msgs_BehaviorRequest_h
#define _ROS_flexbe_msgs_BehaviorRequest_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/Container.h"
namespace flexbe_msgs
{
class BehaviorRequest : public ros::Msg
{
public:
typedef const char* _behavior_name_type;
_behavior_name_type behavior_name;
typedef uint8_t _autonomy_level_type;
_autonomy_level_type autonomy_level;
uint32_t arg_keys_length;
typedef char* _arg_keys_type;
_arg_keys_type st_arg_keys;
_arg_keys_type * arg_keys;
uint32_t arg_values_length;
typedef char* _arg_values_type;
_arg_values_type st_arg_values;
_arg_values_type * arg_values;
uint32_t structure_length;
typedef flexbe_msgs::Container _structure_type;
_structure_type st_structure;
_structure_type * structure;
BehaviorRequest():
behavior_name(""),
autonomy_level(0),
arg_keys_length(0), arg_keys(NULL),
arg_values_length(0), arg_values(NULL),
structure_length(0), structure(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_behavior_name = strlen(this->behavior_name);
varToArr(outbuffer + offset, length_behavior_name);
offset += 4;
memcpy(outbuffer + offset, this->behavior_name, length_behavior_name);
offset += length_behavior_name;
*(outbuffer + offset + 0) = (this->autonomy_level >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy_level);
*(outbuffer + offset + 0) = (this->arg_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_keys_length);
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_arg_keysi = strlen(this->arg_keys[i]);
varToArr(outbuffer + offset, length_arg_keysi);
offset += 4;
memcpy(outbuffer + offset, this->arg_keys[i], length_arg_keysi);
offset += length_arg_keysi;
}
*(outbuffer + offset + 0) = (this->arg_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_values_length);
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_arg_valuesi = strlen(this->arg_values[i]);
varToArr(outbuffer + offset, length_arg_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->arg_values[i], length_arg_valuesi);
offset += length_arg_valuesi;
}
*(outbuffer + offset + 0) = (this->structure_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->structure_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->structure_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->structure_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->structure_length);
for( uint32_t i = 0; i < structure_length; i++){
offset += this->structure[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_behavior_name;
arrToVar(length_behavior_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_behavior_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_behavior_name-1]=0;
this->behavior_name = (char *)(inbuffer + offset-1);
offset += length_behavior_name;
this->autonomy_level = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->autonomy_level);
uint32_t arg_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_keys_length);
if(arg_keys_lengthT > arg_keys_length)
this->arg_keys = (char**)realloc(this->arg_keys, arg_keys_lengthT * sizeof(char*));
arg_keys_length = arg_keys_lengthT;
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_st_arg_keys;
arrToVar(length_st_arg_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_keys-1]=0;
this->st_arg_keys = (char *)(inbuffer + offset-1);
offset += length_st_arg_keys;
memcpy( &(this->arg_keys[i]), &(this->st_arg_keys), sizeof(char*));
}
uint32_t arg_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_values_length);
if(arg_values_lengthT > arg_values_length)
this->arg_values = (char**)realloc(this->arg_values, arg_values_lengthT * sizeof(char*));
arg_values_length = arg_values_lengthT;
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_st_arg_values;
arrToVar(length_st_arg_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_values-1]=0;
this->st_arg_values = (char *)(inbuffer + offset-1);
offset += length_st_arg_values;
memcpy( &(this->arg_values[i]), &(this->st_arg_values), sizeof(char*));
}
uint32_t structure_lengthT = ((uint32_t) (*(inbuffer + offset)));
structure_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
structure_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
structure_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->structure_length);
if(structure_lengthT > structure_length)
this->structure = (flexbe_msgs::Container*)realloc(this->structure, structure_lengthT * sizeof(flexbe_msgs::Container));
structure_length = structure_lengthT;
for( uint32_t i = 0; i < structure_length; i++){
offset += this->st_structure.deserialize(inbuffer + offset);
memcpy( &(this->structure[i]), &(this->st_structure), sizeof(flexbe_msgs::Container));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorRequest"; };
const char * getMD5(){ return "0b55949502d4c602376ee00a64d0d294"; };
};
}
#endif
| 7,122 | C | 42.699386 | 128 | 0.591126 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionResult.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionResult_h
#define _ROS_flexbe_msgs_BehaviorExecutionResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorExecutionResult : public ros::Msg
{
public:
typedef const char* _outcome_type;
_outcome_type outcome;
BehaviorExecutionResult():
outcome("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_outcome = strlen(this->outcome);
varToArr(outbuffer + offset, length_outcome);
offset += 4;
memcpy(outbuffer + offset, this->outcome, length_outcome);
offset += length_outcome;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_outcome;
arrToVar(length_outcome, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_outcome; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_outcome-1]=0;
this->outcome = (char *)(inbuffer + offset-1);
offset += length_outcome;
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorExecutionResult"; };
const char * getMD5(){ return "2b95071cca675b3d5b80ad0bdaf20389"; };
};
}
#endif
| 1,362 | C | 23.339285 | 76 | 0.638767 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionActionGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionActionGoal_h
#define _ROS_flexbe_msgs_BehaviorExecutionActionGoal_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 "flexbe_msgs/BehaviorExecutionGoal.h"
namespace flexbe_msgs
{
class BehaviorExecutionActionGoal : 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 flexbe_msgs::BehaviorExecutionGoal _goal_type;
_goal_type goal;
BehaviorExecutionActionGoal():
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 "flexbe_msgs/BehaviorExecutionActionGoal"; };
const char * getMD5(){ return "60d736806adccc368a03e4e8d2e6f4e7"; };
};
}
#endif
| 1,484 | C | 25.052631 | 80 | 0.66779 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisResult.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisResult_h
#define _ROS_flexbe_msgs_BehaviorSynthesisResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/SynthesisErrorCodes.h"
#include "flexbe_msgs/StateInstantiation.h"
namespace flexbe_msgs
{
class BehaviorSynthesisResult : public ros::Msg
{
public:
typedef flexbe_msgs::SynthesisErrorCodes _error_code_type;
_error_code_type error_code;
uint32_t states_length;
typedef flexbe_msgs::StateInstantiation _states_type;
_states_type st_states;
_states_type * states;
BehaviorSynthesisResult():
error_code(),
states_length(0), states(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->error_code.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->error_code.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 = (flexbe_msgs::StateInstantiation*)realloc(this->states, states_lengthT * sizeof(flexbe_msgs::StateInstantiation));
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(flexbe_msgs::StateInstantiation));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSynthesisResult"; };
const char * getMD5(){ return "088bd6aee1c7ee2902db2babfd6af1c2"; };
};
}
#endif
| 2,486 | C | 34.028169 | 137 | 0.622285 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/ContainerStructure.h | #ifndef _ROS_flexbe_msgs_ContainerStructure_h
#define _ROS_flexbe_msgs_ContainerStructure_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/Container.h"
namespace flexbe_msgs
{
class ContainerStructure : public ros::Msg
{
public:
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
uint32_t containers_length;
typedef flexbe_msgs::Container _containers_type;
_containers_type st_containers;
_containers_type * containers;
ContainerStructure():
behavior_id(0),
containers_length(0), containers(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
*(outbuffer + offset + 0) = (this->containers_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->containers_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->containers_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->containers_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->containers_length);
for( uint32_t i = 0; i < containers_length; i++){
offset += this->containers[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
uint32_t containers_lengthT = ((uint32_t) (*(inbuffer + offset)));
containers_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
containers_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
containers_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->containers_length);
if(containers_lengthT > containers_length)
this->containers = (flexbe_msgs::Container*)realloc(this->containers, containers_lengthT * sizeof(flexbe_msgs::Container));
containers_length = containers_lengthT;
for( uint32_t i = 0; i < containers_length; i++){
offset += this->st_containers.deserialize(inbuffer + offset);
memcpy( &(this->containers[i]), &(this->st_containers), sizeof(flexbe_msgs::Container));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/ContainerStructure"; };
const char * getMD5(){ return "9cd26d15621063b90279d87117694328"; };
};
}
#endif
| 3,334 | C | 36.47191 | 131 | 0.588782 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputAction.h | #ifndef _ROS_flexbe_msgs_BehaviorInputAction_h
#define _ROS_flexbe_msgs_BehaviorInputAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/BehaviorInputActionGoal.h"
#include "flexbe_msgs/BehaviorInputActionResult.h"
#include "flexbe_msgs/BehaviorInputActionFeedback.h"
namespace flexbe_msgs
{
class BehaviorInputAction : public ros::Msg
{
public:
typedef flexbe_msgs::BehaviorInputActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef flexbe_msgs::BehaviorInputActionResult _action_result_type;
_action_result_type action_result;
typedef flexbe_msgs::BehaviorInputActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
BehaviorInputAction():
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 "flexbe_msgs/BehaviorInputAction"; };
const char * getMD5(){ return "409aeef36c5fba868c3b1f845c52f119"; };
};
}
#endif
| 1,660 | C | 28.14035 | 77 | 0.695783 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionAction.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionAction_h
#define _ROS_flexbe_msgs_BehaviorExecutionAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/BehaviorExecutionActionGoal.h"
#include "flexbe_msgs/BehaviorExecutionActionResult.h"
#include "flexbe_msgs/BehaviorExecutionActionFeedback.h"
namespace flexbe_msgs
{
class BehaviorExecutionAction : public ros::Msg
{
public:
typedef flexbe_msgs::BehaviorExecutionActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef flexbe_msgs::BehaviorExecutionActionResult _action_result_type;
_action_result_type action_result;
typedef flexbe_msgs::BehaviorExecutionActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
BehaviorExecutionAction():
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 "flexbe_msgs/BehaviorExecutionAction"; };
const char * getMD5(){ return "5137e5877c4ee9dbe6ca4796ad090f1a"; };
};
}
#endif
| 1,704 | C | 28.91228 | 81 | 0.703638 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/UICommand.h | #ifndef _ROS_flexbe_msgs_UICommand_h
#define _ROS_flexbe_msgs_UICommand_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class UICommand : public ros::Msg
{
public:
typedef const char* _command_type;
_command_type command;
typedef const char* _key_type;
_key_type key;
UICommand():
command(""),
key("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_command = strlen(this->command);
varToArr(outbuffer + offset, length_command);
offset += 4;
memcpy(outbuffer + offset, this->command, length_command);
offset += length_command;
uint32_t length_key = strlen(this->key);
varToArr(outbuffer + offset, length_key);
offset += 4;
memcpy(outbuffer + offset, this->key, length_key);
offset += length_key;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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;
uint32_t length_key;
arrToVar(length_key, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_key; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_key-1]=0;
this->key = (char *)(inbuffer + offset-1);
offset += length_key;
return offset;
}
const char * getType(){ return "flexbe_msgs/UICommand"; };
const char * getMD5(){ return "88f45469138737816fa9cd59fbf3c084"; };
};
}
#endif
| 1,882 | C | 24.79452 | 72 | 0.602019 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSync.h | #ifndef _ROS_flexbe_msgs_BehaviorSync_h
#define _ROS_flexbe_msgs_BehaviorSync_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorSync : public ros::Msg
{
public:
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
typedef int32_t _current_state_checksum_type;
_current_state_checksum_type current_state_checksum;
BehaviorSync():
behavior_id(0),
current_state_checksum(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_current_state_checksum;
u_current_state_checksum.real = this->current_state_checksum;
*(outbuffer + offset + 0) = (u_current_state_checksum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_current_state_checksum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_current_state_checksum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_current_state_checksum.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->current_state_checksum);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_current_state_checksum;
u_current_state_checksum.base = 0;
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_current_state_checksum.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->current_state_checksum = u_current_state_checksum.real;
offset += sizeof(this->current_state_checksum);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSync"; };
const char * getMD5(){ return "118d64f48696509906c4cf4a228608b1"; };
};
}
#endif
| 3,060 | C | 34.183908 | 90 | 0.575163 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorLog.h | #ifndef _ROS_flexbe_msgs_BehaviorLog_h
#define _ROS_flexbe_msgs_BehaviorLog_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorLog : public ros::Msg
{
public:
typedef const char* _text_type;
_text_type text;
typedef uint8_t _status_code_type;
_status_code_type status_code;
enum { INFO = 0 };
enum { WARN = 1 };
enum { HINT = 2 };
enum { ERROR = 3 };
enum { DEBUG = 10 };
BehaviorLog():
text(""),
status_code(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_text = strlen(this->text);
varToArr(outbuffer + offset, length_text);
offset += 4;
memcpy(outbuffer + offset, this->text, length_text);
offset += length_text;
*(outbuffer + offset + 0) = (this->status_code >> (8 * 0)) & 0xFF;
offset += sizeof(this->status_code);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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;
this->status_code = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->status_code);
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorLog"; };
const char * getMD5(){ return "03d7689372c7e2617b8d61fbf552e694"; };
};
}
#endif
| 1,709 | C | 24.147058 | 72 | 0.581627 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/OutcomeCondition.h | #ifndef _ROS_flexbe_msgs_OutcomeCondition_h
#define _ROS_flexbe_msgs_OutcomeCondition_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class OutcomeCondition : public ros::Msg
{
public:
uint32_t state_name_length;
typedef char* _state_name_type;
_state_name_type st_state_name;
_state_name_type * state_name;
uint32_t state_outcome_length;
typedef char* _state_outcome_type;
_state_outcome_type st_state_outcome;
_state_outcome_type * state_outcome;
OutcomeCondition():
state_name_length(0), state_name(NULL),
state_outcome_length(0), state_outcome(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->state_name_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->state_name_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->state_name_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->state_name_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->state_name_length);
for( uint32_t i = 0; i < state_name_length; i++){
uint32_t length_state_namei = strlen(this->state_name[i]);
varToArr(outbuffer + offset, length_state_namei);
offset += 4;
memcpy(outbuffer + offset, this->state_name[i], length_state_namei);
offset += length_state_namei;
}
*(outbuffer + offset + 0) = (this->state_outcome_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->state_outcome_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->state_outcome_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->state_outcome_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->state_outcome_length);
for( uint32_t i = 0; i < state_outcome_length; i++){
uint32_t length_state_outcomei = strlen(this->state_outcome[i]);
varToArr(outbuffer + offset, length_state_outcomei);
offset += 4;
memcpy(outbuffer + offset, this->state_outcome[i], length_state_outcomei);
offset += length_state_outcomei;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t state_name_lengthT = ((uint32_t) (*(inbuffer + offset)));
state_name_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
state_name_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
state_name_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->state_name_length);
if(state_name_lengthT > state_name_length)
this->state_name = (char**)realloc(this->state_name, state_name_lengthT * sizeof(char*));
state_name_length = state_name_lengthT;
for( uint32_t i = 0; i < state_name_length; i++){
uint32_t length_st_state_name;
arrToVar(length_st_state_name, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_state_name; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_state_name-1]=0;
this->st_state_name = (char *)(inbuffer + offset-1);
offset += length_st_state_name;
memcpy( &(this->state_name[i]), &(this->st_state_name), sizeof(char*));
}
uint32_t state_outcome_lengthT = ((uint32_t) (*(inbuffer + offset)));
state_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
state_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
state_outcome_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->state_outcome_length);
if(state_outcome_lengthT > state_outcome_length)
this->state_outcome = (char**)realloc(this->state_outcome, state_outcome_lengthT * sizeof(char*));
state_outcome_length = state_outcome_lengthT;
for( uint32_t i = 0; i < state_outcome_length; i++){
uint32_t length_st_state_outcome;
arrToVar(length_st_state_outcome, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_state_outcome; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_state_outcome-1]=0;
this->st_state_outcome = (char *)(inbuffer + offset-1);
offset += length_st_state_outcome;
memcpy( &(this->state_outcome[i]), &(this->st_state_outcome), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/OutcomeCondition"; };
const char * getMD5(){ return "3f00d7f2d34167712ca29ef288547863"; };
};
}
#endif
| 4,704 | C | 40.637168 | 106 | 0.598852 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputActionGoal.h | #ifndef _ROS_flexbe_msgs_BehaviorInputActionGoal_h
#define _ROS_flexbe_msgs_BehaviorInputActionGoal_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 "flexbe_msgs/BehaviorInputGoal.h"
namespace flexbe_msgs
{
class BehaviorInputActionGoal : 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 flexbe_msgs::BehaviorInputGoal _goal_type;
_goal_type goal;
BehaviorInputActionGoal():
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 "flexbe_msgs/BehaviorInputActionGoal"; };
const char * getMD5(){ return "b2de1aae6b5512cca522fa05361cfdab"; };
};
}
#endif
| 1,456 | C | 24.561403 | 76 | 0.661401 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorExecutionActionResult.h | #ifndef _ROS_flexbe_msgs_BehaviorExecutionActionResult_h
#define _ROS_flexbe_msgs_BehaviorExecutionActionResult_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 "flexbe_msgs/BehaviorExecutionResult.h"
namespace flexbe_msgs
{
class BehaviorExecutionActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorExecutionResult _result_type;
_result_type result;
BehaviorExecutionActionResult():
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 "flexbe_msgs/BehaviorExecutionActionResult"; };
const char * getMD5(){ return "76e505f84da88685989704705a0d9846"; };
};
}
#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/flexbe_msgs/BehaviorSynthesisActionFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisActionFeedback_h
#define _ROS_flexbe_msgs_BehaviorSynthesisActionFeedback_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 "flexbe_msgs/BehaviorSynthesisFeedback.h"
namespace flexbe_msgs
{
class BehaviorSynthesisActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef flexbe_msgs::BehaviorSynthesisFeedback _feedback_type;
_feedback_type feedback;
BehaviorSynthesisActionFeedback():
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 "flexbe_msgs/BehaviorSynthesisActionFeedback"; };
const char * getMD5(){ return "74b2c8a9bddfff7e1b57abd9d9fb5b18"; };
};
}
#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/flexbe_msgs/BehaviorSelection.h | #ifndef _ROS_flexbe_msgs_BehaviorSelection_h
#define _ROS_flexbe_msgs_BehaviorSelection_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/BehaviorModification.h"
namespace flexbe_msgs
{
class BehaviorSelection : public ros::Msg
{
public:
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
typedef int32_t _behavior_checksum_type;
_behavior_checksum_type behavior_checksum;
typedef uint8_t _autonomy_level_type;
_autonomy_level_type autonomy_level;
uint32_t arg_keys_length;
typedef char* _arg_keys_type;
_arg_keys_type st_arg_keys;
_arg_keys_type * arg_keys;
uint32_t arg_values_length;
typedef char* _arg_values_type;
_arg_values_type st_arg_values;
_arg_values_type * arg_values;
uint32_t input_keys_length;
typedef char* _input_keys_type;
_input_keys_type st_input_keys;
_input_keys_type * input_keys;
uint32_t input_values_length;
typedef char* _input_values_type;
_input_values_type st_input_values;
_input_values_type * input_values;
uint32_t modifications_length;
typedef flexbe_msgs::BehaviorModification _modifications_type;
_modifications_type st_modifications;
_modifications_type * modifications;
BehaviorSelection():
behavior_id(0),
behavior_checksum(0),
autonomy_level(0),
arg_keys_length(0), arg_keys(NULL),
arg_values_length(0), arg_values(NULL),
input_keys_length(0), input_keys(NULL),
input_values_length(0), input_values(NULL),
modifications_length(0), modifications(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_behavior_checksum;
u_behavior_checksum.real = this->behavior_checksum;
*(outbuffer + offset + 0) = (u_behavior_checksum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_checksum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_checksum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_checksum.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_checksum);
*(outbuffer + offset + 0) = (this->autonomy_level >> (8 * 0)) & 0xFF;
offset += sizeof(this->autonomy_level);
*(outbuffer + offset + 0) = (this->arg_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_keys_length);
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_arg_keysi = strlen(this->arg_keys[i]);
varToArr(outbuffer + offset, length_arg_keysi);
offset += 4;
memcpy(outbuffer + offset, this->arg_keys[i], length_arg_keysi);
offset += length_arg_keysi;
}
*(outbuffer + offset + 0) = (this->arg_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->arg_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->arg_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->arg_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->arg_values_length);
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_arg_valuesi = strlen(this->arg_values[i]);
varToArr(outbuffer + offset, length_arg_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->arg_values[i], length_arg_valuesi);
offset += length_arg_valuesi;
}
*(outbuffer + offset + 0) = (this->input_keys_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_keys_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_keys_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_keys_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_keys_length);
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_input_keysi = strlen(this->input_keys[i]);
varToArr(outbuffer + offset, length_input_keysi);
offset += 4;
memcpy(outbuffer + offset, this->input_keys[i], length_input_keysi);
offset += length_input_keysi;
}
*(outbuffer + offset + 0) = (this->input_values_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->input_values_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->input_values_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->input_values_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->input_values_length);
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_input_valuesi = strlen(this->input_values[i]);
varToArr(outbuffer + offset, length_input_valuesi);
offset += 4;
memcpy(outbuffer + offset, this->input_values[i], length_input_valuesi);
offset += length_input_valuesi;
}
*(outbuffer + offset + 0) = (this->modifications_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->modifications_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->modifications_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->modifications_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->modifications_length);
for( uint32_t i = 0; i < modifications_length; i++){
offset += this->modifications[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
union {
int32_t real;
uint32_t base;
} u_behavior_checksum;
u_behavior_checksum.base = 0;
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_checksum.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_checksum = u_behavior_checksum.real;
offset += sizeof(this->behavior_checksum);
this->autonomy_level = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->autonomy_level);
uint32_t arg_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_keys_length);
if(arg_keys_lengthT > arg_keys_length)
this->arg_keys = (char**)realloc(this->arg_keys, arg_keys_lengthT * sizeof(char*));
arg_keys_length = arg_keys_lengthT;
for( uint32_t i = 0; i < arg_keys_length; i++){
uint32_t length_st_arg_keys;
arrToVar(length_st_arg_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_keys-1]=0;
this->st_arg_keys = (char *)(inbuffer + offset-1);
offset += length_st_arg_keys;
memcpy( &(this->arg_keys[i]), &(this->st_arg_keys), sizeof(char*));
}
uint32_t arg_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
arg_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->arg_values_length);
if(arg_values_lengthT > arg_values_length)
this->arg_values = (char**)realloc(this->arg_values, arg_values_lengthT * sizeof(char*));
arg_values_length = arg_values_lengthT;
for( uint32_t i = 0; i < arg_values_length; i++){
uint32_t length_st_arg_values;
arrToVar(length_st_arg_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_arg_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_arg_values-1]=0;
this->st_arg_values = (char *)(inbuffer + offset-1);
offset += length_st_arg_values;
memcpy( &(this->arg_values[i]), &(this->st_arg_values), sizeof(char*));
}
uint32_t input_keys_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_keys_length);
if(input_keys_lengthT > input_keys_length)
this->input_keys = (char**)realloc(this->input_keys, input_keys_lengthT * sizeof(char*));
input_keys_length = input_keys_lengthT;
for( uint32_t i = 0; i < input_keys_length; i++){
uint32_t length_st_input_keys;
arrToVar(length_st_input_keys, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_keys; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_keys-1]=0;
this->st_input_keys = (char *)(inbuffer + offset-1);
offset += length_st_input_keys;
memcpy( &(this->input_keys[i]), &(this->st_input_keys), sizeof(char*));
}
uint32_t input_values_lengthT = ((uint32_t) (*(inbuffer + offset)));
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
input_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->input_values_length);
if(input_values_lengthT > input_values_length)
this->input_values = (char**)realloc(this->input_values, input_values_lengthT * sizeof(char*));
input_values_length = input_values_lengthT;
for( uint32_t i = 0; i < input_values_length; i++){
uint32_t length_st_input_values;
arrToVar(length_st_input_values, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_input_values; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_input_values-1]=0;
this->st_input_values = (char *)(inbuffer + offset-1);
offset += length_st_input_values;
memcpy( &(this->input_values[i]), &(this->st_input_values), sizeof(char*));
}
uint32_t modifications_lengthT = ((uint32_t) (*(inbuffer + offset)));
modifications_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
modifications_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
modifications_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->modifications_length);
if(modifications_lengthT > modifications_length)
this->modifications = (flexbe_msgs::BehaviorModification*)realloc(this->modifications, modifications_lengthT * sizeof(flexbe_msgs::BehaviorModification));
modifications_length = modifications_lengthT;
for( uint32_t i = 0; i < modifications_length; i++){
offset += this->st_modifications.deserialize(inbuffer + offset);
memcpy( &(this->modifications[i]), &(this->st_modifications), sizeof(flexbe_msgs::BehaviorModification));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BehaviorSelection"; };
const char * getMD5(){ return "514f1b101295bdbd417ee6cc46e3823c"; };
};
}
#endif
| 12,853 | C | 46.962686 | 162 | 0.584922 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BEStatus.h | #ifndef _ROS_flexbe_msgs_BEStatus_h
#define _ROS_flexbe_msgs_BEStatus_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
namespace flexbe_msgs
{
class BEStatus : public ros::Msg
{
public:
typedef ros::Time _stamp_type;
_stamp_type stamp;
typedef int32_t _behavior_id_type;
_behavior_id_type behavior_id;
typedef uint8_t _code_type;
_code_type code;
uint32_t args_length;
typedef char* _args_type;
_args_type st_args;
_args_type * args;
enum { STARTED = 0 };
enum { FINISHED = 1 };
enum { FAILED = 2 };
enum { LOCKED = 4 };
enum { WAITING = 5 };
enum { SWITCHING = 6 };
enum { WARNING = 10 };
enum { ERROR = 11 };
enum { READY = 20 };
BEStatus():
stamp(),
behavior_id(0),
code(0),
args_length(0), args(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->stamp.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp.sec);
*(outbuffer + offset + 0) = (this->stamp.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->stamp.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->stamp.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->stamp.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->stamp.nsec);
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.real = this->behavior_id;
*(outbuffer + offset + 0) = (u_behavior_id.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_behavior_id.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_behavior_id.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_behavior_id.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->behavior_id);
*(outbuffer + offset + 0) = (this->code >> (8 * 0)) & 0xFF;
offset += sizeof(this->code);
*(outbuffer + offset + 0) = (this->args_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->args_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->args_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->args_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->args_length);
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_argsi = strlen(this->args[i]);
varToArr(outbuffer + offset, length_argsi);
offset += 4;
memcpy(outbuffer + offset, this->args[i], length_argsi);
offset += length_argsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->stamp.sec = ((uint32_t) (*(inbuffer + offset)));
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp.sec);
this->stamp.nsec = ((uint32_t) (*(inbuffer + offset)));
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->stamp.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->stamp.nsec);
union {
int32_t real;
uint32_t base;
} u_behavior_id;
u_behavior_id.base = 0;
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_behavior_id.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->behavior_id = u_behavior_id.real;
offset += sizeof(this->behavior_id);
this->code = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->code);
uint32_t args_lengthT = ((uint32_t) (*(inbuffer + offset)));
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->args_length);
if(args_lengthT > args_length)
this->args = (char**)realloc(this->args, args_lengthT * sizeof(char*));
args_length = args_lengthT;
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_st_args;
arrToVar(length_st_args, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_args; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_args-1]=0;
this->st_args = (char *)(inbuffer + offset-1);
offset += length_st_args;
memcpy( &(this->args[i]), &(this->st_args), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/BEStatus"; };
const char * getMD5(){ return "467355de4ad406f864268f41621cb885"; };
};
}
#endif
| 5,383 | C | 37.457143 | 79 | 0.529073 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorSynthesisAction.h | #ifndef _ROS_flexbe_msgs_BehaviorSynthesisAction_h
#define _ROS_flexbe_msgs_BehaviorSynthesisAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "flexbe_msgs/BehaviorSynthesisActionGoal.h"
#include "flexbe_msgs/BehaviorSynthesisActionResult.h"
#include "flexbe_msgs/BehaviorSynthesisActionFeedback.h"
namespace flexbe_msgs
{
class BehaviorSynthesisAction : public ros::Msg
{
public:
typedef flexbe_msgs::BehaviorSynthesisActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef flexbe_msgs::BehaviorSynthesisActionResult _action_result_type;
_action_result_type action_result;
typedef flexbe_msgs::BehaviorSynthesisActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
BehaviorSynthesisAction():
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 "flexbe_msgs/BehaviorSynthesisAction"; };
const char * getMD5(){ return "3f70602e7ef6378d09fa82dd8284fb29"; };
};
}
#endif
| 1,704 | C | 28.91228 | 81 | 0.703638 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/CommandFeedback.h | #ifndef _ROS_flexbe_msgs_CommandFeedback_h
#define _ROS_flexbe_msgs_CommandFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class CommandFeedback : public ros::Msg
{
public:
typedef const char* _command_type;
_command_type command;
uint32_t args_length;
typedef char* _args_type;
_args_type st_args;
_args_type * args;
CommandFeedback():
command(""),
args_length(0), args(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
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->args_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->args_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->args_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->args_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->args_length);
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_argsi = strlen(this->args[i]);
varToArr(outbuffer + offset, length_argsi);
offset += 4;
memcpy(outbuffer + offset, this->args[i], length_argsi);
offset += length_argsi;
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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;
uint32_t args_lengthT = ((uint32_t) (*(inbuffer + offset)));
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
args_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->args_length);
if(args_lengthT > args_length)
this->args = (char**)realloc(this->args, args_lengthT * sizeof(char*));
args_length = args_lengthT;
for( uint32_t i = 0; i < args_length; i++){
uint32_t length_st_args;
arrToVar(length_st_args, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_st_args; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_st_args-1]=0;
this->st_args = (char *)(inbuffer + offset-1);
offset += length_st_args;
memcpy( &(this->args[i]), &(this->st_args), sizeof(char*));
}
return offset;
}
const char * getType(){ return "flexbe_msgs/CommandFeedback"; };
const char * getMD5(){ return "0c984ea7f8fc562a9c04a778877e1a03"; };
};
}
#endif
| 3,030 | C | 31.591398 | 79 | 0.578548 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/flexbe_msgs/BehaviorInputFeedback.h | #ifndef _ROS_flexbe_msgs_BehaviorInputFeedback_h
#define _ROS_flexbe_msgs_BehaviorInputFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace flexbe_msgs
{
class BehaviorInputFeedback : public ros::Msg
{
public:
BehaviorInputFeedback()
{
}
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 "flexbe_msgs/BehaviorInputFeedback"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 698 | C | 16.923076 | 74 | 0.663324 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rospy_tutorials/HeaderString.h | #ifndef _ROS_rospy_tutorials_HeaderString_h
#define _ROS_rospy_tutorials_HeaderString_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
namespace rospy_tutorials
{
class HeaderString : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef const char* _data_type;
_data_type data;
HeaderString():
header(),
data("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
uint32_t length_data = strlen(this->data);
varToArr(outbuffer + offset, length_data);
offset += 4;
memcpy(outbuffer + offset, this->data, length_data);
offset += length_data;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
uint32_t length_data;
arrToVar(length_data, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_data; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_data-1]=0;
this->data = (char *)(inbuffer + offset-1);
offset += length_data;
return offset;
}
const char * getType(){ return "rospy_tutorials/HeaderString"; };
const char * getMD5(){ return "c99a9440709e4d4a9716d55b8270d5e7"; };
};
}
#endif
| 1,513 | C | 23.419354 | 72 | 0.619299 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rospy_tutorials/AddTwoInts.h | #ifndef _ROS_SERVICE_AddTwoInts_h
#define _ROS_SERVICE_AddTwoInts_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rospy_tutorials
{
static const char ADDTWOINTS[] = "rospy_tutorials/AddTwoInts";
class AddTwoIntsRequest : public ros::Msg
{
public:
typedef int64_t _a_type;
_a_type a;
typedef int64_t _b_type;
_b_type b;
AddTwoIntsRequest():
a(0),
b(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_a;
u_a.real = this->a;
*(outbuffer + offset + 0) = (u_a.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_a.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_a.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_a.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_a.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_a.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_a.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_a.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->a);
union {
int64_t real;
uint64_t base;
} u_b;
u_b.real = this->b;
*(outbuffer + offset + 0) = (u_b.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_b.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_b.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_b.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_b.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_b.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_b.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_b.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->b);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_a;
u_a.base = 0;
u_a.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->a = u_a.real;
offset += sizeof(this->a);
union {
int64_t real;
uint64_t base;
} u_b;
u_b.base = 0;
u_b.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_b.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->b = u_b.real;
offset += sizeof(this->b);
return offset;
}
const char * getType(){ return ADDTWOINTS; };
const char * getMD5(){ return "36d09b846be0b371c5f190354dd3153e"; };
};
class AddTwoIntsResponse : public ros::Msg
{
public:
typedef int64_t _sum_type;
_sum_type sum;
AddTwoIntsResponse():
sum(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_sum;
u_sum.real = this->sum;
*(outbuffer + offset + 0) = (u_sum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sum.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_sum.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_sum.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_sum.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_sum.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->sum);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_sum;
u_sum.base = 0;
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_sum.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->sum = u_sum.real;
offset += sizeof(this->sum);
return offset;
}
const char * getType(){ return ADDTWOINTS; };
const char * getMD5(){ return "b88405221c77b1878a3cbbfff53428d7"; };
};
class AddTwoInts {
public:
typedef AddTwoIntsRequest Request;
typedef AddTwoIntsResponse Response;
};
}
#endif
| 5,573 | C | 32.377245 | 72 | 0.485017 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rospy_tutorials/BadTwoInts.h | #ifndef _ROS_SERVICE_BadTwoInts_h
#define _ROS_SERVICE_BadTwoInts_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rospy_tutorials
{
static const char BADTWOINTS[] = "rospy_tutorials/BadTwoInts";
class BadTwoIntsRequest : public ros::Msg
{
public:
typedef int64_t _a_type;
_a_type a;
typedef int32_t _b_type;
_b_type b;
BadTwoIntsRequest():
a(0),
b(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_a;
u_a.real = this->a;
*(outbuffer + offset + 0) = (u_a.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_a.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_a.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_a.base >> (8 * 3)) & 0xFF;
*(outbuffer + offset + 4) = (u_a.base >> (8 * 4)) & 0xFF;
*(outbuffer + offset + 5) = (u_a.base >> (8 * 5)) & 0xFF;
*(outbuffer + offset + 6) = (u_a.base >> (8 * 6)) & 0xFF;
*(outbuffer + offset + 7) = (u_a.base >> (8 * 7)) & 0xFF;
offset += sizeof(this->a);
union {
int32_t real;
uint32_t base;
} u_b;
u_b.real = this->b;
*(outbuffer + offset + 0) = (u_b.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_b.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_b.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_b.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->b);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int64_t real;
uint64_t base;
} u_a;
u_a.base = 0;
u_a.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
u_a.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
this->a = u_a.real;
offset += sizeof(this->a);
union {
int32_t real;
uint32_t base;
} u_b;
u_b.base = 0;
u_b.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_b.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_b.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_b.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->b = u_b.real;
offset += sizeof(this->b);
return offset;
}
const char * getType(){ return BADTWOINTS; };
const char * getMD5(){ return "29bb5c7dea8bf822f53e94b0ee5a3a56"; };
};
class BadTwoIntsResponse : public ros::Msg
{
public:
typedef int32_t _sum_type;
_sum_type sum;
BadTwoIntsResponse():
sum(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_sum;
u_sum.real = this->sum;
*(outbuffer + offset + 0) = (u_sum.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_sum.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_sum.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_sum.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->sum);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
union {
int32_t real;
uint32_t base;
} u_sum;
u_sum.base = 0;
u_sum.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_sum.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_sum.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_sum.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->sum = u_sum.real;
offset += sizeof(this->sum);
return offset;
}
const char * getType(){ return BADTWOINTS; };
const char * getMD5(){ return "0ba699c25c9418c0366f3595c0c8e8ec"; };
};
class BadTwoInts {
public:
typedef BadTwoIntsRequest Request;
typedef BadTwoIntsResponse Response;
};
}
#endif
| 4,485 | C | 28.708609 | 72 | 0.495652 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/rospy_tutorials/Floats.h | #ifndef _ROS_rospy_tutorials_Floats_h
#define _ROS_rospy_tutorials_Floats_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace rospy_tutorials
{
class Floats : public ros::Msg
{
public:
uint32_t data_length;
typedef float _data_type;
_data_type st_data;
_data_type * data;
Floats():
data_length(0), data(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(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++){
union {
float real;
uint32_t base;
} u_datai;
u_datai.real = this->data[i];
*(outbuffer + offset + 0) = (u_datai.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_datai.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_datai.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_datai.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->data[i]);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
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 = (float*)realloc(this->data, data_lengthT * sizeof(float));
data_length = data_lengthT;
for( uint32_t i = 0; i < data_length; i++){
union {
float real;
uint32_t base;
} u_st_data;
u_st_data.base = 0;
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_st_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->st_data = u_st_data.real;
offset += sizeof(this->st_data);
memcpy( &(this->data[i]), &(this->st_data), sizeof(float));
}
return offset;
}
const char * getType(){ return "rospy_tutorials/Floats"; };
const char * getMD5(){ return "420cd38b6b071cd49f2970c3e2cee511"; };
};
}
#endif
| 2,694 | C | 31.469879 | 79 | 0.530809 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformGoal.h | #ifndef _ROS_tf2_msgs_LookupTransformGoal_h
#define _ROS_tf2_msgs_LookupTransformGoal_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "ros/time.h"
#include "ros/duration.h"
namespace tf2_msgs
{
class LookupTransformGoal : public ros::Msg
{
public:
typedef const char* _target_frame_type;
_target_frame_type target_frame;
typedef const char* _source_frame_type;
_source_frame_type source_frame;
typedef ros::Time _source_time_type;
_source_time_type source_time;
typedef ros::Duration _timeout_type;
_timeout_type timeout;
typedef ros::Time _target_time_type;
_target_time_type target_time;
typedef const char* _fixed_frame_type;
_fixed_frame_type fixed_frame;
typedef bool _advanced_type;
_advanced_type advanced;
LookupTransformGoal():
target_frame(""),
source_frame(""),
source_time(),
timeout(),
target_time(),
fixed_frame(""),
advanced(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_target_frame = strlen(this->target_frame);
varToArr(outbuffer + offset, length_target_frame);
offset += 4;
memcpy(outbuffer + offset, this->target_frame, length_target_frame);
offset += length_target_frame;
uint32_t length_source_frame = strlen(this->source_frame);
varToArr(outbuffer + offset, length_source_frame);
offset += 4;
memcpy(outbuffer + offset, this->source_frame, length_source_frame);
offset += length_source_frame;
*(outbuffer + offset + 0) = (this->source_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->source_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->source_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->source_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->source_time.sec);
*(outbuffer + offset + 0) = (this->source_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->source_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->source_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->source_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->source_time.nsec);
*(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);
*(outbuffer + offset + 0) = (this->target_time.sec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->target_time.sec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->target_time.sec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->target_time.sec >> (8 * 3)) & 0xFF;
offset += sizeof(this->target_time.sec);
*(outbuffer + offset + 0) = (this->target_time.nsec >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->target_time.nsec >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->target_time.nsec >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->target_time.nsec >> (8 * 3)) & 0xFF;
offset += sizeof(this->target_time.nsec);
uint32_t length_fixed_frame = strlen(this->fixed_frame);
varToArr(outbuffer + offset, length_fixed_frame);
offset += 4;
memcpy(outbuffer + offset, this->fixed_frame, length_fixed_frame);
offset += length_fixed_frame;
union {
bool real;
uint8_t base;
} u_advanced;
u_advanced.real = this->advanced;
*(outbuffer + offset + 0) = (u_advanced.base >> (8 * 0)) & 0xFF;
offset += sizeof(this->advanced);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_target_frame;
arrToVar(length_target_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_target_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_target_frame-1]=0;
this->target_frame = (char *)(inbuffer + offset-1);
offset += length_target_frame;
uint32_t length_source_frame;
arrToVar(length_source_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_source_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_source_frame-1]=0;
this->source_frame = (char *)(inbuffer + offset-1);
offset += length_source_frame;
this->source_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->source_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->source_time.sec);
this->source_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->source_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->source_time.nsec);
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);
this->target_time.sec = ((uint32_t) (*(inbuffer + offset)));
this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->target_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->target_time.sec);
this->target_time.nsec = ((uint32_t) (*(inbuffer + offset)));
this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
this->target_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->target_time.nsec);
uint32_t length_fixed_frame;
arrToVar(length_fixed_frame, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_fixed_frame; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_fixed_frame-1]=0;
this->fixed_frame = (char *)(inbuffer + offset-1);
offset += length_fixed_frame;
union {
bool real;
uint8_t base;
} u_advanced;
u_advanced.base = 0;
u_advanced.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
this->advanced = u_advanced.real;
offset += sizeof(this->advanced);
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformGoal"; };
const char * getMD5(){ return "35e3720468131d675a18bb6f3e5f22f8"; };
};
}
#endif
| 8,034 | C | 43.888268 | 83 | 0.564974 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformActionResult.h | #ifndef _ROS_tf2_msgs_LookupTransformActionResult_h
#define _ROS_tf2_msgs_LookupTransformActionResult_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 "tf2_msgs/LookupTransformResult.h"
namespace tf2_msgs
{
class LookupTransformActionResult : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef tf2_msgs::LookupTransformResult _result_type;
_result_type result;
LookupTransformActionResult():
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 "tf2_msgs/LookupTransformActionResult"; };
const char * getMD5(){ return "ac26ce75a41384fa8bb4dc10f491ab90"; };
};
}
#endif
| 1,480 | C | 24.982456 | 77 | 0.670946 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformActionFeedback.h | #ifndef _ROS_tf2_msgs_LookupTransformActionFeedback_h
#define _ROS_tf2_msgs_LookupTransformActionFeedback_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 "tf2_msgs/LookupTransformFeedback.h"
namespace tf2_msgs
{
class LookupTransformActionFeedback : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef actionlib_msgs::GoalStatus _status_type;
_status_type status;
typedef tf2_msgs::LookupTransformFeedback _feedback_type;
_feedback_type feedback;
LookupTransformActionFeedback():
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 "tf2_msgs/LookupTransformActionFeedback"; };
const char * getMD5(){ return "aae20e09065c3809e8a8e87c4c8953fd"; };
};
}
#endif
| 1,506 | C | 25.438596 | 79 | 0.676627 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/FrameGraph.h | #ifndef _ROS_SERVICE_FrameGraph_h
#define _ROS_SERVICE_FrameGraph_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace tf2_msgs
{
static const char FRAMEGRAPH[] = "tf2_msgs/FrameGraph";
class FrameGraphRequest : public ros::Msg
{
public:
FrameGraphRequest()
{
}
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 FRAMEGRAPH; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
class FrameGraphResponse : public ros::Msg
{
public:
typedef const char* _frame_yaml_type;
_frame_yaml_type frame_yaml;
FrameGraphResponse():
frame_yaml("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
uint32_t length_frame_yaml = strlen(this->frame_yaml);
varToArr(outbuffer + offset, length_frame_yaml);
offset += 4;
memcpy(outbuffer + offset, this->frame_yaml, length_frame_yaml);
offset += length_frame_yaml;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t length_frame_yaml;
arrToVar(length_frame_yaml, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_frame_yaml; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_frame_yaml-1]=0;
this->frame_yaml = (char *)(inbuffer + offset-1);
offset += length_frame_yaml;
return offset;
}
const char * getType(){ return FRAMEGRAPH; };
const char * getMD5(){ return "437ea58e9463815a0d511c7326b686b0"; };
};
class FrameGraph {
public:
typedef FrameGraphRequest Request;
typedef FrameGraphResponse Response;
};
}
#endif
| 1,961 | C | 21.295454 | 72 | 0.628761 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformResult.h | #ifndef _ROS_tf2_msgs_LookupTransformResult_h
#define _ROS_tf2_msgs_LookupTransformResult_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/TransformStamped.h"
#include "tf2_msgs/TF2Error.h"
namespace tf2_msgs
{
class LookupTransformResult : public ros::Msg
{
public:
typedef geometry_msgs::TransformStamped _transform_type;
_transform_type transform;
typedef tf2_msgs::TF2Error _error_type;
_error_type error;
LookupTransformResult():
transform(),
error()
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
offset += this->transform.serialize(outbuffer + offset);
offset += this->error.serialize(outbuffer + offset);
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
offset += this->transform.deserialize(inbuffer + offset);
offset += this->error.deserialize(inbuffer + offset);
return offset;
}
const char * getType(){ return "tf2_msgs/LookupTransformResult"; };
const char * getMD5(){ return "3fe5db6a19ca9cfb675418c5ad875c36"; };
};
}
#endif
| 1,208 | C | 22.705882 | 72 | 0.666391 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/TF2Error.h | #ifndef _ROS_tf2_msgs_TF2Error_h
#define _ROS_tf2_msgs_TF2Error_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace tf2_msgs
{
class TF2Error : public ros::Msg
{
public:
typedef uint8_t _error_type;
_error_type error;
typedef const char* _error_string_type;
_error_string_type error_string;
enum { NO_ERROR = 0 };
enum { LOOKUP_ERROR = 1 };
enum { CONNECTIVITY_ERROR = 2 };
enum { EXTRAPOLATION_ERROR = 3 };
enum { INVALID_ARGUMENT_ERROR = 4 };
enum { TIMEOUT_ERROR = 5 };
enum { TRANSFORM_ERROR = 6 };
TF2Error():
error(0),
error_string("")
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->error >> (8 * 0)) & 0xFF;
offset += sizeof(this->error);
uint32_t length_error_string = strlen(this->error_string);
varToArr(outbuffer + offset, length_error_string);
offset += 4;
memcpy(outbuffer + offset, this->error_string, length_error_string);
offset += length_error_string;
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
this->error = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->error);
uint32_t length_error_string;
arrToVar(length_error_string, (inbuffer + offset));
offset += 4;
for(unsigned int k= offset; k< offset+length_error_string; ++k){
inbuffer[k-1]=inbuffer[k];
}
inbuffer[offset+length_error_string-1]=0;
this->error_string = (char *)(inbuffer + offset-1);
offset += length_error_string;
return offset;
}
const char * getType(){ return "tf2_msgs/TF2Error"; };
const char * getMD5(){ return "bc6848fd6fd750c92e38575618a4917d"; };
};
}
#endif
| 1,890 | C | 26.014285 | 74 | 0.595238 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformFeedback.h | #ifndef _ROS_tf2_msgs_LookupTransformFeedback_h
#define _ROS_tf2_msgs_LookupTransformFeedback_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace tf2_msgs
{
class LookupTransformFeedback : public ros::Msg
{
public:
LookupTransformFeedback()
{
}
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 "tf2_msgs/LookupTransformFeedback"; };
const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
};
}
#endif
| 696 | C | 16.871794 | 73 | 0.662356 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformAction.h | #ifndef _ROS_tf2_msgs_LookupTransformAction_h
#define _ROS_tf2_msgs_LookupTransformAction_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "tf2_msgs/LookupTransformActionGoal.h"
#include "tf2_msgs/LookupTransformActionResult.h"
#include "tf2_msgs/LookupTransformActionFeedback.h"
namespace tf2_msgs
{
class LookupTransformAction : public ros::Msg
{
public:
typedef tf2_msgs::LookupTransformActionGoal _action_goal_type;
_action_goal_type action_goal;
typedef tf2_msgs::LookupTransformActionResult _action_result_type;
_action_result_type action_result;
typedef tf2_msgs::LookupTransformActionFeedback _action_feedback_type;
_action_feedback_type action_feedback;
LookupTransformAction():
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 "tf2_msgs/LookupTransformAction"; };
const char * getMD5(){ return "7ee01ba91a56c2245c610992dbaa3c37"; };
};
}
#endif
| 1,652 | C | 28 | 76 | 0.69431 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/LookupTransformActionGoal.h | #ifndef _ROS_tf2_msgs_LookupTransformActionGoal_h
#define _ROS_tf2_msgs_LookupTransformActionGoal_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 "tf2_msgs/LookupTransformGoal.h"
namespace tf2_msgs
{
class LookupTransformActionGoal : 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 tf2_msgs::LookupTransformGoal _goal_type;
_goal_type goal;
LookupTransformActionGoal():
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 "tf2_msgs/LookupTransformActionGoal"; };
const char * getMD5(){ return "f2e7bcdb75c847978d0351a13e699da5"; };
};
}
#endif
| 1,452 | C | 24.491228 | 75 | 0.660468 |
renanmb/Omniverse_legged_robotics/URDF-Descriptions/OpenQuadruped/OpenQuadruped-spot_mini_mini-spot/spot_real/Control/Teensy/SpotMiniMini/lib/ros_lib/tf2_msgs/TFMessage.h | #ifndef _ROS_tf2_msgs_TFMessage_h
#define _ROS_tf2_msgs_TFMessage_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "geometry_msgs/TransformStamped.h"
namespace tf2_msgs
{
class TFMessage : public ros::Msg
{
public:
uint32_t transforms_length;
typedef geometry_msgs::TransformStamped _transforms_type;
_transforms_type st_transforms;
_transforms_type * transforms;
TFMessage():
transforms_length(0), transforms(NULL)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
*(outbuffer + offset + 0) = (this->transforms_length >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (this->transforms_length >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (this->transforms_length >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (this->transforms_length >> (8 * 3)) & 0xFF;
offset += sizeof(this->transforms_length);
for( uint32_t i = 0; i < transforms_length; i++){
offset += this->transforms[i].serialize(outbuffer + offset);
}
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
uint32_t transforms_lengthT = ((uint32_t) (*(inbuffer + offset)));
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
transforms_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
offset += sizeof(this->transforms_length);
if(transforms_lengthT > transforms_length)
this->transforms = (geometry_msgs::TransformStamped*)realloc(this->transforms, transforms_lengthT * sizeof(geometry_msgs::TransformStamped));
transforms_length = transforms_lengthT;
for( uint32_t i = 0; i < transforms_length; i++){
offset += this->st_transforms.deserialize(inbuffer + offset);
memcpy( &(this->transforms[i]), &(this->st_transforms), sizeof(geometry_msgs::TransformStamped));
}
return offset;
}
const char * getType(){ return "tf2_msgs/TFMessage"; };
const char * getMD5(){ return "94810edda583a504dfda3829e70d7eec"; };
};
}
#endif
| 2,234 | C | 33.384615 | 149 | 0.619964 |
Subsets and Splits