internal override ReturnCode wlReq_deinit()
{
ReturnCode result = DDS.ReturnCode.Ok;
if (writerList.Count == 0)
{
IPublisherListener pubListener = listener as IPublisherListener;
if (pubListener != null)
{
this.SetListener(pubListener, (DDS.StatusKind) 0);
}
this.DisableCallbacks();
result = base.wlReq_deinit();
if (result == DDS.ReturnCode.Ok)
{
this.participant = null;
}
}
else
{
result = DDS.ReturnCode.PreconditionNotMet;
ReportStack.Report(result, "Publisher " + this + " cannot be deleted since it still contains " +
writerList.Count + " DataWriters.");
}
return(result);
}
internal override void NotifyListener(Entity source, V_EVENT triggerMask, DDS.OpenSplice.Common.EntityStatus status)
{
IPublisherListener pubListener = listener as IPublisherListener;
if (pubListener != null)
{
DDS.OpenSplice.Common.WriterStatus writerStatus = status as DDS.OpenSplice.Common.WriterStatus;
if ((triggerMask & V_EVENT.LIVELINESS_LOST) == V_EVENT.LIVELINESS_LOST)
{
pubListener.OnLivelinessLost(source as IDataWriter, writerStatus.LivelinessLost);
}
if ((triggerMask & V_EVENT.OFFERED_DEADLINE_MISSED) == V_EVENT.OFFERED_DEADLINE_MISSED)
{
pubListener.OnOfferedDeadlineMissed(source as IDataWriter, writerStatus.DeadlineMissed);
}
if ((triggerMask & V_EVENT.OFFERED_INCOMPATIBLE_QOS) == V_EVENT.OFFERED_INCOMPATIBLE_QOS)
{
pubListener.OnOfferedIncompatibleQos(source as IDataWriter, writerStatus.IncompatibleQos);
}
if ((triggerMask & V_EVENT.PUBLICATION_MATCHED) == V_EVENT.PUBLICATION_MATCHED)
{
pubListener.OnPublicationMatched(source as IDataWriter, writerStatus.PublicationMatch);
}
}
}
public ReturnCode SetListener(IPublisherListener listener, StatusKind mask)
{
ReturnCode result = ReturnCode.Error;
if (listener != null)
{
Gapi.gapi_publisherDataWriterListener gapiListener;
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
lock (listener)
{
using (PublisherDataWriterListenerMarshaler marshaler =
new PublisherDataWriterListenerMarshaler(ref gapiListener))
{
result = Gapi.Publisher.set_listener(
GapiPeer,
marshaler.GapiPtr,
mask);
}
}
}
else
{
result = Gapi.Publisher.set_listener(
GapiPeer,
IntPtr.Zero,
mask);
}
return result;
}
public ReturnCode SetListener(IPublisherListener listener, StatusKind mask)
{
ReturnCode result = ReturnCode.Error;
if (listener != null)
{
Gapi.gapi_publisherDataWriterListener gapiListener;
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
lock (listener)
{
using (PublisherDataWriterListenerMarshaler marshaler =
new PublisherDataWriterListenerMarshaler(ref gapiListener))
{
result = Gapi.Publisher.set_listener(
GapiPeer,
marshaler.GapiPtr,
mask);
}
}
}
else
{
result = Gapi.Publisher.set_listener(
GapiPeer,
IntPtr.Zero,
mask);
}
return(result);
}
public IPublisher CreatePublisher(IPublisherListener listener, StatusKind mask)
{
IPublisher publisher = null;
if (listener != null)
{
// Note: we use the same gapi lister as the DataWriter since the
// publisher doesn't add anything unique
OpenSplice.Gapi.gapi_publisherDataWriterListener gapiListener;
PublisherDataWriterListenerHelper listenerHelper = new PublisherDataWriterListenerHelper();
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
using (PublisherDataWriterListenerMarshaler listenerMarshaler =
new PublisherDataWriterListenerMarshaler(ref gapiListener))
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_publisher(
GapiPeer,
Gapi.NativeConstants.GapiPublisherQosDefault,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
publisher = new Publisher(gapiPtr, listenerHelper);
}
}
}
else
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_publisher(
GapiPeer,
Gapi.NativeConstants.GapiPublisherQosDefault,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
publisher = new Publisher(gapiPtr);
}
}
if (publisher != null)
{
DomainParticipantQos dpQos = null;
ReturnCode result = GetQos(ref dpQos);
if (result == ReturnCode.Ok)
{
if (dpQos.EntityFactory.AutoenableCreatedEntities)
{
publisher.Enable();
}
}
}
return(publisher);
}
public ReturnCode SetListener(IPublisherListener listener, StatusKind mask)
{
ReturnCode result = DDS.ReturnCode.AlreadyDeleted;
ReportStack.Start();
lock (this)
{
if (this.rlReq_isAlive)
{
result = wlReq_SetListener(listener, mask);
}
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
public IPublisher CreatePublisher(PublisherQos qos, IPublisherListener listener, StatusKind mask)
{
return(realParticipant.CreatePublisher(qos, listener, mask));
}
public IPublisher CreatePublisher(PublisherQos qos, IPublisherListener listener, StatusKind mask)
{
return realParticipant.CreatePublisher(qos, listener, mask);
}
public IPublisher CreatePublisher(IPublisherListener listener, StatusKind mask)
{
return realParticipant.CreatePublisher(listener, mask);
}
/// <summary>
/// This operation creates a Publisher with the desired QosPolicy settings and if applicable,
/// attaches the optionally specified PublisherListener to it.
/// </summary>
/// <remarks>
/// This operation creates a Publisher with the desired QosPolicy settings and if
/// applicable, attaches the optionally specified PublisherListener to it. When the
/// PublisherListener is not applicable, the NULL pointer must be supplied instead.
/// To delete the Publisher the operation DeletePublisher or
/// DeleteContainedEntities must be used.
/// In case the specified QosPolicy settings are not consistent, no Publisher is
/// created and the NULL pointer is returned.
/// </remarks>
/// <param name="qos">A collection of QosPolicy settings for the new Publisher.
/// In case these settings are not self consistent, no Publisher is created.</param>
/// <param name="listener">The PublisherListener instance which will be attached to the new Publisher.
/// It is permitted to use null as the value of the listener: this behaves as a PublisherListener
/// whose operations perform no action.</param>
/// <param name="mask">A bit-mask in which each bit enables the invocation of the PublisherListener
/// for a certain status.</param>
/// <returns>The newly created Publisher. In case of an error, a null Publisher is returned.</returns>
public IPublisher CreatePublisher(PublisherQos qos, IPublisherListener listener, StatusKind mask)
{
IPublisher publisher = null;
using (OpenSplice.CustomMarshalers.PublisherQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.PublisherQosMarshaler())
{
// Note: we use the same gapi lister as the DataWriter since the
// publisher doesn't add anything unique
if (marshaler.CopyIn(qos) == ReturnCode.Ok)
{
if (listener != null)
{
Gapi.gapi_publisherDataWriterListener gapiListener;
PublisherDataWriterListenerHelper listenerHelper =
new PublisherDataWriterListenerHelper();
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
using (PublisherDataWriterListenerMarshaler listenerMarshaler =
new PublisherDataWriterListenerMarshaler(ref gapiListener))
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_publisher(
GapiPeer,
marshaler.GapiPtr,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
publisher = new Publisher(gapiPtr, listenerHelper);
}
}
}
else
{
// Invoke the corresponding gapi function.
IntPtr gapiPtr = Gapi.DomainParticipant.create_publisher(
GapiPeer,
marshaler.GapiPtr,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
publisher = new Publisher(gapiPtr);
}
}
}
}
if (publisher != null)
{
DomainParticipantQos dpQos = null;
ReturnCode result = GetQos(ref dpQos);
if (result == ReturnCode.Ok)
{
if (dpQos.EntityFactory.AutoenableCreatedEntities)
{
publisher.Enable();
}
}
}
return publisher;
}
public IPublisher CreatePublisher(IPublisherListener listener, StatusKind mask)
{
IPublisher publisher = null;
if (listener != null)
{
// Note: we use the same gapi lister as the DataWriter since the
// publisher doesn't add anything unique
OpenSplice.Gapi.gapi_publisherDataWriterListener gapiListener;
PublisherDataWriterListenerHelper listenerHelper = new PublisherDataWriterListenerHelper();
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
using (PublisherDataWriterListenerMarshaler listenerMarshaler =
new PublisherDataWriterListenerMarshaler(ref gapiListener))
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_publisher(
GapiPeer,
Gapi.NativeConstants.GapiPublisherQosDefault,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
publisher = new Publisher(gapiPtr, listenerHelper);
}
}
}
else
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_publisher(
GapiPeer,
Gapi.NativeConstants.GapiPublisherQosDefault,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
publisher = new Publisher(gapiPtr);
}
}
if (publisher != null)
{
DomainParticipantQos dpQos = null;
ReturnCode result = GetQos(ref dpQos);
if (result == ReturnCode.Ok)
{
if (dpQos.EntityFactory.AutoenableCreatedEntities)
{
publisher.Enable();
}
}
}
return publisher;
}
/// <summary>
/// This operation creates a Publisher with the desired QosPolicy settings and if applicable,
/// attaches the optionally specified PublisherListener to it.
/// </summary>
/// <remarks>
/// This operation creates a Publisher with the desired QosPolicy settings and if
/// applicable, attaches the optionally specified PublisherListener to it. When the
/// PublisherListener is not applicable, the NULL pointer must be supplied instead.
/// To delete the Publisher the operation DeletePublisher or
/// DeleteContainedEntities must be used.
/// In case the specified QosPolicy settings are not consistent, no Publisher is
/// created and the NULL pointer is returned.
/// </remarks>
/// <param name="qos">A collection of QosPolicy settings for the new Publisher.
/// In case these settings are not self consistent, no Publisher is created.</param>
/// <param name="listener">The PublisherListener instance which will be attached to the new Publisher.
/// It is permitted to use null as the value of the listener: this behaves as a PublisherListener
/// whose operations perform no action.</param>
/// <param name="mask">A bit-mask in which each bit enables the invocation of the PublisherListener
/// for a certain status.</param>
/// <returns>The newly created Publisher. In case of an error, a null Publisher is returned.</returns>
public IPublisher CreatePublisher(PublisherQos qos, IPublisherListener listener, StatusKind mask)
{
IPublisher publisher = null;
using (OpenSplice.CustomMarshalers.PublisherQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.PublisherQosMarshaler())
{
// Note: we use the same gapi lister as the DataWriter since the
// publisher doesn't add anything unique
if (marshaler.CopyIn(qos) == ReturnCode.Ok)
{
if (listener != null)
{
Gapi.gapi_publisherDataWriterListener gapiListener;
PublisherDataWriterListenerHelper listenerHelper =
new PublisherDataWriterListenerHelper();
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
using (PublisherDataWriterListenerMarshaler listenerMarshaler =
new PublisherDataWriterListenerMarshaler(ref gapiListener))
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_publisher(
GapiPeer,
marshaler.GapiPtr,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
publisher = new Publisher(gapiPtr, listenerHelper);
}
}
}
else
{
// Invoke the corresponding gapi function.
IntPtr gapiPtr = Gapi.DomainParticipant.create_publisher(
GapiPeer,
marshaler.GapiPtr,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
publisher = new Publisher(gapiPtr);
}
}
}
}
if (publisher != null)
{
DomainParticipantQos dpQos = null;
ReturnCode result = GetQos(ref dpQos);
if (result == ReturnCode.Ok)
{
if (dpQos.EntityFactory.AutoenableCreatedEntities)
{
publisher.Enable();
}
}
}
return(publisher);
}
