public static void write(halodi_msgs.msg.MotorStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.status_level);

            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.JointNamePubSubType.write(data.joints[i0], cdr);
                }
            }
            cdr.write_type_9(data.motor_id);

            cdr.write_type_7(data.sto_enabled);

            cdr.write_type_7(data.over_temperature);

            cdr.write_type_4(data.motor_serial_number);

            cdr.write_type_4(data.driver_serial_number);

            cdr.write_type_7(data.motor_initialized);

            cdr.write_type_6(data.motor_temperature);

            cdr.write_type_6(data.driver_temperature);

            cdr.write_type_9(data.motor_error);
        }
Esempio n. 2
0
        public static void write(visualization_msgs.msg.InteractiveMarkerControl data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_d(data.name);

            geometry_msgs.msg.QuaternionPubSubType.write(data.orientation, cdr);

            cdr.write_type_9(data.orientation_mode);

            cdr.write_type_9(data.interaction_mode);

            cdr.write_type_7(data.always_visible);

            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.MarkerPubSubType.write(data.markers[i0], cdr);
                }
            }
            cdr.write_type_7(data.independent_marker_orientation);

            cdr.write_type_d(data.description);
        }
Esempio n. 3
0
        public static void write(visualization_msgs.msg.Marker 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.PosePubSubType.write(data.pose, cdr);

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

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

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

            cdr.write_type_7(data.frame_locked);

            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.colors == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int colors_length = data.colors.Count;
                cdr.write_type_2(colors_length);
                for (int i0 = 0; i0 < colors_length; i0++)
                {
                    std_msgs.msg.ColorRGBAPubSubType.write(data.colors[i0], cdr);
                }
            }
            cdr.write_type_d(data.text);

            cdr.write_type_d(data.mesh_resource);

            cdr.write_type_7(data.mesh_use_embedded_materials);
        }
        public static void write(halodi_msgs.msg.JointStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            halodi_msgs.msg.JointNamePubSubType.write(data.joint, cdr);

            cdr.write_type_9(data.status_level);

            cdr.write_type_7(data.critical_for_balance);

            cdr.write_type_7(data.output_encoder_fault);

            cdr.write_type_7(data.tension_ropes);
        }
Esempio n. 5
0
        public static void write(halodi_msgs.msg.RobotStatus data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_9(data.robot_status_level);

            halodi_msgs.msg.BatteryStatusPubSubType.write(data.battery_status, cdr);

            cdr.write_type_7(data.backpack_estop_enabled);

            cdr.write_type_7(data.wireless_estop_enabled);

            cdr.write_type_7(data.over_temperature);

            cdr.write_type_7(data.driving_disabled);

            if (data.joint_status == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int joint_status_length = data.joint_status.Count;
                cdr.write_type_2(joint_status_length);
                for (int i0 = 0; i0 < joint_status_length; i0++)
                {
                    halodi_msgs.msg.JointStatusPubSubType.write(data.joint_status[i0], cdr);
                }
            }
            if (data.motor_status == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int motor_status_length = data.motor_status.Count;
                cdr.write_type_2(motor_status_length);
                for (int i0 = 0; i0 < motor_status_length; i0++)
                {
                    halodi_msgs.msg.MotorStatusPubSubType.write(data.motor_status[i0], cdr);
                }
            }
            cdr.write_type_4(data.runtime_since_start);

            cdr.write_type_4(data.total_runtime);

            cdr.write_type_4(data.numberOfRuns);
        }
Esempio n. 6
0
        public static void write(halodi_msgs.msg.TaskSpaceFeedback data, Halodi.CDR.CDRSerializer cdr)
        {
            halodi_msgs.msg.ReferenceFrameNamePubSubType.write(data.body_frame, cdr);

            halodi_msgs.msg.ReferenceFrameNamePubSubType.write(data.expressed_in_frame, cdr);

            cdr.write_type_7(data.express_in_z_up);

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

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

            if (data.passivity_output == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int passivity_output_length = data.passivity_output.Count;
                cdr.write_type_2(passivity_output_length);
                for (int i0 = 0; i0 < passivity_output_length; i0++)
                {
                    halodi_msgs.msg.PassivityDataPubSubType.write(data.passivity_output[i0], cdr);
                }
            }
        }
Esempio n. 7
0
        public static void write(halodi_msgs.msg.DrivingCommand data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_7(data.filter_driving_command);

            cdr.write_type_6(data.linear_velocity);

            cdr.write_type_6(data.angular_velocity);
        }
        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);
        }
        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(sensor_msgs.msg.RegionOfInterest data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_4(data.x_offset);

            cdr.write_type_4(data.y_offset);

            cdr.write_type_4(data.height);

            cdr.write_type_4(data.width);

            cdr.write_type_7(data.do_rectify);
        }
        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);
        }
Esempio n. 12
0
        public static void write(halodi_msgs.msg.WholeBodyTrajectory data, Halodi.CDR.CDRSerializer cdr)
        {
            unique_identifier_msgs.msg.UUIDPubSubType.write(data.trajectory_id, cdr);

            if (data.start_time == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int start_time_length = data.start_time.Count;
                cdr.write_type_2(start_time_length);
                for (int i0 = 0; i0 < start_time_length; i0++)
                {
                    builtin_interfaces.msg.TimePubSubType.write(data.start_time[i0], cdr);
                }
            }
            if (data.balance_mode == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int balance_mode_length = data.balance_mode.Count;
                cdr.write_type_2(balance_mode_length);
                for (int i0 = 0; i0 < balance_mode_length; i0++)
                {
                    halodi_msgs.msg.BalanceModePubSubType.write(data.balance_mode[i0], cdr);
                }
            }
            cdr.write_type_7(data.append_trajectory);

            halodi_msgs.msg.TrajectoryInterpolationPubSubType.write(data.interpolation_mode, cdr);

            cdr.write_type_6(data.low_pass_filter_break_frequency);

            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.WholeBodyTrajectoryPointPubSubType.write(data.trajectory_points[i0], cdr);
                }
            }
        }
Esempio n. 13
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);
        }
        public static void write(visualization_msgs.msg.InteractiveMarkerFeedback data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_d(data.client_id);

            cdr.write_type_d(data.marker_name);

            cdr.write_type_d(data.control_name);

            cdr.write_type_9(data.event_type);

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

            cdr.write_type_4(data.menu_entry_id);

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

            cdr.write_type_7(data.mouse_point_valid);
        }
        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(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);
                }
            }
        }
        public static void write(test.StatusMessage data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_12(data.sequence_id);

            cdr.write_type_7(data.pause);
        }
Esempio n. 18
0
 public static void write(std_msgs.msg.Bool data, Halodi.CDR.CDRSerializer cdr)
 {
     cdr.write_type_7(data.data);
 }
        public static void write(rcl_interfaces.msg.SetParametersResult data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_7(data.successful);

            cdr.write_type_d(data.reason);
        }
Esempio n. 20
0
 public static void write(std_msgs.msg.Empty data, Halodi.CDR.CDRSerializer cdr)
 {
     cdr.write_type_7(data.unused_placeholder_field);
 }
Esempio n. 21
0
        public static void write(halodi_msgs.msg.WholeBodyState data, Halodi.CDR.CDRSerializer cdr)
        {
            std_msgs.msg.HeaderPubSubType.write(data.header, cdr);

            cdr.write_type_2(data.last_received_sequence_id);

            cdr.write_type_7(data.accepts_commands);

            cdr.write_type_d(data.controller_state);

            halodi_msgs.msg.BalanceModePubSubType.write(data.current_balance_mode, cdr);

            cdr.write_type_9(data.robot_status);

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

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

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

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

            if (data.imu_measurements == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int imu_measurements_length = data.imu_measurements.Count;
                cdr.write_type_2(imu_measurements_length);
                for (int i0 = 0; i0 < imu_measurements_length; i0++)
                {
                    halodi_msgs.msg.ImuMeasurementPubSubType.write(data.imu_measurements[i0], cdr);
                }
            }
            if (data.joint_states == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int joint_states_length = data.joint_states.Count;
                cdr.write_type_2(joint_states_length);
                for (int i0 = 0; i0 < joint_states_length; i0++)
                {
                    halodi_msgs.msg.JointMeasurementPubSubType.write(data.joint_states[i0], cdr);
                }
            }
            if (data.taskspace_feedback == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int taskspace_feedback_length = data.taskspace_feedback.Count;
                cdr.write_type_2(taskspace_feedback_length);
                for (int i0 = 0; i0 < taskspace_feedback_length; i0++)
                {
                    halodi_msgs.msg.TaskSpaceFeedbackPubSubType.write(data.taskspace_feedback[i0], cdr);
                }
            }
        }
Esempio n. 22
0
        public static void write(halodi_msgs.msg.ContactPointCommand data, Halodi.CDR.CDRSerializer cdr)
        {
            halodi_msgs.msg.JointNamePubSubType.write(data.parent_joint, cdr);

            cdr.write_type_2(data.contact_point_id);

            cdr.write_type_7(data.point_in_contact);

            if (data.normal == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int normal_length = data.normal.Count;
                cdr.write_type_2(normal_length);
                for (int i0 = 0; i0 < normal_length; i0++)
                {
                    geometry_msgs.msg.Vector3PubSubType.write(data.normal[i0], cdr);
                }
            }
            if (data.coefficient_of_friction == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int coefficient_of_friction_length = data.coefficient_of_friction.Count;
                cdr.write_type_2(coefficient_of_friction_length);
                for (int i0 = 0; i0 < coefficient_of_friction_length; i0++)
                {
                    cdr.write_type_6(data.coefficient_of_friction[i0]);
                }
            }
            if (data.maximum_contact_force == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int maximum_contact_force_length = data.maximum_contact_force.Count;
                cdr.write_type_2(maximum_contact_force_length);
                for (int i0 = 0; i0 < maximum_contact_force_length; i0++)
                {
                    cdr.write_type_6(data.maximum_contact_force[i0]);
                }
            }
            if (data.rho_weight_divider == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int rho_weight_divider_length = data.rho_weight_divider.Count;
                cdr.write_type_2(rho_weight_divider_length);
                for (int i0 = 0; i0 < rho_weight_divider_length; i0++)
                {
                    cdr.write_type_6(data.rho_weight_divider[i0]);
                }
            }
        }
Esempio n. 23
0
 public static void write(rcl_interfaces.msg.ParameterType data, Halodi.CDR.CDRSerializer cdr)
 {
     cdr.write_type_7(data.unused_placeholder_field);
 }
Esempio n. 24
0
        public static void write(rcl_interfaces.msg.ParameterValue data, Halodi.CDR.CDRSerializer cdr)
        {
            cdr.write_type_9(data.type);

            cdr.write_type_7(data.bool_value);

            cdr.write_type_11(data.integer_value);

            cdr.write_type_6(data.double_value);

            cdr.write_type_d(data.string_value);

            if (data.byte_array_value == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int byte_array_value_length = data.byte_array_value.Count;
                cdr.write_type_2(byte_array_value_length);
                for (int i0 = 0; i0 < byte_array_value_length; i0++)
                {
                    cdr.write_type_9(data.byte_array_value[i0]);
                }
            }
            if (data.bool_array_value == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int bool_array_value_length = data.bool_array_value.Count;
                cdr.write_type_2(bool_array_value_length);
                for (int i0 = 0; i0 < bool_array_value_length; i0++)
                {
                    cdr.write_type_7(data.bool_array_value[i0]);
                }
            }
            if (data.integer_array_value == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int integer_array_value_length = data.integer_array_value.Count;
                cdr.write_type_2(integer_array_value_length);
                for (int i0 = 0; i0 < integer_array_value_length; i0++)
                {
                    cdr.write_type_11(data.integer_array_value[i0]);
                }
            }
            if (data.double_array_value == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int double_array_value_length = data.double_array_value.Count;
                cdr.write_type_2(double_array_value_length);
                for (int i0 = 0; i0 < double_array_value_length; i0++)
                {
                    cdr.write_type_6(data.double_array_value[i0]);
                }
            }
            if (data.string_array_value == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int string_array_value_length = data.string_array_value.Count;
                cdr.write_type_2(string_array_value_length);
                for (int i0 = 0; i0 < string_array_value_length; i0++)
                {
                    cdr.write_type_d(data.string_array_value[i0]);
                }
            }
        }
Esempio n. 25
0
        public static void write(halodi_msgs.msg.TaskSpaceCommand data, Halodi.CDR.CDRSerializer cdr)
        {
            halodi_msgs.msg.ReferenceFrameNamePubSubType.write(data.body_frame, cdr);

            halodi_msgs.msg.ReferenceFrameNamePubSubType.write(data.expressed_in_frame, cdr);

            cdr.write_type_7(data.express_in_z_up);

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

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

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

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

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

            if (data.passivity_input == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int passivity_input_length = data.passivity_input.Count;
                cdr.write_type_2(passivity_input_length);
                for (int i0 = 0; i0 < passivity_input_length; i0++)
                {
                    halodi_msgs.msg.PassivityDataPubSubType.write(data.passivity_input[i0], cdr);
                }
            }
            if (data.orientation_feedback_parameters == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int orientation_feedback_parameters_length = data.orientation_feedback_parameters.Count;
                cdr.write_type_2(orientation_feedback_parameters_length);
                for (int i0 = 0; i0 < orientation_feedback_parameters_length; i0++)
                {
                    halodi_msgs.msg.FeedbackParameters3DPubSubType.write(data.orientation_feedback_parameters[i0], cdr);
                }
            }
            if (data.position_feedback_parameters == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int position_feedback_parameters_length = data.position_feedback_parameters.Count;
                cdr.write_type_2(position_feedback_parameters_length);
                for (int i0 = 0; i0 < position_feedback_parameters_length; i0++)
                {
                    halodi_msgs.msg.FeedbackParameters3DPubSubType.write(data.position_feedback_parameters[i0], cdr);
                }
            }
            if (data.nullspace_command == null)
            {
                cdr.write_type_2(0);
            }
            else
            {
                int nullspace_command_length = data.nullspace_command.Count;
                cdr.write_type_2(nullspace_command_length);
                for (int i0 = 0; i0 < nullspace_command_length; i0++)
                {
                    halodi_msgs.msg.JointNullSpaceConfigurationPubSubType.write(data.nullspace_command[i0], cdr);
                }
            }
        }
Esempio n. 26
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]);
                }
            }
        }