public static extern IntPtr create_datawriter(
IntPtr _this,
IntPtr a_topic,
IntPtr qos,
IntPtr a_listener,
StatusKind mask
);
protected ReturnCode wlReq_SetListener(IListener aListener, StatusKind mask)
{
ReturnCode result = ReturnCode.Ok;
Debug.Assert(listenerDispatcher != null);
if (mask != 0 && aListener != null)
{
result = listenerDispatcher.Add(this, mask);
if (result == DDS.ReturnCode.Ok)
{
wait = true;
}
}
else
{
V_RESULT uResult = User.Entity.SetListener(
rlReq_UserPeer, IntPtr.Zero, IntPtr.Zero, 0);
result = uResultToReturnCode(uResult);
if (result == DDS.ReturnCode.Ok)
{
WaitListenerRemoved();
listenerDispatcher.Remove(this);
}
}
if (result == DDS.ReturnCode.Ok)
{
listener = aListener;
listenerMask = mask;
}
return(result);
}
public ReturnCode SetListener(ITopicListener listener, StatusKind mask)
{
ReturnCode result = ReturnCode.Error;
Gapi.gapi_topicListener gapiListener;
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
if (listener != null)
{
lock (listener)
{
using (TopicListenerMarshaler marshaler = new TopicListenerMarshaler(ref gapiListener))
{
result = Gapi.Topic.set_listener(
GapiPeer,
marshaler.GapiPtr,
mask);
}
}
}
else
{
result = Gapi.Topic.set_listener(
GapiPeer,
IntPtr.Zero,
mask);
}
return(result);
}
public ReturnCode SetListener(ITopicListener listener, StatusKind mask)
{
ReturnCode result = ReturnCode.Error;
Gapi.gapi_topicListener gapiListener;
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
if (listener != null)
{
lock (listener)
{
using (TopicListenerMarshaler marshaler = new TopicListenerMarshaler(ref gapiListener))
{
result = Gapi.Topic.set_listener(
GapiPeer,
marshaler.GapiPtr,
mask);
}
}
}
else
{
result = Gapi.Topic.set_listener(
GapiPeer,
IntPtr.Zero,
mask);
}
return result;
}
/// <summary>
/// Write a message on the status strip, with a given severity.
/// </summary>
/// <param name="message">Message to display.</param>
/// <param name="kind">Severity of message.</param>
public void Status(string message, StatusKind kind)
{
if (parentControl.InvokeRequired)
{
parentControl.Invoke(this.crossInvoke, new object[] { message, kind });
}
else
{
if (kind == StatusKind.Error)
{
this.label.BackColor = Color.Red;
}
else
{
this.label.BackColor = defaultStatusStripBackColor;
}
if (kind == StatusKind.LongOp)
{
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
}
else
{
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.Default;
}
this.label.Text = message;
this.parentControl.Refresh();
Console.WriteLine("{0}: {1}, {2}", DateTime.Now.ToString("hh:mm:ss.ff"), kind, message);
}
}
public static Image GetImage(StatusKind status)
{
switch (status)
{
case StatusKind.Added:
return(GetImage(StatusIcon.Added));
case StatusKind.Deleted:
return(GetImage(StatusIcon.Deleted));
case StatusKind.Modified:
case StatusKind.Replaced:
return(GetImage(StatusIcon.Modified));
case StatusKind.Normal:
return(GetImage(StatusIcon.OK));
case StatusKind.Conflicted:
case StatusKind.Obstructed:
return(GetImage(StatusIcon.Exclamation));
default:
return(null);
}
}
public override void Update()
{
if (timer > 0)
{
timer--;
return;
}
if (stock.stack > 0)
{
foreach (var container in ModContent.GetInstance <TransferAgent>().FindContainerAdjacent(Position.X, Position.Y))
{
container.InjectItem(stock);
if (stock.stack < 1)
{
Status = StatusKind.Success;
break;
}
}
if (stock.stack > 0)
{
timer = 60;
Status = StatusKind.MissingSpace;
}
if (Main.netMode == 2)
{
NetMessage.SendData(MessageID.TileEntitySharing, -1, -1, null, ID, Position.X, Position.Y);
}
}
}
public IDataReader CreateDataReader(
ITopicDescription topic,
IDataReaderListener listener,
StatusKind mask)
{
return(CreateDataReader(topic, defaultDataReaderQos, listener, mask));
}
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 FrmCustomers(Customers c, StatusKind sta)
{
InitializeComponent();
this.statusFrm = sta;
myCust = c;
FillFild(myCust);
}
public override void NetReceive(BinaryReader reader, bool lightReceive)
{
base.NetReceive(reader, lightReceive);
Status = (StatusKind)reader.ReadByte();
MissingItemType = reader.ReadInt32();
stock = reader.ReadItem(true);
}
public IDataWriter CreateDataWriter(
ITopic topic,
IDataWriterListener listener,
StatusKind mask)
{
return(CreateDataWriter(topic, defaultDataWriterQos, listener, mask));
}
/// <summary>
/// This operation creates a new IDomainParticipant which will join the domain
/// identified by domainId (or DDS.DomainId.Default), and attaches the specified
/// IDomainParticipantListener to it and uses the given communication StatusKind mask.
/// </summary>
/// <remarks>
/// It will use default DDS.DomainParticipantQos.
///
/// See
/// @ref DDS.DomainParticipantFactory.CreateParticipant(DomainId domainId, DomainParticipantQos qos, IDomainParticipantListener listener, StatusKind mask) "CreateParticipant"
/// for:<br>
/// - Identifying the Domain
/// - Communication Status
/// - Status Propagation
/// </remarks>
/// @param domainId The ID of the Domain to which the IDomainParticipant is joined.
/// This should be the ID as specified in the configuration file.
/// @param listener A IDomainParticipantListener instance which will be attached to
/// the new IDomainParticipant. It is permitted to use null as the
/// value of the listener: this behaves as a IDomainParticipantListener
/// whose operations perform no action.
/// @param mask A bit-mask in which each bit enables the invocation of the
/// IDomainParticipantListener for a certain status.
/// @return The newly created IDomainParticipant. In case of an error a null is returned.
public IDomainParticipant CreateParticipant(
DomainId domainId,
IDomainParticipantListener listener,
StatusKind mask)
{
return(CreateParticipant(domainId, defaultParticipantQos, listener, mask));
}
public Anomaly(Ichangable item, string message, string propertyInFailed, StatusKind status)
{
this.Item = item;
this.Message = message;
this.PropertyName = propertyInFailed;
this.Status = status;
}
public static extern IntPtr create_datawriter(
IntPtr _this,
IntPtr a_topic,
IntPtr qos,
IntPtr a_listener,
StatusKind mask
);
internal ReturnCode Add(Entity observable, StatusKind mask)
{
ReturnCode result = DDS.ReturnCode.Ok;
V_RESULT uResult;
uint vMask = vEventMarshaler.vEventMaskFromStatusMask(mask);
lock (this)
{
uResult = User.Entity.SetListener(
observable.rlReq_UserPeer, rlReq_UserPeer, IntPtr.Zero, vMask);
result = uResultToReturnCode(uResult);
if (result == DDS.ReturnCode.Ok)
{
if (!Observables.Contains(observable))
{
Observables.Add(observable);
}
Start();
/* result = Start();
* TODO: Restore original listener if thread fails to start.
* See cmn_listenerDispatcher_add for more information. */
}
}
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 ReturnCode SetListener(IDomainParticipantListener listener, StatusKind mask)
{
ReturnCode result = ReturnCode.Error;
if (listener != null)
{
Gapi.gapi_domainParticipantListener gapiListener;
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
lock (listener)
{
using (DomainParticipantListenerMarshaler marshaler = new DomainParticipantListenerMarshaler(ref gapiListener))
{
result = Gapi.DomainParticipant.set_listener(
GapiPeer,
marshaler.GapiPtr,
mask);
}
}
}
else
{
result = Gapi.DomainParticipant.set_listener(
GapiPeer,
IntPtr.Zero,
mask);
}
return(result);
}
static void Main(string[] args)
{
DDSEntityManager mgr = new DDSEntityManager("Listener");
ReturnCode status = ReturnCode.Error;
ListenerDataListener myListener;
String partitionName = "Listener Example";
int count = 0;
// create Domain Participant
mgr.createParticipant(partitionName);
// create Type
MsgTypeSupport msgTS = new MsgTypeSupport();
mgr.registerType(msgTS);
// create Topic
mgr.createTopic("ListenerData_Msg");
// create Subscriber
mgr.createSubscriber();
// create DataReader
mgr.createReader(false);
IDataReader dreader = mgr.getReader();
myListener = new ListenerDataListener();
myListener.MsgDR = dreader as MsgDataReader;
Console.WriteLine("=== [ListenerDataSubscriber] SetListener");
StatusKind kind = StatusKind.DataAvailable | StatusKind.RequestedDeadlineMissed;
status = myListener.MsgDR.SetListener(myListener, kind);
ErrorHandler.checkStatus(status, "DataReader.SetListener");
Console.WriteLine("=== [ListenerDataSubscriber] Ready...");
myListener.terminated = false;
WaitSet ws = new WaitSet();
ws.AttachCondition(myListener.guardCond);
ICondition[] cond = null;
while (!myListener.terminated && count < 1500)
{
Console.WriteLine("=== [SubscriberUsingListener] waiting waitset ...");
ws.Wait(ref cond, Duration.Infinite);
myListener.guardCond.SetTriggerValue(false);
++count;
}
Console.WriteLine("===[ListenerDataSubscriber] Market Closed.");
mgr.getSubscriber().DeleteDataReader(myListener.MsgDR);
mgr.deleteSubscriber();
mgr.deleteTopic();
mgr.deleteParticipant();
}
internal StatusMessage(StatusKind statusKind, string message, int progressValue, int progressMaximumValue, DateTime timeStamp)
{
_statusKind = statusKind;
_message = message;
_progressValue = progressValue;
_progressMaximumValue = progressMaximumValue;
_timeStamp = timeStamp;
}
/// <summary>
/// Display a status message.
/// </summary>
/// <param name="message">Message to display.</param>
/// <param name="statusKind">Message severity.</param>
public void Status(string message, StatusKind statusKind)
{
if (this.canceled || this.IsDisposed)
{
return;
}
this.status.Status(message, statusKind);
}
public static extern IntPtr create_topic(
IntPtr _this,
string topic_name,
string type_name,
IntPtr qos,
IntPtr a_listener,
StatusKind mask
);
public static extern IntPtr create_participant(
IntPtr _this,
string domainId,
IntPtr qos,
IntPtr a_listener,
StatusKind mask,
IntPtr thread_start_action,
IntPtr thread_stop_action,
IntPtr thread_action_arg);
public static extern IntPtr create_participant(
IntPtr _this,
string domainId,
IntPtr qos,
IntPtr a_listener,
StatusKind mask,
IntPtr thread_start_action,
IntPtr thread_stop_action,
IntPtr thread_action_arg);
internal StatusMessage
(StatusKind statusKind, string message, int progressValue, int progressMaximumValue, DateTime timeStamp)
{
_statusKind = statusKind;
_message = message;
_progressValue = progressValue;
_progressMaximumValue = progressMaximumValue;
_timeStamp = timeStamp;
}
/// <summary>
/// This operation creates a new IDomainParticipant which will join the domain
/// identified by domainId, with the desired DomainParticipantQos and attaches
/// the specified IDomainParticipantListener to it and uses the given communication
/// StatusKind mask.
/// </summary>
/// <remarks>
/// <i><b>Identifying the Domain</b></i><br>
/// The IDomainParticipant will attach to the Domain that is specified by the
/// domainId parameter. This parameter consists of an integer specified in the Id tag
/// in the configuration file. Note that to make multiple connections to a Domain (create
/// multiple Participants for the same Domain) within a single process, all of the
/// Participants must use the same identification (i.e. all use the same domain Id).
///
/// The constant DDS.DomainId.Default can be used for this parameter. If this is done
/// the value of Id tag from the configuration file specified by the environment variable
/// called OSPL_URI will be used.
///
/// It is recommended to use this domain Id in conjunction with the OSPL_URI
/// environment variable instead of hard-coding a domain Id into your application,
/// since this gives you much more flexibility in the deployment phase of your product.<br>
/// See also Section 1.3.2.1, The OSPL_URI environment variable, in the Deployment
/// Guide.
///
/// <i><b>Communication Status</b></i><br>
/// For each communication status, the StatusChangedFlag flag is initially set to
/// false. It becomes true whenever that communication status changes. For each
/// communication status activated in the mask , the associated
/// IDomainParticipantListener operation is invoked and the communication
/// status is reset to false , as the listener implicitly accesses the status which is passed
/// as a parameter to that operation. The fact that the status is reset prior to calling the
/// listener means that if the application calls the Get<status_name>Status from
/// inside the listener it will see the status already reset.
///
/// The following statuses are applicable to the IDomainParticipant
/// - DDS.StatusKind InconsistentTopic (propagated)
/// - DDS.StatusKind OfferedDeadlineMissed (propagated)
/// - DDS.StatusKind RequestedDeadlineMissed (propagated)
/// - DDS.StatusKind OfferedIncompatibleQos (propagated)
/// - DDS.StatusKind RequestedIncompatibleQos (propagated)
/// - DDS.StatusKind SampleLost (propagated)
/// - DDS.StatusKind SampleRejected (propagated)
/// - DDS.StatusKind DataOnReaders (propagated)
/// - DDS.StatusKind DataAvailable (propagated)
/// - DDS.StatusKind LivelinessLost (propagated)
/// - DDS.StatusKind LivelinessChanged (propagated)
/// - DDS.StatusKind PublicationMatched (propagated)
/// - DDS.StatusKind SubscriptionMatched (propagated)
///
/// Be aware that the PublicationMatched and SubscriptionMatched
/// statuses are not applicable when the infrastructure does not have the
/// information available to determine connectivity. This is the case when OpenSplice
/// is configured not to maintain discovery information in the Networking Service. (See
/// the description for the NetworkingService/Discovery/enabled property in
/// the Deployment Manual for more information about this subject.) In this case the
/// operation will return NULL.
///
/// Status bits are declared as a constant and can be used by the application in an OR
/// operation to create a tailored mask. The special constant 0 can
/// be used to indicate that the created entity should not respond to any of its available
/// statuses. The DDS will therefore attempt to propagate these statuses to its factory.
///
/// <i><b>Status Propagation</b></i><br>
/// The Data Distribution Service will trigger the most specific and relevant Listener.<br>
/// In other words, in case a communication status is also activated on the Listener of
/// a contained entity, the Listener on that contained entity is invoked instead of the
/// IDomainParticipantListener. This means that a status change on a contained
/// entity only invokes the IDomainParticipantListener if the contained entity
/// itself does not handle the trigger event generated by the status change.
///
/// The statuses DataOnReaders and DataAvailable are
/// “Read Communication Statuses” and are an exception to all other plain
/// communication statuses: they have no corresponding status structure that can be
/// obtained with a Get<status_name>Status operation and they are mutually
/// exclusive. When new information becomes available to a IDataReader, the Data
/// Distribution Service will first look in an attached and activated
/// ISubscriberListener or IDomainParticipantListener (in that order) for the
/// DataOnReaders. In case the DataOnReaders can not be
/// handled, the Data Distribution Service will look in an attached and activated
/// IDataReaderListener, ISubscriberListener or IDomainParticipantListener for
/// the DataAvailable (in that order).
/// </remarks>
/// @param domainId The ID of the Domain to which the IDomainParticipant is joined.
/// This should be the ID as specified in the configuration file.
/// @param qos a DomainParticipantQos for the new IDomainParticipant. When
/// this set of QosPolicy settings is inconsistent, no
/// IDomainParticipant is created.
/// @param listener A IDomainParticipantListener instance which will be attached to
/// the new IDomainParticipant. It is permitted to use null as the
/// value of the listener: this behaves as a IDomainParticipantListener
/// whose operations perform no action.
/// @param mask A bit-mask in which each bit enables the invocation of the
/// IDomainParticipantListener for a certain status.
/// @return The newly created IDomainParticipant. In case of an error a null is returned.
public IDomainParticipant CreateParticipant(
DomainId domainId,
DomainParticipantQos qos,
IDomainParticipantListener listener,
StatusKind mask)
{
DomainParticipant participant = null;
ReturnCode result;
ReportStack.Start();
result = QosManager.checkQos(qos);
if (result == DDS.ReturnCode.Ok)
{
if (domainId != DDS.DomainId.Invalid)
{
lock (singleton_lock)
{
participant = new OpenSplice.DomainParticipant();
result = participant.init(domainId, qos);
if (result == ReturnCode.Ok)
{
result = participant.SetListener(listener, mask);
}
else
{
participant = null;
}
if (result == ReturnCode.Ok)
{
participantList.Add(participant);
if (myQos.EntityFactory.AutoenableCreatedEntities)
{
result = participant.Enable();
}
}
}
}
else
{
ReportStack.Report(DDS.ReturnCode.BadParameter,
"DomainParticipant is using an invalid domain identifier (" + domainId + ").");
}
}
if (result != ReturnCode.Ok && participant != null)
{
// Ignore result because we prefer the original error.
DeleteParticipant(participant);
participant = null;
}
ReportStack.Flush(null, result != ReturnCode.Ok);
return(participant);
}
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 static bool IsInSourceControl(string fileName)
{
if (Commands.RegisterEventsCommand.CanBeVersionControlledFile(fileName))
{
StatusKind status = OverlayIconManager.GetStatus(fileName);
return(status != StatusKind.None && status != StatusKind.Unversioned && status != StatusKind.Ignored);
}
else
{
return(false);
}
}
public ISubscriber CreateSubscriber(ISubscriberListener listener, StatusKind mask)
{
ISubscriber subscriber = null;
if (listener != null)
{
OpenSplice.Gapi.gapi_subscriberListener gapiListener;
SubscriberListenerHelper listenerHelper = new SubscriberListenerHelper();
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
using (SubscriberListenerMarshaler listenerMarshaler =
new SubscriberListenerMarshaler(ref gapiListener))
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_subscriber(
GapiPeer,
Gapi.NativeConstants.GapiSubscriberQosDefault,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
subscriber = new Subscriber(gapiPtr, listenerHelper);
}
}
}
else
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_subscriber(
GapiPeer,
Gapi.NativeConstants.GapiSubscriberQosDefault,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
subscriber = new Subscriber(gapiPtr);
}
}
if (subscriber != null)
{
DomainParticipantQos dpQos = null;
ReturnCode result = GetQos(ref dpQos);
if (result == ReturnCode.Ok)
{
if (dpQos.EntityFactory.AutoenableCreatedEntities)
{
subscriber.Enable();
}
}
}
return(subscriber);
}
internal bool BeginOperation(StatusKind operationStatus, out Guid operationId, out CancellationToken cancelToken)
{
if (!BeginOperation(operationStatus, out operationId))
{
return(false);
}
CurrentOperationCancellationTokenSource = new CancellationTokenSource();
cancelToken = CurrentOperationCancellationTokenSource.Token;
_OngoingOperations[operationId].CancelTokenSource = CurrentOperationCancellationTokenSource;
return(true);
}
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);
}
/// <summary>
/// This operation returns the list of enabled communication statuses of the StatusCondition.
/// </summary>
/// <returns>StatusKind - a bit mask in which each bit shows which status is taken into account
/// for the StatusCondition</returns>
public StatusKind GetEnabledStatuses()
{
StatusKind mask = 0;
bool isAlive;
ReportStack.Start();
lock (this)
{
isAlive = this.rlReq_isAlive;
if (isAlive)
{
mask = enabledStatusMask;
}
}
ReportStack.Flush(this, !isAlive);
return(mask);
}
public static Image GetImage(StatusKind status)
{
switch (status) {
case StatusKind.Added:
return GetImage(StatusIcon.Added);
case StatusKind.Deleted:
return GetImage(StatusIcon.Deleted);
case StatusKind.Modified:
case StatusKind.Replaced:
return GetImage(StatusIcon.Modified);
case StatusKind.Normal:
return GetImage(StatusIcon.OK);
case StatusKind.Conflicted:
case StatusKind.Obstructed:
return GetImage(StatusIcon.Exclamation);
default:
return null;
}
}
public void ShowStatus(string msg, StatusKind kind)
{
switch (kind)
{
case StatusKind.Error:
lblStatusText.Foreground = new SolidColorBrush(Colors.OrangeRed);
break;
case StatusKind.Good:
lblStatusText.Foreground = new SolidColorBrush(Colors.LawnGreen);
break;
case StatusKind.Warning:
lblStatusText.Foreground = new SolidColorBrush(Colors.Yellow);
break;
}
lblStatusText.Text = msg;
((Storyboard)FindResource("animate")).Begin(theStatusBar);
}
internal bool BeginOperation(StatusKind operationKind, out Guid operationId)
{
operationId = Guid.Empty;
if (!IsReady)
{
SignalOperationInProgress();
return(false);
}
ErrorProvider.Instance.LogInfo("BeginOperation " + operationKind.ToString());
Status = operationKind;
operationId = Guid.NewGuid();
_OngoingOperations.Add(operationId, new OperationData {
Status = operationKind
});
return(true);
}
internal ReturnCode init(Entity entity)
{
ReturnCode result;
ReportStack.Start();
IntPtr userPtr = User.StatusCondition.New(entity.rlReq_UserPeer);
if (userPtr != IntPtr.Zero)
{
this.entity = entity;
enabledStatusMask = StatusKind.Any;
result = base.init(userPtr, false);
}
else
{
result = DDS.ReturnCode.Error;
ReportStack.Report(result, "Could not create StatusCondition.");
}
ReportStack.Flush(this, result != ReturnCode.Ok);
return(result);
}
/// <summary>
/// Write a message on the status strip, with a given severity.
/// </summary>
/// <param name="message">Message to display.</param>
/// <param name="kind">Severity of message.</param>
public void Status(string message, StatusKind kind)
{
if (parentControl.InvokeRequired)
{
parentControl.Invoke(this.crossInvoke, new object[] { message, kind });
}
else
{
if (kind == StatusKind.Error)
this.label.BackColor = Color.Red;
else
this.label.BackColor = defaultStatusStripBackColor;
if (kind == StatusKind.LongOp)
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
else
System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.Default;
this.label.Text = message;
this.parentControl.Refresh();
Console.WriteLine("{0}: {1}, {2}", DateTime.Now.ToString("hh:mm:ss.ff"), kind, message);
}
}
public ReturnCode SetListener(IDataWriterListener listener, StatusKind mask)
{
ReturnCode result = ReturnCode.Error;
if (listener != null)
{
Gapi.gapi_publisherDataWriterListener gapiListener;
if (listenerHelper == null)
{
// Since the real DataWriter is created from the TypeSupport,
// the listenerHelper is not "readonly"
listenerHelper = new PublisherDataWriterListenerHelper();
}
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
lock (listener)
{
using (PublisherDataWriterListenerMarshaler marshaler =
new PublisherDataWriterListenerMarshaler(ref gapiListener))
{
result = Gapi.DataWriter.set_listener(
GapiPeer,
marshaler.GapiPtr,
mask);
}
}
}
else
{
result = Gapi.DataWriter.set_listener(
GapiPeer,
IntPtr.Zero,
mask);
}
return result;
}
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>
/// Display the current status.
/// </summary>
/// <param name="msg">Message to display.</param>
/// <param name="kind">Kind of status message.</param>
public void Status(string msg, StatusKind kind)
{
this.status.Status(msg, kind);
}
internal StatusMessage(StatusKind statusKind, string message, DateTime timeStamp)
{
_statusKind = statusKind;
_message = message;
_timeStamp = timeStamp;
}
/// <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 ReturnCode SetListener(IDomainParticipantListener a_listener, StatusKind mask)
{
return realParticipant.SetListener(a_listener, mask);
}
public static extern IntPtr create_topic(
IntPtr _this,
string topic_name,
string type_name,
IntPtr qos,
IntPtr a_listener,
StatusKind mask
);
public IDataWriter CreateDataWriter(
ITopic topic,
IDataWriterListener listener,
StatusKind mask)
{
DataWriter dataWriter = null;
Topic topicObj = topic as Topic;
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.Publisher.create_datawriter(
GapiPeer,
topicObj.GapiPeer,
Gapi.NativeConstants.GapiDataWriterQosDefault,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
DDS.OpenSplice.DomainParticipant participantImpl;
participantImpl = topic.Participant as DDS.OpenSplice.DomainParticipant;
TypeSupportFactory tsFactory = participantImpl.GetTypeSupportFactory(topic.TypeName);
dataWriter = tsFactory.CreateDataWriter(gapiPtr);
dataWriter.SetListener(listenerHelper);
}
}
}
else
{
IntPtr gapiPtr = Gapi.Publisher.create_datawriter(
GapiPeer,
topicObj.GapiPeer,
Gapi.NativeConstants.GapiDataWriterQosDefault,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
DDS.OpenSplice.DomainParticipant participantImpl;
participantImpl = topic.Participant as DDS.OpenSplice.DomainParticipant;
TypeSupportFactory tsFactory = participantImpl.GetTypeSupportFactory(topic.TypeName);
dataWriter = tsFactory.CreateDataWriter(gapiPtr);
}
}
if (dataWriter != null)
{
PublisherQos pubQos = null;
ReturnCode result = GetQos(ref pubQos);
if (result == ReturnCode.Ok)
{
if (pubQos.EntityFactory.AutoenableCreatedEntities)
{
dataWriter.Enable();
}
}
}
return dataWriter;
}
public ReturnCode SetListener(IDomainParticipantListener listener, StatusKind mask)
{
ReturnCode result = ReturnCode.Error;
if (listener != null)
{
Gapi.gapi_domainParticipantListener gapiListener;
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
lock (listener)
{
using (DomainParticipantListenerMarshaler marshaler = new DomainParticipantListenerMarshaler(ref gapiListener))
{
result = Gapi.DomainParticipant.set_listener(
GapiPeer,
marshaler.GapiPtr,
mask);
}
}
}
else
{
result = Gapi.DomainParticipant.set_listener(
GapiPeer,
IntPtr.Zero,
mask);
}
return result;
}
public ITopic CreateTopic(
string topicName,
string typeName,
TopicQos qos,
ITopicListener listener,
StatusKind mask)
{
ITopic topic = null;
using (OpenSplice.CustomMarshalers.TopicQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.TopicQosMarshaler())
{
if (marshaler.CopyIn(qos) == ReturnCode.Ok)
{
if (listener != null)
{
OpenSplice.Gapi.gapi_topicListener gapiListener;
TopicListenerHelper listenerHelper = new TopicListenerHelper();
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
using (TopicListenerMarshaler listenerMarshaler =
new TopicListenerMarshaler(ref gapiListener))
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_topic(
GapiPeer,
topicName,
typeName,
marshaler.GapiPtr,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
topic = new Topic(gapiPtr, listenerHelper);
}
}
}
else
{
// Invoke the corresponding gapi function.
IntPtr gapiPtr = Gapi.DomainParticipant.create_topic(
GapiPeer,
topicName,
typeName,
marshaler.GapiPtr,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
topic = new Topic(gapiPtr);
}
}
}
}
if (topic != null)
{
DomainParticipantQos dpQos = null;
ReturnCode result = GetQos(ref dpQos);
if (result == ReturnCode.Ok)
{
if (dpQos.EntityFactory.AutoenableCreatedEntities)
{
topic.Enable();
}
}
}
return topic;
}
public ITopic CreateTopic(
string topicName,
string typeName,
ITopicListener listener,
StatusKind mask)
{
ITopic topic = null;
if (listener != null)
{
OpenSplice.Gapi.gapi_topicListener gapiListener;
TopicListenerHelper listenerHelper = new TopicListenerHelper();
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
using (TopicListenerMarshaler listenerMarshaler =
new TopicListenerMarshaler(ref gapiListener))
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_topic(
GapiPeer,
topicName,
typeName,
Gapi.NativeConstants.GapiTopicQosDefault,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
topic = new Topic(gapiPtr, listenerHelper);
}
}
}
else
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_topic(
GapiPeer,
topicName,
typeName,
Gapi.NativeConstants.GapiTopicQosDefault,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
topic = new Topic(gapiPtr);
}
}
if (topic != null)
{
DomainParticipantQos dpQos = null;
ReturnCode result = GetQos(ref dpQos);
if (result == ReturnCode.Ok)
{
if (dpQos.EntityFactory.AutoenableCreatedEntities)
{
topic.Enable();
}
}
}
return topic;
}
public ISubscriber CreateSubscriber(SubscriberQos qos, ISubscriberListener listener, StatusKind mask)
{
ISubscriber subscriber = null;
using (OpenSplice.CustomMarshalers.SubscriberQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.SubscriberQosMarshaler())
{
if (marshaler.CopyIn(qos) == ReturnCode.Ok)
{
if (listener != null)
{
OpenSplice.Gapi.gapi_subscriberListener gapiListener;
SubscriberListenerHelper listenerHelper = new SubscriberListenerHelper();
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
using (SubscriberListenerMarshaler listenerMarshaler =
new SubscriberListenerMarshaler(ref gapiListener))
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_subscriber(
GapiPeer,
marshaler.GapiPtr,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
subscriber = new Subscriber(gapiPtr, listenerHelper);
}
}
}
else
{
// Invoke the corresponding gapi function.
IntPtr gapiPtr = Gapi.DomainParticipant.create_subscriber(
GapiPeer,
marshaler.GapiPtr,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
subscriber = new Subscriber(gapiPtr);
}
}
}
}
if (subscriber != null)
{
DomainParticipantQos dpQos = null;
ReturnCode result = GetQos(ref dpQos);
if (result == ReturnCode.Ok)
{
if (dpQos.EntityFactory.AutoenableCreatedEntities)
{
subscriber.Enable();
}
}
}
return subscriber;
}
public ISubscriber CreateSubscriber(ISubscriberListener listener, StatusKind mask)
{
ISubscriber subscriber = null;
if (listener != null)
{
OpenSplice.Gapi.gapi_subscriberListener gapiListener;
SubscriberListenerHelper listenerHelper = new SubscriberListenerHelper();
listenerHelper.Listener = listener;
listenerHelper.CreateListener(out gapiListener);
using (SubscriberListenerMarshaler listenerMarshaler =
new SubscriberListenerMarshaler(ref gapiListener))
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_subscriber(
GapiPeer,
Gapi.NativeConstants.GapiSubscriberQosDefault,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
subscriber = new Subscriber(gapiPtr, listenerHelper);
}
}
}
else
{
IntPtr gapiPtr = Gapi.DomainParticipant.create_subscriber(
GapiPeer,
Gapi.NativeConstants.GapiSubscriberQosDefault,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
subscriber = new Subscriber(gapiPtr);
}
}
if (subscriber != null)
{
DomainParticipantQos dpQos = null;
ReturnCode result = GetQos(ref dpQos);
if (result == ReturnCode.Ok)
{
if (dpQos.EntityFactory.AutoenableCreatedEntities)
{
subscriber.Enable();
}
}
}
return subscriber;
}
public ISubscriber CreateSubscriber(SubscriberQos qos, ISubscriberListener listener, StatusKind mask)
{
return realParticipant.CreateSubscriber(qos, listener, mask);
}
public ITopic CreateTopic(string topicName, string typeName, TopicQos qos, ITopicListener listener, StatusKind mask)
{
return realParticipant.CreateTopic(topicName, typeName, qos, listener, mask);
}
public IDomainParticipant CreateParticipant(
DomainId domainId,
IDomainParticipantListener listener,
StatusKind mask)
{
IDomainParticipant participant = null;
string className = 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,
className);
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,
className);
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 StatusMessage(StatusKind statusKind, string message, int progressValue, int progressMaximumValue)
: this(statusKind, message, progressValue, progressMaximumValue, DateTime.Now)
{
}
public static extern IntPtr create_subscriber(
IntPtr _this,
IntPtr qos,
IntPtr a_listener,
StatusKind mask
);
public IDataWriter CreateDataWriter(
ITopic topic,
DataWriterQos qos,
IDataWriterListener listener,
StatusKind mask)
{
DataWriter dataWriter = null;
Topic topicObj = topic as Topic;
using (OpenSplice.CustomMarshalers.DataWriterQosMarshaler marshaler =
new OpenSplice.CustomMarshalers.DataWriterQosMarshaler())
{
if (marshaler.CopyIn(qos) == ReturnCode.Ok)
{
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.Publisher.create_datawriter(
GapiPeer,
topicObj.GapiPeer,
marshaler.GapiPtr,
listenerMarshaler.GapiPtr,
mask);
if (gapiPtr != IntPtr.Zero)
{
TypeSupport typeSupport = topic.Participant.GetTypeSupport(topic.TypeName)
as OpenSplice.TypeSupport;
dataWriter = typeSupport.CreateDataWriter(gapiPtr);
dataWriter.SetListener(listenerHelper);
}
}
}
else
{
// Invoke the corresponding gapi function.
IntPtr gapiPtr = Gapi.Publisher.create_datawriter(
GapiPeer,
topicObj.GapiPeer,
marshaler.GapiPtr,
IntPtr.Zero,
mask);
if (gapiPtr != IntPtr.Zero)
{
TypeSupport typeSupport = topic.Participant.GetTypeSupport(topic.TypeName)
as OpenSplice.TypeSupport;
dataWriter = typeSupport.CreateDataWriter(gapiPtr);
}
}
}
}
if (dataWriter != null)
{
PublisherQos pubQos = null;
ReturnCode result = GetQos(ref pubQos);
if (result == ReturnCode.Ok)
{
if (pubQos.EntityFactory.AutoenableCreatedEntities)
{
dataWriter.Enable();
}
}
}
return dataWriter;
}
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 static extern ReturnCode set_listener(
IntPtr _this,
IntPtr a_listener,
StatusKind mask
);
/// <summary>
/// Display a status message.
/// </summary>
/// <param name="message">Message to display.</param>
/// <param name="statusKind">Message severity.</param>
public void Status(string message, StatusKind statusKind)
{
this.status.Status(message, statusKind);
}
