/// <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;
}
WQosH.WriterDataLifecycle.AutodisposeUnregisteredInstances = autoDisposeFlag;
writer = publisher.CreateDataWriter(
topic,
WQosH,
null,
StatusKind.Any);
ErrorHandler.checkHandle(writer, "Publisher.CreateDataWriter");
if (exampleName.Equals("Lifecycle"))
{
writerStopper = publisher.CreateDataWriter(
topic,
WQosH,
null,
StatusKind.Any);
ErrorHandler.checkHandle(writerStopper, "Publisher.CreateDataWriter");
}
}
/// <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");
switch (exampleName)
{
case "ContentFilteredTopic":
case "Durability":
case "HelloWorld":
case "WaitSet":
case "Lifecycle":
topicQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
if (durabilityKind.Equals("transient"))
{
topicQos.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos;
}
else
{
topicQos.Durability.Kind = DurabilityQosPolicyKind.PersistentDurabilityQos;
}
break;
case "Ownership":
topicQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
topicQos.Ownership.Kind = OwnershipQosPolicyKind.ExclusiveOwnershipQos;
break;
case "QueryCondition":
topicQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
break;
case "Listener":
topicQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
topicQos.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos;
// DeadlineQoSPolicy : period used to trigger the listener
// (on_requested_deadline_missed)
topicQos.Deadline.Period.NanoSec = 0;
topicQos.Deadline.Period.Sec = 5;
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,
null,
StatusKind.Any
);
ErrorHandler.checkHandle(topic, "DomainParticipant.CreateTopic");
return(topic);
}
/// <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>
/// 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 "ContentFilteredTopic":
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 "HelloWorld":
case "Ownership":
case "WaitSet":
case "QueryCondition":
case "Lifecycle":
break;
default:
break;
}
if (filtered)
{
reader = subscriber.CreateDataReader(
filteredTopic,
RQosH,
null,
StatusKind.Any);
}
else
{
reader = subscriber.CreateDataReader(
topic,
RQosH,
null,
StatusKind.Any);
}
ErrorHandler.checkHandle(reader, "Subscriber.CreateDataReader");
}
/// <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");
}
/// <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 DomainParticipant.
/// </summary>
public void deleteParticipant()
{
status = dpf.DeleteParticipant(participant);
ErrorHandler.checkStatus(status, "DomainParticipantFactory.DeleteParticipant");
}
/// <summary>
/// Deletes the class's Subscriber
/// </summary>
public void deleteSubscriber()
{
status = participant.DeleteSubscriber(subscriber);
ErrorHandler.checkStatus(status, "Participant.DeleteSubscriber");
}
/// <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>
/// Delete a Publisher
/// </summary>
public void deletePublisher()
{
status = participant.DeletePublisher(publisher);
ErrorHandler.checkStatus(status, "DomainParticipant.DeletePublisher");
}
/// <summary>
/// Delete the Topic
/// </summary>
public void deleteTopic()
{
status = participant.DeleteTopic(topic);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.DeleteTopic");
}
/// <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");
}
