示例#1
0
        public static void write(geometry_msgs.msg.Point32 data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_5(data.x);

            cdr.write_type_5(data.y);

            cdr.write_type_5(data.z);
        }
示例#2
0
        public static void write(std_msgs.msg.ColorRGBA data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_5(data.r);

            cdr.write_type_5(data.g);

            cdr.write_type_5(data.b);

            cdr.write_type_5(data.a);
        }
        public static void write(sensor_msgs.msg.BatteryState data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_5(data.voltage);

            cdr.write_type_5(data.temperature);

            cdr.write_type_5(data.current);

            cdr.write_type_5(data.charge);

            cdr.write_type_5(data.capacity);

            cdr.write_type_5(data.design_capacity);

            cdr.write_type_5(data.percentage);

            cdr.write_type_9(data.power_supply_status);

            cdr.write_type_9(data.power_supply_health);

            cdr.write_type_9(data.power_supply_technology);

            cdr.write_type_7(data.present);

            if (data.cell_voltage == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int cell_voltage_length = data.cell_voltage.Count;
                cdr.write_type_2(cell_voltage_length);
                for (int i0 = 0; i0 < cell_voltage_length; i0++)
                {
                    cdr.write_type_5(data.cell_voltage[i0]);
                }
            }
            if (data.cell_temperature == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int cell_temperature_length = data.cell_temperature.Count;
                cdr.write_type_2(cell_temperature_length);
                for (int i0 = 0; i0 < cell_temperature_length; i0++)
                {
                    cdr.write_type_5(data.cell_temperature[i0]);
                }
            }
            cdr.write_type_d(data.location);

            cdr.write_type_d(data.serial_number);
        }
示例#4
0
        public static void write(sensor_msgs.msg.Range data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_9(data.radiation_type);

            cdr.write_type_5(data.field_of_view);

            cdr.write_type_5(data.min_range);

            cdr.write_type_5(data.max_range);

            cdr.write_type_5(data.range);
        }
示例#5
0
        public static void write(sensor_msgs.msg.Joy data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            if (data.axes == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int axes_length = data.axes.Count;
                cdr.write_type_2(axes_length);
                for (int i0 = 0; i0 < axes_length; i0++)
                {
                    cdr.write_type_5(data.axes[i0]);
                }
            }
            if (data.buttons == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int buttons_length = data.buttons.Count;
                cdr.write_type_2(buttons_length);
                for (int i0 = 0; i0 < buttons_length; i0++)
                {
                    cdr.write_type_2(data.buttons[i0]);
                }
            }
        }
 public static void write(ocs2_ros2_msgs.msg.ModeSchedule data, Halodi.CDR.CDRSerializer cdr)
 {
     if (data.event_times == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int event_times_length = data.event_times.Count;
         cdr.write_type_2(event_times_length);
         for (int i0 = 0; i0 < event_times_length; i0++)
         {
             cdr.write_type_5(data.event_times[i0]);
         }
     }
     if (data.mode_sequence == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int mode_sequence_length = data.mode_sequence.Count;
         cdr.write_type_2(mode_sequence_length);
         for (int i0 = 0; i0 < mode_sequence_length; i0++)
         {
             cdr.write_type_2(data.mode_sequence[i0]);
         }
     }
 }
        public static void write(sensor_msgs.msg.JoyFeedback data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.type);

            cdr.write_type_9(data.id);

            cdr.write_type_5(data.intensity);
        }
示例#8
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);
        }
示例#9
0
        public static void write(ocs2_ros2_msgs.msg.MpcObservation data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_5(data.time);

            ocs2_ros2_msgs.msg.MpcStatePubSubType.write(data.state, cdr);

            ocs2_ros2_msgs.msg.MpcInputPubSubType.write(data.input, cdr);

            cdr.write_type_9(data.mode);
        }
示例#10
0
        public static void write(nav_msgs.msg.MapMetaData data, Halodi.CDR.CDRSerializer cdr)
        {
            builtin_interfaces.msg.TimePubSubType.write(data.map_load_time, cdr);

            cdr.write_type_5(data.resolution);

            cdr.write_type_4(data.width);

            cdr.write_type_4(data.height);

            geometry_msgs.msg.PosePubSubType.write(data.origin, cdr);
        }
        public static void write(sensor_msgs.msg.LaserScan data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_5(data.angle_min);

            cdr.write_type_5(data.angle_max);

            cdr.write_type_5(data.angle_increment);

            cdr.write_type_5(data.time_increment);

            cdr.write_type_5(data.scan_time);

            cdr.write_type_5(data.range_min);

            cdr.write_type_5(data.range_max);

            if (data.ranges == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int ranges_length = data.ranges.Count;
                cdr.write_type_2(ranges_length);
                for (int i0 = 0; i0 < ranges_length; i0++)
                {
                    cdr.write_type_5(data.ranges[i0]);
                }
            }
            if (data.intensities == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int intensities_length = data.intensities.Count;
                cdr.write_type_2(intensities_length);
                for (int i0 = 0; i0 < intensities_length; i0++)
                {
                    cdr.write_type_5(data.intensities[i0]);
                }
            }
        }
示例#12
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(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);
        }
        public static void write(visualization_msgs.msg.ImageMarker data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_d(data.ns);

            cdr.write_type_2(data.id);

            cdr.write_type_2(data.type);

            cdr.write_type_2(data.action);

            geometry_msgs.msg.PointPubSubType.write(data.position, cdr);

            cdr.write_type_5(data.scale);

            std_msgs.msg.ColorRGBAPubSubType.write(data.outline_color, cdr);

            cdr.write_type_9(data.filled);

            std_msgs.msg.ColorRGBAPubSubType.write(data.fill_color, cdr);

            builtin_interfaces.msg.DurationPubSubType.write(data.lifetime, cdr);

            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);
                }
            }
            if (data.outline_colors == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int outline_colors_length = data.outline_colors.Count;
                cdr.write_type_2(outline_colors_length);
                for (int i0 = 0; i0 < outline_colors_length; i0++)
                {
                    std_msgs.msg.ColorRGBAPubSubType.write(data.outline_colors[i0], cdr);
                }
            }
        }
示例#15
0
 public static void write(ocs2_ros2_msgs.msg.MpcInput data, Halodi.CDR.CDRSerializer cdr)
 {
     if (data.value == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int value_length = data.value.Count;
         cdr.write_type_2(value_length);
         for (int i0 = 0; i0 < value_length; i0++)
         {
             cdr.write_type_5(data.value[i0]);
         }
     }
 }
 public static void write(sensor_msgs.msg.LaserEcho data, Halodi.CDR.CDRSerializer cdr)
 {
     if (data.echoes == null)
     {
         cdr.write_type_2(0);
     }
     else
     {
         int echoes_length = data.echoes.Count;
         cdr.write_type_2(echoes_length);
         for (int i0 = 0; i0 < echoes_length; i0++)
         {
             cdr.write_type_5(data.echoes[i0]);
         }
     }
 }
示例#17
0
 public static void write(ocs2_ros2_msgs.msg.ControllerData data, Halodi.CDR.CDRSerializer 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_5(data.data[i0]);
         }
     }
 }
        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]);
                }
            }
        }
示例#19
0
        public static void write(std_msgs.msg.Float32MultiArray 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_5(data.data[i0]);
                }
            }
        }
 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);
         }
     }
 }
示例#21
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);
                }
            }
        }
示例#22
0
 public static void write(std_msgs.msg.Float32 data, Halodi.CDR.CDRSerializer cdr)
 {
     cdr.write_type_5(data.data);
 }
示例#23
0
        public static void write(test.IDLElementTest data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_8(data.charTest);

            cdr.write_type_14(data.wcharTest);

            cdr.write_type_9(data.octetTest);

            cdr.write_type_1(data.shortTest);

            cdr.write_type_3(data.ushortTest);

            cdr.write_type_2(data.longTest);

            cdr.write_type_4(data.ulongTest);

            cdr.write_type_11(data.longlongTest);

            cdr.write_type_12(data.ulonglongTest);

            cdr.write_type_5(data.floatTest);

            cdr.write_type_6(data.doubleTest);

            cdr.write_type_7(data.booleanTest);

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


            nested.NestedElementPubSubType.write(data.nestedElementTest, cdr);

            cdr.write_type_d(data.stringTest);

            for (int i0 = 0; i0 < 10; ++i0)
            {
                cdr.write_type_2(data.longArray[i0]);
            }

            for (int i0 = 0; i0 < 5; ++i0)
            {
                for (int i1 = 0; i1 < 3; ++i1)
                {
                    nested.NestedElementPubSubType.write(data.nestedArray[i0, i1], cdr);
                }
            }

            for (int i0 = 0; i0 < 4; ++i0)
            {
                cdr.write_type_d(data.stringArray[i0]);
            }

            for (int i0 = 0; i0 < 6; ++i0)
            {
                cdr.write_type_c((int)data.enumArray[i0]);
            }

            if (data.charSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int charSeqTest_length = data.charSeqTest.Count;
                cdr.write_type_2(charSeqTest_length);
                for (int i0 = 0; i0 < charSeqTest_length; i0++)
                {
                    cdr.write_type_8(data.charSeqTest[i0]);
                }
            }
            if (data.wcharSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int wcharSeqTest_length = data.wcharSeqTest.Count;
                cdr.write_type_2(wcharSeqTest_length);
                for (int i0 = 0; i0 < wcharSeqTest_length; i0++)
                {
                    cdr.write_type_14(data.wcharSeqTest[i0]);
                }
            }
            if (data.octetSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int octetSeqTest_length = data.octetSeqTest.Count;
                cdr.write_type_2(octetSeqTest_length);
                for (int i0 = 0; i0 < octetSeqTest_length; i0++)
                {
                    cdr.write_type_9(data.octetSeqTest[i0]);
                }
            }
            if (data.shortSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int shortSeqTest_length = data.shortSeqTest.Count;
                cdr.write_type_2(shortSeqTest_length);
                for (int i0 = 0; i0 < shortSeqTest_length; i0++)
                {
                    cdr.write_type_1(data.shortSeqTest[i0]);
                }
            }
            if (data.ushortSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int ushortSeqTest_length = data.ushortSeqTest.Count;
                cdr.write_type_2(ushortSeqTest_length);
                for (int i0 = 0; i0 < ushortSeqTest_length; i0++)
                {
                    cdr.write_type_3(data.ushortSeqTest[i0]);
                }
            }
            if (data.longSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int longSeqTest_length = data.longSeqTest.Count;
                cdr.write_type_2(longSeqTest_length);
                for (int i0 = 0; i0 < longSeqTest_length; i0++)
                {
                    cdr.write_type_2(data.longSeqTest[i0]);
                }
            }
            if (data.ulongSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int ulongSeqTest_length = data.ulongSeqTest.Count;
                cdr.write_type_2(ulongSeqTest_length);
                for (int i0 = 0; i0 < ulongSeqTest_length; i0++)
                {
                    cdr.write_type_4(data.ulongSeqTest[i0]);
                }
            }
            if (data.longlongSeqtest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int longlongSeqtest_length = data.longlongSeqtest.Count;
                cdr.write_type_2(longlongSeqtest_length);
                for (int i0 = 0; i0 < longlongSeqtest_length; i0++)
                {
                    cdr.write_type_11(data.longlongSeqtest[i0]);
                }
            }
            if (data.ulonglongSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int ulonglongSeqTest_length = data.ulonglongSeqTest.Count;
                cdr.write_type_2(ulonglongSeqTest_length);
                for (int i0 = 0; i0 < ulonglongSeqTest_length; i0++)
                {
                    cdr.write_type_12(data.ulonglongSeqTest[i0]);
                }
            }
            if (data.floatSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int floatSeqTest_length = data.floatSeqTest.Count;
                cdr.write_type_2(floatSeqTest_length);
                for (int i0 = 0; i0 < floatSeqTest_length; i0++)
                {
                    cdr.write_type_5(data.floatSeqTest[i0]);
                }
            }
            if (data.doubleSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int doubleSeqTest_length = data.doubleSeqTest.Count;
                cdr.write_type_2(doubleSeqTest_length);
                for (int i0 = 0; i0 < doubleSeqTest_length; i0++)
                {
                    cdr.write_type_6(data.doubleSeqTest[i0]);
                }
            }
            if (data.booleanSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int booleanSeqTest_length = data.booleanSeqTest.Count;
                cdr.write_type_2(booleanSeqTest_length);
                for (int i0 = 0; i0 < booleanSeqTest_length; i0++)
                {
                    cdr.write_type_7(data.booleanSeqTest[i0]);
                }
            }
            if (data.nestedSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int nestedSeqTest_length = data.nestedSeqTest.Count;
                cdr.write_type_2(nestedSeqTest_length);
                for (int i0 = 0; i0 < nestedSeqTest_length; i0++)
                {
                    nested.NestedElementPubSubType.write(data.nestedSeqTest[i0], cdr);
                }
            }
            if (data.enumSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int enumSeqTest_length = data.enumSeqTest.Count;
                cdr.write_type_2(enumSeqTest_length);
                for (int i0 = 0; i0 < enumSeqTest_length; i0++)
                {
                    cdr.write_type_c((int)data.enumSeqTest[i0]);
                }
            }
            if (data.stringSeqTest == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int stringSeqTest_length = data.stringSeqTest.Count;
                cdr.write_type_2(stringSeqTest_length);
                for (int i0 = 0; i0 < stringSeqTest_length; i0++)
                {
                    cdr.write_type_d(data.stringSeqTest[i0]);
                }
            }
        }
        public static void write(ocs2_ros2_msgs.msg.MpcFlattenedController data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.controller_type);

            ocs2_ros2_msgs.msg.MpcObservationPubSubType.write(data.init_observation, cdr);

            ocs2_ros2_msgs.msg.MpcTargetTrajectoriesPubSubType.write(data.plan_target_trajectories, cdr);

            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);
                }
            }
            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]);
                }
            }
            ocs2_ros2_msgs.msg.ModeSchedulePubSubType.write(data.mode_schedule, 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++)
                {
                    ocs2_ros2_msgs.msg.ControllerDataPubSubType.write(data.data[i0], cdr);
                }
            }
            ocs2_ros2_msgs.msg.MpcPerformanceIndicesPubSubType.write(data.performance_indices, cdr);
        }