QosProvider.cs

Go to the documentation of this file.

/*
 *                         Vortex OpenSplice
 *
 *   This software and documentation are Copyright 2006 to 2024 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;
using DDS.OpenSplice;
using DDS.OpenSplice.OS;
using DDS.OpenSplice.CustomMarshalers;
using DDS.OpenSplice.Common;
using DDS;

namespace DDS
{
    public class QosProvider : IQosProvider
    {
        private IntPtr cmnQpPtr;
        private cmn_qosProviderInputAttr attr = new cmn_qosProviderInputAttr();

        private void loadQosInputAttr(
                OpenSplice.CustomMarshalers.DatabaseMarshaler qosMarshaler,
                Type dataType,
                ref OpenSplice.Common.cmn_qosInputAttr attr)
        {
            DatabaseMarshaler.Add(null, dataType, qosMarshaler);
            qosMarshaler.InitEmbeddedMarshalers(null);

            attr.copyOut = qosMarshaler.CopyOutDelegate;
        }

        private ReturnCode qpResultToReturnCode (QP_RESULT qpResult)
        {
            ReturnCode result;

            switch (qpResult) {
                case QP_RESULT.OK:
                    result = DDS.ReturnCode.Ok;
                    break;
                case QP_RESULT.NO_DATA:
                    result = DDS.ReturnCode.NoData;
                    break;
                case QP_RESULT.OUT_OF_MEMORY:
                    result = DDS.ReturnCode.OutOfResources;
                    break;
                case QP_RESULT.ILL_PARAM:
                    result = DDS.ReturnCode.BadParameter;
                    break;
                default:
                    result = DDS.ReturnCode.Error;
                    break;
            }

            return result;
        }


        public QosProvider(
            string uri,
            string profile)
        {
            attr = new cmn_qosProviderInputAttr ();
            attr.participantQos = new cmn_qosInputAttr();
            attr.topicQos = new cmn_qosInputAttr();
            attr.publisherQos = new cmn_qosInputAttr();
            attr.dataWriterQos = new cmn_qosInputAttr();
            attr.subscriberQos = new cmn_qosInputAttr();
            attr.dataReaderQos = new cmn_qosInputAttr();

            /* let's assign defaults and see what happens */

            loadQosInputAttr(
                    new __NamedDomainParticipantQosMarshaler(),
                    typeof(NamedDomainParticipantQos),
                    ref attr.participantQos);
            loadQosInputAttr(
                    new __NamedTopicQosMarshaler(),
                    typeof(NamedTopicQos),
                    ref attr.topicQos);
            loadQosInputAttr(
                    new __NamedPublisherQosMarshaler(),
                    typeof(NamedPublisherQos),
                    ref attr.publisherQos);
            loadQosInputAttr(
                    new __NamedSubscriberQosMarshaler(),
                    typeof(NamedSubscriberQos),
                    ref attr.subscriberQos);
            loadQosInputAttr(
                    new __NamedDataWriterQosMarshaler(),
                    typeof(NamedDataWriterQos),
                    ref attr.dataWriterQos);
            loadQosInputAttr(
                    new __NamedDataReaderQosMarshaler(),
                    typeof(NamedDataReaderQos),
                    ref attr.dataReaderQos);

            IntPtr attrPtr = os.malloc(new IntPtr(Marshal.SizeOf(attr)));
            Marshal.StructureToPtr(attr, attrPtr, false);
            cmnQpPtr = OpenSplice.Common.QosProvider.New(uri, profile, attrPtr);
            os.free(attrPtr);

            if (cmnQpPtr == IntPtr.Zero)
            {
                // cmn_qosProviderNew already logged that the qosprovider has not been created
                // successfully. Now create a deliberate null pointer exception to let the current
                // constructor fail.
                throw new System.NullReferenceException("cmn_qosProviderNew returned a NULL pointer.");
            }
        }

        ~QosProvider()
        {
            OpenSplice.Common.QosProvider.Free(cmnQpPtr);
        }

        public ReturnCode
        GetParticipantQos (
            ref DomainParticipantQos participantQos,
            string id)
        {
            ReportStack.Start ();
            NamedDomainParticipantQos pQos = new NamedDomainParticipantQos ();
            GCHandle qosHandle = GCHandle.Alloc (pQos, GCHandleType.Normal);
            ReturnCode result = qpResultToReturnCode (
                    OpenSplice.Common.QosProvider.GetParticipantQos (cmnQpPtr, id, GCHandle.ToIntPtr (qosHandle)));
            if (result == ReturnCode.Ok) {
                participantQos = pQos.DomainparticipantQos;
            } else {
                ReportStack.Report (result, "Could not copy DomainParticipantQos.");
            }
            qosHandle.Free();
            ReportStack.Flush(null, result != ReturnCode.Ok);
            return result;
        }

        public ReturnCode
        GetTopicQos (
            ref TopicQos topicQos,
            string id)
        {
            ReportStack.Start ();
            NamedTopicQos tQos = new NamedTopicQos ();
            GCHandle qosHandle = GCHandle.Alloc (tQos, GCHandleType.Normal);
            ReturnCode result = qpResultToReturnCode (
                    OpenSplice.Common.QosProvider.GetTopicQos (cmnQpPtr, id, GCHandle.ToIntPtr (qosHandle)));
            if (result == ReturnCode.Ok) {
                topicQos = tQos.TopicQos;
            } else {
                ReportStack.Report (result, "Could not copy TopicQos.");
            }
            qosHandle.Free();
            ReportStack.Flush(null, result != ReturnCode.Ok);
            return result;
        }

        public ReturnCode
        GetSubscriberQos (
            ref SubscriberQos subscriberQos,
            string id)
        {
            ReportStack.Start ();
            NamedSubscriberQos sQos = new NamedSubscriberQos ();
            GCHandle qosHandle = GCHandle.Alloc (sQos, GCHandleType.Normal);
            ReturnCode result = qpResultToReturnCode (
                    OpenSplice.Common.QosProvider.GetSubscriberQos (cmnQpPtr, id, GCHandle.ToIntPtr (qosHandle)));
            if (result == ReturnCode.Ok) {
                subscriberQos = sQos.SubscriberQos;
            } else {
                ReportStack.Report (result, "Could not copy subscriberQos.");
            }
            qosHandle.Free();
            ReportStack.Flush(null, result != ReturnCode.Ok);
            return result;
        }

        public ReturnCode
        GetDataReaderQos (
            ref DataReaderQos datareaderQos,
            string id)
        {
            ReportStack.Start ();
            NamedDataReaderQos drQos = new NamedDataReaderQos ();
            GCHandle qosHandle = GCHandle.Alloc (drQos, GCHandleType.Normal);
            ReturnCode result = qpResultToReturnCode (
                    OpenSplice.Common.QosProvider.GetDataReaderQos (cmnQpPtr, id, GCHandle.ToIntPtr (qosHandle)));
            if (result == ReturnCode.Ok) {
                datareaderQos = drQos.DatareaderQos;
            } else {
                ReportStack.Report (result, "Could not copy datareaderQos.");
            }

            qosHandle.Free();
            ReportStack.Flush(null, result != ReturnCode.Ok);
            return result;
        }

        public ReturnCode
        GetPublisherQos (
            ref PublisherQos publisherQos,
            string id)
        {
            ReportStack.Start ();
            NamedPublisherQos pQos = new NamedPublisherQos ();
            GCHandle qosHandle = GCHandle.Alloc (pQos, GCHandleType.Normal);
            ReturnCode result = qpResultToReturnCode (
                    OpenSplice.Common.QosProvider.GetPublisherQos (cmnQpPtr, id, GCHandle.ToIntPtr (qosHandle)));
            if (result == ReturnCode.Ok) {
                publisherQos = pQos.PublisherQos;
            } else {
                ReportStack.Report (result, "Could not copy publisherQos.");
            }

            qosHandle.Free();
            ReportStack.Flush(null, result != ReturnCode.Ok);
            return result;
        }

        public ReturnCode
        GetDataWriterQos (
            ref DataWriterQos datawriterQos,
            string id)
        {
            ReportStack.Start ();
            NamedDataWriterQos dwQos = new NamedDataWriterQos ();
            GCHandle qosHandle = GCHandle.Alloc (dwQos, GCHandleType.Normal);
            ReturnCode result = qpResultToReturnCode (
                    OpenSplice.Common.QosProvider.GetDataWriterQos (cmnQpPtr, id, GCHandle.ToIntPtr (qosHandle)));
            if (result == ReturnCode.Ok) {
                datawriterQos = dwQos.DatawriterQos;
            } else {
                ReportStack.Report (result, "Could not copy datawriterQos.");
            }

            qosHandle.Free();
            ReportStack.Flush(null, result != ReturnCode.Ok);
            return result;
        }

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