public override void InitEmbeddedMarshalers(IDomainParticipant participant)
{
if (attr1Marshaler == null)
{
attr1Marshaler = DatabaseMarshaler.GetMarshaler(participant, typeof(DM.__l_WGS84)) as DM.__l_WGS84Marshaler;
if (attr1Marshaler == null)
{
attr1Marshaler = new DM.__l_WGS84Marshaler();
DatabaseMarshaler.Add(participant, typeof(DM.__l_WGS84), attr1Marshaler);
attr1Marshaler.InitEmbeddedMarshalers(participant);
}
}
if (attr4Marshaler == null)
{
attr4Marshaler = DatabaseMarshaler.GetMarshaler(participant, typeof(DM.__EGI_Data)) as DM.__EGI_DataMarshaler;
if (attr4Marshaler == null)
{
attr4Marshaler = new DM.__EGI_DataMarshaler();
DatabaseMarshaler.Add(participant, typeof(DM.__EGI_Data), attr4Marshaler);
attr4Marshaler.InitEmbeddedMarshalers(participant);
}
}
if (attr5Marshaler == null)
{
attr5Marshaler = DatabaseMarshaler.GetMarshaler(participant, typeof(__Aircraft)) as __AircraftMarshaler;
if (attr5Marshaler == null)
{
attr5Marshaler = new __AircraftMarshaler();
DatabaseMarshaler.Add(participant, typeof(__Aircraft), attr5Marshaler);
attr5Marshaler.InitEmbeddedMarshalers(participant);
}
}
}
public DomainParticipantTransportSource(IDomainParticipant participant, string senderTopic, string receiverTopic)
{
_participant = participant;
var bdt = new ByteDataTypeSupport();
var result = bdt.RegisterType(participant, bdt.TypeName);
if (result != ReturnCode.Ok)
{
throw new Exception("Unable to register type: " + result);
}
_publisher = _participant.CreatePublisher();
_subscriber = _participant.CreateSubscriber();
var senderTopicQos = new TopicQos();
participant.GetDefaultTopicQos(ref senderTopicQos);
var receiverTopicQos = new TopicQos();
participant.GetDefaultTopicQos(ref receiverTopicQos);
_senderTopic = participant.CreateTopic(senderTopic, bdt.TypeName, senderTopicQos);
_receiverTopic = participant.CreateTopic(receiverTopic, bdt.TypeName, receiverTopicQos);
_dataWriter = (ByteDataWriter)_publisher.CreateDataWriter(_senderTopic);
_dataToSendHandle = _dataWriter.RegisterInstance(_dataToSend);
var dataReaderQos = new DataReaderQos();
_subscriber.GetDefaultDataReaderQos(ref dataReaderQos);
_dataReader = (ByteDataReader)_subscriber.CreateDataReader(_receiverTopic, dataReaderQos, this, StatusKind.Any);
}
// TODO: This operation is currently not thread-safe.
public virtual ReturnCode RegisterType(
IDomainParticipant participant,
string typeName,
DatabaseMarshaler marshaler)
{
ReturnCode result = ReturnCode.BadParameter;
if (participant != null && marshaler != null)
{
// Now that a marshaler is present,
result = AttachMarshalerDelegates(GapiPeer, marshaler);
if (result == ReturnCode.Ok)
{
IntPtr domainObj = (participant as DomainParticipant).GapiPeer;
result = Gapi.FooTypeSupport.register_type(
GapiPeer,
domainObj,
typeName);
if (result == ReturnCode.Ok)
{
DatabaseMarshaler.Add(participant, dataType, marshaler);
marshaler.InitEmbeddedMarshalers(participant);
}
}
}
return(result);
}
public IDomainParticipant LookupParticipant(string domainId)
{
IntPtr gapiDP = OpenSplice.Gapi.DomainParticipantFactory.lookup_participant(GapiPeer, domainId);
IDomainParticipant participant = (IDomainParticipant)SacsSuperClass.fromUserData(gapiDP);
return(participant);
}
public DomainParticipantTransportSource(IDomainParticipant participant, string senderTopic, string receiverTopic)
{
_participant = participant;
var bdt = new ByteDataTypeSupport();
var result = bdt.RegisterType(participant, bdt.TypeName);
if (result != ReturnCode.Ok)
throw new Exception("Unable to register type: " + result);
_publisher = _participant.CreatePublisher();
_subscriber = _participant.CreateSubscriber();
var senderTopicQos = new TopicQos();
participant.GetDefaultTopicQos(ref senderTopicQos);
var receiverTopicQos = new TopicQos();
participant.GetDefaultTopicQos(ref receiverTopicQos);
_senderTopic = participant.CreateTopic(senderTopic, bdt.TypeName, senderTopicQos);
_receiverTopic = participant.CreateTopic(receiverTopic, bdt.TypeName, receiverTopicQos);
_dataWriter = (ByteDataWriter)_publisher.CreateDataWriter(_senderTopic);
_dataToSendHandle = _dataWriter.RegisterInstance(_dataToSend);
var dataReaderQos = new DataReaderQos();
_subscriber.GetDefaultDataReaderQos(ref dataReaderQos);
_dataReader = (ByteDataReader)_subscriber.CreateDataReader(_receiverTopic, dataReaderQos, this, StatusKind.Any);
}
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());
}
}
static void Main(string[] args)
{
_dpf = DomainParticipantFactory.Instance;
ErrorHandler.checkHandle(_dpf, "Domain Participant Factory");
_dp = _dpf.CreateParticipant(Domain);
//Initialize QOS
pQos = new PublisherQos();
dwQos = new DataWriterQos();
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 Publisher QOS and Set Partition Name
_dp.GetDefaultPublisherQos(ref pQos);
pQos.Partition.Name = new String[1];
pQos.Partition.Name[0] = PartitionName;
//Create Subscriber for FDMDATA Topic
Publisher = _dp.CreatePublisher(pQos);
ErrorHandler.checkHandle(Publisher, "Cannot Create FDMDATA Publisher");
//Get Data Writer QOS and Set History Depth
Publisher.GetDefaultDataWriterQos(ref dwQos);
ErrorHandler.checkHandle(dwQos, "Cannot get Data Writer Qos");
dwQos.History.Depth = 5;
dwQos.Reliability.Kind = ReliabilityQosPolicyKind.BestEffortReliabilityQos;
//Create DataReader for FDMDATA Topic
parentWriter = Publisher.CreateDataWriter(fdmDataTopic, dwQos);
ErrorHandler.checkHandle(parentWriter, "Cannot Create FDMDATA Data Writer");
//Narrow abstract parentWriter into its typed representative
fdmDataWriter = parentWriter as FDMDataWriter;
ErrorHandler.checkHandle(fdmDataWriter, "Cannot Narrow FDMDATA Data Writer");
fdmData = new FDM();
while (true)
{
StartPublish();
Console.WriteLine("Publishing data! ");
Thread.Sleep(10);
}
}
public IDomainParticipant GetParticipant()
{
IntPtr gapiPtr = Gapi.Publisher.get_participant(GapiPeer);
IDomainParticipant domainParticipant = SacsSuperClass.fromUserData(gapiPtr)
as IDomainParticipant;
return(domainParticipant);
}
public static DatabaseMarshaler GetMarshaler(
IDomainParticipant participant,
Type t)
{
DatabaseMarshaler marshaler;
// Check if a Marshaler for this type already exists, and if so return it.
typeMarshalers.TryGetValue(new KeyValuePair <IDomainParticipant, Type>(participant, t), out marshaler);
return(marshaler);
}
/// <summary>
/// Create Domain Participant
/// </summary>
/// <param name="partitionName">Create the participant and assign the partition name.</param>
public void createParticipant(String partitionName)
{
dpf = DomainParticipantFactory.Instance;
dpQos = new DomainParticipantQos();
dpf.GetDefaultParticipantQos(ref dpQos);
ErrorHandler.checkHandle(dpf, "DomainParticipantFactory.Instance");
participant = dpf.CreateParticipant(null, dpQos);
ErrorHandler.checkHandle(participant, "DomainParticipantFactory.CreateParticipant");
this.partitionName = partitionName;
}
/// <summary>
/// Create Domain Participant
/// </summary>
/// <param name="partitionName">Create the participant and assign the partition name.</param>
public void createParticipant(String partitionName)
{
dpf = DomainParticipantFactory.Instance;
dpQos = new DomainParticipantQos();
dpf.GetDefaultParticipantQos(ref dpQos);
ErrorHandler.checkHandle(dpf, "DomainParticipantFactory.Instance");
participant = dpf.CreateParticipant(DDS.DomainId.Default,dpQos);
ErrorHandler.checkHandle(participant, "DomainParticipantFactory.CreateParticipant");
this.partitionName = partitionName;
}
public override void InitEmbeddedMarshalers(IDomainParticipant participant)
{
if (attr2Marshaler == null)
{
attr2Marshaler = DatabaseMarshaler.GetMarshaler(participant, typeof(DM.__l_WGS84)) as DM.__l_WGS84Marshaler;
if (attr2Marshaler == null)
{
attr2Marshaler = new DM.__l_WGS84Marshaler();
DatabaseMarshaler.Add(participant, typeof(DM.__l_WGS84), attr2Marshaler);
attr2Marshaler.InitEmbeddedMarshalers(participant);
}
}
}
public static void Add(
IDomainParticipant participant,
Type t,
DatabaseMarshaler marshaler)
{
DatabaseMarshaler tmp;
// Check if a Marshaler for this type already exists, and if not, add it.
if (!typeMarshalers.TryGetValue(new KeyValuePair <IDomainParticipant, Type>(participant, t), out tmp))
{
// Add the new marshaler to the list of known marshalers.
typeMarshalers.Add(new KeyValuePair <IDomainParticipant, Type>(participant, t), marshaler);
}
}
public ReturnCode DeleteParticipant(IDomainParticipant a_participant)
{
ReturnCode result = ReturnCode.BadParameter;
DomainParticipant participant = a_participant as DomainParticipant;
if (participant != null)
{
result = OpenSplice.Gapi.DomainParticipantFactory.delete_participant(
GapiPeer,
participant.GapiPeer);
}
return(result);
}
public virtual ReturnCode RegisterType(
IDomainParticipant participant,
string typeName,
DatabaseMarshaler marshaler)
{
ReturnCode result = ReturnCode.BadParameter;
DomainParticipant dp;
ReportStack.Start();
if (participant == null)
{
ReportStack.Report(result, "domain '<NULL>' is invalid.");
}
else if (marshaler == null)
{
ReportStack.Report(result, "marshaler '<NULL>' is invalid.");
}
else
{
dp = participant as DomainParticipant;
if (dp == null)
{
ReportStack.Report(result, "domain is invalid, not of type " +
"DDS::OpenSplice::DomainParticipant");
}
else
{
if (typeName == null)
{
typeName = this.typeName;
}
result = dp.nlReq_LoadTypeSupport(this, typeName);
if (result == ReturnCode.AlreadyDeleted)
{
result = ReturnCode.BadParameter;
}
else
{
DatabaseMarshaler.Add(dp, dataType, marshaler);
marshaler.InitEmbeddedMarshalers(dp);
}
}
}
ReportStack.Flush(null, result != ReturnCode.Ok);
return(result);
}
public Publisher(Topic <T> topic, string partitionName, AdapterWriterQos desiredQos)
{
currentTopic = topic;
IDomainParticipant participant = topic.Participant;
var publisherQos = new PublisherQos();
ReturnCode status = participant.GetDefaultPublisherQos(ref publisherQos);
ErrorHandler.CheckStatus(status, "Publisher.GetDefaultSubscriberQos (Publisher)");
publisherQos.Partition.Name = new string[1];
publisherQos.Partition.Name[0] = partitionName;
// Create a Subscriber for the application.
topicPublisher = participant.CreatePublisher(publisherQos);
ErrorHandler.CheckHandle(
topicPublisher, "Publisher.CreateSubscriber (Publisher)");
InitializeWriter(desiredQos);
}
/// <summary>
/// This operation deletes an IDomainParticipant.
/// </summary>
/// <remarks>
/// An IDomainParticipant cannot
/// be deleted when it has any attached Entity objects. When the operation is called
/// on a IDomainParticipant with existing Entity objects, the operation returns
/// DDS.ReturnCode PreconditionNotMet.
/// </remarks>
/// @param a_participant The IDomainParticipant that is to be deleted.
/// @return DDS.ReturnCode Ok - The IDomainParticipant is deleted
/// @return DDS.ReturnCode Error - An internal error has occurred
/// @return DDS.ReturnCode BadParameter - The given IDomainParticipant is not valid
/// @return DDS.ReturnCode OutOfResources - The Data Distribution Service ran out of
/// resources to complete this operation.
/// @return DDS.ReturnCode PreconditionNotMet - The IDomainParticipant contains one
/// or more Entity objects.
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 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);
}
public abstract void InitEmbeddedMarshalers(IDomainParticipant participant);
private void init()
{
MyTopicTypeSupport typeSupport;
DataWriterQos wQos = null;
string msg = "Unknown error";
/**
* @addtogroup group_dds1290
*
* \b Test \b ID: \b sacs_invalid_data_000
*
* \b Test \b Objectives:
*
* Create and initialise all required DDS entities
*
* \b Test \b Procedure:
*
* \e Action
*
* The following entities are obtained/created
* \arg \c DomainParticipantFactory
* \arg \c DomainParticipant with default QoS settings
* \arg \c Publisher with default QoS settings
* \arg \c Subscriber with default QoS settings
* \arg \c The MyTopicModule::MyTopic type is registered
* \arg \c A topic T1 of type MyTopicModule::MyTopic is created with default QoS settings
* \arg \c A DataWriter W1 for T1 with default QoS settings, writer_data_lifecycle.autodispose_unregistered_instances = FALSE
* \arg \c A DataWriter W2 for T1 with default QoS settings, writer_data_lifecycle.autodispose_unregistered_instances = FALSE
* \arg \c A DataReader for T1 with default QoS settings
*
* \e Result
* It is expected that all entities are created/initialized correctly and without any failures. \n
* If a failure occurs at any of the above stages, the test fails, this is reported and no further testing is performed
*/
/*- INITIALIZATION ---------------------------------------------------------*/
tfw.TestStart ("sacs_invalid_data_000","invalid_data","initialization");
tfw.TestTitle ("Test initialization.");
tfw.TestPurpose ("Test initialization.");
factory = DomainParticipantFactory.Instance;
if(factory == null){
msg = "DomainParticipantFactory could NOT be resolved";
proceed = false;
} else {
participant = factory.CreateParticipant(DDS.DomainId.Default);
if(participant == null){
msg = "DomainParticipant could NOT be created";
proceed = false;
} else {
typeSupport = new MyTopicTypeSupport();
result = typeSupport.RegisterType(participant, "MyTopic");
if(result == ReturnCode.Ok){
topic = participant.CreateTopic("my_topic", "MyTopic");
if(topic != null){
subscriber = participant.CreateSubscriber();
if(subscriber != null){
reader = subscriber.CreateDataReader(topic) as MyTopicDataReader;
if(reader != null){
publisher = participant.CreatePublisher();
if(publisher != null){
result = publisher.GetDefaultDataWriterQos(ref wQos);
if(wQos != null && result == ReturnCode.Ok){
wQos.WriterDataLifecycle.AutodisposeUnregisteredInstances = false;
writer1 = publisher.CreateDataWriter(topic, wQos) as MyTopicDataWriter;
if(writer1 != null){
writer2 = publisher.CreateDataWriter(topic, wQos) as MyTopicDataWriter;
if(writer2 == null){
msg = "DataWriter could NOT be created";
proceed = false;
}
} else {
msg = "DataWriter could NOT be created";
proceed = false;
}
} else {
reportResultCode(result);
msg = "Default DataWriterQos could NOT be retrieved";
proceed = false;
}
} else {
msg = "Publisher could NOT be created";
proceed = false;
}
} else {
msg = "DataReader could NOT be created";
proceed = false;
}
} else {
msg = "Subscriber could NOT be created";
proceed = false;
}
} else {
msg = "Topic could NOT be created";
proceed = false;
}
} else {
msg = "Typesupport NOT loaded into DomainParticipant";
proceed = false;
}
}
}
if(proceed == true){
tfw.TestResult("Initialization OK", "Initialization OK", TestVerdict.Pass, TestVerdict.Pass);
tfw.TestFinish();
} else {
tfw.TestResult("Initialization OK", msg, TestVerdict.Pass, TestVerdict.Fail);
tfw.TestFinish();
}
/*- END OF INITIALIZATION --------------------------------------------------*/
}
// The RegisterType operation should be implemented in its type specific specialization.
public abstract ReturnCode RegisterType(
IDomainParticipant participant,
string typeName);
// TODO: This operation is currently not thread-safe.
public virtual ReturnCode RegisterType(
IDomainParticipant participant,
string typeName,
DatabaseMarshaler marshaler)
{
ReturnCode result = ReturnCode.BadParameter;
if (participant != null && marshaler != null)
{
// Now that a marshaler is present,
result = AttachMarshalerDelegates(GapiPeer, marshaler);
if (result == ReturnCode.Ok)
{
IntPtr domainObj = (participant as DomainParticipant).GapiPeer;
result = Gapi.FooTypeSupport.register_type(
GapiPeer,
domainObj,
typeName);
if (result == ReturnCode.Ok)
{
DatabaseMarshaler.Add(participant, dataType, marshaler);
marshaler.InitEmbeddedMarshalers(participant);
}
}
}
return result;
}
// The RegisterType operation should be implemented in its type specific specialization.
public abstract ReturnCode RegisterType(
IDomainParticipant participant,
string typeName);
public ReturnCode DeleteParticipant(IDomainParticipant a_participant)
{
ReturnCode result = ReturnCode.BadParameter;
DomainParticipant participant = a_participant as DomainParticipant;
if (participant != null)
{
result = OpenSplice.Gapi.DomainParticipantFactory.delete_participant(
GapiPeer,
participant.GapiPeer);
}
return result;
}
public IDomainParticipant CreateParticipant(
string domainId,
IDomainParticipantListener listener,
StatusKind mask)
{
IDomainParticipant participant = null;
if (listener != null)
{
OpenSplice.Gapi.gapi_domainParticipantListener gapiListener;
DomainParticipantListenerHelper listenerHelper = new DomainParticipantListenerHelper();
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
using (DomainParticipantListenerMarshaler listenerMarshaler =
new DomainParticipantListenerMarshaler(ref gapiListener))
{
// Invoke the corresponding gapi function.
IntPtr gapiParticipant = OpenSplice.Gapi.DomainParticipantFactory.create_participant(
GapiPeer,
domainId,
OpenSplice.Gapi.NativeConstants.GapiParticipantQosDefault,
listenerMarshaler.GapiPtr,
mask,
IntPtr.Zero,
IntPtr.Zero,
IntPtr.Zero);
if (gapiParticipant != IntPtr.Zero)
{
participant = new OpenSplice.DomainParticipant(gapiParticipant, listenerHelper);
}
}
}
else
{
// Invoke the corresponding gapi function.
IntPtr gapiParticipant = OpenSplice.Gapi.DomainParticipantFactory.create_participant(
GapiPeer,
domainId,
OpenSplice.Gapi.NativeConstants.GapiParticipantQosDefault,
IntPtr.Zero,
mask,
IntPtr.Zero,
IntPtr.Zero,
IntPtr.Zero);
if (gapiParticipant != IntPtr.Zero)
{
participant = new OpenSplice.DomainParticipant(gapiParticipant);
}
}
if (participant != null)
{
DomainParticipantFactoryQos dpfQos = null;
ReturnCode result = GetQos(ref dpfQos);
if (result == ReturnCode.Ok)
{
if (dpfQos.EntityFactory.AutoenableCreatedEntities)
{
participant.Enable();
}
}
}
return(participant);
}
public static DatabaseMarshaler GetMarshaler(
IDomainParticipant participant,
Type t)
{
DatabaseMarshaler marshaler;
// Check if a Marshaler for this type already exists, and if so return it.
typeMarshalers.TryGetValue(new KeyValuePair<IDomainParticipant, Type>(participant, t), out marshaler);
return marshaler;
}
static void Main(string[] args)
{
string partitionName = "ChatRoom";
int domain = DDS.DomainId.Default;
/* Options: MessageBoard [ownID] */
/* Messages having owner ownID will be ignored */
string[] parameterList = new string[1];
if (args.Length > 0)
{
parameterList[0] = args[0];
}
else
{
parameterList[0] = "0";
}
/* Create a DomainParticipantFactory and a DomainParticipant
* (using Default QoS settings. */
DomainParticipantFactory dpf = DomainParticipantFactory.Instance;
ErrorHandler.checkHandle(
dpf, "DDS.DomainParticipantFactory.Instance");
IDomainParticipant parentDP = dpf.CreateParticipant(
domain, null, StatusKind.Any);
ErrorHandler.checkHandle(
parentDP, "DDS.DomainParticipantFactory.CreateParticipant");
/* Register the required datatype for ChatMessage. */
ChatMessageTypeSupport chatMessageTS = new ChatMessageTypeSupport();
string chatMessageTypeName = chatMessageTS.TypeName;
ReturnCode status = chatMessageTS.RegisterType(parentDP, 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(parentDP, nameServiceTypeName);
ErrorHandler.checkStatus(
status, "Chat.NameServiceTypeSupport.RegisterType");
/* Register the required datatype for NamedMessage. */
NamedMessageTypeSupport namedMessageTS = new NamedMessageTypeSupport();
ErrorHandler.checkHandle(
namedMessageTS, "new NamedMessageTypeSupport");
string namedMessageTypeName = namedMessageTS.TypeName;
status = namedMessageTS.RegisterType(parentDP, namedMessageTypeName);
ErrorHandler.checkStatus(
status, "Chat.NamedMessageTypeSupport.RegisterType");
/* Narrow the normal participant to its extended representative */
ExtDomainParticipant participant = new ExtDomainParticipant(parentDP);
/* Initialise QoS variables */
TopicQos reliableTopicQos = new TopicQos();
TopicQos settingTopicQos = new TopicQos();
SubscriberQos subQos = new SubscriberQos();
/* Set the ReliabilityQosPolicy to RELIABLE. */
status = participant.GetDefaultTopicQos(ref reliableTopicQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.GetDefaultTopicQos");
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. */
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 (NameService)");
/* Create a multitopic that substitutes the userID
* with its corresponding userName. */
ITopic namedMessageTopic = participant.CreateSimulatedMultitopic(
"Chat_NamedMessage",
namedMessageTypeName,
"SELECT userID, name AS userName, index, content " +
"FROM Chat_NameService NATURAL JOIN Chat_ChatMessage " +
"WHERE userID <> %0",
parameterList);
ErrorHandler.checkHandle(
namedMessageTopic,
"ExtDomainParticipant.create_simulated_multitopic");
/* Adapt the default SubscriberQos to read from the "ChatRoom" Partition. */
status = participant.GetDefaultSubscriberQos(ref subQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.GetDefaultSubscriberQos");
subQos.Partition.Name = new string[1];
subQos.Partition.Name[0] = partitionName;
/* Create a Subscriber for the MessageBoard application. */
ISubscriber chatSubscriber = participant.CreateSubscriber(subQos);
ErrorHandler.checkHandle(
chatSubscriber, "DDS.DomainParticipant.CreateSubscriber");
/* Create a DataReader for the NamedMessage Topic
* (using the appropriate QoS). */
IDataReader parentReader = chatSubscriber.CreateDataReader(
namedMessageTopic);
ErrorHandler.checkHandle(
parentReader, "DDS.Subscriber.CreateDatareader");
NamedMessageDataReader chatAdmin = parentReader as NamedMessageDataReader;
/* Print a message that the MessageBoard has opened. */
System.Console.WriteLine(
"MessageBoard has opened: send a ChatMessage " +
"with userID = -1 to close it....\n");
bool terminated = false;
NamedMessage[] messages = null;;
SampleInfo[] infos = null;
while (!terminated)
{
/* Note: using read does not remove the samples from
* unregistered instances from the DataReader. This means
* that the DataRase would use more and more resources.
* That's why we use take here instead. */
status = chatAdmin.Take(
ref messages,
ref infos,
SampleStateKind.Any,
ViewStateKind.Any,
InstanceStateKind.Alive);
ErrorHandler.checkStatus(
status, "Chat.NamedMessageDataReader.take");
foreach (NamedMessage msg in messages)
{
if (msg.userID == TERMINATION_MESSAGE)
{
System.Console.WriteLine("Termination message received: exiting...");
terminated = true;
}
else
{
System.Console.WriteLine("{0}: {1}", msg.userName, msg.content);
}
}
status = chatAdmin.ReturnLoan(ref messages, ref infos);
ErrorHandler.checkStatus(status, "Chat.ChatMessageDataReader.ReturnLoan");
System.Threading.Thread.Sleep(100);
}
/* Remove the DataReader */
status = chatSubscriber.DeleteDataReader(chatAdmin);
ErrorHandler.checkStatus(
status, "DDS.Subscriber.DeleteDatareader");
/* Remove the Subscriber. */
status = participant.DeleteSubscriber(chatSubscriber);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.DeleteSubscriber");
/* Remove the Topics. */
status = participant.DeleteSimulatedMultitopic(namedMessageTopic);
ErrorHandler.checkStatus(
status, "DDS.ExtDomainParticipant.DeleteSimulatedMultitopic");
status = participant.DeleteTopic(nameServiceTopic);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.DeleteTopic (nameServiceTopic)");
status = participant.DeleteTopic(chatMessageTopic);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.DeleteTopic (chatMessageTopic)");
/* Remove the DomainParticipant. */
status = dpf.DeleteParticipant(parentDP);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipantFactory.DeleteParticipant");
}
public static ITransportSource GenerateTransportSource(this IDomainParticipant participant, string senderTopic, string receiverTopic)
{
return(new DomainParticipantTransportSource(participant, senderTopic, receiverTopic));
}
public override ReturnCode RegisterType(IDomainParticipant participant, string typeName)
{
return RegisterType(participant, typeName, new ByteDataMarshler());
}
public override void InitEmbeddedMarshalers(IDomainParticipant participant)
{
// NOP
}
public override void InitEmbeddedMarshalers(IDomainParticipant participant)
{
// NOP
}
/***
* Constructor
***/
public ExtDomainParticipant(IDomainParticipant aParticipant)
{
this.realParticipant = aParticipant;
}
public override ReturnCode RegisterType(IDomainParticipant participant, string typeName)
{
return(RegisterType(participant, typeName, new ByteDataMarshler()));
}
private void init()
{
tstTypeSupport typeSupport;
string errMsg = "Unknown error";
for ( int i = 0; i < MAX_INSTANCE; i++ ) {
testData[i] = new tst();
testData[i].long_1 = i;
testData[i].long_2 = 0;
testData[i].long_3 = 0;
}
initialiseInstanceData();
/**
* @addtogroup group_dds1290
*
* \b Test \b ID: \b saj_invalid_data_000
*
* \b Test \b Objectives:
*
* Create and initialise all required DDS entities
*
* \b Test \b Procedure:
*
* \e Action
*
* The following entities are obtained/created
* \arg \c DomainParticipantFactory
* \arg \c DomainParticipant with default QoS settings
* \arg \c Publisher with default QoS settings
* \arg \c Subscriber with default QoS settings
* \arg \c The mod::tst type is registered
* \arg \c A topic T1 of type tstModule::tst is created with default QoS settings
* \arg \c A DataWriter W for T1 with default QoS settings, writer_data_lifecycle.autodispose_unregistered_instances = FALSE
* \arg \c A DataReader for T1 with default QoS settings
*
* \e Result
* It is expected that all entities are created/initialized correctly and without any failures. \n
* If a failure occurs at any of the above stages, the test fails, this is reported and no further testing is performed
*/
/*- INITIALIZATION ---------------------------------------------------------*/
tfw.TestStart ("sacs_sampleInfo_000","SampleInfo","initialization");
tfw.TestTitle ("Test SampleInfo initialization.");
tfw.TestPurpose ("Test SampleInfo initialization.");
factory = DomainParticipantFactory.Instance;
if(factory == null){
errMsg = "DomainParticipantFactory could NOT be resolved";
proceed = false;
} else {
participant = factory.CreateParticipant(domainId);
if(participant == null){
errMsg = "DomainParticipant could NOT be created";
proceed = false;
} else {
typeSupport = new tstTypeSupport();
result = typeSupport.RegisterType(participant, "tst");
if(result == ReturnCode.Ok){
topic = participant.CreateTopic("my_topic", "tst");
if(topic != null){
subscriber = participant.CreateSubscriber();
if(subscriber != null){
subscriber.GetDefaultDataReaderQos(ref drQos);
if(drQos != null){
drQos.History.Kind = HistoryQosPolicyKind.KeepLastHistoryQos;
drQos.History.Depth = MAX_DEPTH;
reader = subscriber.CreateDataReader(topic, drQos) as tstDataReader;
if(reader != null){
publisher = participant.CreatePublisher();
if(publisher != null){
result = publisher.GetDefaultDataWriterQos(ref dwQos);
if(dwQos != null && result == ReturnCode.Ok){
dwQos.WriterDataLifecycle.AutodisposeUnregisteredInstances = false;
writer = publisher.CreateDataWriter(topic, dwQos) as tstDataWriter;
if(writer == null){
errMsg = "DataWriter could NOT be created";
proceed = false;
}
} else {
reportResultCode(result);
errMsg = "Default DataWriterQos could NOT be retrieved";
proceed = false;
}
} else {
errMsg = "Publisher could NOT be created";
proceed = false;
}
} else {
errMsg = "DataReader could NOT be created";
proceed = false;
}
} else {
errMsg = "Default DataReaderQos could not be resolved.";
proceed = false;
}
} else {
errMsg = "Subscriber could NOT be created";
proceed = false;
}
} else {
errMsg = "Topic could NOT be created";
proceed = false;
}
} else {
errMsg = "Typesupport NOT loaded into DomainParticipant";
proceed = false;
}
}
}
if(proceed == true){
tfw.TestResult("Initialization OK", "Initialization OK", TestVerdict.Pass, TestVerdict.Pass);
tfw.TestFinish();
} else {
tfw.TestResult("Initialization OK", errMsg, TestVerdict.Pass, TestVerdict.Fail);
tfw.TestFinish();
}
/*- END OF INITIALIZATION --------------------------------------------------*/
}
public override ReturnCode RegisterType(IDomainParticipant participant, string typeName)
{
return(clientTypeSupport.RegisterType(participant, typeName));
}
static void Main(string[] args)
{
int ownID = 1;
string chatterName = null;
int domain = DDS.DomainId.Default;
string partitionName = "ChatRoom";
/* Options: Chatter [ownID [name]] */
if (args.Length > 0)
{
ownID = int.Parse(args[0]);
if (args.Length > 1)
{
chatterName = args[1];
}
}
/* Create a DomainParticipantFactory and a DomainParticipant
* (using Default QoS settings. */
DomainParticipantFactory dpf = DomainParticipantFactory.Instance;
ErrorHandler.checkHandle(dpf, "DDS.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();
string nameServiceTypeName = nameServiceTS.TypeName;
status = nameServiceTS.RegisterType(
participant, nameServiceTypeName);
ErrorHandler.checkStatus(
status, "Chat.NameServiceTypeSupport.RegisterType");
/* Initialise Qos variables */
TopicQos reliableTopicQos = new TopicQos();
TopicQos settingTopicQos = new TopicQos();
PublisherQos pubQos = new PublisherQos();
DataWriterQos dwQos = new DataWriterQos();
DataWriterQos nsDwQos = new DataWriterQos();
/* Set the ReliabilityQosPolicy to RELIABLE. */
status = participant.GetDefaultTopicQos(ref reliableTopicQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.GetDefaultTopicQos");
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. */
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 (NameService)");
/* Adapt the default PublisherQos to write into the
* "ChatRoom" Partition. */
status = participant.GetDefaultPublisherQos(ref pubQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.GetDefaultPublisherQos");
pubQos.Partition.Name = new string[1];
pubQos.Partition.Name[0] = partitionName;
/* Create a Publisher for the chatter application. */
IPublisher chatPublisher = participant.CreatePublisher(pubQos);
ErrorHandler.checkHandle(
chatPublisher, "DDS.DomainParticipant.CreatePublisher");
/* Create a DataWriter for the ChatMessage Topic
* (using the appropriate QoS). */
chatPublisher.GetDefaultDataWriterQos(ref dwQos);
status = chatPublisher.CopyFromTopicQos(ref dwQos, reliableTopicQos);
ErrorHandler.checkStatus(status, "DDS.Publisher.CopyFromTopicQos");
IDataWriter parentWriter = chatPublisher.CreateDataWriter(chatMessageTopic, dwQos);
ErrorHandler.checkHandle(
parentWriter, "DDS.Publisher.CreateDatawriter (chatMessage)");
/* Narrow the abstract parent into its typed representative. */
ChatMessageDataWriter talker = parentWriter as ChatMessageDataWriter;
ErrorHandler.checkHandle(
talker, "Chat.ChatMessageDataWriter");
/* Create a DataWriter for the NameService Topic
* (using the appropriate QoS). */
status = chatPublisher.GetDefaultDataWriterQos(ref nsDwQos);
ErrorHandler.checkStatus(
status, "DDS.Publisher.GetDefaultDatawriterQos");
status = chatPublisher.CopyFromTopicQos(ref nsDwQos, settingTopicQos);
ErrorHandler.checkStatus(status, "DDS.Publisher.CopyFromTopicQos");
WriterDataLifecycleQosPolicy writerDataLifecycle = nsDwQos.WriterDataLifecycle;
writerDataLifecycle.AutodisposeUnregisteredInstances = false;
IDataWriter nsParentWriter = chatPublisher.CreateDataWriter(nameServiceTopic, nsDwQos);
ErrorHandler.checkHandle(
nsParentWriter, "DDS.Publisher.CreateDatawriter (NameService)");
/* Narrow the abstract parent into its typed representative. */
NameServiceDataWriter nameServer = nsParentWriter as NameServiceDataWriter;
ErrorHandler.checkHandle(
nameServer, "Chat.NameServiceDataWriterHelper");
/* Initialize the NameServer attributes. */
NameService ns = new NameService();
ns.userID = ownID;
if (chatterName != null)
{
ns.name = chatterName;
}
else
{
ns.name = "Chatter " + ownID;
}
/* Write the user-information into the system
* (registering the instance implicitly). */
status = nameServer.Write(ns);
ErrorHandler.checkStatus(status, "Chat.ChatMessageDataWriter.Write");
/* Initialize the chat messages. */
ChatMessage msg = new ChatMessage();
msg.userID = ownID;
msg.index = 0;
if (ownID == TERMINATION_MESSAGE)
{
msg.content = "Termination message.";
}
else
{
msg.content = "Hi there, I will send you " +
NUM_MSG + " more messages.";
}
System.Console.WriteLine("Writing message: \"" + msg.content + "\"");
/* Register a chat message for this user
* (pre-allocating resources for it!!) */
InstanceHandle userHandle = talker.RegisterInstance(msg);
/* Write a message using the pre-generated instance handle. */
status = talker.Write(msg, userHandle);
ErrorHandler.checkStatus(status, "Chat.ChatMessageDataWriter.Write");
Thread.Sleep(1000);
/* Write any number of messages . */
for (int i = 1; i <= NUM_MSG && ownID != TERMINATION_MESSAGE; i++)
{
msg.index = i;
msg.content = "Message no. " + i;
Console.WriteLine("Writing message: \"" + msg.content + "\"");
status = talker.Write(msg, userHandle);
ErrorHandler.checkStatus(status, "Chat.ChatMessageDataWriter.Write");
Thread.Sleep(1000); /* do not run so fast! */
}
/* Leave the room by disposing and unregistering the message instance */
status = talker.Dispose(msg, userHandle);
ErrorHandler.checkStatus(
status, "Chat.ChatMessageDataWriter.Dispose");
status = talker.UnregisterInstance(msg, userHandle);
ErrorHandler.checkStatus(
status, "Chat.ChatMessageDataWriter.unregister_instance");
/* Also unregister our name. */
status = nameServer.UnregisterInstance(ns, InstanceHandle.Nil);
ErrorHandler.checkStatus(
status, "Chat.NameServiceDataWriter.unregister_instance");
/* Remove the DataWriters */
status = chatPublisher.DeleteDataWriter(talker);
ErrorHandler.checkStatus(
status, "DDS.Publisher.DeleteDatawriter (talker)");
status = chatPublisher.DeleteDataWriter(nameServer);
ErrorHandler.checkStatus(status,
"DDS.Publisher.DeleteDatawriter (nameServer)");
/* Remove the Publisher. */
status = participant.DeletePublisher(chatPublisher);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.DeletePublisher");
/* Remove the Topics. */
status = participant.DeleteTopic(nameServiceTopic);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.DeleteTopic (nameServiceTopic)");
status = participant.DeleteTopic(chatMessageTopic);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.DeleteTopic (chatMessageTopic)");
/* Remove the DomainParticipant. */
status = dpf.DeleteParticipant(participant);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipantFactory.DeleteParticipant");
}
/***
* Constructor
***/
public ExtDomainParticipant(IDomainParticipant aParticipant)
{
this.realParticipant = aParticipant;
}
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();
}
public static void Add(
IDomainParticipant participant,
Type t,
DatabaseMarshaler marshaler)
{
DatabaseMarshaler tmp;
// Check if a Marshaler for this type already exists, and if not, add it.
if (!typeMarshalers.TryGetValue(new KeyValuePair<IDomainParticipant, Type>(participant, t), out tmp))
{
// Add the new marshaler to the list of known marshalers.
typeMarshalers.Add(new KeyValuePair<IDomainParticipant, Type>(participant, t), marshaler);
}
}
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 abstract void InitEmbeddedMarshalers(IDomainParticipant participant);
public override ReturnCode RegisterType(IDomainParticipant participant, string typeName)
{
return(RegisterType(participant, typeName, new FDMDATAMarshaler()));
}
