/// <summary>
/// This event handler is called by the native layer whenever the a recap is requested by the
/// native layer.
/// </summary>
/// <param name="nativeHandle">
/// The native handle for the subscription.
/// </param>
/// <param name="closure">
/// Native reference to the closure.
/// </param>
private static void onRecapRequest(IntPtr nativeHandle, IntPtr closure)
{
// Obtain the handle from the closure
GCHandle handle = (GCHandle)closure;
// Extract the impl from the handle
MamaSubscriptionImpl impl = (MamaSubscriptionImpl)handle.Target;
// Use the impl to invoke the callback
impl.InvokeRecapRequest();
}
/// <summary>
/// This event handler is called by the native layer whenever the quality of the data in the subscription
/// changes.
/// </summary>
/// <param name="nativeHandle">
/// The native handle to the subscription.
/// </param>
/// <param name="quality">
/// The current quality.
/// </param>
/// <param name="symbol">
/// The symbol being subscribed to.
/// </param>
/// <param name="cause">
/// The cause of the quality change.
/// </param>
/// <param name="platformInfo">
/// Platform specific information.
/// </param>
/// <param name="closure">
/// Native reference to the closure.
/// </param>
private static void OnQuality(IntPtr nativeHandle, int quality, string symbol, short cause, string platformInfo, IntPtr closure)
{
// Obtain the handle from the closure
GCHandle handle = (GCHandle)closure;
// Extract the impl from the handle
MamaSubscriptionImpl impl = (MamaSubscriptionImpl)handle.Target;
// Use the impl to invoke the callback
impl.InvokeQuality(quality, symbol);
}
/* ************************************************************** */
#region Internal Operations
/// <summary>
/// This function creates a new impl and returns an IntPtr that can then be passed to
/// the native layer.
/// </summary>
/// <param name="callback">
/// The user callback implementation, can be an instance of the MamaSubscriptionCallbackEx
/// interface to receive destroy notifications.
/// </param>
/// <param name="closure">
/// The closure supplied to the MamaSubscription.create function.
/// </param>
/// <param name="subscription">
/// The actual C# subscription object.
/// </param>
/// <returns>
/// The IntPtr that can then be used for the closure.
/// </returns>
internal static IntPtr Create(MamaSubscriptionCallback callback, object closure, MamaSubscription subscription)
{
// Allocate a new impl
MamaSubscriptionImpl impl = new MamaSubscriptionImpl(callback, closure, subscription);
// Create a GC handle
GCHandle handle = GCHandle.Alloc(impl);
// Return the native pointer
return((IntPtr)handle);
}
/* ************************************************************** */
#region Private Static Functions
/// <summary>
/// This event handler is called by the native layer whenever the subscription has been fully destroyed.
/// Note that clean up will only be performed if the subscription is about to be destroyed or deallocated,
/// this can be determined by using the getState function.
/// </summary>
/// <param name="subscription">
/// The native subscription.
/// </param>
/// <param name="closure">
/// The closure passed down to the native layer.
/// </param>
private static void onDestroy(IntPtr subscription, IntPtr closure)
{
// Obtain the handle from the closure
GCHandle handle = (GCHandle)closure;
/* If the target is a basic impl then createBasic has been invoked on this class instead of the base class,
* however as the MamaSubscriptionImpl is a derived class from MamaBasicSubscriptionImpl we must check for
* the derived class first.
*/
if (handle.Target is MamaSubscriptionImpl)
{
// Extract the impl from the handle
MamaSubscriptionImpl impl = (MamaSubscriptionImpl)handle.Target;
/* Get the state before the destroy is called, (in case the user recreates the subscription on
* the callback).
*/
mamaSubscriptionState state = impl.Subscription.State;
// Use the impl to invoke the destroy callback, (if this has been supplied)
impl.InvokeDestroy();
// If we are destroying rather than deactivating then delete the impl
if ((mamaSubscriptionState.MAMA_SUBSCRIPTION_DESTROYED == state) || (mamaSubscriptionState.MAMA_SUBSCRIPTION_DEALLOCATING == state))
{
/* The subscription has now been destroyed or deleted and the impl is no longer required, free the handle to
* allow the garbage collector to clean it up.
*/
handle.Free();
}
}
else if (handle.Target is MamaBasicSubscriptionImpl)
{
// Extract the impl from the handle
MamaBasicSubscriptionImpl impl = (MamaBasicSubscriptionImpl)handle.Target;
// Use the impl to invoke the destroy callback, (if this has been supplied)
impl.InvokeDestroy();
/* The timer has now been destroyed and the impl is no longer required, free the handle to
* allow the garbage collector to clean it up.
*/
handle.Free();
}
else
{
// Otherwise something has gone wrong
throw new InvalidOperationException();
}
}
/// <summary>
/// Set the parameters for a subscription that may be actually activated later.
/// Activate the subscription using MamaSubscription.activate().
/// </summary>
/// <param name="queue">
/// The mama queue.
/// </param>
/// <param name="callback">
/// The callback.
/// </param>
/// <param name="source">
/// The MamaSource identifying the publisher for this symbol.
/// </param>
/// <param name="symbol">
/// The symbol for the listener.
/// </param>
/// <param name="closure">
/// The caller supplied closure.
/// </param>
public void setup(MamaQueue queue, MamaSubscriptionCallback callback, MamaSource source, string symbol, object closure)
{
// Verify that the subscription has been created
EnsurePeerCreated();
// Save arguments in member variables
base.mClosure = closure;
base.mQueue = queue;
base.mTransport = source.transport;
// Create the impl
IntPtr impl = MamaSubscriptionImpl.Create(callback, closure, this);
// Call into the native layer to setup the subscription
CheckResultCode(SubscriptionNativeMethods.mamaSubscription_setup(
NativeHandle,
queue.NativeHandle,
ref MamaBasicSubscription.mCallbackDelegates,
source.NativeHandle,
symbol,
impl));
}
/* ************************************************************** */
#region Internal Operations
/// <summary>
/// This function creates a new impl and returns an IntPtr that can then be passed to
/// the native layer.
/// </summary>
/// <param name="callback">
/// The user callback implementation, can be an instance of the MamaSubscriptionCallbackEx
/// interface to receive destroy notifications.
/// </param>
/// <param name="closure">
/// The closure supplied to the MamaSubscription.create function.
/// </param>
/// <param name="subscription">
/// The actual C# subscription object.
/// </param>
/// <returns>
/// The IntPtr that can then be used for the closure.
/// </returns>
internal static IntPtr Create(MamaSubscriptionCallback callback, object closure, MamaSubscription subscription)
{
// Allocate a new impl
MamaSubscriptionImpl impl = new MamaSubscriptionImpl(callback, closure, subscription);
// Create a GC handle
GCHandle handle = GCHandle.Alloc(impl);
// Return the native pointer
return (IntPtr)handle;
}
