/// <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; }