     }
 }
 
-final private class CallbacksBlocksHolder<Value, Error: ErrorType>
-{
+final private class CallbacksBlocksHolder<Value, Error: ErrorType> {
+
     var progressCallback: AsyncProgressCallback?
     var stateCallback   : AsyncChangeStateCallback?
     var finishCallback  : AsyncTypes<Value, Error>.DidFinishAsyncCallback?
-    
+
     init(
         progressCallback: AsyncProgressCallback?,
         stateCallback   : AsyncChangeStateCallback?,
-        finishCallback  : AsyncTypes<Value, Error>.DidFinishAsyncCallback?)
-    {
+        finishCallback  : AsyncTypes<Value, Error>.DidFinishAsyncCallback?) {
+
         self.progressCallback = progressCallback
         self.stateCallback    = stateCallback
         self.finishCallback   = finishCallback
     }
-    
+
     func clearCallbacks() {
-        
+
         progressCallback = nil
         stateCallback    = nil
         finishCallback   = nil

        //so set loader again
        setAsyncLoader(loader)
    }
    
    //private def getObjectRelatedPropertyData: ObjectRelatedPropertyData[ValueT] = {
    func getObjectRelatedPropertyData() -> ObjectRelatedPropertyData<ValueT, ErrorT>
    {
        let resultOption = cacheObject!.delegatesByKey[uniqueKey]
        
        if let result = resultOption {
            return result
        }
        
        let result = ObjectRelatedPropertyData<ValueT, ErrorT>()
        cacheObject!.delegatesByKey[uniqueKey] = result
        return result
    }
    
    func copyDelegates() -> [CallbacksBlocksHolder<ValueT, ErrorT>] {
        return getObjectRelatedPropertyData().copyDelegates()
    }
    
    func eachDelegate(block: (obj: CallbacksBlocksHolder<ValueT, ErrorT>) -> ()) {
        return getObjectRelatedPropertyData().eachDelegate(block)
    }
    
    func hasDelegates() -> Bool {
        return getObjectRelatedPropertyData().hasDelegates()
    }
    
    func clearDelegates() {
        getObjectRelatedPropertyData().clearDelegates()
    }
    
    //func getDelegates: mutable.ArrayBuffer[CallbacksBlocksHolder[ValueT]] = {
    func addDelegate(delegate: CallbacksBlocksHolder<ValueT, ErrorT>) {
        getObjectRelatedPropertyData().addDelegate(delegate)
    }
    
    func removeDelegate(delegate: CallbacksBlocksHolder<ValueT, ErrorT>) {
        getObjectRelatedPropertyData().removeDelegate(delegate)
    }
    
    func getLoaderHandler() -> AsyncHandler? {
        return getObjectRelatedPropertyData().loaderHandler
    }
    
    func setLoaderHandler(handler: AsyncHandler?) {
        getObjectRelatedPropertyData().loaderHandler = handler
    }
    
    //def getAsyncLoader: Async[ValueT] =
    func getAsyncLoader() -> AsyncTypes<ValueT, ErrorT>.Async? {
        return getObjectRelatedPropertyData().asyncLoader
    }
    
    //def setAsyncLoader(loader: Async[ValueT])
    func setAsyncLoader(loader: AsyncTypes<ValueT, ErrorT>.Async?) {
        getObjectRelatedPropertyData().asyncLoader = loader
    }
    
    func getAsyncResult() -> AsyncResult<ValueT, ErrorT>? {
        return getterOption?()
    }
    
    func clear() {
        
        if cleared {
            return
        }
        
        cacheObject!.delegatesByKey.removeValueForKey(uniqueKey)
        
        setterOption = nil
        getterOption = nil
        cacheObject  = nil
        
        cleared = true
    }
}

            }
        }
    }

    private func performNativeLoader(
        propertyExtractor: PropertyExtractorType,
        callbacks: CallbacksBlocksHolder<Value, Error>) -> AsyncHandler {

        func progressCallback(progressInfo: AnyObject) {

            propertyExtractor.eachDelegate { delegate -> Void in
                delegate.progressCallback?(progressInfo: progressInfo)
            }
        }

        let doneCallback = doneCallbackBlock(propertyExtractor)

        func stateCallback(state: AsyncState) {

            propertyExtractor.eachDelegate { delegate -> Void in
                delegate.stateCallback?(state: state)
            }
        }

        let loader  = propertyExtractor.getAsyncLoader()
