DomainParticipantFactory.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;
using System.Collections.Generic;
using DDS.OpenSplice;
using DDS.OpenSplice.OS;
using DDS.OpenSplice.CustomMarshalers;
using DDS.OpenSplice.Kernel;

namespace DDS
{
    public class DomainParticipantFactory : IDomainParticipantFactory
    {
        //
        // Attribute containing the singleton 'self' reference.
        //
        private static DomainParticipantFactory singletonSelf = null;
        private static readonly object singleton_lock = new object();
        private DDS.DomainParticipantFactoryQos myQos = new DDS.DomainParticipantFactoryQos();
        private DDS.DomainParticipantQos defaultParticipantQos = new DDS.DomainParticipantQos();
        private List<DomainParticipant> participantList = new List<DomainParticipant>();

        // Attribute containing the delegates to the individual Listener functions.

        private static DomainParticipantFactory GetInstance()
        {
            // GetInstance() is called very infrequently so a simple locked singleton
            // approach is used.
            lock(singleton_lock)
            {
                if (singletonSelf == null) // If singleton doesn't exist, create it.
                {
                    if (DDS.OpenSplice.User.u.userInitialise() == V_RESULT.OK)
                    {
                        ReportStack.Start();
                        singletonSelf = new DomainParticipantFactory();
                        ReportStack.Flush(null, singletonSelf == null);
                        if (singletonSelf != null) {
                            AppDomain.CurrentDomain.ProcessExit += new EventHandler(ProcessExit);
                        }
                    }
                }
                return singletonSelf;
            }
        }

        public static DomainParticipantFactory Instance
        {
            get { return GetInstance(); }
        }

        protected DomainParticipantFactory()
        {
            DDS.ReturnCode result;

            // Init default ParticipantFactoryQos and default ParticipantQos.
            using (OpenSplice.CustomMarshalers.DomainParticipantQosMarshaler marshaler =
                new OpenSplice.CustomMarshalers.DomainParticipantQosMarshaler())
            {
                result = marshaler.CopyIn(QosManager.defaultDomainParticipantQos);
                if (result == ReturnCode.Ok)
                {
                    marshaler.CopyOut(ref defaultParticipantQos);
                }
            }
            myQos.EntityFactory = new EntityFactoryQosPolicy();
            myQos.EntityFactory.AutoenableCreatedEntities = true;
        }

        public IDomainParticipant CreateParticipant(
            DomainId domainId)
        {
            return CreateParticipant(domainId, defaultParticipantQos, null, 0);
        }

        public IDomainParticipant CreateParticipant(
            DomainId domainId,
            IDomainParticipantListener listener,
            StatusKind mask)
        {
            return CreateParticipant(domainId, defaultParticipantQos, listener, mask);
        }

        public IDomainParticipant CreateParticipant(
            DomainId domainId,
            DomainParticipantQos qos)
        {
            return CreateParticipant(domainId, qos, null, 0);
        }

        public IDomainParticipant CreateParticipant(
            DomainId domainId,
            DomainParticipantQos qos,
            IDomainParticipantListener listener,
            StatusKind mask)
        {
            DomainParticipant participant = null;
            ReturnCode result;

            ReportStack.Start();
            result = QosManager.checkQos(qos);
            if (result == DDS.ReturnCode.Ok)
            {
                if (domainId != DDS.DomainId.Invalid)
                {
                    lock(singleton_lock)
                    {
                        participant = new OpenSplice.DomainParticipant();
                        result = participant.init(domainId, qos);
                        if (result == ReturnCode.Ok)
                        {
                            result = participant.SetListener(listener, mask);
                        }
                        else
                        {
                            participant = null;
                        }

                        if (result == ReturnCode.Ok)
                        {
                            participantList.Add(participant);
                            if (myQos.EntityFactory.AutoenableCreatedEntities)
                            {
                                result = participant.Enable();
                            }
                        }
                    }
                }
                else
                {
                    ReportStack.Report(DDS.ReturnCode.BadParameter,
                                "DomainParticipant is using an invalid domain identifier (" + domainId + ").");
                }
            }

            if (result != ReturnCode.Ok && participant != null)
            {
                // Ignore result because we prefer the original error.
                DeleteParticipant(participant);
                participant = null;
            }

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

        public ReturnCode DeleteParticipant(IDomainParticipant a_participant)
        {
            ReturnCode result = DDS.ReturnCode.Ok;

            ReportStack.Start();
            DomainParticipant participant = a_participant as DomainParticipant;
            if (participant != null)
            {
                lock(singleton_lock)
                {
                    if (participantList.Remove(participant))
                    {
                        result = participant.wlReq_deinit();
                        if (result != DDS.ReturnCode.Ok)
                        {
                            participantList.Add(participant);
                        }
                    }
                    else
                    {
                        /* Since there is only one DomainParticipantFactory, the participant
                         * has to be created by this one. If we can't find it anymore, it
                         * must have beel deleted already.
                         */
                        result = DDS.ReturnCode.BadParameter;
                        ReportStack.Report(result, "DomainParticipant was already deleted.");
                    }
                }
            }
            else
            {
                result = ReturnCode.BadParameter;
                ReportStack.Report(result, "Participant parameter 'a_participant' is null.");
            }

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

        public IDomainParticipant LookupParticipant(DomainId domainId)
        {
            DomainParticipant participant;

            if (domainId == DDS.DomainId.Default) {
                domainId = DDS.OpenSplice.User.u.GetDomainIdFromEnvUri();
            }
            lock(singleton_lock)
            {
                participant = participantList.Find(
                    delegate (DomainParticipant a_participant)
                    {
                        return a_participant.DomainId == domainId;
                    }
                );
            }
            return participant;
        }

        public ReturnCode SetDefaultParticipantQos(DomainParticipantQos qos)
        {
            ReturnCode result;

            lock(singleton_lock)
            {
                ReportStack.Start();
                result = QosManager.checkQos(qos);
                if (result == DDS.ReturnCode.Ok) {
                    using (OpenSplice.CustomMarshalers.DomainParticipantQosMarshaler marshaler =
                        new OpenSplice.CustomMarshalers.DomainParticipantQosMarshaler())
                    {
                        result = marshaler.CopyIn(qos);
                        if (result == ReturnCode.Ok)
                        {
                            marshaler.CopyOut(ref defaultParticipantQos);
                            // Listener scheduling qospolicy is not part of User Layer, so obtain it separately from participant.
                            if (qos.ListenerScheduling.SchedulingClass == null)
                            {
                                return ReturnCode.BadParameter;
                            }
                            this.defaultParticipantQos.ListenerScheduling.SchedulingClass.Kind = qos.ListenerScheduling.SchedulingClass.Kind;
                            if (qos.ListenerScheduling.SchedulingPriorityKind == null)
                            {
                                return ReturnCode.BadParameter;
                            }
                            this.defaultParticipantQos.ListenerScheduling.SchedulingPriorityKind.Kind = qos.ListenerScheduling.SchedulingPriorityKind.Kind;
                            this.defaultParticipantQos.ListenerScheduling.SchedulingPriority = qos.ListenerScheduling.SchedulingPriority;
                        }
                    }
                }
                ReportStack.Flush(null, result != ReturnCode.Ok);
            }
            return result;
        }

        public ReturnCode GetDefaultParticipantQos(ref DomainParticipantQos qos)
        {
            ReturnCode result;

            using (OpenSplice.CustomMarshalers.DomainParticipantQosMarshaler marshaler =
                    new OpenSplice.CustomMarshalers.DomainParticipantQosMarshaler())
            {
                lock(singleton_lock)
                {
                    ReportStack.Start();
                    result = marshaler.CopyIn(defaultParticipantQos);
                    if (result == ReturnCode.Ok)
                    {
                        marshaler.CopyOut(ref qos);
                        // Listener scheduling qospolicy is not part of User Layer, so obtain it separately from participant.
                        if (qos.ListenerScheduling.SchedulingClass == null)
                        {
                            qos.ListenerScheduling.SchedulingClass = new SchedulingClassQosPolicy();
                        }
                        qos.ListenerScheduling.SchedulingClass.Kind = this.defaultParticipantQos.ListenerScheduling.SchedulingClass.Kind;
                        if (qos.ListenerScheduling.SchedulingPriorityKind == null)
                        {
                            qos.ListenerScheduling.SchedulingPriorityKind = new SchedulingPriorityQosPolicy();
                        }
                        qos.ListenerScheduling.SchedulingPriorityKind.Kind = this.defaultParticipantQos.ListenerScheduling.SchedulingPriorityKind.Kind;
                        qos.ListenerScheduling.SchedulingPriority = this.defaultParticipantQos.ListenerScheduling.SchedulingPriority;
                    }
                    ReportStack.Flush(null, result != ReturnCode.Ok);
                }
            }

            return result;
        }

        public ReturnCode SetQos(DomainParticipantFactoryQos qos)
        {
            lock(singleton_lock)
            {
                myQos.EntityFactory.AutoenableCreatedEntities = qos.EntityFactory.AutoenableCreatedEntities;
                return ReturnCode.Ok;
            }
        }

        public ReturnCode GetQos(ref DomainParticipantFactoryQos qos)
        {
            lock(singleton_lock)
            {
                if (qos == null) qos = new DomainParticipantFactoryQos();
                if (qos.EntityFactory == null) qos.EntityFactory = new EntityFactoryQosPolicy();
                qos.EntityFactory.AutoenableCreatedEntities = myQos.EntityFactory.AutoenableCreatedEntities;
                return ReturnCode.Ok;
            }
        }

        public ReturnCode DeleteContainedEntities()
        {
            ReturnCode result = DDS.ReturnCode.Ok;

            lock(singleton_lock)
            {
                foreach (DomainParticipant p in participantList) {
                    result = p.DeleteContainedEntities();
                    if (result == DDS.ReturnCode.Ok)
                    {
                        result = p.deinit();
                    }
                    if (result != DDS.ReturnCode.Ok)
                    {
                        break;
                    }
                }
            }

            if (result == DDS.ReturnCode.Ok)
            {
                participantList.Clear();
            }

            return ReturnCode.Ok;
        }

        public ReturnCode DetachAllDomains(bool blockOperations, bool deleteEntities)
        {
            uint flags = 0;

            if (blockOperations) {
                flags |= DDS.OpenSplice.User.u.BLOCK_OPERATIONS;
            }
            if (deleteEntities) {
                flags |= DDS.OpenSplice.User.u.DELETE_ENTITIES;
            }

                        return SacsSuperClass.uResultToReturnCode(DDS.OpenSplice.User.u.userDetach(flags));
        }

        static void ProcessExit(object sender, EventArgs args)
        {
            try {
                DDS.OpenSplice.User.u.userDetach(DDS.OpenSplice.User.u.DELETE_ENTITIES);
            } catch (Exception e) {
                Console.WriteLine(e.ToString());
            }
        }
    }
}