             }
             
             // Convert from the unmanaged value
-            return Unmanaged<BindingContext>.fromOpaque(COpaquePointer(unmanagedContext)).takeUnretainedValue();
+            return Unmanaged<QueueBindingContext>.fromOpaque(COpaquePointer(unmanagedContext)).takeUnretainedValue();
+        }
+    }
+    
+    ///
+    /// Retrieves the binding context for the current queue (or nil if there isn't one)
+    ///
+    public static var current: BindingContext? {
+        get {
+            return currentStorage?.context;
         }
     }
     

        
        // Create a queue to use the context in
        let queue       = dispatch_queue_create("io.logicalshift.binding", nil);
        let retained    = Unmanaged<BindingContext>.passRetained(newContext).toOpaque();
        
        dispatch_queue_set_specific(queue, _contextSpecificName, UnsafeMutablePointer<Void>(retained), { context in
            // Release the context
            Unmanaged<BindingContext>.fromOpaque(COpaquePointer(context)).release();
        });
        
        return queue;

    /// it in effect
    ///
    public static func withNewContext(action: () -> ()) {
        if let existingStorage = BindingContext.currentStorage {
            // Generate a new context
            let oldContext  = existingStorage.context;
            let newContext  = BindingContext();
            
            // If there's an existing context, append the new context to it and perform the action rather than creating a whole new context
            // Creating new contexts is expensive
            existingStorage.context = newContext;
            action();
            existingStorage.context = oldContext;
        } else {
            // Create a queue to use the context in
            let queue = BindingContext.createQueueWithNewContext();
