static void Main(string[] args) { _dpf = DomainParticipantFactory.Instance; ErrorHandler.checkHandle(_dpf, "Domain Participant Factory"); _dp = _dpf.CreateParticipant(Domain); //Initialize QOS sQos = new SubscriberQos(); drQos = new DataReaderQos(); fdmDataType = new FDMTypeSupport(); string FDMDATATypeName = fdmDataType.TypeName; ReturnCode status = fdmDataType.RegisterType(_dp, FDMDATATypeName); ErrorHandler.checkStatus(status, "FDMDATA: Cannot Register Type"); //Create FDMDATA Topic fdmDataTopic = _dp.FindTopic("FDMDATA", Duration.FromMilliseconds(1000)); if (fdmDataTopic == null) { fdmDataTopic = _dp.CreateTopic("FDMDATA", FDMDATATypeName); } ErrorHandler.checkHandle(fdmDataTopic, "Cannot Create Topic FDMDATA"); //Get Subscriber QOS and Set Partition Name _dp.GetDefaultSubscriberQos(ref sQos); sQos.Partition.Name = new String[1]; sQos.Partition.Name[0] = PartitionName; //Create Subscriber for FDMDATA Topic Subscriber = _dp.CreateSubscriber(sQos); ErrorHandler.checkHandle(Subscriber, "Cannot Create FDMDATA Subscriber"); //Get Data Reader QOS and Set History Depth Subscriber.GetDefaultDataReaderQos(ref drQos); ErrorHandler.checkHandle(drQos, "Cannot get Data Reader Qos"); drQos.History.Depth = 5; drQos.Reliability.Kind = ReliabilityQosPolicyKind.BestEffortReliabilityQos; //Create DataReader for FDMDATA Topic parentReader = Subscriber.CreateDataReader(fdmDataTopic, drQos); ErrorHandler.checkHandle(parentReader, "Cannot Create FDMDATA Data Reader"); //Narrow abstract parentReader into its typed representative fdmDataReader = parentReader as FDMDataReader; ErrorHandler.checkHandle(fdmDataReader, "Cannot Narrow FDMDATA Data Reader"); // drQos.Durability.Kind = DurabilityQosPolicyKind.TransientLocalDurabilityQos; fdmData = new FDM(); //Rececieve Loop while (true) { StartReceive(); Console.WriteLine("abc: " + fdmData.aa.ToString()); } }
/// <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, null, StatusKind.Any); ErrorHandler.checkHandle(subscriber, "DomainParticipant.CreateSubscriber"); }
public Subscriber(Topic <T> topic, string partitionName, AdapterReaderQos desiredQos, DataReaderListener <T> listener, int waitForHistoricalData) { currentTopic = topic; this.partitionName = partitionName; this.listener = listener; IDomainParticipant participant = topic.Participant; var subQos = new SubscriberQos(); ReturnCode status = participant.GetDefaultSubscriberQos(ref subQos); ErrorHandler.CheckStatus( status, "Subscriber.GetDefaultSubscriberQos (Subscriber)"); subQos.Partition.Name = new string[1]; subQos.Partition.Name[0] = partitionName; // Create a Subscriber for the application. topicSubscriber = participant.CreateSubscriber(subQos); ErrorHandler.CheckHandle( topicSubscriber, "Subscriber.CreateSubscriber (Subscriber)"); CreateDataReader(desiredQos, listener, waitForHistoricalData); }
/*** * Operations ***/ public ITopic CreateSimulatedMultitopic( string name, string type_name, string subscription_expression, string[] expression_parameters) { /* Type-specific DDS entities */ ChatMessageDataReader chatMessageDR; NameServiceDataReader nameServiceDR; NamedMessageDataWriter namedMessageDW; /* Query related stuff */ IQueryCondition nameFinder; string[] nameFinderParams; /* QosPolicy holders */ TopicQos namedMessageQos = new TopicQos(); SubscriberQos subQos = new SubscriberQos(); PublisherQos pubQos = new PublisherQos(); /* Others */ IDataReader parentReader; IDataWriter parentWriter; string partitionName = "ChatRoom"; string nameFinderExpr; ReturnCode status; /* Lookup both components that constitute the multi-topic. */ chatMessageTopic = realParticipant.FindTopic( "Chat_ChatMessage", Duration.Infinite); ErrorHandler.checkHandle( chatMessageTopic, "DDS.DomainParticipant.FindTopic (Chat_ChatMessage)"); nameServiceTopic = realParticipant.FindTopic( "Chat_NameService", Duration.Infinite); ErrorHandler.checkHandle( nameServiceTopic, "DDS.DomainParticipant.FindTopic (Chat_NameService)"); /* Create a ContentFilteredTopic to filter out * our own ChatMessages. */ filteredMessageTopic = realParticipant.CreateContentFilteredTopic( "Chat_FilteredMessage", chatMessageTopic, "userID <> %0", expression_parameters); ErrorHandler.checkHandle( filteredMessageTopic, "DDS.DomainParticipant.CreateContentFilteredTopic"); /* Adapt the default SubscriberQos to read from the * "ChatRoom" Partition. */ status = realParticipant.GetDefaultSubscriberQos(ref subQos); ErrorHandler.checkStatus( status, "DDS.DomainParticipant.GetDefaultSubscriberQos"); subQos.Partition.Name = new string[1]; subQos.Partition.Name[0] = partitionName; /* Create a private Subscriber for the multitopic simulator. */ multiSub = realParticipant.CreateSubscriber(subQos); ErrorHandler.checkHandle( multiSub, "DDS.DomainParticipant.CreateSubscriber (for multitopic)"); /* Create a DataReader for the FilteredMessage Topic * (using the appropriate QoS). */ DataReaderQos drQos = new DataReaderQos(); TopicQos topicQos = new TopicQos(); multiSub.GetDefaultDataReaderQos(ref drQos); filteredMessageTopic.RelatedTopic.GetQos(ref topicQos); multiSub.CopyFromTopicQos(ref drQos, topicQos); parentReader = multiSub.CreateDataReader(filteredMessageTopic, drQos); ErrorHandler.checkHandle( parentReader, "DDS.Subscriber.create_datareader (ChatMessage)"); /* Narrow the abstract parent into its typed representative. */ chatMessageDR = parentReader as ChatMessageDataReader; /* Allocate the DataReaderListener Implementation. */ msgListener = new DataReaderListenerImpl(); /* Attach the DataReaderListener to the DataReader, * only enabling the data_available event. */ status = chatMessageDR.SetListener(msgListener, StatusKind.DataAvailable); ErrorHandler.checkStatus(status, "DDS.DataReader_set_listener"); /* Create a DataReader for the nameService Topic * (using the appropriate QoS). */ DataReaderQos nsDrQos = new DataReaderQos(); TopicQos nsQos = new TopicQos(); nameServiceTopic.GetQos(ref nsQos); multiSub.CopyFromTopicQos(ref nsDrQos, nsQos); parentReader = multiSub.CreateDataReader(nameServiceTopic, nsDrQos); ErrorHandler.checkHandle(parentReader, "DDS.Subscriber.CreateDatareader (NameService)"); /* Narrow the abstract parent into its typed representative. */ nameServiceDR = parentReader as NameServiceDataReader; /* Define the SQL expression (using a parameterized value). */ nameFinderExpr = "userID = %0"; /* Allocate and assign the query parameters. */ nameFinderParams = new string[1]; nameFinderParams[0] = expression_parameters[0]; /* Create a QueryCondition to only read corresponding * nameService information by key-value. */ nameFinder = nameServiceDR.CreateQueryCondition( SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.Any, nameFinderExpr, nameFinderParams); ErrorHandler.checkHandle( nameFinder, "DDS.DataReader.create_querycondition (nameFinder)"); /* Create the Topic that simulates the multi-topic * (use Qos from chatMessage).*/ status = chatMessageTopic.GetQos(ref namedMessageQos); ErrorHandler.checkStatus(status, "DDS.Topic.GetQos"); /* Create the NamedMessage Topic whose samples simulate * the MultiTopic */ namedMessageTopic = realParticipant.CreateTopic( "Chat_NamedMessage", type_name, namedMessageQos); ErrorHandler.checkHandle( namedMessageTopic, "DDS.DomainParticipant.CreateTopic (NamedMessage)"); /* Adapt the default PublisherQos to write into the * "ChatRoom" Partition. */ status = realParticipant.GetDefaultPublisherQos(ref pubQos); ErrorHandler.checkStatus( status, "DDS.DomainParticipant.get_default_publisher_qos"); pubQos.Partition.Name = new string[1]; pubQos.Partition.Name[0] = partitionName; /* Create a private Publisher for the multitopic simulator. */ multiPub = realParticipant.CreatePublisher(pubQos); ErrorHandler.checkHandle( multiPub, "DDS.DomainParticipant.create_publisher (for multitopic)"); DataWriterQos nmDwQos = new DataWriterQos(); TopicQos nmQos = new TopicQos(); multiPub.GetDefaultDataWriterQos(ref nmDwQos); namedMessageTopic.GetQos(ref nmQos); multiPub.CopyFromTopicQos(ref nmDwQos, nmQos); /* Create a DataWriter for the multitopic. */ parentWriter = multiPub.CreateDataWriter(namedMessageTopic, nmDwQos); ErrorHandler.checkHandle( parentWriter, "DDS.Publisher.CreateDatawriter (NamedMessage)"); /* Narrow the abstract parent into its typed representative. */ namedMessageDW = parentWriter as NamedMessageDataWriter; /* Store the relevant Entities in our Listener. */ msgListener.ChatMessageDR = chatMessageDR; msgListener.NameServiceDR = nameServiceDR; msgListener.NamedMessageDW = namedMessageDW; msgListener.NameFinder = nameFinder; msgListener.NameFinderParams = nameFinderParams; /* Return the simulated Multitopic. */ return(namedMessageTopic); }
static void Main(string[] args) { int domain = DDS.DomainId.Default; /* Create a DomainParticipant */ DomainParticipantFactory dpf = DomainParticipantFactory.Instance; IDomainParticipant participant = dpf.CreateParticipant( domain, null, StatusKind.Any); ErrorHandler.checkHandle( participant, "DDS.DomainParticipantFactory.CreateParticipant"); /* Register the required datatype for ChatMessage. */ ChatMessageTypeSupport chatMessageTS = new ChatMessageTypeSupport(); string chatMessageTypeName = chatMessageTS.TypeName; ReturnCode status = chatMessageTS.RegisterType( participant, chatMessageTypeName); ErrorHandler.checkStatus( status, "Chat.ChatMessageTypeSupport.RegisterType"); /* Register the required datatype for NameService. */ NameServiceTypeSupport nameServiceTS = new NameServiceTypeSupport(); ErrorHandler.checkHandle( nameServiceTS, "new NameServiceTypeSupport"); string nameServiceTypeName = nameServiceTS.TypeName; status = nameServiceTS.RegisterType( participant, nameServiceTypeName); ErrorHandler.checkStatus( status, "Chat.NameServiceTypeSupport.RegisterType"); /* Set the ReliabilityQosPolicy to RELIABLE. */ TopicQos reliableTopicQos = new TopicQos(); status = participant.GetDefaultTopicQos(ref reliableTopicQos); ErrorHandler.checkStatus( status, "DDS.DomainParticipant.get_DefaultTopicQos"); reliableTopicQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; /* Make the tailored QoS the new default. */ status = participant.SetDefaultTopicQos(reliableTopicQos); ErrorHandler.checkStatus( status, "DDS.DomainParticipant.SetDefaultTopicQos"); /* Use the changed policy when defining the ChatMessage topic */ ITopic chatMessageTopic = participant.CreateTopic( "Chat_ChatMessage", chatMessageTypeName, reliableTopicQos); ErrorHandler.checkHandle( chatMessageTopic, "DDS.DomainParticipant.CreateTopic (ChatMessage)"); /* Set the DurabilityQosPolicy to TRANSIENT. */ TopicQos settingTopicQos = new TopicQos(); status = participant.GetDefaultTopicQos(ref settingTopicQos); ErrorHandler.checkStatus( status, "DDS.DomainParticipant.GetDefaultTopicQos"); settingTopicQos.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos; /* Create the NameService Topic. */ ITopic nameServiceTopic = participant.CreateTopic( "Chat_NameService", nameServiceTypeName, settingTopicQos); ErrorHandler.checkHandle( nameServiceTopic, "DDS.DomainParticipant.CreateTopic"); /* Adapt the default SubscriberQos to read from the * "ChatRoom" Partition. */ SubscriberQos subQos = new SubscriberQos(); status = participant.GetDefaultSubscriberQos(ref subQos); ErrorHandler.checkStatus( status, "DDS.DomainParticipant.GetDefaultSubscriberQos"); subQos.Partition.Name = new string[1]; subQos.Partition.Name[0] = "ChatRoom"; /* Create a Subscriber for the UserLoad application. */ ISubscriber chatSubscriber = participant.CreateSubscriber(subQos); ErrorHandler.checkHandle( chatSubscriber, "DDS.DomainParticipant.CreateSubscriber"); /* Create a DataReader for the NameService Topic * (using the appropriate QoS). */ DataReaderQos nsQos = null; status = chatSubscriber.GetDefaultDataReaderQos(ref nsQos); ErrorHandler.checkStatus( status, "DDS.Subscriber.GetDefaultDataReaderQos"); status = chatSubscriber.CopyFromTopicQos(ref nsQos, settingTopicQos); ErrorHandler.checkStatus( status, "DDS.Subscriber.CopyFromTopicQos"); IDataReader parentReader = chatSubscriber.CreateDataReader( nameServiceTopic, nsQos, null, StatusKind.Any); ErrorHandler.checkHandle( parentReader, "DDS.Subscriber.CreateDatareader (NameService)"); NameServiceDataReader nameServer = parentReader as NameServiceDataReader; /* Adapt the DataReaderQos for the ChatMessageDataReader to * keep track of all messages. */ DataReaderQos messageQos = new DataReaderQos(); status = chatSubscriber.GetDefaultDataReaderQos(ref messageQos); ErrorHandler.checkStatus( status, "DDS.Subscriber.GetDefaultDataReaderQos"); status = chatSubscriber.CopyFromTopicQos( ref messageQos, reliableTopicQos); ErrorHandler.checkStatus( status, "DDS.Subscriber.CopyFromTopicQos"); messageQos.History.Kind = HistoryQosPolicyKind.KeepAllHistoryQos; /* Create a DataReader for the ChatMessage Topic * (using the appropriate QoS). */ parentReader = chatSubscriber.CreateDataReader( chatMessageTopic, messageQos); ErrorHandler.checkHandle( parentReader, "DDS.Subscriber.CreateDataReader (ChatMessage)"); /* Narrow the abstract parent into its typed representative. */ ChatMessageDataReader loadAdmin = parentReader as ChatMessageDataReader; /* Initialize the Query Arguments. */ string[] parameters = { "0" }; /* Create a QueryCondition that will contain all messages * with userID=ownID */ IQueryCondition singleUser = loadAdmin.CreateQueryCondition("userID=%0", parameters); ErrorHandler.checkHandle(singleUser, "DDS.DataReader.CreateQuerycondition"); /* Create a ReadCondition that will contain new users only */ IReadCondition newUser = nameServer.CreateReadCondition(SampleStateKind.NotRead, ViewStateKind.New, InstanceStateKind.Alive); ErrorHandler.checkHandle(newUser, "DDS.DataReader.create_readcondition"); /* Obtain a StatusCondition that triggers only when a Writer * changes Liveliness */ IStatusCondition leftUser = loadAdmin.StatusCondition; ErrorHandler.checkHandle(leftUser, "DDS.DataReader.GetStatusCondition"); status = leftUser.SetEnabledStatuses(StatusKind.LivelinessChanged); ErrorHandler.checkStatus(status, "DDS.StatusCondition.SetEnabledStatuses"); /* Create a bare guard which will be used to close the room */ escape = new GuardCondition(); /* Create a waitset and add the ReadConditions */ WaitSet userLoadWS = new WaitSet(); status = userLoadWS.AttachCondition(newUser); ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (newUser)"); status = userLoadWS.AttachCondition(leftUser); ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (leftUser)"); status = userLoadWS.AttachCondition(escape); ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (escape)"); /* Initialize and pre-allocate the GuardList used to obtain * the triggered Conditions. */ ICondition[] guardList = new ICondition[3]; /* Remove all known Users that are not currently active. */ NameService[] nsMsgs = null; SampleInfo[] nsInfos = null; status = nameServer.Take(ref nsMsgs, ref nsInfos, Length.Unlimited, SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.NotAlive); ErrorHandler.checkStatus( status, "Chat.NameServiceDataReader.Take"); status = nameServer.ReturnLoan(ref nsMsgs, ref nsInfos); ErrorHandler.checkStatus( status, "Chat.NameServiceDataReader.ReturnLoan"); /* Start the sleeper thread. */ new Thread(new UserLoad().doWait).Start(); bool closed = false; int prevCount = 0; ChatMessage[] msgs = null; SampleInfo[] msgInfos = null; while (!closed) { /* Wait until at least one of the Conditions in the * waitset triggers. */ status = userLoadWS.Wait(ref guardList, Duration.Infinite); ErrorHandler.checkStatus(status, "DDS.WaitSet.Wait"); /* Walk over all guards to display information */ foreach (ICondition guard in guardList) { if (guard == newUser) { /* The newUser ReadCondition contains data */ status = nameServer.ReadWithCondition(ref nsMsgs, ref nsInfos, newUser); ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.read_w_condition"); foreach (NameService ns in nsMsgs) { Console.WriteLine("New user: "******"Chat.NameServiceDataReader.ReturnLoan"); } else if (guard == leftUser) { // Some liveliness has changed (either a DataWriter // joined or a DataWriter left) LivelinessChangedStatus livelinessStatus = new LivelinessChangedStatus(); status = loadAdmin.GetLivelinessChangedStatus(ref livelinessStatus); ErrorHandler.checkStatus(status, "DDS.DataReader.getLivelinessChangedStatus"); if (livelinessStatus.AliveCount < prevCount) { /* A user has left the ChatRoom, since a DataWriter * lost its liveliness. Take the effected users * so they will not appear in the list later on. */ status = nameServer.Take( ref nsMsgs, ref nsInfos, Length.Unlimited, SampleStateKind.Any, ViewStateKind.Any, InstanceStateKind.NotAliveNoWriters); ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.Take"); foreach (NameService nsMsg in nsMsgs) { /* re-apply query arguments */ parameters[0] = nsMsg.userID.ToString(); status = singleUser.SetQueryParameters(parameters); ErrorHandler.checkStatus(status, "DDS.QueryCondition.SetQueryParameters"); /* Read this user's history */ status = loadAdmin.TakeWithCondition( ref msgs, ref msgInfos, singleUser); ErrorHandler.checkStatus( status, "Chat.ChatMessageDataReader.TakeWithCondition"); /* Display the user and his history */ Console.WriteLine("Departed user {0} has sent {1} messages ", nsMsg.name, msgs.Length); status = loadAdmin.ReturnLoan(ref msgs, ref msgInfos); ErrorHandler.checkStatus(status, "Chat.ChatMessageDataReader.ReturnLoan"); } status = nameServer.ReturnLoan(ref nsMsgs, ref nsInfos); ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.ReturnLoan"); } prevCount = livelinessStatus.AliveCount; } else if (guard == escape) { Console.WriteLine("UserLoad has terminated."); closed = true; } else { //System.Diagnostics.Debug.Fail("Unknown Condition"); } } /* for */ } /* while (!closed) */ /* Remove all Conditions from the WaitSet. */ status = userLoadWS.DetachCondition(escape); ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (escape)"); status = userLoadWS.DetachCondition(leftUser); ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (leftUser)"); status = userLoadWS.DetachCondition(newUser); ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (newUser)"); /* Free all resources */ status = participant.DeleteContainedEntities(); ErrorHandler.checkStatus(status, "DDS.DomainParticipant.DeleteContainedEntities"); status = dpf.DeleteParticipant(participant); ErrorHandler.checkStatus(status, "DDS.DomainParticipantFactory.DeleteParticipant"); }
public void Run() { #if DBCallTests DDS.Test.DatabaseTests(); #endif Console.WriteLine("Press enter to enter..."); Console.ReadLine(); Data.DataTest detectionData = new Data.DataTest(); detectionData.TestId = 3214; detectionData.Emergency = true; detectionData.TestStr = "not really"; //detectionData.SeqInt[3] = 23; #if TestMarshaling //Tactical.DetectionTypeSupport support = new Tactical.DetectionTypeSupport(); //Tactical.Detection cachedObj = new Tactical.Detection(); //support.Copy(cachedObj, detectionData); //SampleMarshaler marshaler = SampleMarshalerFactory.CreateMarshaler(detectionData); //using (SampleMarshalHelper helper = new SampleMarshalHelper(marshaler)) //{ // DDS.OpenSplice.Gapi.Test.test_detection(helper.GapiPtr); // Tactical.Detection detectionData2 = new Tactical.Detection(); // SampleMarshaler marshaler2 = SampleMarshalerFactory.CreateMarshaler(detectionData2); // marshaler2.CopyOut(helper.GapiPtr, 0); //} //Duration d = new Duration(234, 2343); //int sec; //uint nanosec; //DDS.OpenSplice.Gapi.Test.test_duration(d, out sec, out nanosec); //LivelinessChangedStatus status; //DDS.OpenSplice.Gapi.Test.get_liveliness_changed_status(out status); //Time t = new Time(1, 2); //int size = Marshal.SizeOf(t); //IntPtr ptr = Marshal.AllocHGlobal(size); //Marshal.StructureToPtr(t, ptr, true); #endif //DDS.Test.TestDataReaderQos(); //DDS.Test.TestTopicQos(); // Create a DomainParticipantFactory DomainParticipantFactory dpf = DomainParticipantFactory.Instance; Console.WriteLine("DomainParticipantFactory: " + dpf); // Tailor the DomainPartipantFactoryQos; DomainParticipantFactoryQos dpfQos = null; ReturnCode result = dpf.GetQos(ref dpfQos); Console.WriteLine("DomainParticipantFactory.get_qos: {0}", result); Console.WriteLine("DomainParticipantFactoryQos.entity_factory.autoenable_created_entities: " + dpfQos.EntityFactory.AutoenableCreatedEntities); dpfQos.EntityFactory.AutoenableCreatedEntities = false; result = dpf.SetQos(dpfQos); Console.WriteLine("DomainParticipantFactory.set_qos: {0}", result); // Get the QOS settings for the Factory... Check values without additional changes DomainParticipantFactoryQos dpf2Qos = null; result = dpf.GetQos(ref dpf2Qos); Console.WriteLine("DomainParticipantFactory.get_qos: {0}", result); Console.WriteLine("DomainParticipantFactoryQos.entity_factory.autoenable_created_entities: " + dpf2Qos.EntityFactory.AutoenableCreatedEntities); // Create the domainParticipant itself. DomainParticipantQos dpQos = new DomainParticipantQos(); dpQos.UserData.Value = new byte[] { (byte)1, (byte)2, (byte)3 }; dpQos.EntityFactory.AutoenableCreatedEntities = true; dpQos.ListenerScheduling.SchedulingClass.Kind = SchedulingClassQosPolicyKind.ScheduleDefault; dpQos.ListenerScheduling.SchedulingPriorityKind.Kind = SchedulingPriorityQosPolicyKind.PriorityRelative; dpQos.ListenerScheduling.SchedulingPriority = 0; dpQos.WatchdogScheduling.SchedulingClass.Kind = SchedulingClassQosPolicyKind.ScheduleDefault; dpQos.WatchdogScheduling.SchedulingPriorityKind.Kind = SchedulingPriorityQosPolicyKind.PriorityRelative; dpQos.WatchdogScheduling.SchedulingPriority = 4; IDomainParticipant dp = dpf.CreateParticipant(null, dpQos); Console.Write("DomainParticipant: "); Console.WriteLine(dp != null ? "yes" : "no"); if (dp.ContainsEntity(0)) { Console.WriteLine("contains_entity with nil handle incorrect"); } if (dp.ContainsEntity(100)) { Console.WriteLine("contains_entity with incorrect handle incorrect"); } Time currentTime; dp.GetCurrentTime(out currentTime); Console.WriteLine("Current Local Time: {0}", currentTime.ToDatetime().ToLocalTime()); // And look up this DomainParticipant. IDomainParticipant dp2 = dpf.LookupParticipant(null); DomainParticipantQos dp2Qos = null; Console.Write("lookup DomainParticipant: "); Console.WriteLine(dp2 != null ? "Success" : "Fail"); result = dp2.GetQos(ref dp2Qos); Console.WriteLine("DomainParticipant.get_qos: {0}", result); Console.WriteLine("DomainParticipantQos.entity_factory.autoenable_created_entities: " + dp2Qos.EntityFactory.AutoenableCreatedEntities); // Create a new PublisherQos and set some values... PublisherQos publisherQos = new PublisherQos(); publisherQos.EntityFactory.AutoenableCreatedEntities = true; publisherQos.Partition.Name = new string[] { "howdy" }; //, "neighbor", "partition" }; // true not supported in 4.1 ?? publisherQos.Presentation.OrderedAccess = false; // Create the Publisher dp.Enable(); IPublisher publisher = dp.CreatePublisher(publisherQos); Console.WriteLine("Create Publisher: {0}", publisher); //DataWriterQos dwQos; //publisher.GetDefaultDataWriterQos(out dwQos); // Create a Detection Type Support and register it's type Data.DataTestTypeSupport support = new Data.DataTestTypeSupport(); string test2 = support.TypeName; Console.WriteLine("Register Typesupport"); result = support.RegisterType(dp, support.TypeName); Console.WriteLine("Register Typesupport Result: {0}", result); // Create a topic for the Detection type TopicQos topicQos = null; result = dp.GetDefaultTopicQos(ref topicQos); //topicQos.Ownership.Kind = OwnershipQosPolicyKind.ExclusiveOwnershipQos; //DDS.Test.TestTopicQos2(ref topicQos); // Add a listener to the topic ITopic topic = dp.CreateTopic("Data_DataTest", support.TypeName, topicQos, this, StatusKind.InconsistentTopic); topicQos.History.Depth = 5; ITopic topic2 = dp.CreateTopic("Data_DataTest", support.TypeName, topicQos); // ErrorCode errorCode; // string msg; // result = ErrorInfo.Update(); // result = ErrorInfo.GetCode(out errorCode); // result = ErrorInfo.GetMessage(out msg); // Create a DataWriter for the topic Data.IDataTestDataWriter dataWriter = publisher.CreateDataWriter(topic) as Data.IDataTestDataWriter; // Create a SubscriberQos object and set the partition name SubscriberQos subscriberQos = null; result = dp.GetDefaultSubscriberQos(ref subscriberQos); subscriberQos.Partition.Name = new string[] { "howdy" }; // Create the subscriber ISubscriber sub = dp.CreateSubscriber(subscriberQos); // Verify that the subsciber was created... if (sub == null) { Console.WriteLine("Subscriber not created"); return; } DDS.DataReaderQos readerQos = null; sub.GetDefaultDataReaderQos(ref readerQos); //readerQos.SubscriptionKeys.KeyList = new string[] { "test" }; //readerQos.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos; //readerQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos; // Create a DataReader for the Detection topic Data.IDataTestDataReader dataReader = sub.CreateDataReader(topic, readerQos, this, StatusKind.DataAvailable) as Data.IDataTestDataReader; // Create a filtered detection topic (only read detections that have an id != 4) IContentFilteredTopic filteredTopic = dp.CreateContentFilteredTopic("Another", topic, "TestId <> %0", "4"); string[] testParams = null; result = filteredTopic.GetExpressionParameters(ref testParams); result = filteredTopic.SetExpressionParameters("hello", "test"); result = filteredTopic.GetExpressionParameters(ref testParams); // Create a DataReader to read the filtered topic IDataReader reader2 = sub.CreateDataReader(filteredTopic); IQueryCondition queryCondition = dataReader.CreateQueryCondition( "TestId = %0", "234"); // just for testing... //GC.Collect(); // WaitSet WaitSet waitSet = new WaitSet(); // either use status conditions...or IStatusCondition sc = reader2.StatusCondition; sc.SetEnabledStatuses(StatusKind.DataAvailable); waitSet.AttachCondition(sc); IStatusCondition sc2 = reader2.StatusCondition; // read conditions... // IReadCondition readCond = reader2.CreateReadCondition(); // waitSet.AttachCondition(readCond); ICondition[] cond = null; //waitSet.Wait(ref cond, Duration.Infinite); Console.WriteLine("Press enter to write data"); Console.ReadLine(); detectionData.SequenceTest = new int[1];// new System.Collections.Generic.List<int>(); //detectionData.SequenceTest.Add(4); detectionData.SequenceTest[0] = 4; // Write detection data result = dataWriter.Write(detectionData); detectionData = new Data.DataTest(); detectionData.TestId = 234; dataWriter.Write(detectionData, InstanceHandle.Nil); detectionData = new Data.DataTest(); detectionData.TestId = 235; dataWriter.Write(detectionData); detectionData = new Data.DataTest(); detectionData.TestId = 236; dataWriter.Write(detectionData); detectionData = new Data.DataTest(); detectionData.TestId = 237; dataWriter.Write(detectionData); Console.WriteLine("Press enter to read data"); Console.ReadLine(); // Read the data SampleInfo[] infos = null; Data.DataTest[] dataValues = null; // result = dataReader.ReadWithCondition(ref dataValues, ref infos, DDS.Length.Unlimited, queryCondition); result = dataReader.Read(ref dataValues, ref infos); Console.WriteLine("dataReader: {0}", dataReader); if (dataValues != null) { Console.WriteLine("Number of samples received: {0}", dataValues.Length); for (int index = 0; index < dataValues.Length; index++) { Console.WriteLine("TestId: {0}, ProviderId: {1}, Emergency: {2}, TestStr: {3}", dataValues[index].TestId, dataValues[index].ProviderId, dataValues[index].Emergency, dataValues[index].TestStr); Console.WriteLine("info: ValidData: {0}, InstHandle: {1}, PubHandle:{2}, SourceTS: {3}, ArrivalTS: {4}, sample: {5}, view: {6}, instance: {7}", infos[index].ValidData, infos[index].InstanceHandle, infos[index].PublicationHandle, infos[index].SourceTimestamp, infos[index].ArrivalTimestamp, infos[index].SampleState, infos[index].ViewState, infos[index].InstanceState); } } Console.WriteLine("Press enter to cleanup"); Console.ReadLine(); Console.WriteLine("DeleteContainedEntities"); result = dp.DeleteContainedEntities(); // If you don't use DeleteContainedEntities then you must delete everything that was created //result = sub.DeleteDataReader(dataReader); //result = publisher.DeleteDataWriter(dataWriter); //result = dp.DeleteTopic(topic); //result = dp.DeletePublisher(publisher); //result = dp.DeleteSubscriber(sub); Console.WriteLine("DeleteParticipant"); result = dpf.DeleteParticipant(dp); Console.WriteLine("Press enter to exit"); Console.ReadLine(); }