Exemplo n.º 1
0
        public static void write(geometry_msgs.msg.Inertia data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_6(data.m);

            geometry_msgs.msg.Vector3PubSubType.write(data.com, cdr);

            cdr.write_type_6(data.ixx);

            cdr.write_type_6(data.ixy);

            cdr.write_type_6(data.ixz);

            cdr.write_type_6(data.iyy);

            cdr.write_type_6(data.iyz);

            cdr.write_type_6(data.izz);
        }
        public static void write(shape_msgs.msg.SolidPrimitive data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.type);

            if (data.dimensions == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int dimensions_length = data.dimensions.Count;
                cdr.write_type_2(dimensions_length);
                for (int i0 = 0; i0 < dimensions_length; i0++)
                {
                    cdr.write_type_6(data.dimensions[i0]);
                }
            }
        }
        public static void write(actionlib_msgs.msg.GoalStatusArray data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            if (data.status_list == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int status_list_length = data.status_list.Count;
                cdr.write_type_2(status_list_length);
                for (int i0 = 0; i0 < status_list_length; i0++)
                {
                    actionlib_msgs.msg.GoalStatusPubSubType.write(data.status_list[i0], cdr);
                }
            }
        }
Exemplo n.º 4
0
        public static void write(nav_msgs.msg.Path data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            if (data.poses == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int poses_length = data.poses.Count;
                cdr.write_type_2(poses_length);
                for (int i0 = 0; i0 < poses_length; i0++)
                {
                    geometry_msgs.msg.PoseStampedPubSubType.write(data.poses[i0], cdr);
                }
            }
        }
        public static void write(test.FooEnumType data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_d(data.name);

            if (data.enumValues == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int enumValues_length = data.enumValues.Count;
                cdr.write_type_2(enumValues_length);
                for (int i0 = 0; i0 < enumValues_length; i0++)
                {
                    cdr.write_type_d(data.enumValues[i0]);
                }
            }
        }
Exemplo n.º 6
0
        public static void write(stereo_msgs.msg.DisparityImage data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            sensor_msgs.msg.ImagePubSubType.write(data.image, cdr);

            cdr.write_type_5(data.f);

            cdr.write_type_5(data.t);

            sensor_msgs.msg.RegionOfInterestPubSubType.write(data.valid_window, cdr);

            cdr.write_type_5(data.min_disparity);

            cdr.write_type_5(data.max_disparity);

            cdr.write_type_5(data.delta_d);
        }
        public static void write(std_msgs.msg.Int64MultiArray data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.MultiArrayLayoutPubSubType.write(data.layout, cdr);

            if (data.data == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int data_length = data.data.Count;
                cdr.write_type_2(data_length);
                for (int i0 = 0; i0 < data_length; i0++)
                {
                    cdr.write_type_11(data.data[i0]);
                }
            }
        }
Exemplo n.º 8
0
        public static void write(test.BigMessage data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_2(data.id);

            if (data.largeSequence == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int largeSequence_length = data.largeSequence.Count;
                cdr.write_type_2(largeSequence_length);
                for (int i0 = 0; i0 < largeSequence_length; i0++)
                {
                    test.IDLSubmessagePubSubType.write(data.largeSequence[i0], cdr);
                }
            }
        }
Exemplo n.º 9
0
        public static void write(halodi_msgs.msg.ARMarkers data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            if (data.markers == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int markers_length = data.markers.Count;
                cdr.write_type_2(markers_length);
                for (int i0 = 0; i0 < markers_length; i0++)
                {
                    halodi_msgs.msg.ARMarkerPubSubType.write(data.markers[i0], cdr);
                }
            }
        }
        public static void write(sensor_msgs.msg.ChannelFloat32 data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_d(data.name);

            if (data.values == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int values_length = data.values.Count;
                cdr.write_type_2(values_length);
                for (int i0 = 0; i0 < values_length; i0++)
                {
                    cdr.write_type_5(data.values[i0]);
                }
            }
        }
        public static void write(diagnostic_msgs.msg.DiagnosticArray data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            if (data.status == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int status_length = data.status.Count;
                cdr.write_type_2(status_length);
                for (int i0 = 0; i0 < status_length; i0++)
                {
                    diagnostic_msgs.msg.DiagnosticStatusPubSubType.write(data.status[i0], cdr);
                }
            }
        }
Exemplo n.º 12
0
        public static void write(sensor_msgs.msg.CameraInfo data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_4(data.height);

            cdr.write_type_4(data.width);

            cdr.write_type_d(data.distortion_model);

            if (data.d == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int d_length = data.d.Count;
                cdr.write_type_2(d_length);
                for (int i0 = 0; i0 < d_length; i0++)
                {
                    cdr.write_type_6(data.d[i0]);
                }
            }
            for (int i0 = 0; i0 < 9; ++i0)
            {
                cdr.write_type_6(data.k[i0]);
            }

            for (int i0 = 0; i0 < 9; ++i0)
            {
                cdr.write_type_6(data.r[i0]);
            }

            for (int i0 = 0; i0 < 12; ++i0)
            {
                cdr.write_type_6(data.p[i0]);
            }

            cdr.write_type_4(data.binning_x);

            cdr.write_type_4(data.binning_y);

            sensor_msgs.msg.RegionOfInterestPubSubType.write(data.roi, cdr);
        }
Exemplo n.º 13
0
        public static void write(sensor_msgs.msg.NavSatFix data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            sensor_msgs.msg.NavSatStatusPubSubType.write(data.status, cdr);

            cdr.write_type_6(data.latitude);

            cdr.write_type_6(data.longitude);

            cdr.write_type_6(data.altitude);

            for (int i0 = 0; i0 < 9; ++i0)
            {
                cdr.write_type_6(data.position_covariance[i0]);
            }

            cdr.write_type_9(data.position_covariance_type);
        }
Exemplo n.º 14
0
        public static void write(halodi_msgs.msg.ARMarker data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_d(data.data);

            if (data.points == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int points_length = data.points.Count;
                cdr.write_type_2(points_length);
                for (int i0 = 0; i0 < points_length; i0++)
                {
                    geometry_msgs.msg.PointPubSubType.write(data.points[i0], cdr);
                }
            }
            geometry_msgs.msg.PoseStampedPubSubType.write(data.pose, cdr);
        }
Exemplo n.º 15
0
        public static void write(sensor_msgs.msg.PointCloud2 data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_4(data.height);

            cdr.write_type_4(data.width);

            if (data.fields == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int fields_length = data.fields.Count;
                cdr.write_type_2(fields_length);
                for (int i0 = 0; i0 < fields_length; i0++)
                {
                    sensor_msgs.msg.PointFieldPubSubType.write(data.fields[i0], cdr);
                }
            }
            cdr.write_type_7(data.is_bigendian);

            cdr.write_type_4(data.point_step);

            cdr.write_type_4(data.row_step);

            if (data.data == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int data_length = data.data.Count;
                cdr.write_type_2(data_length);
                for (int i0 = 0; i0 < data_length; i0++)
                {
                    cdr.write_type_9(data.data[i0]);
                }
            }
            cdr.write_type_7(data.is_dense);
        }
 public static void write(halodi_msgs.msg.ExtrinsicCalibration data, Halodi.CDR.CDRSerializer cdr)
 {
     if (data.sensors == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int sensors_length = data.sensors.Count;
         cdr.write_type_2(sensors_length);
         for (int i0 = 0; i0 < sensors_length; i0++)
         {
             geometry_msgs.msg.TransformStampedPubSubType.write(data.sensors[i0], cdr);
         }
     }
     if (data.links == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int links_length = data.links.Count;
         cdr.write_type_2(links_length);
         for (int i0 = 0; i0 < links_length; i0++)
         {
             geometry_msgs.msg.TransformStampedPubSubType.write(data.links[i0], cdr);
         }
     }
     if (data.joints == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int joints_length = data.joints.Count;
         cdr.write_type_2(joints_length);
         for (int i0 = 0; i0 < joints_length; i0++)
         {
             halodi_msgs.msg.JointCalibrationPubSubType.write(data.joints[i0], cdr);
         }
     }
 }
 public static void write(rcl_interfaces.msg.ParameterEventDescriptors data, Halodi.CDR.CDRSerializer cdr)
 {
     if (data.new_parameters == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int new_parameters_length = data.new_parameters.Count;
         cdr.write_type_2(new_parameters_length);
         for (int i0 = 0; i0 < new_parameters_length; i0++)
         {
             rcl_interfaces.msg.ParameterDescriptorPubSubType.write(data.new_parameters[i0], cdr);
         }
     }
     if (data.changed_parameters == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int changed_parameters_length = data.changed_parameters.Count;
         cdr.write_type_2(changed_parameters_length);
         for (int i0 = 0; i0 < changed_parameters_length; i0++)
         {
             rcl_interfaces.msg.ParameterDescriptorPubSubType.write(data.changed_parameters[i0], cdr);
         }
     }
     if (data.deleted_parameters == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int deleted_parameters_length = data.deleted_parameters.Count;
         cdr.write_type_2(deleted_parameters_length);
         for (int i0 = 0; i0 < deleted_parameters_length; i0++)
         {
             rcl_interfaces.msg.ParameterDescriptorPubSubType.write(data.deleted_parameters[i0], cdr);
         }
     }
 }
 public static void write(ocs2_ros2_msgs.msg.MpcTargetTrajectories data, Halodi.CDR.CDRSerializer cdr)
 {
     if (data.time_trajectory == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int time_trajectory_length = data.time_trajectory.Count;
         cdr.write_type_2(time_trajectory_length);
         for (int i0 = 0; i0 < time_trajectory_length; i0++)
         {
             cdr.write_type_5(data.time_trajectory[i0]);
         }
     }
     if (data.state_trajectory == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int state_trajectory_length = data.state_trajectory.Count;
         cdr.write_type_2(state_trajectory_length);
         for (int i0 = 0; i0 < state_trajectory_length; i0++)
         {
             ocs2_ros2_msgs.msg.MpcStatePubSubType.write(data.state_trajectory[i0], cdr);
         }
     }
     if (data.input_trajectory == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int input_trajectory_length = data.input_trajectory.Count;
         cdr.write_type_2(input_trajectory_length);
         for (int i0 = 0; i0 < input_trajectory_length; i0++)
         {
             ocs2_ros2_msgs.msg.MpcInputPubSubType.write(data.input_trajectory[i0], cdr);
         }
     }
 }
        public static void write(visualization_msgs.msg.InteractiveMarkerInit data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_d(data.server_id);

            cdr.write_type_12(data.seq_num);

            if (data.markers == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int markers_length = data.markers.Count;
                cdr.write_type_2(markers_length);
                for (int i0 = 0; i0 < markers_length; i0++)
                {
                    visualization_msgs.msg.InteractiveMarkerPubSubType.write(data.markers[i0], cdr);
                }
            }
        }
Exemplo n.º 20
0
        public static void write(nav_msgs.msg.OccupancyGrid data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            nav_msgs.msg.MapMetaDataPubSubType.write(data.info, cdr);

            if (data.data == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int data_length = data.data.Count;
                cdr.write_type_2(data_length);
                for (int i0 = 0; i0 < data_length; i0++)
                {
                    cdr.write_type_9(data.data[i0]);
                }
            }
        }
        public static void write(test.FooSummary data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_7(data.createSummary);

            cdr.write_type_d(data.summaryTriggerVariable);

            if (data.summarizedVariables == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int summarizedVariables_length = data.summarizedVariables.Count;
                cdr.write_type_2(summarizedVariables_length);
                for (int i0 = 0; i0 < summarizedVariables_length; i0++)
                {
                    cdr.write_type_d(data.summarizedVariables[i0]);
                }
            }
        }
        public static void write(sensor_msgs.msg.CompressedImage data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_d(data.format);

            if (data.data == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int data_length = data.data.Count;
                cdr.write_type_2(data_length);
                for (int i0 = 0; i0 < data_length; i0++)
                {
                    cdr.write_type_9(data.data[i0]);
                }
            }
        }
Exemplo n.º 23
0
        public static void write(halodi_msgs.msg.JointSpaceCommand data, Halodi.CDR.CDRSerializer cdr)
        {
            halodi_msgs.msg.JointNamePubSubType.write(data.joint, cdr);

            cdr.write_type_6(data.q_desired);

            cdr.write_type_6(data.qd_desired);

            cdr.write_type_6(data.qdd_desired);

            cdr.write_type_7(data.use_default_gains);

            cdr.write_type_6(data.stiffness);

            cdr.write_type_6(data.damping);

            cdr.write_type_6(data.motorDampingScale);

            cdr.write_type_6(data.max_feedback);
        }
Exemplo n.º 24
0
        public static void write(halodi_msgs.msg.DrivingTrajectory data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_6(data.look_ahead_distance);

            cdr.write_type_6(data.K);

            if (data.trajectory_points == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int trajectory_points_length = data.trajectory_points.Count;
                cdr.write_type_2(trajectory_points_length);
                for (int i0 = 0; i0 < trajectory_points_length; i0++)
                {
                    halodi_msgs.msg.DrivingTrajectoryPointPubSubType.write(data.trajectory_points[i0], cdr);
                }
            }
        }
        public static void write(ocs2_ros2_msgs.msg.MpcPerformanceIndices data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_5(data.init_time);

            cdr.write_type_5(data.merit);

            cdr.write_type_5(data.total_cost);

            cdr.write_type_5(data.state_eq_constraint_ise);

            cdr.write_type_5(data.state_eq_constraint_penalty);

            cdr.write_type_5(data.state_eq_finalconstraint_sse);

            cdr.write_type_5(data.state_eq_finalconstraint_penalty);

            cdr.write_type_5(data.state_input_eq_constraint_ise);

            cdr.write_type_5(data.inequality_constraint_ise);

            cdr.write_type_5(data.inequality_constraint_penalty);
        }
Exemplo n.º 26
0
        public static void write(nav_msgs.msg.GridCells data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_5(data.cell_width);

            cdr.write_type_5(data.cell_height);

            if (data.cells == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int cells_length = data.cells.Count;
                cdr.write_type_2(cells_length);
                for (int i0 = 0; i0 < cells_length; i0++)
                {
                    geometry_msgs.msg.PointPubSubType.write(data.cells[i0], cdr);
                }
            }
        }
        public static void write(rcl_interfaces.msg.ParameterDescriptor data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_d(data.name);

            cdr.write_type_9(data.type);

            cdr.write_type_d(data.description);

            cdr.write_type_d(data.additional_constraints);

            cdr.write_type_7(data.read_only);

            if (data.floating_point_range == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int floating_point_range_length = data.floating_point_range.Count;
                cdr.write_type_2(floating_point_range_length);
                for (int i0 = 0; i0 < floating_point_range_length; i0++)
                {
                    rcl_interfaces.msg.FloatingPointRangePubSubType.write(data.floating_point_range[i0], cdr);
                }
            }
            if (data.integer_range == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int integer_range_length = data.integer_range.Count;
                cdr.write_type_2(integer_range_length);
                for (int i0 = 0; i0 < integer_range_length; i0++)
                {
                    rcl_interfaces.msg.IntegerRangePubSubType.write(data.integer_range[i0], cdr);
                }
            }
        }
Exemplo n.º 28
0
        public static void write(visualization_msgs.msg.InteractiveMarker data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            geometry_msgs.msg.PosePubSubType.write(data.pose, cdr);

            cdr.write_type_d(data.name);

            cdr.write_type_d(data.description);

            cdr.write_type_5(data.scale);

            if (data.menu_entries == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int menu_entries_length = data.menu_entries.Count;
                cdr.write_type_2(menu_entries_length);
                for (int i0 = 0; i0 < menu_entries_length; i0++)
                {
                    visualization_msgs.msg.MenuEntryPubSubType.write(data.menu_entries[i0], cdr);
                }
            }
            if (data.controls == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int controls_length = data.controls.Count;
                cdr.write_type_2(controls_length);
                for (int i0 = 0; i0 < controls_length; i0++)
                {
                    visualization_msgs.msg.InteractiveMarkerControlPubSubType.write(data.controls[i0], cdr);
                }
            }
        }
        public static void write(test.FooYoVariableDefinition data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_d(data.name);

            cdr.write_type_d(data.description);

            cdr.write_type_c((int)data.type);


            cdr.write_type_3(data.registry);

            cdr.write_type_3(data.enumType);

            cdr.write_type_7(data.allowNullValues);

            cdr.write_type_7(data.isParameter);

            cdr.write_type_6(data.min);

            cdr.write_type_6(data.max);

            cdr.write_type_c((int)data.loadStatus);
        }
        public static void write(diagnostic_msgs.msg.DiagnosticStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.level);

            cdr.write_type_d(data.name);

            cdr.write_type_d(data.message);

            cdr.write_type_d(data.hardware_id);

            if (data.values == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int values_length = data.values.Count;
                cdr.write_type_2(values_length);
                for (int i0 = 0; i0 < values_length; i0++)
                {
                    diagnostic_msgs.msg.KeyValuePubSubType.write(data.values[i0], cdr);
                }
            }
        }