static void publish(int domain_id, int sample_count)
{
// --- Create participant --- //
/* To customize participant QoS, use
* the configuration file USER_QOS_PROFILES.xml */
DDS.DomainParticipant participant =
DDS.DomainParticipantFactory.get_instance().create_participant(
domain_id,
DDS.DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT,
null /* listener */,
DDS.StatusMask.STATUS_MASK_NONE);
if (participant == null)
{
shutdown(participant);
throw new ApplicationException("create_participant error");
}
// --- Create publisher --- //
/* To customize publisher QoS, use
* the configuration file USER_QOS_PROFILES.xml */
DDS.Publisher publisher = participant.create_publisher(
DDS.DomainParticipant.PUBLISHER_QOS_DEFAULT,
null /* listener */,
DDS.StatusMask.STATUS_MASK_NONE);
if (publisher == null)
{
shutdown(participant);
throw new ApplicationException("create_publisher error");
}
// --- Create topic --- //
/* Register type before creating topic */
System.String type_name = keysTypeSupport.get_type_name();
try
{
keysTypeSupport.register_type(
participant, type_name);
}
catch (DDS.Exception e)
{
Console.WriteLine("register_type error {0}", e);
shutdown(participant);
throw e;
}
/* To customize topic QoS, use
* the configuration file USER_QOS_PROFILES.xml */
DDS.Topic topic = participant.create_topic(
"Example keys",
type_name,
DDS.DomainParticipant.TOPIC_QOS_DEFAULT,
null /* listener */,
DDS.StatusMask.STATUS_MASK_NONE);
if (topic == null)
{
shutdown(participant);
throw new ApplicationException("create_topic error");
}
// --- Create writer --- //
/* We are going to load different QoS profiles for the two DWs */
DDS.DataWriterQos writerQos = new DDS.DataWriterQos();
/* To customize data writer QoS, use
* the configuration file USER_QOS_PROFILES.xml */
DDS.DataWriter writer = publisher.create_datawriter(
topic,
DDS.Publisher.DATAWRITER_QOS_DEFAULT,
null /* listener */,
DDS.StatusMask.STATUS_MASK_NONE);
DDS.DomainParticipantFactory.get_instance().get_datawriter_qos_from_profile(writerQos, "keys_Library", "keys_Profile_dw2");
/* If you want to set the writer_data_lifecycle QoS settings
* programmatically rather than using the XML, you will need to add
* the following lines to your code and comment out the create_datawriter
* and get_datawriter_qos_from_profile calls above.
*/
/*
* publisher.get_default_datawriter_qos(writerQos);
*
* writerQos.writer_data_lifecycle.autodispose_unregistered_instances = false;
* writerQos.ownership.kind = DDS.OwnershipQosPolicyKind.EXCLUSIVE_OWNERSHIP_QOS;
* writerQos.ownership_strength.value = 10;
*
* DDS.DataWriter writer = publisher.create_datawriter(
* topic,
* writerQos,
* null,
* DDS.StatusMask.STATUS_MASK_NONE);
*
* writerQos.ownership_strength.value = 5;
*/
DDS.DataWriter writer2 = publisher.create_datawriter(
topic,
writerQos,
null /* listener */,
DDS.StatusMask.STATUS_MASK_NONE);
if (writer == null)
{
shutdown(participant);
throw new ApplicationException("create_datawriter error");
}
keysDataWriter keys_writer = (keysDataWriter)writer;
if (writer2 == null)
{
shutdown(participant);
throw new ApplicationException("create_datawriter error");
}
keysDataWriter keys_writer2 = (keysDataWriter)writer2;
// --- Write --- //
/* Creates three instances */
keys[] instance = new keys[3] {
null, null, null
};
/* Create data sample for writing */
instance[0] = keysTypeSupport.create_data();
instance[1] = keysTypeSupport.create_data();
instance[2] = keysTypeSupport.create_data();
if ((instance[0] == null)
||
(instance[1] == null)
||
(instance[2] == null)
)
{
shutdown(participant);
throw new ApplicationException(
"keysTypeSupport.create_data error");
}
/* RTI Connext could examine the key fields each time it needs to determine
* which data-instance is being modified.
* However, for performance and semantic reasons, it is better
* for your application to declare all the data-instances it intends to
* modify prior to actually writing any samples. This is known as registration.
*/
/* In order to register the instances, we must set their associated keys first */
instance[0].code = 0;
instance[1].code = 1;
instance[2].code = 2;
/* For a data type that has a key, if the same instance is going to be
* written multiple times, initialize the key here
* and register the keyed instance prior to writing */
DDS.InstanceHandle_t[] handle = new DDS.InstanceHandle_t[3];
Console.WriteLine("----DW1 registering instance handle", instance[0].code);
handle[0] = keys_writer.register_instance(instance[0]);
// Init coordinates
instance[0].x = 1;
instance[1].x = 1;
instance[2].x = 1;
int[] active = new int[] { 1, 0, 0 }; // Only send active keys.
/* Make variables for the instance for the second datawriter to use.
* Note that it actually refers to the same logical instance, but
* because we're running both datawriters in the same thread, we
* to create separate variables so they don't clobber each other.
*/
keys instance_dw2 = null;
instance_dw2 = keysTypeSupport.create_data();
if (instance_dw2 == null)
{
shutdown(participant);
throw new ApplicationException("keysTypeSupport.create_data error");
}
/* instance_dw2 and instance[1] have the same key, and thus
* will write to the same instance (ins1).
*/
instance_dw2.code = instance[1].code;
instance_dw2.x = 2;
DDS.InstanceHandle_t handle_dw2 = keys_writer2.register_instance(instance_dw2);
int active_dw2 = 1;
/* Main loop */
const System.Int32 send_period = 1000; // milliseconds
for (int count = 0; (sample_count == 0) || (count < sample_count); ++count)
{
System.Threading.Thread.Sleep(send_period);
/* Modify the data to be sent here */
instance[0].y = count;
instance[1].y = count + 1000;
instance[2].y = count + 2000;
instance_dw2.y = -count - 1000;
/* We control two datawriters via a state machine here rather than
* introducing separate threads.
*/
/* Control first DataWriter */
switch (count)
{
case 4:
{ /* Start sending the second (ins1) and third instances (ins2) */
Console.WriteLine("----DW1 registering instance {0}", instance[1].code);
Console.WriteLine("----DW1 registering instance {0}", instance[2].code);
handle[1] = keys_writer.register_instance(instance[1]);
handle[2] = keys_writer.register_instance(instance[2]);
active[1] = 1;
active[2] = 1;
} break;
case 8:
{ /* Dispose the second instance (ins1) */
Console.WriteLine("----DW1 disposing instance {0}", instance[1].code);
try
{
keys_writer.dispose(instance[1], ref handle[1]);
}
catch (DDS.Exception e)
{
Console.WriteLine("dispose instance error: {0}", e);
return;
}
active[1] = 0;
} break;
case 10:
{ /* Unregister the second instance (ins1) */
Console.WriteLine("----DW1 unregistering instance {0}", instance[1].code);
try
{
keys_writer.unregister_instance(instance[1], ref handle[1]);
}
catch (DDS.Exception e)
{
Console.WriteLine("unregister instance error: {0}", e);
return;
}
active[1] = 0;
} break;
case 12:
{ /* Unregister the third instance (ins2) */
Console.WriteLine("----DW1 unregistering instance {0}", instance[2].code);
try
{
keys_writer.unregister_instance(instance[2], ref handle[2]);
}
catch (DDS.Exception e)
{
Console.WriteLine("unregister instance error: {0}", e);
return;
}
active[2] = 0;
/* Re-register the second instance (ins1) */
Console.WriteLine("----DW1 re-registering instance {0}", instance[1].code);
handle[1] = keys_writer.register_instance(instance[1]);
active[1] = 1;
} break;
case 16:
{ /* Re-register the third instance (ins2) */
Console.WriteLine("----DW1 re-registering instance {0}", instance[2].code);
handle[2] = keys_writer.register_instance(instance[2]);
active[2] = 1;
} break;
}
for (int i = 0; i < 3; ++i)
{
if (active[i] == 1)
{
Console.WriteLine("DW1 write; code: {0}, x: {1}, y: {2}",
instance[i].code, instance[i].x, instance[i].y);
try
{
keys_writer.write(instance[i], ref handle[i]);
}
catch (DDS.Exception e)
{
Console.WriteLine("write error {0}", e);
return;
}
}
}
/* Control second datawriter */
switch (count)
{
case 16:
{ /* Dispose the instance (ins1).
* Since it has lower ownership strength, this does nothing */
Console.WriteLine("----DW2 disposing instance {0}", instance_dw2.code);
try
{
keys_writer2.dispose(instance_dw2, ref handle_dw2);
}
catch (DDS.Exception e)
{
Console.WriteLine("dispose error {0}", e);
return;
}
active_dw2 = 0;
} break;
}
if (active_dw2 == 1)
{
Console.WriteLine("DW2 write; code: {0}, x: {1}, y: {2}",
instance_dw2.code, instance_dw2.x, instance_dw2.y);
try
{
keys_writer2.write(instance_dw2, ref handle_dw2);
}
catch (DDS.Exception e)
{
Console.WriteLine("write error {0}", e);
return;
}
}
}
// --- Shutdown --- //
/* Delete data sample */
for (int i = 0; i < 3; i++)
{
try
{
keysTypeSupport.delete_data(instance[i]);
}
catch (DDS.Exception e)
{
Console.WriteLine(
"keysTypeSupport.delete_data error: {0}", e);
}
}
try
{
keysTypeSupport.delete_data(instance_dw2);
}
catch (DDS.Exception e)
{
Console.WriteLine(
"keysTypeSupport.delete_data error: {0}", e);
}
/* Delete all entities */
shutdown(participant);
}
static void publish(int domain_id, int sample_count)
{
// --- Create participant --- //
/* To customize participant QoS, use
* the configuration file USER_QOS_PROFILES.xml */
DDS.DomainParticipant participant =
DDS.DomainParticipantFactory.get_instance().create_participant(
domain_id,
DDS.DomainParticipantFactory.PARTICIPANT_QOS_DEFAULT,
null /* listener */,
DDS.StatusMask.STATUS_MASK_NONE);
if (participant == null)
{
shutdown(participant);
throw new ApplicationException("create_participant error");
}
// --- Create publisher --- //
/* To customize publisher QoS, use
* the configuration file USER_QOS_PROFILES.xml */
DDS.Publisher publisher = participant.create_publisher(
DDS.DomainParticipant.PUBLISHER_QOS_DEFAULT,
null /* listener */,
DDS.StatusMask.STATUS_MASK_NONE);
if (publisher == null)
{
shutdown(participant);
throw new ApplicationException("create_publisher error");
}
// --- Create topic --- //
/* Register type before creating topic */
System.String type_name = keysTypeSupport.get_type_name();
try {
keysTypeSupport.register_type(
participant, type_name);
}
catch (DDS.Exception e) {
Console.WriteLine("register_type error {0}", e);
shutdown(participant);
throw e;
}
/* To customize topic QoS, use
* the configuration file USER_QOS_PROFILES.xml */
DDS.Topic topic = participant.create_topic(
"Example keys",
type_name,
DDS.DomainParticipant.TOPIC_QOS_DEFAULT,
null /* listener */,
DDS.StatusMask.STATUS_MASK_NONE);
if (topic == null)
{
shutdown(participant);
throw new ApplicationException("create_topic error");
}
// --- Create writer --- //
/* To customize data writer QoS, use
* the configuration file USER_QOS_PROFILES.xml */
DDS.DataWriter writer = publisher.create_datawriter(
topic,
DDS.Publisher.DATAWRITER_QOS_DEFAULT,
null /* listener */,
DDS.StatusMask.STATUS_MASK_NONE);
/* If you want to set the writer_data_lifecycle QoS settings
* programmatically rather than using the XML, you will need to add
* the following lines to your code and comment out the create_datawriter
* call above.
*/
/*DDS.DataWriterQos datawriter_qos = new DDS.DataWriterQos();
* try
* {
* publisher.get_default_datawriter_qos(datawriter_qos);
* }
* catch (DDS.Exception e)
* {
* Console.WriteLine("get_default_datawriter_qos error", e);
* }
*
* datawriter_qos.writer_data_lifecycle.autodispose_unregistered_instances = false;
*
* DDS.DataWriter writer = publisher.create_datawriter(
* topic,
* datawriter_qos,
* null,
* DDS.StatusMask.STATUS_MASK_NONE);
*/
if (writer == null)
{
shutdown(participant);
throw new ApplicationException("create_datawriter error");
}
keysDataWriter keys_writer = (keysDataWriter)writer;
// --- Write --- //
/* For a data type that has a key, if the same instance is going to be
* written multiple times, initialize the key here
* and register the keyed instance prior to writing */
DDS.InstanceHandle_t instance_handle = DDS.InstanceHandle_t.HANDLE_NIL;
/* Creates three instances */
keys[] instance = new keys[3] {
null, null, null
};
/* Create data samples for writing */
instance[0] = keysTypeSupport.create_data();
instance[1] = keysTypeSupport.create_data();
instance[2] = keysTypeSupport.create_data();
if (instance[0] == null || instance[1] == null || instance[2] == null)
{
shutdown(participant);
throw new ApplicationException(
"keysTypeSupport::create_data error\n");
}
/* RTI Connext could examine the key fields each time it needs to determine
* which data-instance is being modified.
* However, for performance and semantic reasons, it is better
* for your application to declare all the data-instances it intends to
* modify prior to actually writing any samples. This is known as registration.
*/
/* In order to register the instances, we must set their associated keys first */
instance[0].code = 0;
instance[1].code = 1;
instance[2].code = 2;
/* Creates three handles for managing the registrations */
DDS.InstanceHandle_t[] handle =
new DDS.InstanceHandle_t[]
{ DDS.InstanceHandle_t.HANDLE_NIL, DDS.InstanceHandle_t.HANDLE_NIL,
DDS.InstanceHandle_t.HANDLE_NIL };
/* The keys must have been set before making this call */
Console.WriteLine("Registering instance {0}", instance[0].code);
handle[0] = keys_writer.register_instance(instance[0]);
/* Modify the data to be sent here */
instance[0].x = 1000;
instance[1].x = 2000;
instance[2].x = 3000;
/* We only will send data over the instances marked as active */
int[] active = new int[] { 1, 0, 0 }; // Only send active tracks.
/* Main loop */
const System.Int32 send_period = 1000; // milliseconds
for (int count = 0;
(sample_count == 0) || (count < sample_count);
++count)
{
//Console.WriteLine("Writing keys, count {0}", count);
switch (count)
{
case 5:
{ /* Start sending the second and third instances */
Console.WriteLine("----Registering instance {0}", instance[1].code);
Console.WriteLine("----Registering instance {0}", instance[2].code);
handle[1] = keys_writer.register_instance(instance[1]);
handle[2] = keys_writer.register_instance(instance[2]);
active[1] = 1;
active[2] = 1;
} break;
case 10:
{ /* Unregister the second instance */
Console.WriteLine("----Unregistering instance {0}", instance[1].code);
try
{
keys_writer.unregister_instance(instance[1], ref handle[1]);
}
catch (DDS.Exception e)
{
Console.WriteLine("unregister instance error {0}", e);
}
active[1] = 0;
} break;
case 15:
{ /* Dispose the third instance */
Console.WriteLine("----Disposing instance {0}", instance[2].code);
try
{
keys_writer.dispose(instance[2], ref handle[2]);
}
catch (DDS.Exception e)
{
Console.WriteLine("dispose instance error {0}", e);
}
active[2] = 0;
} break;
}
/* Modify the data to be sent here */
instance[0].y = count;
instance[1].y = count;
instance[2].y = count;
for (int i = 0; i < 3; ++i)
{
if (active[i] == 1)
{
Console.WriteLine("Writing instance {0}, x: {1}, y: {2}",
instance[i].code, instance[i].x, instance[i].y);
try
{
keys_writer.write(instance[i], ref handle[i]);
}
catch (DDS.Exception e)
{
Console.WriteLine("write error {0}", e);
}
}
}
System.Threading.Thread.Sleep(send_period);
}
// --- Shutdown --- //
/* Delete data samples */
try
{
keysTypeSupport.delete_data(instance[0]);
}
catch (DDS.Exception e)
{
Console.WriteLine("keysTypeSupport.delete_data error: {0}", e);
}
try
{
keysTypeSupport.delete_data(instance[1]);
}
catch (DDS.Exception e)
{
Console.WriteLine("keysTypeSupport.delete_data error: {0}", e);
}
try
{
keysTypeSupport.delete_data(instance[2]);
}
catch (DDS.Exception e)
{
Console.WriteLine("keysTypeSupport.delete_data error: {0}", e);
}
/* Delete all entities */
shutdown(participant);
}