first commit Unity and ROS part

ROS/linerobot/src/depthimage_view/CMakeLists.txt

@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.8)
+project(depthimage_view)
+
+if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  add_compile_options(-Wall -Wextra -Wpedantic)
+endif()
+
+# find dependencies
+find_package(ament_cmake REQUIRED)
+find_package(rclcpp REQUIRED)
+find_package(std_msgs REQUIRED)
+find_package(sensor_msgs REQUIRED)
+
+add_executable(view_depthimage src/view_depthimage.cpp)
+ament_target_dependencies(view_depthimage rclcpp sensor_msgs std_msgs)
+
+target_include_directories(view_depthimage PUBLIC
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  $<INSTALL_INTERFACE:include>)
+target_compile_features(view_depthimage PUBLIC c_std_99 cxx_std_17)  # Require C99 and C++17
+
+install(TARGETS view_depthimage
+  view_depthimage
+  DESTINATION lib/${PROJECT_NAME})
+
+if(BUILD_TESTING)
+  find_package(ament_lint_auto REQUIRED)
+  ament_lint_auto_find_test_dependencies()
+endif()
+
+ament_package()

ROS/linerobot/src/depthimage_view/package.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0"?>
+<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>depthimage_view</name>
+  <version>0.0.0</version>
+  <description>View DepthImage</description>
+  <maintainer email="edward@confirmat.nl">edward</maintainer>
+  <license>fdsfsd</license>
+
+  <buildtool_depend>ament_cmake</buildtool_depend>
+  <depend>rclcpp</depend>
+  <depend>std_msgs</depend>
+  <depend>sensor_msgs</depend>
+
+  <test_depend>ament_lint_auto</test_depend>
+  <test_depend>ament_lint_common</test_depend>
+
+  <export>
+    <build_type>ament_cmake</build_type>
+  </export>
+</package>

ROS/linerobot/src/depthimage_view/scripts/depthimage_viewer.py

@@ -0,0 +1,47 @@
+import rclpy
+from rclpy.node import Node
+from sensor_msgs.msg import Image
+from cv_bridge import CvBridge
+import cv2
+import numpy as np
+
+class ImageSubscriber(Node):
+  def __init__(self):
+    super().__init__('depthimage_subscriber')
+    self.subscription = self.create_subscription(
+      Image, 
+      'depth_image', 
+      self.listener_callback, 
+      10)
+    self.subscription # prevent unused variable warning
+    self.br = CvBridge()
+
+  def listener_callback(self, data):
+    # Convert ROS Image message to OpenCV image
+    current_frame = self.br.imgmsg_to_cv2(data) #np.ndarray
+   	#minVal, maxVal, min_loc, max_loc = cv2.minMaxLoc(current_frame)
+    clipmin = 0.3
+    clipmax = 2.0
+    
+    new_frame = current_frame.copy()
+    np.clip(new_frame, clipmin, clipmax, out=new_frame)
+    new_frame -= clipmin
+    new_frame /= (clipmax-clipmin)/255.0
+    new_frame = new_frame.astype(dtype=np.uint8, copy=False)
+
+    im_color = cv2.applyColorMap(new_frame, cv2.COLORMAP_JET); # cv2.COLORMAP_AUTUMN
+  
+    cv2.imshow("camera", im_color)
+    cv2.waitKey(1) # 1 for automatic update
+
+  
+def main(args=None):
+  
+  rclpy.init(args=args)
+  image_subscriber = ImageSubscriber()
+  rclpy.spin(image_subscriber)
+  image_subscriber.destroy_node()
+  rclpy.shutdown()
+  
+if __name__ == '__main__':
+  main()

ROS/linerobot/src/depthimage_view/scripts/velocity_sp_generator.py

@@ -0,0 +1,73 @@
+
+# subscribe to topic: /redsensor (type: float)
+#
+# publish to: 	/speedsetpointL  (type: float)
+# 		/speedsetpointR  (type: float)
+#
+
+import rclpy
+from rclpy.node import Node
+from std_msgs.msg import Float32, Float32MultiArray, MultiArrayDimension
+
+class VelocitySetpointGenerator(Node):
+
+    SpeedSP = Float32MultiArray()
+    
+    def __init__(self):
+        super().__init__('velocity_setpoint_generator')
+        self.subscription = self.create_subscription(
+            Float32, 
+            'redsensor',
+            self.controller_callback,
+            10)
+        self.publisherSP = self.create_publisher(Float32MultiArray, 'speedsetpoint', 10)
+        self.subscription  # prevent unused variable warning
+
+        self.DistanceCenterToWheel = 0.07
+        self.ForwardSpeedSetpoint = 0.1
+        self.K = 2.0
+        
+        #self.SpeedSP.layout
+        d = MultiArrayDimension()
+        d.stride = 0
+        d.size = 2
+        self.SpeedSP.layout.dim = [d]
+
+    def controller_callback(self, msg):
+        #self.get_logger().info('I heard: "%s"' % msg.data)
+        
+        omega = self.K * self.make_dimensionless(msg.data)
+        L = self.ForwardSpeedSetpoint - omega * self.DistanceCenterToWheel
+        R = self.ForwardSpeedSetpoint + omega * self.DistanceCenterToWheel
+        self.SpeedSP.data = [L, R]
+        self.publisherSP.publish(self.SpeedSP)
+        
+    def make_dimensionless(self, meas):
+        Dark = 0.6
+        Bright = 1.0
+        Threshold1 = 0.78
+        Threshold2 = 0.83
+        if meas < Dark:
+            dimlessvalue = -1.0
+        elif meas < Threshold1:
+            dimlessvalue = -1.0 * (Threshold1 - meas ) / (Threshold1 - Dark)
+        elif meas < Threshold2:
+            dimlessvalue = 0.0
+        elif meas < Bright:
+            dimlessvalue =  (meas - Threshold2) / (Bright - Threshold2)
+        else:
+            dimlessvalue = 1.0
+        return dimlessvalue
+    
+def main(args=None):
+    rclpy.init(args=args)
+
+    vel_controller = VelocitySetpointGenerator()
+    rclpy.spin(vel_controller)
+
+    vel_controller.destroy_node()
+    rclpy.shutdown()
+
+if __name__ == '__main__':
+    main()
+

ROS/linerobot/src/depthimage_view/src/view_depthimage.cpp

@@ -0,0 +1,75 @@
+#include <cstdio>
+#include "rclcpp/rclcpp.hpp"
+#include "sensor_msgs/msg/image.hpp"
+
+//#include <opencv2/opencv.hpp>
+//#include <opencv2/imgproc/imgproc.hpp>
+//#include <opencv2/highgui/highgui.hpp>
+
+using namespace std::placeholders;
+ 
+class MinimalDepthSubscriber : public rclcpp::Node {
+  public:
+    MinimalDepthSubscriber()
+        : Node("depthviewer_node") {
+
+        rclcpp::QoS depth_qos(10);
+        depth_qos.keep_last(10);
+        depth_qos.best_effort();
+        depth_qos.durability_volatile();
+
+        // Create depth map subscriber
+        mDepthSub = create_subscription<sensor_msgs::msg::Image>(
+                   "depth_image", depth_qos,
+                   std::bind(&MinimalDepthSubscriber::depthCallback, this, _1) );
+    }
+
+  protected:
+    void depthCallback(const sensor_msgs::msg::Image::SharedPtr msg) {
+        float* depths = (float*)(&msg->data[0]);
+
+        // Image coordinates of the center pixel
+        int u = msg->width / 2;
+        int v = msg->height / 2;
+
+        // Linear index of the center pixel
+        int centerIdx = u + msg->width * v;
+
+        // Output the measure
+        RCLCPP_INFO(get_logger(), "Center distance : %g m", depths[centerIdx]);
+    }
+    
+    /* void depthCallback2(const sensor_msgs::msg::Image::SharedPtr msg) {
+        float* depths = (float*)(&msg->data[0]);
+
+	cv_bridge::CvImagePtr cv_ptr;
+	cv_ptr = cv_bridge::toCvShare(msg, msg->encoding ); // of sensor_msgs::image_encodings::TYPE_32FC1
+	
+	double minVal, maxVal;
+	minMaxLoc(cv_ptr->image, &minVal, &maxVal);
+	    //Mat draw;
+	cv::Mat blur_img; // opencv Mat
+    	cv_ptr->image.convertTo(blur_img, CV_8U, 255.0/(maxVal - minVal), -minVal * 255.0/(maxVal - minVal));
+
+	cv::Mat resultMap;
+	applyColorMap(data8uc, resultMap, cv::COLORMAP_JET); // cv::COLORMAP_AUTUMN
+	cv::imshow("Jet-colormap", resultMap);
+
+    }*/
+    
+
+  private:
+    rclcpp::Subscription<sensor_msgs::msg::Image>::SharedPtr mDepthSub;
+};
+
+// The main function
+int main(int argc, char* argv[]) {
+    rclcpp::init(argc, argv);
+
+    auto depth_node = std::make_shared<MinimalDepthSubscriber>();
+
+    rclcpp::spin(depth_node);
+    rclcpp::shutdown();
+    return 0;
+}
+

Unity/LineRobot/.vsconfig

@@ -0,0 +1,6 @@
+{
+  "version": "1.0",
+  "components": [
+    "Microsoft.VisualStudio.Workload.ManagedGame"
+  ]
+}

Unity/LineRobot/Assets/DDS.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 291fadf64ea972441bbbf698f7b8af0f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/DDSEntityManager_ROS.cs

@@ -0,0 +1,537 @@
+/*
+ *                         Vortex OpenSplice
+ *
+ *   This software and documentation are Copyright 2006 to  ADLINK
+ *   Technology Limited, its affiliated companies and licensors. All rights
+ *   reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *   
+ *   EDWARD HAGE 9 AUG 2019 - Added "ROS" profile.
+ *   EDWARD HAGE 5 JULI 2020 - Added "ROS_BE" profile , BE = best effort
+ *   TO DO: Rework this file for different 'Qos_settings', maybe profiles same as the pre-defined profiles in ROS2.
+ */
+
+using System;
+using System.Text; // for encoding 29-9-2021 edward
+using System.Threading;
+
+using DDS;
+using DDS.OpenSplice;
+using DDS.OpenSplice.CustomMarshalers;
+
+
+namespace DDSAPIHelper
+{
+    /// <summary>
+    /// The DDSEntityManager class is provided as a utility class for
+    /// the various Vortex OpenSplice operations used in the examples demonstrating
+    /// various DDS concepts.
+    /// </summary>
+    public sealed class DDSEntityManager
+    {
+        private DomainParticipantFactory dpf;
+        private DomainParticipantQos dpQos;
+        private IDomainParticipant participant;
+        private ITopic topic;
+        private IContentFilteredTopic filteredTopic;
+        private TopicQos topicQos = new TopicQos();
+        private PublisherQos pubQos = new PublisherQos();
+        private SubscriberQos subQos = new SubscriberQos();
+
+        private DataWriterQos WQosH = new DataWriterQos();
+        private DataReaderQos RQosH = new DataReaderQos();
+
+        private IPublisher publisher;
+        private IDataWriter writer;
+        private IDataWriter writerStopper;
+
+        private ISubscriber subscriber;
+        private IDataReader reader;
+
+        private String typeName;
+        private String partitionName;
+        private String durabilityKind = "transient";
+        private Boolean autoDisposeFlag = false;
+        private ReturnCode status = ReturnCode.Error;
+        private String exampleName;
+        private String ROSNodeName = null;
+        /// <summary>
+        /// The constructor to use for creating the various entities.
+        /// </summary>
+        /// <param name="name">The example name to create an entity manager. This is used to manage different example needs.</param>
+        public DDSEntityManager(String name)
+        {
+            exampleName = name;
+        }
+
+        //edward: introspection
+        public TopicQos gettopicqos()
+        {
+            return topicQos;
+        }
+
+        public PublisherQos getpublisherqos() { return pubQos; }
+        public SubscriberQos getsubscriberqos() { return subQos; }
+        public DataWriterQos getdatawriterqos() { return WQosH; }
+        public DataReaderQos getdatareaderqos() { return RQosH; }
+
+        /// <summary>
+        /// Create Domain Participant
+        /// </summary>
+        /// <param name="partitionName">Create the participant and assign the partition name.</param>
+        public void createParticipant(String partitionName, String ROSNodeName = null )
+        {
+            dpf = DomainParticipantFactory.Instance;
+            dpQos = new DomainParticipantQos();
+
+            dpf.GetDefaultParticipantQos(ref dpQos);
+            ErrorHandler.checkHandle(dpf, "DomainParticipantFactory.Instance");
+
+            // 29-9-2021 add name=service_name voor ROS  service in QoS
+            if (ROSNodeName != null)
+            {
+                dpQos.UserData.Value = Encoding.ASCII.GetBytes("name=" + ROSNodeName + ";"); // namespace=myns;");
+            }
+            //participant = dpf.CreateParticipant(DDS.DomainId.Default, dpQos); // dit is origineel
+            participant = dpf.CreateParticipant(DDS.DomainId.Default,dpQos,null,StatusKind.Any);
+            //Debug.Log("De domainID=" + DDS.DomainId.Default.ToString());
+            //////// end van 29-9 ///////
+            
+            ErrorHandler.checkHandle(participant, "DomainParticipantFactory.CreateParticipant");
+            this.partitionName = partitionName;
+            this.ROSNodeName = ROSNodeName;
+        }
+
+        /// <summary>
+        /// Set the Durability Kind transient | persistent
+        /// </summary>
+        /// <param name="kind">transient|persistent</param>
+        public void setDurabilityKind(String kind)
+        {
+            durabilityKind = kind;
+        }
+
+        /// <summary>
+        /// Set the flag for auto disposing of unregistered instances
+        /// </summary>
+        /// <param name="autoDispose">true | false</param>
+        public void setAutoDispose(Boolean autoDisposeFlag)
+        {
+            this.autoDisposeFlag = autoDisposeFlag;
+        }
+
+        /// <summary>
+        /// Delete the DomainParticipant.
+        /// </summary>
+        public void deleteParticipant()
+        {
+            status = dpf.DeleteParticipant(participant);
+            ErrorHandler.checkStatus(status, "DomainParticipantFactory.DeleteParticipant");
+        }
+        /// <summary>
+        /// Register the type we are interested with the DDS Infrastructure
+        /// </summary>
+        /// <param name="ts">The TypeSupport class</param>
+        public void registerType(ITypeSupport ts)
+        {
+            typeName = ts.TypeName;
+            status = ts.RegisterType(participant, typeName);
+            ErrorHandler.checkStatus(status, "ITypeSupport.RegisterType");
+        }
+
+        /// <summary>
+        /// Utility method to create a DDS Topic.
+        /// </summary>
+        /// <param name="topicName">The Topic name to create the topic with.</param>
+        /// <param name="exampleNameToCreateTopicFor">The name of the example we are
+        /// creating the topic for. This is used to define any specific Qos that the example
+        /// requires.</param>
+        /// <returns>The newly created Topic</returns>
+        public ITopic createTopic(String topicName)
+        {
+            status = participant.GetDefaultTopicQos(ref topicQos);
+            ErrorHandler.checkStatus(status, "DomainParticipant.GetDefaultTopicQos");
+            topicQos.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos;
+            topicQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
+
+            switch (exampleName)
+            {
+                case "QueryCondition":
+                case "ContentFilteredTopic":
+                    topicQos.DestinationOrder.Kind = DestinationOrderQosPolicyKind.BySourceTimestampDestinationorderQos;
+                    break;
+                case "Durability":
+                case "HelloWorld":
+                case "WaitSet":
+                case "Lifecycle":
+                    if (!durabilityKind.Equals("transient"))
+                        topicQos.Durability.Kind = DurabilityQosPolicyKind.PersistentDurabilityQos;
+                    break;
+                case "Ownership":
+                    topicQos.Ownership.Kind = OwnershipQosPolicyKind.ExclusiveOwnershipQos;
+                    break;
+                case "Listener":
+                    // DeadlineQoSPolicy : period used to trigger the listener
+                    // (on_requested_deadline_missed)
+                    topicQos.Deadline.Period.NanoSec = 0;
+                    topicQos.Deadline.Period.Sec = 1;
+                    break;
+                case "ROS":
+                    topicQos.Durability.Kind = DurabilityQosPolicyKind.VolatileDurabilityQos;
+                    topicQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
+                    break;
+                case "ROSSERVICE":
+                    topicQos.Durability.Kind = DurabilityQosPolicyKind.TransientLocalDurabilityQos;
+                    topicQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
+                    break;
+                case "ROS_BE":
+                    topicQos.Durability.Kind = DurabilityQosPolicyKind.VolatileDurabilityQos;
+                    topicQos.Reliability.Kind = ReliabilityQosPolicyKind.BestEffortReliabilityQos;
+                    break;
+                default:
+                    Console.WriteLine("Unidentified example to create topic for.");
+                    break;
+            }
+
+            status = participant.SetDefaultTopicQos(topicQos);
+            ErrorHandler.checkStatus(status, "DomainParticipant.SetDefaultTopicQos");
+            topic = participant.CreateTopic(
+                    topicName,
+                    typeName,
+                    topicQos);
+            ErrorHandler.checkHandle(topic, "DomainParticipant.CreateTopic");
+            return topic;
+        }
+
+        /// <summary>
+        /// Create a ContentFilteredTopic
+        /// </summary>
+        /// <param name="topicFName">The name of the topic.</param>
+        /// <param name="topic">The topic to which the filter is applied.</param>
+        /// <param name="arg">The handle to a sequence of strings with the parameter
+        /// value used in the SQL expression.</param>
+        public void createContentFilter(String topicName, ITopic topic, String arg)
+        {
+            String[] tab = new String[1];
+            tab[0] = arg;
+            String filter = "ticker = %0";
+
+            filteredTopic =
+                participant.CreateContentFilteredTopic(topicName, topic, filter, tab);
+            ErrorHandler.checkHandle(filteredTopic, "DomainParticipant.CreateContentFilteredTopic");
+        }
+
+        /// <summary>
+        /// Delete a ContentFilteredTopic
+        /// </summary>
+        public void deleteContentFilteredTopic()
+        {
+            if (filteredTopic == null)
+            {
+                return;
+            }
+            else
+            {
+                status = participant.DeleteContentFilteredTopic(filteredTopic);
+                ErrorHandler.checkStatus(status, "DDS.DomainParticipant.DeleteContentFilteredTopic");
+            }
+        }
+
+        /// <summary>
+        /// Delete the Topic
+        /// </summary>
+        public void deleteTopic()
+        {
+            status = participant.DeleteTopic(topic);
+            ErrorHandler.checkStatus(
+                    status, "DDS.DomainParticipant.DeleteTopic");
+        }
+
+        /// <summary>
+        /// Create a Publisher
+        /// </summary>
+        public void createPublisher()
+        {
+            status = participant.GetDefaultPublisherQos(ref pubQos);
+            ErrorHandler.checkStatus(status, "DomainParticipant.GetDefaultPublisherQos");
+
+            pubQos.Partition.Name = new String[1];
+            pubQos.Partition.Name[0] = partitionName;
+            publisher = participant.CreatePublisher(pubQos);
+            ErrorHandler.checkHandle(publisher, "DomainParticipant.CreatePublisher");
+        }
+
+        /// <summary>
+        /// Delete a Publisher
+        /// </summary>
+        public void deletePublisher()
+        {
+            status = participant.DeletePublisher(publisher);
+            ErrorHandler.checkStatus(status, "DomainParticipant.DeletePublisher");
+        }
+
+        /// <summary>
+        /// Create DataWriter(s)
+        /// </summary>
+        public void createWriter()
+        {
+            status = publisher.GetDefaultDataWriterQos(ref WQosH);
+            ErrorHandler.checkStatus(status, "Publisher.GetDefaultDataWriterQos");
+            status = publisher.CopyFromTopicQos(ref WQosH, topicQos);
+            ErrorHandler.checkStatus(status, "Publisher.CopyFromTopicQos");
+
+            if (durabilityKind.Equals("transient"))
+                WQosH.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos;
+            else
+                WQosH.Durability.Kind = DurabilityQosPolicyKind.PersistentDurabilityQos;
+
+            if (exampleName.Equals("ROS"))
+            {
+                WQosH.Durability.Kind = DurabilityQosPolicyKind.VolatileDurabilityQos;
+                if (this.ROSNodeName != null)
+                {
+                    WQosH.UserData.Value = Encoding.ASCII.GetBytes("name=" + this.ROSNodeName + ";");
+                }
+            }
+            if (exampleName.Equals("ROS_BE")) WQosH.Durability.Kind = DurabilityQosPolicyKind.VolatileDurabilityQos;
+            if (exampleName.Equals("ROSSERVICE")) WQosH.Durability.Kind = DurabilityQosPolicyKind.TransientLocalDurabilityQos;
+            
+
+            WQosH.WriterDataLifecycle.AutodisposeUnregisteredInstances = autoDisposeFlag;
+            writer = publisher.CreateDataWriter(
+                    topic,
+                    WQosH);
+            ErrorHandler.checkHandle(writer, "Publisher.CreateDataWriter");
+
+            if (exampleName.Equals("Lifecycle"))
+            {
+                writerStopper = publisher.CreateDataWriter(
+                    topic,
+                    WQosH);
+                ErrorHandler.checkHandle(writerStopper, "Publisher.CreateDataWriter");
+            }
+        }
+
+        public void createWriterWithStrength(int strength)
+        {
+            status = publisher.GetDefaultDataWriterQos(ref WQosH);
+            ErrorHandler.checkStatus(status, "Publisher.GetDefaultDataWriterQos");
+            status = publisher.CopyFromTopicQos(ref WQosH, topicQos);
+            ErrorHandler.checkStatus(status, "Publisher.CopyFromTopicQos");
+            if (durabilityKind.Equals("transient"))
+                WQosH.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos;
+            else
+                WQosH.Durability.Kind = DurabilityQosPolicyKind.PersistentDurabilityQos;
+
+            if (exampleName.Equals("ROS"))
+            {
+                WQosH.Durability.Kind = DurabilityQosPolicyKind.VolatileDurabilityQos;
+                // zou niet nodig moeten zijn, alleen bij DomainParticipant maar even kijken of ros node nu zichtbaar is
+                if (this.ROSNodeName != null)
+                {
+                    RQosH.UserData.Value = Encoding.ASCII.GetBytes("name=" + this.ROSNodeName + ";"); // namespace=myns;");
+                }
+            }
+            if (exampleName.Equals("ROS_BE")) WQosH.Durability.Kind = DurabilityQosPolicyKind.VolatileDurabilityQos;
+            if (exampleName.Equals("ROSSERVICE")) WQosH.Durability.Kind = DurabilityQosPolicyKind.TransientLocalDurabilityQos;
+
+            WQosH.WriterDataLifecycle.AutodisposeUnregisteredInstances = autoDisposeFlag;
+			WQosH.OwnershipStrength.Value = strength;
+            writer = publisher.CreateDataWriter(
+                    topic,
+                    WQosH);
+            ErrorHandler.checkHandle(writer, "Publisher.CreateDataWriter");
+
+            if (exampleName.Equals("Lifecycle"))
+            {
+                writerStopper = publisher.CreateDataWriter(
+                    topic,
+                    WQosH);
+                ErrorHandler.checkHandle(writerStopper, "Publisher.CreateDataWriter");
+            }
+        }
+
+        /// <summary>
+        /// Method to delete a data writer.
+        /// </summary>
+        /// <param name="dataWriter">The DataWriter instance to delete.</param>
+        public void deleteWriter(IDataWriter dataWriter)
+        {
+            status = publisher.DeleteDataWriter(dataWriter);
+            ErrorHandler.checkStatus(status, "Publisher.DeleteDataWriter");
+        }
+
+        /// <summary>
+        /// Creates a Subscriber
+        /// </summary>
+        public void createSubscriber()
+        {
+            status = participant.GetDefaultSubscriberQos(ref subQos);
+            ErrorHandler.checkStatus(status, "DomainParticipant.GetDefaultSubscriberQos");
+
+            subQos.Partition.Name = new String[1];
+            subQos.Partition.Name[0] = partitionName;
+            subscriber = participant.CreateSubscriber(
+                    subQos);
+            ErrorHandler.checkHandle(subscriber, "DomainParticipant.CreateSubscriber");
+        }
+
+        /// <summary>
+        /// Deletes the class's Subscriber
+        /// </summary>
+        public void deleteSubscriber()
+        {
+            status = participant.DeleteSubscriber(subscriber);
+            ErrorHandler.checkStatus(status, "Participant.DeleteSubscriber");
+        }
+
+        /// <summary>
+        /// Creates a DataReader
+        /// </summary>
+        /// <param name="exampleNameToCreateReaderFor">The example name to create the
+        /// DataReader for. This param is used to define any specific Qos values the
+        /// example requires.</param>
+        /// <param name="filtered">This param determines whether a reader will be created
+        /// for a normal or filtered topic.</param>
+        public void createReader(Boolean filtered)
+        {
+            status = subscriber.GetDefaultDataReaderQos(ref RQosH);
+            ErrorHandler.checkStatus(status, "Subscriber.GetDefaultDataReaderQoS");
+            status = subscriber.CopyFromTopicQos(ref RQosH, topicQos);
+            ErrorHandler.checkStatus(status, "Subscriber.CopyFromTopicQoS");
+
+            switch (exampleName)
+            {
+                case "Listener":
+                    RQosH.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos;
+                    break;
+                case "Durability":
+                    if (durabilityKind.Equals("transient"))
+                        RQosH.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos;
+                    else
+                        RQosH.Durability.Kind = DurabilityQosPolicyKind.PersistentDurabilityQos;
+
+                    break;
+                case "QueryCondition":
+                case "ContentFilteredTopic":
+                case "HelloWorld":
+                case "Ownership":
+                case "WaitSet":
+                case "Lifecycle":
+                    break;
+                case "ROS":
+                    // zou niet nodig moeten zijn, alleen bij DomainParticipant maar even kijken of ros node nu zichtbaar is
+                    if (this.ROSNodeName != null)
+                    {
+                        RQosH.UserData.Value = Encoding.ASCII.GetBytes("name=" + this.ROSNodeName + ";"); // namespace=myns;");
+                    }
+                    RQosH.Durability.Kind = DurabilityQosPolicyKind.VolatileDurabilityQos;
+                    break;
+                case "ROS_BE":
+                    RQosH.Durability.Kind = DurabilityQosPolicyKind.VolatileDurabilityQos;
+                    break;
+                case "ROSSERVICE":
+                    RQosH.Durability.Kind = DurabilityQosPolicyKind.TransientLocalDurabilityQos;
+                    break;
+                default:
+                    break;
+            }
+            if (filtered)
+            {
+                reader = subscriber.CreateDataReader(
+                        filteredTopic,
+                        RQosH);
+            }
+            else
+            {
+                reader = subscriber.CreateDataReader(
+                        topic,
+                        RQosH);
+            }
+            ErrorHandler.checkHandle(reader, "Subscriber.CreateDataReader");
+        }
+
+        /// <summary>
+        /// Accessor method to get the class's DataReader
+        /// </summary>
+        /// <returns></returns>
+        public IDataReader getReader()
+        {
+            return reader;
+        }
+
+        /// <summary>
+        /// Accessor method to get the class's DataWriter
+        /// </summary>
+        /// <returns></returns>
+        public IDataWriter getWriter()
+        {
+            return writer;
+        }
+
+        /// <summary>
+        /// Accessor method to get the class's DataWriter stopper. Only available for the Lifecycle example.
+        /// </summary>
+        /// <returns></returns>
+        public IDataWriter getWriterStopper()
+        {
+            return writerStopper;
+        }
+
+        /// <summary>
+        /// Accessor method to get the class's Publisher
+        /// </summary>
+        /// <returns></returns>
+        public IPublisher getPublisher()
+        {
+            return publisher;
+        }
+
+        /// <summary>
+        /// Accessor method to get the class's Subscriber
+        /// </summary>
+        /// <returns></returns>
+        public ISubscriber getSubscriber()
+        {
+            return subscriber;
+        }
+
+        /// <summary>
+        /// Accessor method to get the class's Topic
+        /// </summary>
+        /// <returns></returns>
+        public ITopic getTopic()
+        {
+            return topic;
+        }
+
+        /// <summary>
+        /// Accessor method to get the class's DomainParticipant
+        /// </summary>
+        /// <returns></returns>
+        public IDomainParticipant getParticipant()
+        {
+            return participant;
+        }
+
+        /// <summary>
+        /// Accessor method to get the class's DomainParticipantFactory
+        /// </summary>
+        /// <returns></returns>
+        public IDomainParticipantFactory getDomainParticipantFactory()
+        {
+            return dpf;
+        }
+    }
+}

Unity/LineRobot/Assets/DDS/DDSEntityManager_ROS.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d80be7ab8f8caaa4cb4a1a9a7a2f06fa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cecbb7c25e84fbc4aab07fe98ca3ffbe
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/Editor/CreateStartupFile.cs

@@ -0,0 +1,46 @@
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.Callbacks;
+using System.IO;
+
+public class CreateStartupFile : MonoBehaviour
+{
+
+    [PostProcessBuild(2)]
+    public static void OnPostprocessBuild(BuildTarget target, string pathToBuiltProject)
+    {
+        string OsplHomeDirectory = "";
+        string OsplConfigFile = "";
+        int cnt = 0;
+        if (EditorPrefs.HasKey("OsplHomeDirectory"))
+        {
+            OsplHomeDirectory = EditorPrefs.GetString("OsplHomeDirectory");
+            if (OsplHomeDirectory != "")
+                cnt += 1;
+        }
+        if (EditorPrefs.HasKey("OsplConfigFile"))
+        {
+            OsplConfigFile = EditorPrefs.GetString("OsplConfigFile");
+            if (OsplConfigFile != "")
+                cnt += 1;
+        }
+        if (cnt < 2)
+        {
+            Debug.LogWarning("No batch-file is created to start the app with DDS enabled because not enough information is provided (DDS/Vortex)");
+        }
+        else
+        {
+            string filecontents = "@echo off\necho Setting paths for Vortex OpenSplice ..\nif \"%SPLICE_ORB%\"==\"\" set SPLICE_ORB=DDS_OpenFusion_1_6_1\nset OSPL_HOME=";
+            filecontents += OsplHomeDirectory;
+            filecontents += "\nset PATH=%OSPL_HOME%\\bin;%OSPL_HOME%\\lib;%OSPL_HOME%\\examples\\lib;%PATH%\n";
+            filecontents += "set OSPL_TMPL_PATH=%OSPL_HOME%\\etc\\idlpp\n";
+            filecontents += "if \"%OSPL_URI%\"==\"\" set OSPL_URI=file://" + OsplConfigFile + "\necho Starting the application ..\n";
+            filecontents += "\"" + pathToBuiltProject + "\"\n";
+            Debug.Log(filecontents);
+            Debug.Log("PATH:" + Path.GetDirectoryName(pathToBuiltProject) + "\\start_with_DDS.bat");
+            File.WriteAllText(Path.GetDirectoryName(pathToBuiltProject) + "\\start_with_DDS.bat", filecontents);
+            Debug.Log("Created batch-file to start the app with DDS enabled.");
+        }
+    }
+
+}

Unity/LineRobot/Assets/DDS/Editor/CreateStartupFile.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 522b6bc3c32666049b4a59cdf0f837d6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/Editor/DefineDDS.cs

@@ -0,0 +1,69 @@
+using UnityEngine;
+using UnityEditor;
+
+public class DefineDDS : EditorWindow
+{
+    string OsplHomeDirectory = "D:\\HDE\\x86_64.win64";
+    string OsplConfigFile = "D:\\HDE\\x86_64.win64\\etc\\config\\ospl_vm.xml";
+
+    [MenuItem("DDS/Vortex")]
+    static void Init()
+    {
+        // Get existing open window or if none, make a new one:
+        DefineDDS window = (DefineDDS)EditorWindow.GetWindow(typeof(DefineDDS));
+        window.Show();
+    }
+
+    void OnGUI()
+    {
+        GUILayout.Label("Vortex DDS Locations", EditorStyles.boldLabel);
+        EditorGUILayout.BeginHorizontal();
+        OsplHomeDirectory = EditorGUILayout.TextField("OSPL Home Directory", OsplHomeDirectory);
+        if (GUILayout.Button("Find", EditorStyles.miniButtonRight, GUILayout.Width(40)))
+        {
+            string FileOsplHomeDirectory = EditorUtility.OpenFolderPanel("OSPL Home Directory", "C:\\", "HDE");
+            if (FileOsplHomeDirectory != "")
+            {
+                OsplHomeDirectory = FileOsplHomeDirectory;
+                EditorPrefs.SetString("OsplHomeDirectory", OsplHomeDirectory);
+            }
+        }
+        EditorGUILayout.EndHorizontal();
+        EditorGUILayout.BeginHorizontal();
+        OsplConfigFile = EditorGUILayout.TextField("OSPL Config File", OsplConfigFile);
+        if (GUILayout.Button("Find", EditorStyles.miniButtonRight, GUILayout.Width(40)))
+        {
+            string FileOsplConfigFile = EditorUtility.OpenFilePanel("OSDPL Config File", "C:\\", "xml");
+            if (FileOsplConfigFile != "")
+            {
+                OsplConfigFile = FileOsplConfigFile;
+                EditorPrefs.SetString("OsplConfigFile", OsplConfigFile);
+            }
+        }
+        EditorGUILayout.EndHorizontal();
+    }
+
+    void OnFocus()
+    {
+        if (EditorPrefs.HasKey("OsplHomeDirectory"))
+            OsplHomeDirectory = EditorPrefs.GetString("OsplHomeDirectory");
+        if (EditorPrefs.HasKey("OsplConfigFile"))
+            OsplConfigFile = EditorPrefs.GetString("OsplConfigFile");
+    }
+
+    void OnLostFocus()
+    {
+        SetEditorPrefs();
+    }
+
+    void OnDestroy()
+    {
+        SetEditorPrefs();
+    }
+
+    void SetEditorPrefs()
+    {
+        EditorPrefs.SetString("OsplHomeDirectory", OsplHomeDirectory);
+        EditorPrefs.SetString("OsplConfigFile", OsplConfigFile);
+    }
+}

Unity/LineRobot/Assets/DDS/Editor/DefineDDS.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e62aa62a4bbf1a54ca5b9fd7e2f7f9a3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/Editor/postbuild.cs

@@ -0,0 +1,14 @@
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.Callbacks;
+
+public class postbuild : MonoBehaviour
+{
+    [PostProcessBuild(1)]
+    public static void OnPostprocessBuild(BuildTarget target, string pathToBuiltProject)
+    {
+        FileUtil.CopyFileOrDirectory("Assets/DDS/ManagedPlugins/dcpssacs.netmodule", pathToBuiltProject.Replace(".exe", "") + "_Data/Managed/dcpssacs.netmodule");
+        Debug.Log("Copied dcpssacs.netmodule to build-directory");
+    }
+
+}

Unity/LineRobot/Assets/DDS/Editor/postbuild.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cdda1de536765d440bdca89bf7ee8241
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/ErrorHandler.cs

@@ -0,0 +1,97 @@
+/*
+ *                         Vortex OpenSplice
+ *
+ *   This software and documentation are Copyright 2006 to  ADLINK
+ *   Technology Limited, its affiliated companies and licensors. All rights
+ *   reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ *
+ */
+
+/********************************************************************************
+ * LOGICAL_NAME:    ErrorHandler.cs
+ * FUNCTION:        OpenSplice ContentFilteredTopic example code.
+ * MODULE:          ContentFilteredTopic example for the C# programming language.
+ * DATE             October 2010.
+ *********************************************************************************
+ *
+ * This file contains the implementation for the error handling operations.
+ *
+ ***/
+using DDS;
+
+namespace DDSAPIHelper {
+
+    /// <summary>
+    /// Utility class to check the status of various Vortex OpenSplice operations.
+    /// </summary>
+public sealed class ErrorHandler {
+
+    public const int NR_ERROR_CODES = 13;
+
+	/* Array to hold the names for all ReturnCodes. */
+	public static string[] RetCodeName =  new string[NR_ERROR_CODES];
+	public static int t;
+
+	static ErrorHandler() {
+		RetCodeName[0] 	= "DDS_RETCODE_OK";
+		RetCodeName[1] 	= "DDS_RETCODE_ERROR";
+		RetCodeName[2] 	= "DDS_RETCODE_UNSUPPORTED";
+		RetCodeName[3] 	= "DDS_RETCODE_BAD_PARAMETER";
+		RetCodeName[4] 	= "DDS_RETCODE_PRECONDITION_NOT_MET";
+		RetCodeName[5] 	= "DDS_RETCODE_OUT_OF_RESOURCES";
+		RetCodeName[6] 	= "DDS_RETCODE_NOT_ENABLED";
+		RetCodeName[7] 	= "DDS_RETCODE_IMMUTABLE_POLICY";
+		RetCodeName[8] 	= "DDS_RETCODE_INCONSISTENT_POLICY";
+		RetCodeName[9] 	= "DDS_RETCODE_ALREADY_DELETED";
+		RetCodeName[10] = "DDS_RETCODE_TIMEOUT";
+		RetCodeName[11] = "DDS_RETCODE_NO_DATA";
+        RetCodeName[12] = "DDS_RETCODE_ILLEGAL_OPERATION";
+	}
+
+	/**
+	 * Returns the name of an error code.
+	 **/
+	public static string getErrorName(ReturnCode status) {
+		return RetCodeName[(int)status];
+	}
+
+	/**
+	 * Check the return status for errors. If there is an error,
+     * then terminate.
+	 **/
+	public static void checkStatus(ReturnCode status, string info) {
+        if (status != ReturnCode.Ok &&
+             status != ReturnCode.NoData)
+        {
+            System.Console.WriteLine(
+                "Error in " + info + ": " + getErrorName(status));
+            System.Environment.Exit(-1);
+        }
+	}
+
+	/**
+	 * Check whether a valid handle has been returned. If not, then terminate.
+	 **/
+	public static void checkHandle(object handle, string info) {
+		if (handle == null) {
+	        System.Console.WriteLine (
+                "Error in " + info + ": Creation failed: invalid handle");
+            System.Environment.Exit(-1);
+	     }
+	}
+
+}
+
+}

Unity/LineRobot/Assets/DDS/ErrorHandler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 12462b6a25c2854439ec04d66fe3aaa9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/ManagedPlugins.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e2625023377e28547bd9fdbe965fbf97
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/ManagedPlugins/dcpssacs.netmodule.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: b22e1fec3ea254248a7eef03c5cccd4c
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/ManagedPlugins/dcpssacsAssembly.dll.meta

@@ -0,0 +1,74 @@
+fileFormatVersion: 2
+guid: 4d3db8c4d8bc7014fa8f1d5d50e99fe5
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      : Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Editor: 0
+        Exclude Linux64: 0
+        Exclude OSXUniversal: 0
+        Exclude Win: 1
+        Exclude Win64: 0
+        Exclude WindowsStoreApps: 0
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 1
+      settings:
+        CPU: x86_64
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 1
+      settings:
+        CPU: x86_64
+  - first:
+      Standalone: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: None
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 1
+      settings:
+        CPU: x86_64
+  - first:
+      Windows Store Apps: WindowsStoreApps
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+        DontProcess: false
+        PlaceholderPath: 
+        SDK: AnySDK
+        ScriptingBackend: AnyScriptingBackend
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/helper.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 969ea6058907458439cd9900b5491b4e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/helper/ROSHelper.cs

@@ -0,0 +1,26 @@
+using System;
+
+using DDSAPIHelper;
+using builtin_interfaces.msg.dds_;
+
+namespace ros_helper 
+{
+    public class RosHelper
+    {
+        
+        public static Time_ GetUnixTimestamp()
+        {
+            double unixTimestamp = (DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
+            int sec = (int)unixTimestamp;
+            uint nsec = (uint) ((unixTimestamp - sec) * 1e9);
+            Time_ t = new Time_
+            {
+                sec_ = sec,
+                nanosec_ = nsec
+            };
+            return t;
+        }
+
+    }
+}
+

Unity/LineRobot/Assets/DDS/helper/ROSHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6da211f21ab92eb46babd97795816ac5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 969c8d6a874de554880f6ae831b5f6d2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ce3b140a5e911384da0ba43c37064aae
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Duration_.cs

@@ -0,0 +1,24 @@
+using DDS;
+using System.Runtime.InteropServices;
+
+namespace builtin_interfaces
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region Duration_
+            [StructLayout(LayoutKind.Sequential)]
+            public sealed class Duration_
+            {
+                public int sec_;
+                public uint nanosec_;
+            };
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Duration_.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c08e3c7ea1f0ff1488479c825fc232bc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Duration_Dcps.cs

@@ -0,0 +1,629 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using DDS;
+using DDS.OpenSplice;
+using DDS.OpenSplice.CustomMarshalers;
+
+namespace builtin_interfaces
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region Duration_DataReader
+            public class Duration_DataReader : DDS.OpenSplice.FooDataReader<Duration_, __Duration_Marshaler>, 
+                                                 IDuration_DataReader
+            {
+                public Duration_DataReader(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public ReturnCode Read(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Read(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Read(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Read(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Read(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Read(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode Take(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Take(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Take(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Take(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Take(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Take(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadWithCondition(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return ReadWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode ReadWithCondition(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeWithCondition(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return TakeWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode TakeWithCondition(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public override ReturnCode ReadNextSample(
+                        ref Duration_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.ReadNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public override ReturnCode TakeNextSample(
+                        ref Duration_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.TakeNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public ReturnCode ReadInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadInstance(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeInstance(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadNextInstance(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeNextInstance(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstanceWithCondition(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return ReadNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode ReadNextInstanceWithCondition(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstanceWithCondition(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return TakeNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode TakeNextInstanceWithCondition(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+
+                    return result;
+                }
+
+                public override ReturnCode ReturnLoan(
+                        ref Duration_[] dataValues,
+                        ref SampleInfo[] sampleInfos)
+                {
+                    ReturnCode result =
+                        base.ReturnLoan(
+                                ref dataValues,
+                                ref sampleInfos);
+
+                    return result;
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref Duration_ key,
+                        InstanceHandle handle)
+                {
+                    ReturnCode result = base.GetKeyValue(
+                                ref key,
+                                handle);
+                    return result;
+                }
+
+                public override InstanceHandle LookupInstance(
+                        Duration_ instance)
+                {
+                    return
+                        base.LookupInstance(
+                                instance);
+                }
+
+            }
+            #endregion
+            
+            #region Duration_DataWriter
+            public class Duration_DataWriter : DDS.OpenSplice.FooDataWriter<Duration_, __Duration_Marshaler>, 
+                                                 IDuration_DataWriter
+            {
+                public Duration_DataWriter(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public InstanceHandle RegisterInstance(
+                        Duration_ instanceData)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            Time.Current);
+                }
+
+                public InstanceHandle RegisterInstanceWithTimestamp(
+                        Duration_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode UnregisterInstance(
+                        Duration_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode UnregisterInstanceWithTimestamp(
+                        Duration_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Write(Duration_ instanceData)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode Write(
+                        Duration_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        Duration_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        Duration_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Dispose(
+                        Duration_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode DisposeWithTimestamp(
+                        Duration_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDispose(
+                        Duration_ instanceData)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDispose(
+                        Duration_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        Duration_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        Duration_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref Duration_ key,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.GetKeyValue(ref key, instanceHandle);
+                }
+
+                public override InstanceHandle LookupInstance(
+                    Duration_ instanceData)
+                {
+                    return base.LookupInstance(instanceData);
+                }
+            }
+            #endregion
+
+            #region Duration_TypeSupport
+            public class Duration_TypeSupport : DDS.OpenSplice.TypeSupport
+            {
+                private static readonly string[] metaDescriptor = {"<MetaData version=\"1.0.0\"><Module name=\"builtin_interfaces\"><Module name=\"msg\"><Module name=\"dds_\">",
+"<Struct name=\"Duration_\"><Member name=\"sec_\"><Long/></Member><Member name=\"nanosec_\"><ULong/></Member>",
+"</Struct></Module></Module></Module></MetaData>"};
+
+                public Duration_TypeSupport()
+                    : base(typeof(Duration_), metaDescriptor, "builtin_interfaces::msg::dds_::Duration_", "", "")
+                { }
+
+
+                public override ReturnCode RegisterType(IDomainParticipant participant, string typeName)
+                {
+                    return RegisterType(participant, typeName, new __Duration_Marshaler());
+                }
+
+                public override DDS.OpenSplice.DataWriter CreateDataWriter(DatabaseMarshaler marshaler)
+                {
+                    return new Duration_DataWriter(marshaler);
+                }
+
+                public override DDS.OpenSplice.DataReader CreateDataReader(DatabaseMarshaler marshaler)
+                {
+                    return new Duration_DataReader(marshaler);
+                }
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Duration_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ce5546f3b9fb815409989fad37dca4e6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Duration_SplDcps.cs

@@ -0,0 +1,96 @@
+using DDS;
+using DDS.OpenSplice.CustomMarshalers;
+using DDS.OpenSplice.Database;
+using DDS.OpenSplice.Kernel;
+using System;
+using System.Runtime.InteropServices;
+
+namespace builtin_interfaces
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region __Duration_
+            [StructLayout(LayoutKind.Sequential)]
+            public struct __Duration_
+            {
+                public int sec_;
+                public uint nanosec_;
+            }
+            #endregion
+
+            #region __Duration_Marshaler
+            public sealed class __Duration_Marshaler : DDS.OpenSplice.CustomMarshalers.FooDatabaseMarshaler<builtin_interfaces.msg.dds_.Duration_>
+            {
+                public static readonly string fullyScopedName = "builtin_interfaces::msg::dds_::Duration_";
+
+                public override void InitEmbeddedMarshalers(IDomainParticipant participant)
+                {
+                }
+
+                public override V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, System.IntPtr from, System.IntPtr to)
+                {
+                    GCHandle tmpGCHandle = GCHandle.FromIntPtr(from);
+                    builtin_interfaces.msg.dds_.Duration_ fromData = tmpGCHandle.Target as builtin_interfaces.msg.dds_.Duration_;
+                    return CopyIn(typePtr, fromData, to);
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, builtin_interfaces.msg.dds_.Duration_ from, System.IntPtr to)
+                {
+                    __Duration_ nativeImg = new __Duration_();
+                    V_COPYIN_RESULT result = CopyIn(typePtr, from, ref nativeImg);
+                    if (result == V_COPYIN_RESULT.OK)
+                    {
+                        Marshal.StructureToPtr(nativeImg, to, false);
+                    }
+                    return result;
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, builtin_interfaces.msg.dds_.Duration_ from, ref __Duration_ to)
+                {
+                    if (from == null) return V_COPYIN_RESULT.INVALID;
+                    to.sec_ = from.sec_;
+                    to.nanosec_ = from.nanosec_;
+                    return V_COPYIN_RESULT.OK;
+                }
+
+                public override void CopyOut(System.IntPtr from, System.IntPtr to)
+                {
+                    __Duration_ nativeImg = (__Duration_) Marshal.PtrToStructure(from, typeof(__Duration_));
+                    GCHandle tmpGCHandleTo = GCHandle.FromIntPtr(to);
+                    builtin_interfaces.msg.dds_.Duration_ toObj = tmpGCHandleTo.Target as builtin_interfaces.msg.dds_.Duration_;
+                    CopyOut(ref nativeImg, ref toObj);
+                    tmpGCHandleTo.Target = toObj;
+                }
+
+                public override void CopyOut(System.IntPtr from, ref builtin_interfaces.msg.dds_.Duration_ to)
+                {
+                    __Duration_ nativeImg = (__Duration_) Marshal.PtrToStructure(from, typeof(__Duration_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void StaticCopyOut(System.IntPtr from, ref builtin_interfaces.msg.dds_.Duration_ to)
+                {
+                    __Duration_ nativeImg = (__Duration_) Marshal.PtrToStructure(from, typeof(__Duration_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void CopyOut(ref __Duration_ from, ref builtin_interfaces.msg.dds_.Duration_ to)
+                {
+                    if (to == null) {
+                        to = new builtin_interfaces.msg.dds_.Duration_();
+                    }
+                    to.sec_ = from.sec_;
+                    to.nanosec_ = from.nanosec_;
+                }
+
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Duration_SplDcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c54d6cc9649b51d4aa74e3589a0d2bf6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/IDuration_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace builtin_interfaces
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IDuration_DataReader
+            public interface IDuration_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref Duration_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref Duration_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref Duration_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref Duration_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    Duration_ instance);
+            }
+            #endregion
+
+            #region IDuration_DataWriter
+            public interface IDuration_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    Duration_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    Duration_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    Duration_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    Duration_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    Duration_ instanceData);
+
+                ReturnCode Write(
+                    Duration_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    Duration_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    Duration_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    Duration_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    Duration_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    Duration_ instanceData);
+
+                ReturnCode WriteDispose(
+                    Duration_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Duration_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Duration_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref Duration_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    Duration_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/IDuration_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8c63d4bd3b855384eb27396ce8befd5a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/ITime_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace builtin_interfaces
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region ITime_DataReader
+            public interface ITime_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref Time_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref Time_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref Time_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    Time_ instance);
+            }
+            #endregion
+
+            #region ITime_DataWriter
+            public interface ITime_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    Time_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    Time_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    Time_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    Time_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    Time_ instanceData);
+
+                ReturnCode Write(
+                    Time_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    Time_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    Time_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    Time_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    Time_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    Time_ instanceData);
+
+                ReturnCode WriteDispose(
+                    Time_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Time_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Time_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref Time_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    Time_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/ITime_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a6996478a933a2f4e8e30f57cc7632ea
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Time_.cs

@@ -0,0 +1,24 @@
+using DDS;
+using System.Runtime.InteropServices;
+
+namespace builtin_interfaces
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region Time_
+            [StructLayout(LayoutKind.Sequential)]
+            public sealed class Time_
+            {
+                public int sec_;
+                public uint nanosec_;
+            };
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Time_.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 260916dfdaddc6b4fb8533294547cb70
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Time_Dcps.cs

@@ -0,0 +1,629 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using DDS;
+using DDS.OpenSplice;
+using DDS.OpenSplice.CustomMarshalers;
+
+namespace builtin_interfaces
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region Time_DataReader
+            public class Time_DataReader : DDS.OpenSplice.FooDataReader<Time_, __Time_Marshaler>, 
+                                                 ITime_DataReader
+            {
+                public Time_DataReader(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public ReturnCode Read(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Read(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Read(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Read(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Read(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Read(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode Take(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Take(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Take(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Take(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Take(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Take(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadWithCondition(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return ReadWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode ReadWithCondition(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeWithCondition(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return TakeWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode TakeWithCondition(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public override ReturnCode ReadNextSample(
+                        ref Time_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.ReadNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public override ReturnCode TakeNextSample(
+                        ref Time_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.TakeNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public ReturnCode ReadInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadInstance(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeInstance(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadNextInstance(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref Time_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeNextInstance(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstanceWithCondition(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return ReadNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode ReadNextInstanceWithCondition(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstanceWithCondition(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return TakeNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode TakeNextInstanceWithCondition(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+
+                    return result;
+                }
+
+                public override ReturnCode ReturnLoan(
+                        ref Time_[] dataValues,
+                        ref SampleInfo[] sampleInfos)
+                {
+                    ReturnCode result =
+                        base.ReturnLoan(
+                                ref dataValues,
+                                ref sampleInfos);
+
+                    return result;
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref Time_ key,
+                        InstanceHandle handle)
+                {
+                    ReturnCode result = base.GetKeyValue(
+                                ref key,
+                                handle);
+                    return result;
+                }
+
+                public override InstanceHandle LookupInstance(
+                        Time_ instance)
+                {
+                    return
+                        base.LookupInstance(
+                                instance);
+                }
+
+            }
+            #endregion
+            
+            #region Time_DataWriter
+            public class Time_DataWriter : DDS.OpenSplice.FooDataWriter<Time_, __Time_Marshaler>, 
+                                                 ITime_DataWriter
+            {
+                public Time_DataWriter(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public InstanceHandle RegisterInstance(
+                        Time_ instanceData)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            Time.Current);
+                }
+
+                public InstanceHandle RegisterInstanceWithTimestamp(
+                        Time_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode UnregisterInstance(
+                        Time_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode UnregisterInstanceWithTimestamp(
+                        Time_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Write(Time_ instanceData)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode Write(
+                        Time_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        Time_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        Time_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Dispose(
+                        Time_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode DisposeWithTimestamp(
+                        Time_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDispose(
+                        Time_ instanceData)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDispose(
+                        Time_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        Time_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        Time_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref Time_ key,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.GetKeyValue(ref key, instanceHandle);
+                }
+
+                public override InstanceHandle LookupInstance(
+                    Time_ instanceData)
+                {
+                    return base.LookupInstance(instanceData);
+                }
+            }
+            #endregion
+
+            #region Time_TypeSupport
+            public class Time_TypeSupport : DDS.OpenSplice.TypeSupport
+            {
+                private static readonly string[] metaDescriptor = {"<MetaData version=\"1.0.0\"><Module name=\"builtin_interfaces\"><Module name=\"msg\"><Module name=\"dds_\">",
+"<Struct name=\"Time_\"><Member name=\"sec_\"><Long/></Member><Member name=\"nanosec_\"><ULong/></Member>",
+"</Struct></Module></Module></Module></MetaData>"};
+
+                public Time_TypeSupport()
+                    : base(typeof(Time_), metaDescriptor, "builtin_interfaces::msg::dds_::Time_", "", "")
+                { }
+
+
+                public override ReturnCode RegisterType(IDomainParticipant participant, string typeName)
+                {
+                    return RegisterType(participant, typeName, new __Time_Marshaler());
+                }
+
+                public override DDS.OpenSplice.DataWriter CreateDataWriter(DatabaseMarshaler marshaler)
+                {
+                    return new Time_DataWriter(marshaler);
+                }
+
+                public override DDS.OpenSplice.DataReader CreateDataReader(DatabaseMarshaler marshaler)
+                {
+                    return new Time_DataReader(marshaler);
+                }
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Time_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0e22606cfda9c6c489440d67727fa6ab
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Time_SplDcps.cs

@@ -0,0 +1,96 @@
+using DDS;
+using DDS.OpenSplice.CustomMarshalers;
+using DDS.OpenSplice.Database;
+using DDS.OpenSplice.Kernel;
+using System;
+using System.Runtime.InteropServices;
+
+namespace builtin_interfaces
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region __Time_
+            [StructLayout(LayoutKind.Sequential)]
+            public struct __Time_
+            {
+                public int sec_;
+                public uint nanosec_;
+            }
+            #endregion
+
+            #region __Time_Marshaler
+            public sealed class __Time_Marshaler : DDS.OpenSplice.CustomMarshalers.FooDatabaseMarshaler<builtin_interfaces.msg.dds_.Time_>
+            {
+                public static readonly string fullyScopedName = "builtin_interfaces::msg::dds_::Time_";
+
+                public override void InitEmbeddedMarshalers(IDomainParticipant participant)
+                {
+                }
+
+                public override V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, System.IntPtr from, System.IntPtr to)
+                {
+                    GCHandle tmpGCHandle = GCHandle.FromIntPtr(from);
+                    builtin_interfaces.msg.dds_.Time_ fromData = tmpGCHandle.Target as builtin_interfaces.msg.dds_.Time_;
+                    return CopyIn(typePtr, fromData, to);
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, builtin_interfaces.msg.dds_.Time_ from, System.IntPtr to)
+                {
+                    __Time_ nativeImg = new __Time_();
+                    V_COPYIN_RESULT result = CopyIn(typePtr, from, ref nativeImg);
+                    if (result == V_COPYIN_RESULT.OK)
+                    {
+                        Marshal.StructureToPtr(nativeImg, to, false);
+                    }
+                    return result;
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, builtin_interfaces.msg.dds_.Time_ from, ref __Time_ to)
+                {
+                    if (from == null) return V_COPYIN_RESULT.INVALID;
+                    to.sec_ = from.sec_;
+                    to.nanosec_ = from.nanosec_;
+                    return V_COPYIN_RESULT.OK;
+                }
+
+                public override void CopyOut(System.IntPtr from, System.IntPtr to)
+                {
+                    __Time_ nativeImg = (__Time_) Marshal.PtrToStructure(from, typeof(__Time_));
+                    GCHandle tmpGCHandleTo = GCHandle.FromIntPtr(to);
+                    builtin_interfaces.msg.dds_.Time_ toObj = tmpGCHandleTo.Target as builtin_interfaces.msg.dds_.Time_;
+                    CopyOut(ref nativeImg, ref toObj);
+                    tmpGCHandleTo.Target = toObj;
+                }
+
+                public override void CopyOut(System.IntPtr from, ref builtin_interfaces.msg.dds_.Time_ to)
+                {
+                    __Time_ nativeImg = (__Time_) Marshal.PtrToStructure(from, typeof(__Time_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void StaticCopyOut(System.IntPtr from, ref builtin_interfaces.msg.dds_.Time_ to)
+                {
+                    __Time_ nativeImg = (__Time_) Marshal.PtrToStructure(from, typeof(__Time_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void CopyOut(ref __Time_ from, ref builtin_interfaces.msg.dds_.Time_ to)
+                {
+                    if (to == null) {
+                        to = new builtin_interfaces.msg.dds_.Time_();
+                    }
+                    to.sec_ = from.sec_;
+                    to.nanosec_ = from.nanosec_;
+                }
+
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/builtin_interfaces/Time_SplDcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c460ee5e485205c4683ae5bd3e77f86a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 081db23b843aa2746a56dba9f2df545b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelStamped_.cs

@@ -0,0 +1,24 @@
+using DDS;
+using System.Runtime.InteropServices;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region AccelStamped_
+            [StructLayout(LayoutKind.Sequential)]
+            public sealed class AccelStamped_
+            {
+                public std_msgs.msg.dds_.Header_ header_ = new std_msgs.msg.dds_.Header_();
+                public geometry_msgs.msg.dds_.Accel_ accel_ = new geometry_msgs.msg.dds_.Accel_();
+            };
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelStamped_.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c679f89ce25d2eb4aa3f02c97b130eba
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelStamped_Dcps.cs

@@ -0,0 +1,638 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using DDS;
+using DDS.OpenSplice;
+using DDS.OpenSplice.CustomMarshalers;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region AccelStamped_DataReader
+            public class AccelStamped_DataReader : DDS.OpenSplice.FooDataReader<AccelStamped_, __AccelStamped_Marshaler>, 
+                                                 IAccelStamped_DataReader
+            {
+                public AccelStamped_DataReader(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public ReturnCode Read(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Read(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Read(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Read(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Read(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Read(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode Take(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Take(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Take(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Take(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Take(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Take(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadWithCondition(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return ReadWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode ReadWithCondition(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeWithCondition(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return TakeWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode TakeWithCondition(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public override ReturnCode ReadNextSample(
+                        ref AccelStamped_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.ReadNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public override ReturnCode TakeNextSample(
+                        ref AccelStamped_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.TakeNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public ReturnCode ReadInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadInstance(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeInstance(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadNextInstance(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeNextInstance(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstanceWithCondition(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return ReadNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode ReadNextInstanceWithCondition(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstanceWithCondition(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return TakeNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode TakeNextInstanceWithCondition(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+
+                    return result;
+                }
+
+                public override ReturnCode ReturnLoan(
+                        ref AccelStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos)
+                {
+                    ReturnCode result =
+                        base.ReturnLoan(
+                                ref dataValues,
+                                ref sampleInfos);
+
+                    return result;
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref AccelStamped_ key,
+                        InstanceHandle handle)
+                {
+                    ReturnCode result = base.GetKeyValue(
+                                ref key,
+                                handle);
+                    return result;
+                }
+
+                public override InstanceHandle LookupInstance(
+                        AccelStamped_ instance)
+                {
+                    return
+                        base.LookupInstance(
+                                instance);
+                }
+
+            }
+            #endregion
+            
+            #region AccelStamped_DataWriter
+            public class AccelStamped_DataWriter : DDS.OpenSplice.FooDataWriter<AccelStamped_, __AccelStamped_Marshaler>, 
+                                                 IAccelStamped_DataWriter
+            {
+                public AccelStamped_DataWriter(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public InstanceHandle RegisterInstance(
+                        AccelStamped_ instanceData)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            Time.Current);
+                }
+
+                public InstanceHandle RegisterInstanceWithTimestamp(
+                        AccelStamped_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode UnregisterInstance(
+                        AccelStamped_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode UnregisterInstanceWithTimestamp(
+                        AccelStamped_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Write(AccelStamped_ instanceData)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode Write(
+                        AccelStamped_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        AccelStamped_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        AccelStamped_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Dispose(
+                        AccelStamped_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode DisposeWithTimestamp(
+                        AccelStamped_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDispose(
+                        AccelStamped_ instanceData)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDispose(
+                        AccelStamped_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        AccelStamped_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        AccelStamped_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref AccelStamped_ key,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.GetKeyValue(ref key, instanceHandle);
+                }
+
+                public override InstanceHandle LookupInstance(
+                    AccelStamped_ instanceData)
+                {
+                    return base.LookupInstance(instanceData);
+                }
+            }
+            #endregion
+
+            #region AccelStamped_TypeSupport
+            public class AccelStamped_TypeSupport : DDS.OpenSplice.TypeSupport
+            {
+                private static readonly string[] metaDescriptor = {"<MetaData version=\"1.0.0\"><Module name=\"geometry_msgs\"><Module name=\"msg\"><Module name=\"dds_\">",
+"<Struct name=\"Vector3_\"><Member name=\"x_\"><Double/></Member><Member name=\"y_\"><Double/></Member>",
+"<Member name=\"z_\"><Double/></Member></Struct><Struct name=\"Accel_\"><Member name=\"linear_\"><Type name=\"Vector3_\"/>",
+"</Member><Member name=\"angular_\"><Type name=\"Vector3_\"/></Member></Struct></Module></Module></Module>",
+"<Module name=\"builtin_interfaces\"><Module name=\"msg\"><Module name=\"dds_\"><Struct name=\"Time_\">",
+"<Member name=\"sec_\"><Long/></Member><Member name=\"nanosec_\"><ULong/></Member></Struct></Module></Module>",
+"</Module><Module name=\"std_msgs\"><Module name=\"msg\"><Module name=\"dds_\"><Struct name=\"Header_\">",
+"<Member name=\"stamp_\"><Type name=\"::builtin_interfaces::msg::dds_::Time_\"/></Member><Member name=\"frame_id_\">",
+"<String/></Member></Struct></Module></Module></Module><Module name=\"geometry_msgs\"><Module name=\"msg\">",
+"<Module name=\"dds_\"><Struct name=\"AccelStamped_\"><Member name=\"header_\"><Type name=\"::std_msgs::msg::dds_::Header_\"/>",
+"</Member><Member name=\"accel_\"><Type name=\"Accel_\"/></Member></Struct></Module></Module></Module>",
+"</MetaData>"};
+
+                public AccelStamped_TypeSupport()
+                    : base(typeof(AccelStamped_), metaDescriptor, "geometry_msgs::msg::dds_::AccelStamped_", "", "")
+                { }
+
+
+                public override ReturnCode RegisterType(IDomainParticipant participant, string typeName)
+                {
+                    return RegisterType(participant, typeName, new __AccelStamped_Marshaler());
+                }
+
+                public override DDS.OpenSplice.DataWriter CreateDataWriter(DatabaseMarshaler marshaler)
+                {
+                    return new AccelStamped_DataWriter(marshaler);
+                }
+
+                public override DDS.OpenSplice.DataReader CreateDataReader(DatabaseMarshaler marshaler)
+                {
+                    return new AccelStamped_DataReader(marshaler);
+                }
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelStamped_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1a588f9c4dbfdd54ba56cf8b258dcc33
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelStamped_SplDcps.cs

@@ -0,0 +1,120 @@
+using DDS;
+using DDS.OpenSplice.CustomMarshalers;
+using DDS.OpenSplice.Database;
+using DDS.OpenSplice.Kernel;
+using System;
+using System.Runtime.InteropServices;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region __AccelStamped_
+            [StructLayout(LayoutKind.Sequential)]
+            public struct __AccelStamped_
+            {
+                public std_msgs.msg.dds_.__Header_ header_;
+                public geometry_msgs.msg.dds_.__Accel_ accel_;
+            }
+            #endregion
+
+            #region __AccelStamped_Marshaler
+            public sealed class __AccelStamped_Marshaler : DDS.OpenSplice.CustomMarshalers.FooDatabaseMarshaler<geometry_msgs.msg.dds_.AccelStamped_>
+            {
+                public static readonly string fullyScopedName = "geometry_msgs::msg::dds_::AccelStamped_";
+                private std_msgs.msg.dds_.__Header_Marshaler attr0Marshaler;
+                private geometry_msgs.msg.dds_.__Accel_Marshaler attr1Marshaler;
+
+                public override void InitEmbeddedMarshalers(IDomainParticipant participant)
+                {
+                    if (attr0Marshaler == null) {
+                        attr0Marshaler = DatabaseMarshaler.GetMarshaler(participant, typeof(std_msgs.msg.dds_.__Header_)) as std_msgs.msg.dds_.__Header_Marshaler;
+                        if (attr0Marshaler == null) {
+                            attr0Marshaler = new std_msgs.msg.dds_.__Header_Marshaler();
+                            DatabaseMarshaler.Add(participant, typeof(std_msgs.msg.dds_.__Header_), attr0Marshaler);
+                            attr0Marshaler.InitEmbeddedMarshalers(participant);
+                        }
+                    }
+                    if (attr1Marshaler == null) {
+                        attr1Marshaler = DatabaseMarshaler.GetMarshaler(participant, typeof(geometry_msgs.msg.dds_.__Accel_)) as geometry_msgs.msg.dds_.__Accel_Marshaler;
+                        if (attr1Marshaler == null) {
+                            attr1Marshaler = new geometry_msgs.msg.dds_.__Accel_Marshaler();
+                            DatabaseMarshaler.Add(participant, typeof(geometry_msgs.msg.dds_.__Accel_), attr1Marshaler);
+                            attr1Marshaler.InitEmbeddedMarshalers(participant);
+                        }
+                    }
+                }
+
+                public override V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, System.IntPtr from, System.IntPtr to)
+                {
+                    GCHandle tmpGCHandle = GCHandle.FromIntPtr(from);
+                    geometry_msgs.msg.dds_.AccelStamped_ fromData = tmpGCHandle.Target as geometry_msgs.msg.dds_.AccelStamped_;
+                    return CopyIn(typePtr, fromData, to);
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, geometry_msgs.msg.dds_.AccelStamped_ from, System.IntPtr to)
+                {
+                    __AccelStamped_ nativeImg = new __AccelStamped_();
+                    V_COPYIN_RESULT result = CopyIn(typePtr, from, ref nativeImg);
+                    if (result == V_COPYIN_RESULT.OK)
+                    {
+                        Marshal.StructureToPtr(nativeImg, to, false);
+                    }
+                    return result;
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, geometry_msgs.msg.dds_.AccelStamped_ from, ref __AccelStamped_ to)
+                {
+                    if (from == null) return V_COPYIN_RESULT.INVALID;
+                    {
+                        V_COPYIN_RESULT result = attr0Marshaler.CopyIn(typePtr, from.header_, ref to.header_);
+                        if (result != V_COPYIN_RESULT.OK) return result;
+                    }
+                    {
+                        V_COPYIN_RESULT result = attr1Marshaler.CopyIn(typePtr, from.accel_, ref to.accel_);
+                        if (result != V_COPYIN_RESULT.OK) return result;
+                    }
+                    return V_COPYIN_RESULT.OK;
+                }
+
+                public override void CopyOut(System.IntPtr from, System.IntPtr to)
+                {
+                    __AccelStamped_ nativeImg = (__AccelStamped_) Marshal.PtrToStructure(from, typeof(__AccelStamped_));
+                    GCHandle tmpGCHandleTo = GCHandle.FromIntPtr(to);
+                    geometry_msgs.msg.dds_.AccelStamped_ toObj = tmpGCHandleTo.Target as geometry_msgs.msg.dds_.AccelStamped_;
+                    CopyOut(ref nativeImg, ref toObj);
+                    tmpGCHandleTo.Target = toObj;
+                }
+
+                public override void CopyOut(System.IntPtr from, ref geometry_msgs.msg.dds_.AccelStamped_ to)
+                {
+                    __AccelStamped_ nativeImg = (__AccelStamped_) Marshal.PtrToStructure(from, typeof(__AccelStamped_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void StaticCopyOut(System.IntPtr from, ref geometry_msgs.msg.dds_.AccelStamped_ to)
+                {
+                    __AccelStamped_ nativeImg = (__AccelStamped_) Marshal.PtrToStructure(from, typeof(__AccelStamped_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void CopyOut(ref __AccelStamped_ from, ref geometry_msgs.msg.dds_.AccelStamped_ to)
+                {
+                    if (to == null) {
+                        to = new geometry_msgs.msg.dds_.AccelStamped_();
+                    }
+                    std_msgs.msg.dds_.__Header_Marshaler.CopyOut(ref from.header_, ref to.header_);
+                    geometry_msgs.msg.dds_.__Accel_Marshaler.CopyOut(ref from.accel_, ref to.accel_);
+                }
+
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelStamped_SplDcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 886c390f40f59f44089bd87c2b6b3c11
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovarianceStamped_.cs

@@ -0,0 +1,24 @@
+using DDS;
+using System.Runtime.InteropServices;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region AccelWithCovarianceStamped_
+            [StructLayout(LayoutKind.Sequential)]
+            public sealed class AccelWithCovarianceStamped_
+            {
+                public std_msgs.msg.dds_.Header_ header_ = new std_msgs.msg.dds_.Header_();
+                public geometry_msgs.msg.dds_.AccelWithCovariance_ accel_ = new geometry_msgs.msg.dds_.AccelWithCovariance_();
+            };
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovarianceStamped_.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b396e9d493d236d4088e4761f5bf2c10
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovarianceStamped_Dcps.cs

@@ -0,0 +1,639 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using DDS;
+using DDS.OpenSplice;
+using DDS.OpenSplice.CustomMarshalers;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region AccelWithCovarianceStamped_DataReader
+            public class AccelWithCovarianceStamped_DataReader : DDS.OpenSplice.FooDataReader<AccelWithCovarianceStamped_, __AccelWithCovarianceStamped_Marshaler>, 
+                                                 IAccelWithCovarianceStamped_DataReader
+            {
+                public AccelWithCovarianceStamped_DataReader(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public ReturnCode Read(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Read(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Read(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Read(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Read(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Read(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode Take(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Take(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Take(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Take(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Take(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Take(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadWithCondition(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return ReadWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode ReadWithCondition(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeWithCondition(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return TakeWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode TakeWithCondition(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public override ReturnCode ReadNextSample(
+                        ref AccelWithCovarianceStamped_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.ReadNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public override ReturnCode TakeNextSample(
+                        ref AccelWithCovarianceStamped_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.TakeNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public ReturnCode ReadInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadInstance(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeInstance(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadNextInstance(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeNextInstance(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstanceWithCondition(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return ReadNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode ReadNextInstanceWithCondition(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstanceWithCondition(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return TakeNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode TakeNextInstanceWithCondition(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+
+                    return result;
+                }
+
+                public override ReturnCode ReturnLoan(
+                        ref AccelWithCovarianceStamped_[] dataValues,
+                        ref SampleInfo[] sampleInfos)
+                {
+                    ReturnCode result =
+                        base.ReturnLoan(
+                                ref dataValues,
+                                ref sampleInfos);
+
+                    return result;
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref AccelWithCovarianceStamped_ key,
+                        InstanceHandle handle)
+                {
+                    ReturnCode result = base.GetKeyValue(
+                                ref key,
+                                handle);
+                    return result;
+                }
+
+                public override InstanceHandle LookupInstance(
+                        AccelWithCovarianceStamped_ instance)
+                {
+                    return
+                        base.LookupInstance(
+                                instance);
+                }
+
+            }
+            #endregion
+            
+            #region AccelWithCovarianceStamped_DataWriter
+            public class AccelWithCovarianceStamped_DataWriter : DDS.OpenSplice.FooDataWriter<AccelWithCovarianceStamped_, __AccelWithCovarianceStamped_Marshaler>, 
+                                                 IAccelWithCovarianceStamped_DataWriter
+            {
+                public AccelWithCovarianceStamped_DataWriter(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public InstanceHandle RegisterInstance(
+                        AccelWithCovarianceStamped_ instanceData)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            Time.Current);
+                }
+
+                public InstanceHandle RegisterInstanceWithTimestamp(
+                        AccelWithCovarianceStamped_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode UnregisterInstance(
+                        AccelWithCovarianceStamped_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode UnregisterInstanceWithTimestamp(
+                        AccelWithCovarianceStamped_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Write(AccelWithCovarianceStamped_ instanceData)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode Write(
+                        AccelWithCovarianceStamped_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        AccelWithCovarianceStamped_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        AccelWithCovarianceStamped_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Dispose(
+                        AccelWithCovarianceStamped_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode DisposeWithTimestamp(
+                        AccelWithCovarianceStamped_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDispose(
+                        AccelWithCovarianceStamped_ instanceData)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDispose(
+                        AccelWithCovarianceStamped_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        AccelWithCovarianceStamped_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        AccelWithCovarianceStamped_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref AccelWithCovarianceStamped_ key,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.GetKeyValue(ref key, instanceHandle);
+                }
+
+                public override InstanceHandle LookupInstance(
+                    AccelWithCovarianceStamped_ instanceData)
+                {
+                    return base.LookupInstance(instanceData);
+                }
+            }
+            #endregion
+
+            #region AccelWithCovarianceStamped_TypeSupport
+            public class AccelWithCovarianceStamped_TypeSupport : DDS.OpenSplice.TypeSupport
+            {
+                private static readonly string[] metaDescriptor = {"<MetaData version=\"1.0.0\"><Module name=\"geometry_msgs\"><Module name=\"msg\"><Module name=\"dds_\">",
+"<Struct name=\"Vector3_\"><Member name=\"x_\"><Double/></Member><Member name=\"y_\"><Double/></Member>",
+"<Member name=\"z_\"><Double/></Member></Struct><Struct name=\"Accel_\"><Member name=\"linear_\"><Type name=\"Vector3_\"/>",
+"</Member><Member name=\"angular_\"><Type name=\"Vector3_\"/></Member></Struct><Struct name=\"AccelWithCovariance_\">",
+"<Member name=\"accel_\"><Type name=\"Accel_\"/></Member><Member name=\"covariance_\"><Array size=\"36\">",
+"<Double/></Array></Member></Struct></Module></Module></Module><Module name=\"builtin_interfaces\"><Module name=\"msg\">",
+"<Module name=\"dds_\"><Struct name=\"Time_\"><Member name=\"sec_\"><Long/></Member><Member name=\"nanosec_\">",
+"<ULong/></Member></Struct></Module></Module></Module><Module name=\"std_msgs\"><Module name=\"msg\"><Module name=\"dds_\">",
+"<Struct name=\"Header_\"><Member name=\"stamp_\"><Type name=\"::builtin_interfaces::msg::dds_::Time_\"/>",
+"</Member><Member name=\"frame_id_\"><String/></Member></Struct></Module></Module></Module><Module name=\"geometry_msgs\">",
+"<Module name=\"msg\"><Module name=\"dds_\"><Struct name=\"AccelWithCovarianceStamped_\"><Member name=\"header_\">",
+"<Type name=\"::std_msgs::msg::dds_::Header_\"/></Member><Member name=\"accel_\"><Type name=\"AccelWithCovariance_\"/>",
+"</Member></Struct></Module></Module></Module></MetaData>"};
+
+                public AccelWithCovarianceStamped_TypeSupport()
+                    : base(typeof(AccelWithCovarianceStamped_), metaDescriptor, "geometry_msgs::msg::dds_::AccelWithCovarianceStamped_", "", "")
+                { }
+
+
+                public override ReturnCode RegisterType(IDomainParticipant participant, string typeName)
+                {
+                    return RegisterType(participant, typeName, new __AccelWithCovarianceStamped_Marshaler());
+                }
+
+                public override DDS.OpenSplice.DataWriter CreateDataWriter(DatabaseMarshaler marshaler)
+                {
+                    return new AccelWithCovarianceStamped_DataWriter(marshaler);
+                }
+
+                public override DDS.OpenSplice.DataReader CreateDataReader(DatabaseMarshaler marshaler)
+                {
+                    return new AccelWithCovarianceStamped_DataReader(marshaler);
+                }
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovarianceStamped_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6fafd861ab581e643b4b5831d5d4a422
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovarianceStamped_SplDcps.cs

@@ -0,0 +1,120 @@
+using DDS;
+using DDS.OpenSplice.CustomMarshalers;
+using DDS.OpenSplice.Database;
+using DDS.OpenSplice.Kernel;
+using System;
+using System.Runtime.InteropServices;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region __AccelWithCovarianceStamped_
+            [StructLayout(LayoutKind.Sequential)]
+            public struct __AccelWithCovarianceStamped_
+            {
+                public std_msgs.msg.dds_.__Header_ header_;
+                public geometry_msgs.msg.dds_.__AccelWithCovariance_ accel_;
+            }
+            #endregion
+
+            #region __AccelWithCovarianceStamped_Marshaler
+            public sealed class __AccelWithCovarianceStamped_Marshaler : DDS.OpenSplice.CustomMarshalers.FooDatabaseMarshaler<geometry_msgs.msg.dds_.AccelWithCovarianceStamped_>
+            {
+                public static readonly string fullyScopedName = "geometry_msgs::msg::dds_::AccelWithCovarianceStamped_";
+                private std_msgs.msg.dds_.__Header_Marshaler attr0Marshaler;
+                private geometry_msgs.msg.dds_.__AccelWithCovariance_Marshaler attr1Marshaler;
+
+                public override void InitEmbeddedMarshalers(IDomainParticipant participant)
+                {
+                    if (attr0Marshaler == null) {
+                        attr0Marshaler = DatabaseMarshaler.GetMarshaler(participant, typeof(std_msgs.msg.dds_.__Header_)) as std_msgs.msg.dds_.__Header_Marshaler;
+                        if (attr0Marshaler == null) {
+                            attr0Marshaler = new std_msgs.msg.dds_.__Header_Marshaler();
+                            DatabaseMarshaler.Add(participant, typeof(std_msgs.msg.dds_.__Header_), attr0Marshaler);
+                            attr0Marshaler.InitEmbeddedMarshalers(participant);
+                        }
+                    }
+                    if (attr1Marshaler == null) {
+                        attr1Marshaler = DatabaseMarshaler.GetMarshaler(participant, typeof(geometry_msgs.msg.dds_.__AccelWithCovariance_)) as geometry_msgs.msg.dds_.__AccelWithCovariance_Marshaler;
+                        if (attr1Marshaler == null) {
+                            attr1Marshaler = new geometry_msgs.msg.dds_.__AccelWithCovariance_Marshaler();
+                            DatabaseMarshaler.Add(participant, typeof(geometry_msgs.msg.dds_.__AccelWithCovariance_), attr1Marshaler);
+                            attr1Marshaler.InitEmbeddedMarshalers(participant);
+                        }
+                    }
+                }
+
+                public override V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, System.IntPtr from, System.IntPtr to)
+                {
+                    GCHandle tmpGCHandle = GCHandle.FromIntPtr(from);
+                    geometry_msgs.msg.dds_.AccelWithCovarianceStamped_ fromData = tmpGCHandle.Target as geometry_msgs.msg.dds_.AccelWithCovarianceStamped_;
+                    return CopyIn(typePtr, fromData, to);
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, geometry_msgs.msg.dds_.AccelWithCovarianceStamped_ from, System.IntPtr to)
+                {
+                    __AccelWithCovarianceStamped_ nativeImg = new __AccelWithCovarianceStamped_();
+                    V_COPYIN_RESULT result = CopyIn(typePtr, from, ref nativeImg);
+                    if (result == V_COPYIN_RESULT.OK)
+                    {
+                        Marshal.StructureToPtr(nativeImg, to, false);
+                    }
+                    return result;
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, geometry_msgs.msg.dds_.AccelWithCovarianceStamped_ from, ref __AccelWithCovarianceStamped_ to)
+                {
+                    if (from == null) return V_COPYIN_RESULT.INVALID;
+                    {
+                        V_COPYIN_RESULT result = attr0Marshaler.CopyIn(typePtr, from.header_, ref to.header_);
+                        if (result != V_COPYIN_RESULT.OK) return result;
+                    }
+                    {
+                        V_COPYIN_RESULT result = attr1Marshaler.CopyIn(typePtr, from.accel_, ref to.accel_);
+                        if (result != V_COPYIN_RESULT.OK) return result;
+                    }
+                    return V_COPYIN_RESULT.OK;
+                }
+
+                public override void CopyOut(System.IntPtr from, System.IntPtr to)
+                {
+                    __AccelWithCovarianceStamped_ nativeImg = (__AccelWithCovarianceStamped_) Marshal.PtrToStructure(from, typeof(__AccelWithCovarianceStamped_));
+                    GCHandle tmpGCHandleTo = GCHandle.FromIntPtr(to);
+                    geometry_msgs.msg.dds_.AccelWithCovarianceStamped_ toObj = tmpGCHandleTo.Target as geometry_msgs.msg.dds_.AccelWithCovarianceStamped_;
+                    CopyOut(ref nativeImg, ref toObj);
+                    tmpGCHandleTo.Target = toObj;
+                }
+
+                public override void CopyOut(System.IntPtr from, ref geometry_msgs.msg.dds_.AccelWithCovarianceStamped_ to)
+                {
+                    __AccelWithCovarianceStamped_ nativeImg = (__AccelWithCovarianceStamped_) Marshal.PtrToStructure(from, typeof(__AccelWithCovarianceStamped_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void StaticCopyOut(System.IntPtr from, ref geometry_msgs.msg.dds_.AccelWithCovarianceStamped_ to)
+                {
+                    __AccelWithCovarianceStamped_ nativeImg = (__AccelWithCovarianceStamped_) Marshal.PtrToStructure(from, typeof(__AccelWithCovarianceStamped_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void CopyOut(ref __AccelWithCovarianceStamped_ from, ref geometry_msgs.msg.dds_.AccelWithCovarianceStamped_ to)
+                {
+                    if (to == null) {
+                        to = new geometry_msgs.msg.dds_.AccelWithCovarianceStamped_();
+                    }
+                    std_msgs.msg.dds_.__Header_Marshaler.CopyOut(ref from.header_, ref to.header_);
+                    geometry_msgs.msg.dds_.__AccelWithCovariance_Marshaler.CopyOut(ref from.accel_, ref to.accel_);
+                }
+
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovarianceStamped_SplDcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 05f7b7a5e75f3e34ca4d17b77fd00d9e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovariance_.cs

@@ -0,0 +1,24 @@
+using DDS;
+using System.Runtime.InteropServices;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region AccelWithCovariance_
+            [StructLayout(LayoutKind.Sequential)]
+            public sealed class AccelWithCovariance_
+            {
+                public geometry_msgs.msg.dds_.Accel_ accel_ = new geometry_msgs.msg.dds_.Accel_();
+                public double[] covariance_ = new double[36];
+            };
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovariance_.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cbecf7d6199c33644b96a405a99eea43
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovariance_Dcps.cs

@@ -0,0 +1,632 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using DDS;
+using DDS.OpenSplice;
+using DDS.OpenSplice.CustomMarshalers;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region AccelWithCovariance_DataReader
+            public class AccelWithCovariance_DataReader : DDS.OpenSplice.FooDataReader<AccelWithCovariance_, __AccelWithCovariance_Marshaler>, 
+                                                 IAccelWithCovariance_DataReader
+            {
+                public AccelWithCovariance_DataReader(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public ReturnCode Read(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Read(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Read(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Read(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Read(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Read(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode Take(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Take(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Take(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Take(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Take(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Take(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadWithCondition(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return ReadWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode ReadWithCondition(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeWithCondition(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return TakeWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode TakeWithCondition(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public override ReturnCode ReadNextSample(
+                        ref AccelWithCovariance_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.ReadNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public override ReturnCode TakeNextSample(
+                        ref AccelWithCovariance_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.TakeNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public ReturnCode ReadInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadInstance(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeInstance(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadNextInstance(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeNextInstance(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstanceWithCondition(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return ReadNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode ReadNextInstanceWithCondition(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstanceWithCondition(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return TakeNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode TakeNextInstanceWithCondition(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+
+                    return result;
+                }
+
+                public override ReturnCode ReturnLoan(
+                        ref AccelWithCovariance_[] dataValues,
+                        ref SampleInfo[] sampleInfos)
+                {
+                    ReturnCode result =
+                        base.ReturnLoan(
+                                ref dataValues,
+                                ref sampleInfos);
+
+                    return result;
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref AccelWithCovariance_ key,
+                        InstanceHandle handle)
+                {
+                    ReturnCode result = base.GetKeyValue(
+                                ref key,
+                                handle);
+                    return result;
+                }
+
+                public override InstanceHandle LookupInstance(
+                        AccelWithCovariance_ instance)
+                {
+                    return
+                        base.LookupInstance(
+                                instance);
+                }
+
+            }
+            #endregion
+            
+            #region AccelWithCovariance_DataWriter
+            public class AccelWithCovariance_DataWriter : DDS.OpenSplice.FooDataWriter<AccelWithCovariance_, __AccelWithCovariance_Marshaler>, 
+                                                 IAccelWithCovariance_DataWriter
+            {
+                public AccelWithCovariance_DataWriter(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public InstanceHandle RegisterInstance(
+                        AccelWithCovariance_ instanceData)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            Time.Current);
+                }
+
+                public InstanceHandle RegisterInstanceWithTimestamp(
+                        AccelWithCovariance_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode UnregisterInstance(
+                        AccelWithCovariance_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode UnregisterInstanceWithTimestamp(
+                        AccelWithCovariance_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Write(AccelWithCovariance_ instanceData)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode Write(
+                        AccelWithCovariance_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        AccelWithCovariance_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        AccelWithCovariance_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Dispose(
+                        AccelWithCovariance_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode DisposeWithTimestamp(
+                        AccelWithCovariance_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDispose(
+                        AccelWithCovariance_ instanceData)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDispose(
+                        AccelWithCovariance_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        AccelWithCovariance_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        AccelWithCovariance_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref AccelWithCovariance_ key,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.GetKeyValue(ref key, instanceHandle);
+                }
+
+                public override InstanceHandle LookupInstance(
+                    AccelWithCovariance_ instanceData)
+                {
+                    return base.LookupInstance(instanceData);
+                }
+            }
+            #endregion
+
+            #region AccelWithCovariance_TypeSupport
+            public class AccelWithCovariance_TypeSupport : DDS.OpenSplice.TypeSupport
+            {
+                private static readonly string[] metaDescriptor = {"<MetaData version=\"1.0.0\"><Module name=\"geometry_msgs\"><Module name=\"msg\"><Module name=\"dds_\">",
+"<Struct name=\"Vector3_\"><Member name=\"x_\"><Double/></Member><Member name=\"y_\"><Double/></Member>",
+"<Member name=\"z_\"><Double/></Member></Struct><Struct name=\"Accel_\"><Member name=\"linear_\"><Type name=\"Vector3_\"/>",
+"</Member><Member name=\"angular_\"><Type name=\"Vector3_\"/></Member></Struct><Struct name=\"AccelWithCovariance_\">",
+"<Member name=\"accel_\"><Type name=\"Accel_\"/></Member><Member name=\"covariance_\"><Array size=\"36\">",
+"<Double/></Array></Member></Struct></Module></Module></Module></MetaData>"};
+
+                public AccelWithCovariance_TypeSupport()
+                    : base(typeof(AccelWithCovariance_), metaDescriptor, "geometry_msgs::msg::dds_::AccelWithCovariance_", "", "")
+                { }
+
+
+                public override ReturnCode RegisterType(IDomainParticipant participant, string typeName)
+                {
+                    return RegisterType(participant, typeName, new __AccelWithCovariance_Marshaler());
+                }
+
+                public override DDS.OpenSplice.DataWriter CreateDataWriter(DatabaseMarshaler marshaler)
+                {
+                    return new AccelWithCovariance_DataWriter(marshaler);
+                }
+
+                public override DDS.OpenSplice.DataReader CreateDataReader(DatabaseMarshaler marshaler)
+                {
+                    return new AccelWithCovariance_DataReader(marshaler);
+                }
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovariance_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6a56137acfe4fe548988378fb42effb0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovariance_SplDcps.cs

@@ -0,0 +1,123 @@
+using DDS;
+using DDS.OpenSplice.CustomMarshalers;
+using DDS.OpenSplice.Database;
+using DDS.OpenSplice.Kernel;
+using System;
+using System.Runtime.InteropServices;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region __AccelWithCovariance_
+            [StructLayout(LayoutKind.Sequential)]
+            public struct __AccelWithCovariance_
+            {
+                public geometry_msgs.msg.dds_.__Accel_ accel_;
+                [MarshalAs(UnmanagedType.ByValArray, SizeConst=36)]
+                public double[] covariance_;
+            }
+            #endregion
+
+            #region __AccelWithCovariance_Marshaler
+            public sealed class __AccelWithCovariance_Marshaler : DDS.OpenSplice.CustomMarshalers.FooDatabaseMarshaler<geometry_msgs.msg.dds_.AccelWithCovariance_>
+            {
+                public static readonly string fullyScopedName = "geometry_msgs::msg::dds_::AccelWithCovariance_";
+                private geometry_msgs.msg.dds_.__Accel_Marshaler attr0Marshaler;
+                private IntPtr attr1Col0Type = IntPtr.Zero;
+                private static readonly int attr1Col0Size = 1 * Marshal.SizeOf(typeof(double));
+
+                public override void InitEmbeddedMarshalers(IDomainParticipant participant)
+                {
+                    if (attr0Marshaler == null) {
+                        attr0Marshaler = DatabaseMarshaler.GetMarshaler(participant, typeof(geometry_msgs.msg.dds_.__Accel_)) as geometry_msgs.msg.dds_.__Accel_Marshaler;
+                        if (attr0Marshaler == null) {
+                            attr0Marshaler = new geometry_msgs.msg.dds_.__Accel_Marshaler();
+                            DatabaseMarshaler.Add(participant, typeof(geometry_msgs.msg.dds_.__Accel_), attr0Marshaler);
+                            attr0Marshaler.InitEmbeddedMarshalers(participant);
+                        }
+                    }
+                }
+
+                public override V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, System.IntPtr from, System.IntPtr to)
+                {
+                    GCHandle tmpGCHandle = GCHandle.FromIntPtr(from);
+                    geometry_msgs.msg.dds_.AccelWithCovariance_ fromData = tmpGCHandle.Target as geometry_msgs.msg.dds_.AccelWithCovariance_;
+                    return CopyIn(typePtr, fromData, to);
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, geometry_msgs.msg.dds_.AccelWithCovariance_ from, System.IntPtr to)
+                {
+                    __AccelWithCovariance_ nativeImg = new __AccelWithCovariance_();
+                    V_COPYIN_RESULT result = CopyIn(typePtr, from, ref nativeImg);
+                    if (result == V_COPYIN_RESULT.OK)
+                    {
+                        Marshal.StructureToPtr(nativeImg, to, false);
+                    }
+                    return result;
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, geometry_msgs.msg.dds_.AccelWithCovariance_ from, ref __AccelWithCovariance_ to)
+                {
+                    if (from == null) return V_COPYIN_RESULT.INVALID;
+                    {
+                        V_COPYIN_RESULT result = attr0Marshaler.CopyIn(typePtr, from.accel_, ref to.accel_);
+                        if (result != V_COPYIN_RESULT.OK) return result;
+                    }
+                    if (from.covariance_ == null) return V_COPYIN_RESULT.INVALID;
+                    if (from.covariance_.GetLength(0) != 36) return V_COPYIN_RESULT.INVALID;
+                    to.covariance_ = new double[36];
+                    if (attr1Col0Type == IntPtr.Zero) {
+                        IntPtr memberOwnerType = DDS.OpenSplice.Database.c.resolve(c.getBase(typePtr), fullyScopedName);
+                        IntPtr specifier = DDS.OpenSplice.Database.c.metaResolveSpecifier(memberOwnerType, "covariance_");
+                        IntPtr specifierType = DDS.OpenSplice.Database.c.specifierType(specifier);
+                        attr1Col0Type = DDS.OpenSplice.Database.c.typeActualType(specifierType);
+                    }
+                    System.Buffer.BlockCopy(from.covariance_, 0, to.covariance_, 0, (36 * Marshal.SizeOf(typeof(double))));
+                    return V_COPYIN_RESULT.OK;
+                }
+
+                public override void CopyOut(System.IntPtr from, System.IntPtr to)
+                {
+                    __AccelWithCovariance_ nativeImg = (__AccelWithCovariance_) Marshal.PtrToStructure(from, typeof(__AccelWithCovariance_));
+                    GCHandle tmpGCHandleTo = GCHandle.FromIntPtr(to);
+                    geometry_msgs.msg.dds_.AccelWithCovariance_ toObj = tmpGCHandleTo.Target as geometry_msgs.msg.dds_.AccelWithCovariance_;
+                    CopyOut(ref nativeImg, ref toObj);
+                    tmpGCHandleTo.Target = toObj;
+                }
+
+                public override void CopyOut(System.IntPtr from, ref geometry_msgs.msg.dds_.AccelWithCovariance_ to)
+                {
+                    __AccelWithCovariance_ nativeImg = (__AccelWithCovariance_) Marshal.PtrToStructure(from, typeof(__AccelWithCovariance_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void StaticCopyOut(System.IntPtr from, ref geometry_msgs.msg.dds_.AccelWithCovariance_ to)
+                {
+                    __AccelWithCovariance_ nativeImg = (__AccelWithCovariance_) Marshal.PtrToStructure(from, typeof(__AccelWithCovariance_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void CopyOut(ref __AccelWithCovariance_ from, ref geometry_msgs.msg.dds_.AccelWithCovariance_ to)
+                {
+                    if (to == null) {
+                        to = new geometry_msgs.msg.dds_.AccelWithCovariance_();
+                    }
+                    geometry_msgs.msg.dds_.__Accel_Marshaler.CopyOut(ref from.accel_, ref to.accel_);
+                    if (to.covariance_ == null || to.covariance_.GetLength(0) != 36) {
+                        to.covariance_ = new double[36];
+                    }
+                    System.Buffer.BlockCopy(from.covariance_, 0, to.covariance_, 0, (36 * Marshal.SizeOf(typeof(double))));
+                }
+
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/AccelWithCovariance_SplDcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9a91375d3a0a55942920804c1b7c7340
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/Accel_.cs

@@ -0,0 +1,24 @@
+using DDS;
+using System.Runtime.InteropServices;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region Accel_
+            [StructLayout(LayoutKind.Sequential)]
+            public sealed class Accel_
+            {
+                public geometry_msgs.msg.dds_.Vector3_ linear_ = new geometry_msgs.msg.dds_.Vector3_();
+                public geometry_msgs.msg.dds_.Vector3_ angular_ = new geometry_msgs.msg.dds_.Vector3_();
+            };
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/Accel_.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b21c81db834684a42b558789a22227fb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/Accel_Dcps.cs

@@ -0,0 +1,631 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using DDS;
+using DDS.OpenSplice;
+using DDS.OpenSplice.CustomMarshalers;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region Accel_DataReader
+            public class Accel_DataReader : DDS.OpenSplice.FooDataReader<Accel_, __Accel_Marshaler>, 
+                                                 IAccel_DataReader
+            {
+                public Accel_DataReader(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public ReturnCode Read(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Read(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Read(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Read(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Read(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Read(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Read(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode Take(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited);
+                }
+
+                public ReturnCode Take(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples)
+                {
+                    return Take(ref dataValues, ref sampleInfos, maxSamples, SampleStateKind.Any,
+                        ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public ReturnCode Take(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates)
+                {
+                    return Take(ref dataValues, ref sampleInfos, Length.Unlimited, sampleStates,
+                        viewStates, instanceStates);
+                }
+
+                public override ReturnCode Take(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.Take(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadWithCondition(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return ReadWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode ReadWithCondition(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeWithCondition(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition)
+                {
+                    return TakeWithCondition(ref dataValues, ref sampleInfos,
+                        Length.Unlimited, readCondition);
+                }
+
+                public override ReturnCode TakeWithCondition(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                readCondition);
+                    return result;
+                }
+
+                public override ReturnCode ReadNextSample(
+                        ref Accel_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.ReadNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public override ReturnCode TakeNextSample(
+                        ref Accel_ dataValue,
+                        ref SampleInfo sampleInfo)
+                {
+                    ReturnCode result =
+                        base.TakeNextSample(
+                                ref dataValue,
+                                ref sampleInfo);
+                    return result;
+                }
+
+                public ReturnCode ReadInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadInstance(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeInstance(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode ReadNextInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return ReadNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode ReadNextInstance(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, Length.Unlimited, instanceHandle);
+                }
+
+                public ReturnCode TakeNextInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle)
+                {
+                    return TakeNextInstance(ref dataValues, ref sampleInfos, maxSamples, instanceHandle,
+                        SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any);
+                }
+
+                public override ReturnCode TakeNextInstance(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        SampleStateKind sampleStates,
+                        ViewStateKind viewStates,
+                        InstanceStateKind instanceStates)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstance(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                sampleStates,
+                                viewStates,
+                                instanceStates);
+                    return result;
+                }
+
+                public ReturnCode ReadNextInstanceWithCondition(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return ReadNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode ReadNextInstanceWithCondition(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.ReadNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+                    return result;
+                }
+
+                public ReturnCode TakeNextInstanceWithCondition(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    return TakeNextInstanceWithCondition(
+                        ref dataValues,
+                        ref sampleInfos,
+                        Length.Unlimited,
+                        instanceHandle,
+                        readCondition);
+                }
+
+                public override ReturnCode TakeNextInstanceWithCondition(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos,
+                        int maxSamples,
+                        InstanceHandle instanceHandle,
+                        IReadCondition readCondition)
+                {
+                    ReturnCode result =
+                        base.TakeNextInstanceWithCondition(
+                                ref dataValues,
+                                ref sampleInfos,
+                                maxSamples,
+                                instanceHandle,
+                                readCondition);
+
+                    return result;
+                }
+
+                public override ReturnCode ReturnLoan(
+                        ref Accel_[] dataValues,
+                        ref SampleInfo[] sampleInfos)
+                {
+                    ReturnCode result =
+                        base.ReturnLoan(
+                                ref dataValues,
+                                ref sampleInfos);
+
+                    return result;
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref Accel_ key,
+                        InstanceHandle handle)
+                {
+                    ReturnCode result = base.GetKeyValue(
+                                ref key,
+                                handle);
+                    return result;
+                }
+
+                public override InstanceHandle LookupInstance(
+                        Accel_ instance)
+                {
+                    return
+                        base.LookupInstance(
+                                instance);
+                }
+
+            }
+            #endregion
+            
+            #region Accel_DataWriter
+            public class Accel_DataWriter : DDS.OpenSplice.FooDataWriter<Accel_, __Accel_Marshaler>, 
+                                                 IAccel_DataWriter
+            {
+                public Accel_DataWriter(DatabaseMarshaler marshaler)
+                    : base(marshaler) { }
+
+                public InstanceHandle RegisterInstance(
+                        Accel_ instanceData)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            Time.Current);
+                }
+
+                public InstanceHandle RegisterInstanceWithTimestamp(
+                        Accel_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.RegisterInstance(
+                            instanceData,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode UnregisterInstance(
+                        Accel_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode UnregisterInstanceWithTimestamp(
+                        Accel_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.UnregisterInstance(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Write(Accel_ instanceData)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode Write(
+                        Accel_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        Accel_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteWithTimestamp(
+                        Accel_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Write(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode Dispose(
+                        Accel_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode DisposeWithTimestamp(
+                        Accel_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.Dispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDispose(
+                        Accel_ instanceData)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDispose(
+                        Accel_ instanceData,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            Time.Current);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        Accel_ instanceData,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            InstanceHandle.Nil,
+                            sourceTimestamp);
+                }
+
+                public ReturnCode WriteDisposeWithTimestamp(
+                        Accel_ instanceData,
+                        InstanceHandle instanceHandle,
+                        Time sourceTimestamp)
+                {
+                    return base.WriteDispose(
+                            instanceData,
+                            instanceHandle,
+                            sourceTimestamp);
+                }
+
+                public override ReturnCode GetKeyValue(
+                        ref Accel_ key,
+                        InstanceHandle instanceHandle)
+                {
+                    return base.GetKeyValue(ref key, instanceHandle);
+                }
+
+                public override InstanceHandle LookupInstance(
+                    Accel_ instanceData)
+                {
+                    return base.LookupInstance(instanceData);
+                }
+            }
+            #endregion
+
+            #region Accel_TypeSupport
+            public class Accel_TypeSupport : DDS.OpenSplice.TypeSupport
+            {
+                private static readonly string[] metaDescriptor = {"<MetaData version=\"1.0.0\"><Module name=\"geometry_msgs\"><Module name=\"msg\"><Module name=\"dds_\">",
+"<Struct name=\"Vector3_\"><Member name=\"x_\"><Double/></Member><Member name=\"y_\"><Double/></Member>",
+"<Member name=\"z_\"><Double/></Member></Struct><Struct name=\"Accel_\"><Member name=\"linear_\"><Type name=\"Vector3_\"/>",
+"</Member><Member name=\"angular_\"><Type name=\"Vector3_\"/></Member></Struct></Module></Module></Module>",
+"</MetaData>"};
+
+                public Accel_TypeSupport()
+                    : base(typeof(Accel_), metaDescriptor, "geometry_msgs::msg::dds_::Accel_", "", "")
+                { }
+
+
+                public override ReturnCode RegisterType(IDomainParticipant participant, string typeName)
+                {
+                    return RegisterType(participant, typeName, new __Accel_Marshaler());
+                }
+
+                public override DDS.OpenSplice.DataWriter CreateDataWriter(DatabaseMarshaler marshaler)
+                {
+                    return new Accel_DataWriter(marshaler);
+                }
+
+                public override DDS.OpenSplice.DataReader CreateDataReader(DatabaseMarshaler marshaler)
+                {
+                    return new Accel_DataReader(marshaler);
+                }
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/Accel_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6ba8bea9f87472d4b86516795e2e0ef0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/Accel_SplDcps.cs

@@ -0,0 +1,120 @@
+using DDS;
+using DDS.OpenSplice.CustomMarshalers;
+using DDS.OpenSplice.Database;
+using DDS.OpenSplice.Kernel;
+using System;
+using System.Runtime.InteropServices;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region __Accel_
+            [StructLayout(LayoutKind.Sequential)]
+            public struct __Accel_
+            {
+                public geometry_msgs.msg.dds_.__Vector3_ linear_;
+                public geometry_msgs.msg.dds_.__Vector3_ angular_;
+            }
+            #endregion
+
+            #region __Accel_Marshaler
+            public sealed class __Accel_Marshaler : DDS.OpenSplice.CustomMarshalers.FooDatabaseMarshaler<geometry_msgs.msg.dds_.Accel_>
+            {
+                public static readonly string fullyScopedName = "geometry_msgs::msg::dds_::Accel_";
+                private geometry_msgs.msg.dds_.__Vector3_Marshaler attr0Marshaler;
+                private geometry_msgs.msg.dds_.__Vector3_Marshaler attr1Marshaler;
+
+                public override void InitEmbeddedMarshalers(IDomainParticipant participant)
+                {
+                    if (attr0Marshaler == null) {
+                        attr0Marshaler = DatabaseMarshaler.GetMarshaler(participant, typeof(geometry_msgs.msg.dds_.__Vector3_)) as geometry_msgs.msg.dds_.__Vector3_Marshaler;
+                        if (attr0Marshaler == null) {
+                            attr0Marshaler = new geometry_msgs.msg.dds_.__Vector3_Marshaler();
+                            DatabaseMarshaler.Add(participant, typeof(geometry_msgs.msg.dds_.__Vector3_), attr0Marshaler);
+                            attr0Marshaler.InitEmbeddedMarshalers(participant);
+                        }
+                    }
+                    if (attr1Marshaler == null) {
+                        attr1Marshaler = DatabaseMarshaler.GetMarshaler(participant, typeof(geometry_msgs.msg.dds_.__Vector3_)) as geometry_msgs.msg.dds_.__Vector3_Marshaler;
+                        if (attr1Marshaler == null) {
+                            attr1Marshaler = new geometry_msgs.msg.dds_.__Vector3_Marshaler();
+                            DatabaseMarshaler.Add(participant, typeof(geometry_msgs.msg.dds_.__Vector3_), attr1Marshaler);
+                            attr1Marshaler.InitEmbeddedMarshalers(participant);
+                        }
+                    }
+                }
+
+                public override V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, System.IntPtr from, System.IntPtr to)
+                {
+                    GCHandle tmpGCHandle = GCHandle.FromIntPtr(from);
+                    geometry_msgs.msg.dds_.Accel_ fromData = tmpGCHandle.Target as geometry_msgs.msg.dds_.Accel_;
+                    return CopyIn(typePtr, fromData, to);
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, geometry_msgs.msg.dds_.Accel_ from, System.IntPtr to)
+                {
+                    __Accel_ nativeImg = new __Accel_();
+                    V_COPYIN_RESULT result = CopyIn(typePtr, from, ref nativeImg);
+                    if (result == V_COPYIN_RESULT.OK)
+                    {
+                        Marshal.StructureToPtr(nativeImg, to, false);
+                    }
+                    return result;
+                }
+
+                public V_COPYIN_RESULT CopyIn(System.IntPtr typePtr, geometry_msgs.msg.dds_.Accel_ from, ref __Accel_ to)
+                {
+                    if (from == null) return V_COPYIN_RESULT.INVALID;
+                    {
+                        V_COPYIN_RESULT result = attr0Marshaler.CopyIn(typePtr, from.linear_, ref to.linear_);
+                        if (result != V_COPYIN_RESULT.OK) return result;
+                    }
+                    {
+                        V_COPYIN_RESULT result = attr1Marshaler.CopyIn(typePtr, from.angular_, ref to.angular_);
+                        if (result != V_COPYIN_RESULT.OK) return result;
+                    }
+                    return V_COPYIN_RESULT.OK;
+                }
+
+                public override void CopyOut(System.IntPtr from, System.IntPtr to)
+                {
+                    __Accel_ nativeImg = (__Accel_) Marshal.PtrToStructure(from, typeof(__Accel_));
+                    GCHandle tmpGCHandleTo = GCHandle.FromIntPtr(to);
+                    geometry_msgs.msg.dds_.Accel_ toObj = tmpGCHandleTo.Target as geometry_msgs.msg.dds_.Accel_;
+                    CopyOut(ref nativeImg, ref toObj);
+                    tmpGCHandleTo.Target = toObj;
+                }
+
+                public override void CopyOut(System.IntPtr from, ref geometry_msgs.msg.dds_.Accel_ to)
+                {
+                    __Accel_ nativeImg = (__Accel_) Marshal.PtrToStructure(from, typeof(__Accel_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void StaticCopyOut(System.IntPtr from, ref geometry_msgs.msg.dds_.Accel_ to)
+                {
+                    __Accel_ nativeImg = (__Accel_) Marshal.PtrToStructure(from, typeof(__Accel_));
+                    CopyOut(ref nativeImg, ref to);
+                }
+
+                public static void CopyOut(ref __Accel_ from, ref geometry_msgs.msg.dds_.Accel_ to)
+                {
+                    if (to == null) {
+                        to = new geometry_msgs.msg.dds_.Accel_();
+                    }
+                    geometry_msgs.msg.dds_.__Vector3_Marshaler.CopyOut(ref from.linear_, ref to.linear_);
+                    geometry_msgs.msg.dds_.__Vector3_Marshaler.CopyOut(ref from.angular_, ref to.angular_);
+                }
+
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/Accel_SplDcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c9cb593794773914f920e760a73b30ec
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IAccelStamped_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IAccelStamped_DataReader
+            public interface IAccelStamped_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref AccelStamped_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref AccelStamped_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref AccelStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref AccelStamped_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    AccelStamped_ instance);
+            }
+            #endregion
+
+            #region IAccelStamped_DataWriter
+            public interface IAccelStamped_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    AccelStamped_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    AccelStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    AccelStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    AccelStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    AccelStamped_ instanceData);
+
+                ReturnCode Write(
+                    AccelStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    AccelStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    AccelStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    AccelStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    AccelStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    AccelStamped_ instanceData);
+
+                ReturnCode WriteDispose(
+                    AccelStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    AccelStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    AccelStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref AccelStamped_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    AccelStamped_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IAccelStamped_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7a8634b302aa626409c298bd7429f2d1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IAccelWithCovarianceStamped_Dcps.cs

@@ -0,0 +1,283 @@
+using DDS;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IAccelWithCovarianceStamped_DataReader
+            public interface IAccelWithCovarianceStamped_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref AccelWithCovarianceStamped_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref AccelWithCovarianceStamped_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref AccelWithCovarianceStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref AccelWithCovarianceStamped_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    AccelWithCovarianceStamped_ instance);
+            }
+            #endregion
+
+            #region IAccelWithCovarianceStamped_DataWriter
+            public interface IAccelWithCovarianceStamped_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    AccelWithCovarianceStamped_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    AccelWithCovarianceStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    AccelWithCovarianceStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    AccelWithCovarianceStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    AccelWithCovarianceStamped_ instanceData);
+
+                ReturnCode Write(
+                    AccelWithCovarianceStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    AccelWithCovarianceStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    AccelWithCovarianceStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    AccelWithCovarianceStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    AccelWithCovarianceStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    AccelWithCovarianceStamped_ instanceData);
+
+                ReturnCode WriteDispose(
+                    AccelWithCovarianceStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    AccelWithCovarianceStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    AccelWithCovarianceStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref AccelWithCovarianceStamped_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    AccelWithCovarianceStamped_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IAccelWithCovarianceStamped_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 11a0125ed655fcc419342a9a4ee53c5e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IAccelWithCovariance_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IAccelWithCovariance_DataReader
+            public interface IAccelWithCovariance_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref AccelWithCovariance_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref AccelWithCovariance_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref AccelWithCovariance_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref AccelWithCovariance_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    AccelWithCovariance_ instance);
+            }
+            #endregion
+
+            #region IAccelWithCovariance_DataWriter
+            public interface IAccelWithCovariance_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    AccelWithCovariance_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    AccelWithCovariance_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    AccelWithCovariance_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    AccelWithCovariance_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    AccelWithCovariance_ instanceData);
+
+                ReturnCode Write(
+                    AccelWithCovariance_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    AccelWithCovariance_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    AccelWithCovariance_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    AccelWithCovariance_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    AccelWithCovariance_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    AccelWithCovariance_ instanceData);
+
+                ReturnCode WriteDispose(
+                    AccelWithCovariance_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    AccelWithCovariance_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    AccelWithCovariance_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref AccelWithCovariance_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    AccelWithCovariance_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IAccelWithCovariance_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7aedb2c75abde014ea71cce10775d605
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IAccel_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IAccel_DataReader
+            public interface IAccel_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref Accel_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref Accel_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref Accel_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref Accel_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    Accel_ instance);
+            }
+            #endregion
+
+            #region IAccel_DataWriter
+            public interface IAccel_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    Accel_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    Accel_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    Accel_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    Accel_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    Accel_ instanceData);
+
+                ReturnCode Write(
+                    Accel_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    Accel_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    Accel_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    Accel_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    Accel_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    Accel_ instanceData);
+
+                ReturnCode WriteDispose(
+                    Accel_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Accel_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Accel_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref Accel_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    Accel_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IAccel_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 58a538666ef8279449c74aa827ab7315
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IInertiaStamped_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IInertiaStamped_DataReader
+            public interface IInertiaStamped_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref InertiaStamped_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref InertiaStamped_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref InertiaStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref InertiaStamped_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    InertiaStamped_ instance);
+            }
+            #endregion
+
+            #region IInertiaStamped_DataWriter
+            public interface IInertiaStamped_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    InertiaStamped_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    InertiaStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    InertiaStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    InertiaStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    InertiaStamped_ instanceData);
+
+                ReturnCode Write(
+                    InertiaStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    InertiaStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    InertiaStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    InertiaStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    InertiaStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    InertiaStamped_ instanceData);
+
+                ReturnCode WriteDispose(
+                    InertiaStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    InertiaStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    InertiaStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref InertiaStamped_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    InertiaStamped_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IInertiaStamped_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 84fa168bbeac976449a6c2c7c4c0d407
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IInertia_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IInertia_DataReader
+            public interface IInertia_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref Inertia_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref Inertia_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref Inertia_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref Inertia_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    Inertia_ instance);
+            }
+            #endregion
+
+            #region IInertia_DataWriter
+            public interface IInertia_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    Inertia_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    Inertia_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    Inertia_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    Inertia_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    Inertia_ instanceData);
+
+                ReturnCode Write(
+                    Inertia_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    Inertia_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    Inertia_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    Inertia_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    Inertia_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    Inertia_ instanceData);
+
+                ReturnCode WriteDispose(
+                    Inertia_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Inertia_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Inertia_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref Inertia_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    Inertia_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IInertia_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0e93ae223f4e3c341b62be8ae39248f4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPoint32_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IPoint32_DataReader
+            public interface IPoint32_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref Point32_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref Point32_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref Point32_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref Point32_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    Point32_ instance);
+            }
+            #endregion
+
+            #region IPoint32_DataWriter
+            public interface IPoint32_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    Point32_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    Point32_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    Point32_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    Point32_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    Point32_ instanceData);
+
+                ReturnCode Write(
+                    Point32_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    Point32_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    Point32_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    Point32_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    Point32_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    Point32_ instanceData);
+
+                ReturnCode WriteDispose(
+                    Point32_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Point32_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Point32_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref Point32_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    Point32_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPoint32_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: decd6727486ff2f4c8678f2881858ce4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPointStamped_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IPointStamped_DataReader
+            public interface IPointStamped_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref PointStamped_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref PointStamped_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref PointStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref PointStamped_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    PointStamped_ instance);
+            }
+            #endregion
+
+            #region IPointStamped_DataWriter
+            public interface IPointStamped_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    PointStamped_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    PointStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    PointStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    PointStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    PointStamped_ instanceData);
+
+                ReturnCode Write(
+                    PointStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    PointStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    PointStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    PointStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    PointStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    PointStamped_ instanceData);
+
+                ReturnCode WriteDispose(
+                    PointStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    PointStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    PointStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref PointStamped_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    PointStamped_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPointStamped_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8a89b1e7d1354984b9a584cb33fe2958
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPoint_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IPoint_DataReader
+            public interface IPoint_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref Point_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref Point_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref Point_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref Point_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    Point_ instance);
+            }
+            #endregion
+
+            #region IPoint_DataWriter
+            public interface IPoint_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    Point_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    Point_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    Point_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    Point_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    Point_ instanceData);
+
+                ReturnCode Write(
+                    Point_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    Point_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    Point_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    Point_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    Point_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    Point_ instanceData);
+
+                ReturnCode WriteDispose(
+                    Point_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Point_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Point_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref Point_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    Point_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPoint_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7573bd8d504e20a498e08cbd4f88870f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPolygonStamped_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IPolygonStamped_DataReader
+            public interface IPolygonStamped_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref PolygonStamped_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref PolygonStamped_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref PolygonStamped_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref PolygonStamped_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    PolygonStamped_ instance);
+            }
+            #endregion
+
+            #region IPolygonStamped_DataWriter
+            public interface IPolygonStamped_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    PolygonStamped_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    PolygonStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    PolygonStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    PolygonStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    PolygonStamped_ instanceData);
+
+                ReturnCode Write(
+                    PolygonStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    PolygonStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    PolygonStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    PolygonStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    PolygonStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    PolygonStamped_ instanceData);
+
+                ReturnCode WriteDispose(
+                    PolygonStamped_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    PolygonStamped_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    PolygonStamped_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref PolygonStamped_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    PolygonStamped_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPolygonStamped_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e2335db9365c8ac409b3af7e65169c34
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPolygon_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IPolygon_DataReader
+            public interface IPolygon_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref Polygon_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref Polygon_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref Polygon_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref Polygon_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    Polygon_ instance);
+            }
+            #endregion
+
+            #region IPolygon_DataWriter
+            public interface IPolygon_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    Polygon_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    Polygon_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    Polygon_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    Polygon_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    Polygon_ instanceData);
+
+                ReturnCode Write(
+                    Polygon_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    Polygon_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    Polygon_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    Polygon_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    Polygon_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    Polygon_ instanceData);
+
+                ReturnCode WriteDispose(
+                    Polygon_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Polygon_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Polygon_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref Polygon_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    Polygon_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPolygon_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ca296689cc48c6f478edcbf705a555b2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPose2D_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IPose2D_DataReader
+            public interface IPose2D_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref Pose2D_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref Pose2D_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref Pose2D_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref Pose2D_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    Pose2D_ instance);
+            }
+            #endregion
+
+            #region IPose2D_DataWriter
+            public interface IPose2D_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    Pose2D_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    Pose2D_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    Pose2D_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    Pose2D_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    Pose2D_ instanceData);
+
+                ReturnCode Write(
+                    Pose2D_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    Pose2D_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    Pose2D_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    Pose2D_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    Pose2D_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    Pose2D_ instanceData);
+
+                ReturnCode WriteDispose(
+                    Pose2D_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Pose2D_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    Pose2D_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref Pose2D_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    Pose2D_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPose2D_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d508d65570ebdfe46a025a983d41d7cb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPoseArray_Dcps.cs

@@ -0,0 +1,284 @@
+using DDS;
+using DDS.OpenSplice;
+
+namespace geometry_msgs
+{
+    namespace msg
+    {
+        namespace dds_
+        {
+            #region IPoseArray_DataReader
+            public interface IPoseArray_DataReader : DDS.IDataReader
+            {
+                ReturnCode Read(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Read(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Read(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Read(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode Take(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples);
+
+                ReturnCode Take(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode Take(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadWithCondition(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadWithCondition(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeWithCondition(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextSample(
+                    ref PoseArray_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode TakeNextSample(
+                    ref PoseArray_ dataValue,
+                    ref SampleInfo sampleInfo);
+
+                ReturnCode ReadInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode ReadNextInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode TakeNextInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode TakeNextInstance(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    SampleStateKind sampleStates,
+                    ViewStateKind viewStates,
+                    InstanceStateKind instanceStates);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReadNextInstanceWithCondition(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode TakeNextInstanceWithCondition(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos,
+                    int maxSamples,
+                    InstanceHandle instanceHandle,
+                    IReadCondition readCondition);
+
+                ReturnCode ReturnLoan(
+                    ref PoseArray_[] dataValues,
+                    ref SampleInfo[] sampleInfos);
+
+                ReturnCode GetKeyValue(
+                    ref PoseArray_ key,
+                    InstanceHandle handle);
+
+                InstanceHandle LookupInstance(
+                    PoseArray_ instance);
+            }
+            #endregion
+
+            #region IPoseArray_DataWriter
+            public interface IPoseArray_DataWriter : DDS.IDataWriter
+            {
+                InstanceHandle RegisterInstance(
+                    PoseArray_ instanceData);
+
+                InstanceHandle RegisterInstanceWithTimestamp(
+                    PoseArray_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode UnregisterInstance(
+                    PoseArray_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode UnregisterInstanceWithTimestamp(
+                    PoseArray_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Write(
+                    PoseArray_ instanceData);
+
+                ReturnCode Write(
+                    PoseArray_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteWithTimestamp(
+                    PoseArray_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteWithTimestamp(
+                    PoseArray_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode Dispose(
+                    PoseArray_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode DisposeWithTimestamp(
+                    PoseArray_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDispose(
+                    PoseArray_ instanceData);
+
+                ReturnCode WriteDispose(
+                    PoseArray_ instanceData,
+                    InstanceHandle instanceHandle);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    PoseArray_ instanceData,
+                    Time sourceTimestamp);
+
+                ReturnCode WriteDisposeWithTimestamp(
+                    PoseArray_ instanceData,
+                    InstanceHandle instanceHandle,
+                    Time sourceTimestamp);
+
+                ReturnCode GetKeyValue(
+                    ref PoseArray_ key,
+                    InstanceHandle instanceHandle);
+
+                InstanceHandle LookupInstance(
+                    PoseArray_ instanceData);
+            }
+            #endregion
+
+        }
+
+    }
+
+}
+

Unity/LineRobot/Assets/DDS/idlpp/geometry_msgs/IPoseArray_Dcps.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 10a00aa9293e4654d9e68cc762db7d91
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: