DdsDcpsInterfaces.cs

Go to the documentation of this file.

/*
 *                         Vortex OpenSplice
 *
 *   This software and documentation are Copyright 2006 to 2021 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.
 */

using System;
using System.Runtime.InteropServices;

namespace DDS
{
    // ----------------------------------------------------------------------
    // Conditions
    // ----------------------------------------------------------------------
    public interface ICondition
    {
        bool GetTriggerValue();
    }

    public interface IWaitSet
    {
        ReturnCode Wait(ref ICondition[] activeConditions, Duration timeout);
        ReturnCode AttachCondition(ICondition condition);
        ReturnCode DetachCondition(ICondition condition);
        ReturnCode GetConditions(ref ICondition[] attachedConditions);
    }

    public interface IGuardCondition : ICondition
    {
        ReturnCode SetTriggerValue(bool value);
    }

    public interface IStatusCondition : ICondition
    {
        StatusKind GetEnabledStatuses();

        ReturnCode SetEnabledStatuses(StatusKind mask);

        IEntity GetEntity();
    }

    public interface IReadCondition : ICondition
    {
        SampleStateKind GetSampleStateMask();

        ViewStateKind GetViewStateMask();

        InstanceStateKind GetInstanceStateMask();

        IDataReader GetDataReader();
    }

    public interface IQueryCondition : IReadCondition
    {
        string GetQueryExpression();

        ReturnCode GetQueryParameters(ref string[] queryParameters);

        ReturnCode SetQueryParameters(params string[] queryParameters);
    }

    // ----------------------------------------------------------------------
    // Factory
    // ----------------------------------------------------------------------
    public interface IDomainParticipantFactory
    {
        IDomainParticipant CreateParticipant(DomainId domainId);
        IDomainParticipant CreateParticipant(DomainId domainId,
            IDomainParticipantListener listener, StatusKind mask);
        IDomainParticipant CreateParticipant(DomainId domainId, DomainParticipantQos qos);
        IDomainParticipant CreateParticipant(DomainId domainId, DomainParticipantQos qos,
            IDomainParticipantListener listener, StatusKind mask);

        ReturnCode DeleteParticipant(IDomainParticipant participant);

        IDomainParticipant LookupParticipant(DomainId domainId);

        ReturnCode SetDefaultParticipantQos(DomainParticipantQos qos);
        ReturnCode GetDefaultParticipantQos(ref DomainParticipantQos qos);

        ReturnCode SetQos(DomainParticipantFactoryQos qos);
        ReturnCode GetQos(ref DomainParticipantFactoryQos qos);

        ReturnCode DetachAllDomains(bool blockOperations, bool deleteEntities);
    }

    // ----------------------------------------------------------------------
    // Entities
    // ----------------------------------------------------------------------
    public interface IEntity
    {
        ReturnCode Enable();

        IStatusCondition StatusCondition { get; }

        StatusKind StatusChanges { get; }

        InstanceHandle InstanceHandle { get; }
    }

    public interface IDomainParticipant : IEntity
    {
        IPublisher CreatePublisher();

        IPublisher CreatePublisher(
                IPublisherListener listener,
                StatusKind mask);

        IPublisher CreatePublisher(PublisherQos qos);

        IPublisher CreatePublisher(
                PublisherQos qos,
                IPublisherListener listener,
                StatusKind mask);

        ReturnCode DeletePublisher(IPublisher p);

        ISubscriber CreateSubscriber();

        ISubscriber CreateSubscriber(
                ISubscriberListener listener,
                StatusKind mask);

        ISubscriber CreateSubscriber(SubscriberQos qos);

        ISubscriber CreateSubscriber(
                SubscriberQos qos,
                ISubscriberListener listener,
                StatusKind mask);

        ReturnCode DeleteSubscriber(ISubscriber s);

        ISubscriber BuiltInSubscriber { get; }

        ITopic CreateTopic(string topicName, string typeName);

        ITopic CreateTopic(
                string topicName,
                string typeName,
                ITopicListener listener,
                StatusKind mask);

        ITopic CreateTopic(string topicName, string typeName, TopicQos qos);

        ITopic CreateTopic(
                string topicName,
                string typeName,
                TopicQos qos,
                ITopicListener listener,
                StatusKind mask);

        ReturnCode DeleteTopic(ITopic topic);

        ITopic FindTopic(string topicName, Duration timeout);

        ITopicDescription LookupTopicDescription(string name);

        IContentFilteredTopic CreateContentFilteredTopic(
                string name,
                ITopic relatedTopic,
                string filterExpression,
                params string[] expressionParameters);

        ReturnCode DeleteContentFilteredTopic(IContentFilteredTopic aContentFilteredTopic);

        IMultiTopic CreateMultiTopic(
                string name,
                string typeName,
                string subscriptionExpression,
                params string[] expressionParameters);

        ReturnCode DeleteMultiTopic(IMultiTopic multiTopic);

        ReturnCode DeleteContainedEntities();

        ReturnCode SetQos(DomainParticipantQos qos);

        ReturnCode GetQos(ref DomainParticipantQos qos);

        IDomainParticipantListener Listener { get; }

        ReturnCode SetListener(IDomainParticipantListener listener, StatusKind mask);

        ReturnCode IgnoreParticipant(InstanceHandle handle);

        ReturnCode IgnoreTopic(InstanceHandle handle);

        ReturnCode IgnorePublication(InstanceHandle handle);

        ReturnCode IgnoreSubscription(InstanceHandle handle);

        DomainId DomainId { get; }

        ReturnCode AssertLiveliness();

        ReturnCode SetDefaultPublisherQos(PublisherQos qos);

        ReturnCode GetDefaultPublisherQos(ref PublisherQos qos);

        ReturnCode SetDefaultSubscriberQos(SubscriberQos qos);

        ReturnCode GetDefaultSubscriberQos(ref SubscriberQos qos);

        ReturnCode SetDefaultTopicQos(TopicQos qos);

        ReturnCode GetDefaultTopicQos(ref TopicQos qos);

        bool ContainsEntity(InstanceHandle handle);

        ReturnCode GetCurrentTime(out Time currentTime);

        ReturnCode GetDiscoveredParticipants (ref InstanceHandle[] participantHandles);

        ReturnCode GetDiscoveredParticipantData (ref ParticipantBuiltinTopicData data, InstanceHandle handle);

        ReturnCode GetDiscoveredTopics (ref InstanceHandle[] topicHandles);

        ReturnCode GetDiscoveredTopicData (ref TopicBuiltinTopicData data, InstanceHandle handle);

        ReturnCode GetProperty(ref Property property);

        ReturnCode SetProperty(Property property);

    }

    public interface ITypeSupport
    {
        ReturnCode RegisterType(IDomainParticipant domain, string typeName);
        string TypeName { get; }
        string TypeDescriptor { get; }
        string KeyList { get; }
    }

    // ----------------------------------------------------------------------
    // Topics
    // ----------------------------------------------------------------------
    public interface ITopicDescription
    {
        string TypeName { get; }
        string Name { get; }
        IDomainParticipant Participant { get; }
    }

    public interface ITopic : IEntity, ITopicDescription
    {
        ReturnCode GetInconsistentTopicStatus(ref InconsistentTopicStatus aStatus);
        ReturnCode GetQos(ref TopicQos qos);
        ReturnCode SetQos(TopicQos qos);
        ITopicListener Listener { get; }
        ReturnCode SetListener(ITopicListener listener, StatusKind mask);
    }

    public interface IContentFilteredTopic : ITopicDescription
    {
        string GetFilterExpression();
        ReturnCode GetExpressionParameters(ref string[] expressionParameters);
        ReturnCode SetExpressionParameters(params string[] expressionParameters);
        ITopic RelatedTopic { get; }
    }

    public interface IMultiTopic : ITopicDescription
    {
        string SubscriptionExpression { get; }
        ReturnCode GetExpressionParameters(ref string[] expressionParameters);
        ReturnCode SetExpressionParameters(params string[] expressionParameters);
    }

    // ----------------------------------------------------------------------
    // IPublisher/ISubscriber, IDataWriter/IDataReader
    // ----------------------------------------------------------------------
    public interface IPublisher : IEntity
    {
        IDataWriter CreateDataWriter(ITopic topic);
        IDataWriter CreateDataWriter(
                ITopic topic,
                IDataWriterListener listener, StatusKind mask);
        IDataWriter CreateDataWriter(ITopic topic, DataWriterQos qos);
        IDataWriter CreateDataWriter(
                ITopic topic,
                DataWriterQos qos,
                IDataWriterListener listener,
                StatusKind mask);
        ReturnCode DeleteDataWriter(IDataWriter dataWriter);
        IDataWriter LookupDataWriter(string topicName);
        ReturnCode DeleteContainedEntities();
        ReturnCode SetQos(PublisherQos qos);
        ReturnCode GetQos(ref PublisherQos qos);
       IPublisherListener Listener { get; }
        ReturnCode SetListener(IPublisherListener listener, StatusKind mask);
        ReturnCode SuspendPublications();
        ReturnCode ResumePublications();
        ReturnCode BeginCoherentChanges();
        ReturnCode EndCoherentChanges();
        ReturnCode WaitForAcknowledgments(Duration maxWait);
        IDomainParticipant GetParticipant();
        ReturnCode SetDefaultDataWriterQos(DataWriterQos qos);
        ReturnCode GetDefaultDataWriterQos(ref DataWriterQos qos);
        ReturnCode CopyFromTopicQos(ref DataWriterQos dataWriterQos, TopicQos topicQos);
    }

    public interface IDataWriter : IEntity
    {
        ReturnCode SetQos(DataWriterQos qos);
        ReturnCode GetQos(ref DataWriterQos qos);
        IDataWriterListener Listener { get; }
        ReturnCode SetListener(IDataWriterListener listener, StatusKind mask);
        ITopic Topic { get; }
        IPublisher Publisher { get; }
        ReturnCode WaitForAcknowledgments(Duration maxWait);
        ReturnCode GetLivelinessLostStatus(ref LivelinessLostStatus status);
        ReturnCode GetOfferedDeadlineMissedStatus(ref OfferedDeadlineMissedStatus status);
        ReturnCode GetOfferedIncompatibleQosStatus(ref OfferedIncompatibleQosStatus status);
        ReturnCode GetPublicationMatchedStatus(ref PublicationMatchedStatus status);
        ReturnCode AssertLiveliness();
        ReturnCode GetMatchedSubscriptions(ref InstanceHandle[] subscriptionHandles);
        ReturnCode GetMatchedSubscriptionData(
                ref SubscriptionBuiltinTopicData subscriptionData,
                InstanceHandle subscriptionHandle);

#if DOXYGEN_FOR_CS
//
// The above compile switch is never (and must never) be defined in normal compilation.
//
// QoS and Policy related enums are part of the generated code for builtin topics.
// They are repeated here for easy documentation generation.
//

        InstanceHandle RegisterInstance(<type> instanceData);

        InstanceHandle RegisterInstanceWithTimestamp(
                <type> instanceData,
                Time sourceTimestamp);

        ReturnCode UnregisterInstance(
                <type> instanceData,
                InstanceHandle instanceHandle);

        ReturnCode UnregisterInstanceWithTimestamp(
                <type> instanceData,
                InstanceHandle instanceHandle,
                Time sourceTimestamp);

        ReturnCode Write(<type> instanceData);

        ReturnCode Write(
                <type> instanceData,
                InstanceHandle instanceHandle);

        ReturnCode WriteWithTimestamp(
                <type> instanceData,
                Time sourceTimestamp);

        ReturnCode WriteWithTimestamp(
                <type> instanceData,
                InstanceHandle instanceHandle,
                Time sourceTimestamp);

        ReturnCode Dispose(
                <type> instanceData,
                InstanceHandle instanceHandle);

        ReturnCode DisposeWithTimestamp(
                <type> instanceData,
                InstanceHandle instanceHandle,
                Time sourceTimestamp);

        ReturnCode WriteDispose(
                <type> instanceData);

        ReturnCode WriteDispose(
                <type> instanceData,
                InstanceHandle instanceHandle);

        ReturnCode WriteDisposeWithTimestamp(
                <type> instanceData,
                Time sourceTimestamp);

        ReturnCode WriteDisposeWithTimestamp(
                <type> instanceData,
                InstanceHandle instanceHandle,
                Time sourceTimestamp);

        ReturnCode GetKeyValue(
                ref <type> key,
                InstanceHandle instanceHandle);

        InstanceHandle LookupInstance(<type> instanceData);

#endif

    }
    public interface ISubscriber : IEntity
    {
        IDataReader CreateDataReader(ITopicDescription topic);

        IDataReader CreateDataReader(
                ITopicDescription topic,
                IDataReaderListener listener, StatusKind mask);

        IDataReader CreateDataReader(ITopicDescription topic, DataReaderQos qos);

        IDataReader CreateDataReader(
                ITopicDescription topic,
                DataReaderQos qos,
                IDataReaderListener listener,
                StatusKind mask);

        ReturnCode DeleteDataReader(IDataReader dataReader);

        ReturnCode DeleteContainedEntities();

        IDataReader LookupDataReader(string topicName);

        //          EndAccess() block as required by its QosPolicy settings.</item>
        ReturnCode GetDataReaders(ref IDataReader[] readers);

        //          EndAccess() block as required by its QosPolicy settings.</item>
        ReturnCode GetDataReaders(
                ref IDataReader[] readers,
                SampleStateKind sampleStates,
                ViewStateKind viewStates,
                InstanceStateKind instanceStates);

        ReturnCode NotifyDataReaders();

        ReturnCode SetQos(SubscriberQos qos);

        ReturnCode GetQos(ref SubscriberQos qos);

        ISubscriberListener Listener { get; }

        ReturnCode SetListener(ISubscriberListener listener, StatusKind mask);

        ReturnCode BeginAccess();

        ReturnCode EndAccess();

        IDomainParticipant Participant { get; }

        ReturnCode SetDefaultDataReaderQos(DataReaderQos qos);

        ReturnCode GetDefaultDataReaderQos(ref DataReaderQos qos);

        ReturnCode CopyFromTopicQos(ref DataReaderQos dataReaderQos, TopicQos topicQos);

    }

    public interface IDataReader : IEntity
    {
        IReadCondition CreateReadCondition();

        IReadCondition CreateReadCondition(
                SampleStateKind sampleStates,
                ViewStateKind viewStates,
                InstanceStateKind instanceStates);

        IQueryCondition CreateQueryCondition(
                string queryExpression,
                params string[] queryParameters);

        IQueryCondition CreateQueryCondition(
                SampleStateKind sampleStates,
                ViewStateKind viewStates,
                InstanceStateKind instanceStates,
                string queryExpression,
                params string[] queryParameters);

        ReturnCode DeleteReadCondition(IReadCondition condition);

        ReturnCode DeleteContainedEntities();

        ReturnCode SetQos(DataReaderQos qos);

        ReturnCode GetQos(ref DataReaderQos qos);

        IDataReaderListener Listener { get; }

        ReturnCode SetListener(IDataReaderListener listener, StatusKind mask);

        ITopicDescription GetTopicDescription();

        ISubscriber Subscriber { get; }

        ReturnCode GetSampleRejectedStatus(ref SampleRejectedStatus status);

        ReturnCode GetLivelinessChangedStatus(ref LivelinessChangedStatus status);

        ReturnCode GetRequestedDeadlineMissedStatus(ref RequestedDeadlineMissedStatus status);

        ReturnCode GetRequestedIncompatibleQosStatus(ref RequestedIncompatibleQosStatus status);

        ReturnCode GetSubscriptionMatchedStatus(ref SubscriptionMatchedStatus status);

        ReturnCode GetSampleLostStatus(ref SampleLostStatus status);

        ReturnCode WaitForHistoricalData(Duration maxWait);

        ReturnCode GetMatchedPublications(ref InstanceHandle[] publicationHandles);

        ReturnCode GetMatchedPublicationData(
                ref PublicationBuiltinTopicData publicationData,
                InstanceHandle publicationHandle);

#if DOXYGEN_FOR_CS
//
// The above compile switch is never (and must never) be defined in normal compilation.
//
// QoS and Policy related enums are part of the generated code for builtin topics.
// They are repeated here for easy documentation generation.
//

        ReturnCode Read(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos);

        ReturnCode Read(
            ref <data> dataValues,
            ref SampleInfo[] sampleInfos,
            int maxSamples);

        ReturnCode Read(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            SampleStateKind sampleStates,
            ViewStateKind viewStates,
            InstanceStateKind instanceStates);

        ReturnCode Read(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                int maxSamples,
                SampleStateKind sampleStates,
                ViewStateKind viewStates,
                InstanceStateKind instanceStates);

        ReturnCode Take(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos);

        ReturnCode Take(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            int maxSamples);

        ReturnCode Take(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            SampleStateKind sampleStates,
            ViewStateKind viewStates,
            InstanceStateKind instanceStates);

        ReturnCode Take(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                int maxSamples,
                SampleStateKind sampleStates,
                ViewStateKind viewStates,
                InstanceStateKind instanceStates);

        ReturnCode ReadWithCondition(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            IReadCondition readCondition);

        ReturnCode ReadWithCondition(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                int maxSamples,
                IReadCondition readCondition);

        ReturnCode TakeWithCondition(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            IReadCondition readCondition);

        ReturnCode TakeWithCondition(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                int maxSamples,
                IReadCondition readCondition);

        ReturnCode ReadNextSample(
                ref Space.Foo dataValue,
                ref SampleInfo sampleInfo);

        ReturnCode TakeNextSample(
                ref Space.Foo dataValue,
                ref SampleInfo sampleInfo);

        ReturnCode ReadInstance(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            InstanceHandle instanceHandle);

        ReturnCode ReadInstance(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            int maxSamples,
            InstanceHandle instanceHandle);

        ReturnCode ReadInstance(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                int maxSamples,
                InstanceHandle instanceHandle,
                SampleStateKind sampleStates,
                ViewStateKind viewStates,
                InstanceStateKind instanceStates);

        ReturnCode TakeInstance(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            InstanceHandle instanceHandle);

        ReturnCode TakeInstance(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            int maxSamples,
            InstanceHandle instanceHandle);

        ReturnCode TakeInstance(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                int maxSamples,
                InstanceHandle instanceHandle,
                SampleStateKind sampleStates,
                ViewStateKind viewStates,
                InstanceStateKind instanceStates);

        ReturnCode ReadNextInstance(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            InstanceHandle instanceHandle);

        ReturnCode ReadNextInstance(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            int maxSamples,
            InstanceHandle instanceHandle);

        ReturnCode ReadNextInstance(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                int maxSamples,
                InstanceHandle instanceHandle,
                SampleStateKind sampleStates,
                ViewStateKind viewStates,
                InstanceStateKind instanceStates);

        ReturnCode TakeNextInstance(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            InstanceHandle instanceHandle);

        ReturnCode TakeNextInstance(
            ref <data>[] dataValues,
            ref SampleInfo[] sampleInfos,
            int maxSamples,
            InstanceHandle instanceHandle);

        ReturnCode TakeNextInstance(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                int maxSamples,
                InstanceHandle instanceHandle,
                SampleStateKind sampleStates,
                ViewStateKind viewStates,
                InstanceStateKind instanceStates);

        ReturnCode ReadNextInstanceWithCondition(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                InstanceHandle instanceHandle,
                IReadCondition readCondition);

        ReturnCode ReadNextInstanceWithCondition(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                int maxSamples,
                InstanceHandle instanceHandle,
                IReadCondition readCondition);

        ReturnCode TakeNextInstanceWithCondition(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                InstanceHandle instanceHandle,
                IReadCondition readCondition);

        ReturnCode TakeNextInstanceWithCondition(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos,
                int maxSamples,
                InstanceHandle instanceHandle,
                IReadCondition readCondition);

        ReturnCode ReturnLoan(
                ref <data>[] dataValues,
                ref SampleInfo[] sampleInfos);

        ReturnCode GetKeyValue(
                ref <data> key,
                InstanceHandle handle);

        InstanceHandle LookupInstance(
                <data> instance);

#endif // DOXYGEN_FOR_CS

    }

    // listener interfaces

    public interface IListener
    {
        // Just an empty tagging interface.
    }
    public interface ITopicListener : IListener
    {
        void OnInconsistentTopic(ITopic entityInterface, InconsistentTopicStatus status);
    }

    public interface IDataWriterListener : IListener
    {
        void OnOfferedDeadlineMissed(IDataWriter entityInterface, OfferedDeadlineMissedStatus status);
        void OnOfferedIncompatibleQos(IDataWriter entityInterface, OfferedIncompatibleQosStatus status);
        void OnLivelinessLost(IDataWriter entityInterface, LivelinessLostStatus status);

        void OnPublicationMatched(IDataWriter entityInterface, PublicationMatchedStatus status);
    }
    public interface IPublisherListener : IDataWriterListener
    {
    }
    public interface IDataReaderListener : IListener
    {

        void OnRequestedDeadlineMissed(IDataReader entityInterface, RequestedDeadlineMissedStatus status);

        void OnRequestedIncompatibleQos(IDataReader entityInterface, RequestedIncompatibleQosStatus status);

        void OnSampleRejected(IDataReader entityInterface, SampleRejectedStatus status);

                void OnLivelinessChanged(IDataReader entityInterface, LivelinessChangedStatus status);

                void OnDataAvailable(IDataReader entityInterface);


        void OnSubscriptionMatched(IDataReader entityInterface, SubscriptionMatchedStatus status);

        void OnSampleLost(IDataReader entityInterface, SampleLostStatus status);
    }

    public interface ISubscriberListener : IDataReaderListener
    {
        void OnDataOnReaders(ISubscriber entityInterface);
    }
    public interface IDomainParticipantListener : ITopicListener, IPublisherListener, ISubscriberListener
    {
    }

    public interface IQosProvider {


        ReturnCode
        GetParticipantQos (
            ref DomainParticipantQos participantQos,
            string id);

        ReturnCode
        GetTopicQos (
            ref TopicQos topicQos,
            string id);

        ReturnCode
        GetSubscriberQos (
            ref SubscriberQos subscriberQos,
            string id);

        ReturnCode
        GetDataReaderQos (
            ref DataReaderQos datareaderQos,
            string id);

        ReturnCode
        GetPublisherQos (
            ref PublisherQos publisherQos,
            string id);

        ReturnCode
        GetDataWriterQos (
            ref DataWriterQos datawriterQos,
            string id);

        // Future expansion will allow the user to share QoSs over DDS
        //
        // ReturnCode_t
        // subscribe ();
        //
        // ReturnCode_t
        // publish ();
    }


} // end namespace DDS