First attempt of using Swift. This is a port of an image cache utility that I wrote for one of my apps

MSImageCache.swift

//
//  MSImageCache.swift
//  Stasis
//
//  Created by Cory D. Wiles on 8/17/14.
//  Copyright (c) 2014 Macspots. All rights reserved.
//

import Foundation
import UIKit

enum MSImageCacheType: Int {
  case MSImageCacheTypeNone
  case MSImageCacheTypeDisk
  case MSImageCacheTypeMemory
}

// move to struct
// including the queue creation

let MSDiskOperationQueueName:String     = "com.macspots.fetchRequests.queue"
let MSDefaultImageCacheDirectory:String = "Macspots-Stasis-Images"
let MSSaveImageErrorDomain:String       = "com.macspots.image.save.error"
let MSImageCacheRequestQueue:String     = "com.macspots.image.request.queue"

typealias MSImageQueryCompletionBlock  = (image: UIImage?, cacheType:MSImageCacheType!) -> Void
typealias MSImageSavingCompletionBlock = (success: Bool!, error: NSError?) -> Void

class MSImageCache: NSObject {

// MARK: Public Properties

  var maxCacheSize: Int = 30 * 1024
  
  /**
   * You can't use enums so I'll have to use readonly constants
   */

  let MSImageCacheTypeNone: String   = "MSImageCacheTypeNone"
  let MSImageCacheTypeDisk: String   = "MSImageCacheTypeDisk"
  let MSImageCacheTypeMemory: String = "MSImageCacheTypeMemory"
  
// MARK: Private Properties

  private let memCache: NSCache                          = NSCache()
  private let fileManager: NSFileManager                 = NSFileManager()
  private let defaultImageRequestQueue: NSOperationQueue = NSOperationQueue()

  private var diskOperationDispatchQueue: dispatch_queue_t = 0
  private var cachePathName: String = ""

  private lazy var imageRequestOperations: Dictionary<String, NSOperation> = Dictionary<String, NSOperation>()

// MARK: Class setup
  
  override class func load() {
    
    let notificationCenter = NSNotificationCenter.defaultCenter()
    
    notificationCenter.addObserver(self, selector: "clearMemoryCache",
      name: UIApplicationDidReceiveMemoryWarningNotification, object: nil)
    
    notificationCenter.addObserver(self, selector: "clearDisk",
      name: UIApplicationWillTerminateNotification, object: nil)

    notificationCenter.addObserver(self, selector: "clearDiskCacheWithBackgroundTask",
      name: UIApplicationDidEnterBackgroundNotification, object: nil)
  }
  
  deinit {
    NSNotificationCenter.defaultCenter().removeObserver(self)
  }
  
  struct Static {
    static var token : dispatch_once_t = 0
    static var instance : MSImageCache?
  }
  
  class var sharedInstance: MSImageCache {
    
    dispatch_once(&Static.token) {
      Static.instance = MSImageCache()
    }
  
    return Static.instance!
  }
  
  init(imageCachePathName: String) {
  
    super.init();

    self.cachePathName = imageCachePathName;
    self.diskOperationDispatchQueue = dispatch_queue_create(MSDiskOperationQueueName, DISPATCH_QUEUE_CONCURRENT);
    
    self.memCache.name = imageCachePathName;
    self.defaultImageRequestQueue.name = MSImageCacheRequestQueue
    self.defaultImageRequestQueue.maxConcurrentOperationCount = NSOperationQueueDefaultMaxConcurrentOperationCount
  }
  
  convenience override init() {
    self.init(imageCachePathName: MSDefaultImageCacheDirectory);
  }
  
// MARK: Public Methods
  
  func storeImage(image: UIImage!, cacheKey: String!, completionBlock:((success: Bool!, error: NSError?) -> Void)?) -> Void{

    /**
     * UIImage / NSString don't "convert" bool for checking. Should this be done?
     * see https://medium.com/arthurs-coding-tips/optionals-in-swift-c94fd231e7a4
     */

    let imageCost:Int = Int(image.size.height * image.size.width * image.scale)
    
    self.memCache.setObject(image, forKey: cacheKey, cost: imageCost)
    
    /**
     * @note Need to make this queue a gloabl struct?
     */

    dispatch_async(self.diskOperationDispatchQueue, {
      
      var successfulProcessing: Bool = true

      if let data:NSData = UIImagePNGRepresentation(image) {
        
        let fileDoesExist: Bool = self.fileManager.fileExistsAtPath(self.diskCachePath())
        
        if (fileDoesExist) {
          
          var createCacheDirectoryError: NSError?
          var saveImageError: NSError?

          self.fileManager.createDirectoryAtPath(self.diskCachePath(), withIntermediateDirectories: true, attributes: nil, error: &createCacheDirectoryError)
          
          let filePath:String    = self.cachePathForKey(cacheKey, path: self.diskCachePath())
          let saveImageFile:Bool = self.fileManager.createFileAtPath(filePath, contents: data, attributes: nil)

          
          if ((completionBlock) != nil) {
          
            if ((createCacheDirectoryError) != nil) {
              
              successfulProcessing = false
              saveImageError       = createCacheDirectoryError

            } else if (!saveImageFile) {
              
              let userInfo: [String: String] = [NSLocalizedDescriptionKey : NSLocalizedString("Operation was unsuccessful.", comment: "NSLocalizedDescriptionKey"),
                                                NSLocalizedFailureReasonErrorKey : NSLocalizedString("The save image operation failed.", comment: "NSLocalizedFailureReasonErrorKey"),
                                                NSLocalizedRecoverySuggestionErrorKey : NSLocalizedString("Does the path exist?", comment: "NSLocalizedRecoverySuggestionErrorKey")]
              successfulProcessing = false
              saveImageError = NSError(domain: MSSaveImageErrorDomain, code: NSURLErrorCannotCreateFile, userInfo: userInfo)
            }
       
            completionBlock!(success: successfulProcessing, error: saveImageError)
          }
        }
      }
    })
  }
  
  func fetchImage(photo: Photo!, photoType:String!, completionBlock:((image: UIImage?) -> Void)?) {

    var cacheKey: String = ""

    /**
     * Because I'm capturing the value in the block there has to be an initalization
     * of the variable
     */
    
    var imageURL: NSURL = NSURL()

    if (photoType == "STSPhotoTypePreviewImage") {

      cacheKey = photo.previewImageUUID()
      imageURL = photo.previewImageSourceURL()
    }

    if (self.imageRequestOperations[cacheKey] != nil) {
      self.imageRequestOperations.removeValueForKey(cacheKey)
    }

    self.fetchImageFromCache(cacheKey, completionBlock: {returnedImage, cacheType in

      if let image: UIImage = returnedImage {

        if (completionBlock != nil) {

          dispatch_async(dispatch_get_main_queue(), {
            completionBlock!(image: image)
          })
        }

      } else {
        
        /**
         * Fetch remote image
         */

        let remoteImageRequestOperation: NSOperation = NSBlockOperation.init(block: {

          let imageData: NSData? = NSData(contentsOfURL: imageURL)
          
          if let remoteImageData: NSData = imageData {

            let imageFromData: UIImage? = UIImage(data: imageData!, scale: UIScreen.mainScreen().scale)
            
            if let image: UIImage = imageFromData {
              
              self.storeImage(image, cacheKey: cacheKey, completionBlock: {success, error in

                NSOperationQueue.mainQueue().addOperationWithBlock({
                  
                  if let finishedOperation: NSOperation = self.imageRequestOperations[cacheKey] {
                    
                    self.imageRequestOperations.removeValueForKey(cacheKey)
                    
                    if (completionBlock != nil) {
                      completionBlock!(image: image)
                    }
                  }
                })
              })
            }

          } else {

            NSOperationQueue.mainQueue().addOperationWithBlock({
              
              if let finishedOperation: NSOperation = self.imageRequestOperations[cacheKey] {
                
                self.imageRequestOperations.removeValueForKey(cacheKey)
                
                if (completionBlock != nil) {
                  completionBlock!(image: nil)
                }
              }
            })
          }
        })
        
        self.imageRequestOperations[cacheKey] = remoteImageRequestOperation
        self.defaultImageRequestQueue.addOperation(remoteImageRequestOperation)
      }
    })
  }
  
  func removeImageForKey(cacheKey: String?, completionBlock:((success: Bool!, error: NSError?) -> Void)?) -> Void {
  
    if let imageKey: String = cacheKey {
    
      self.memCache.removeObjectForKey(imageKey)
      
      if (self.isCacheRequestRunningForKey(imageKey)) {
     
        self.imageRequestOperations.removeValueForKey(imageKey)
        self.cancelImageRequestForKey(imageKey)
      }
      
      dispatch_async(self.diskOperationDispatchQueue, {
      
        let imagePath: String = self.cachePathForKey(imageKey, path: self.diskCachePath())
        var removeError: NSError?
        var didRemoveItem = self.fileManager.removeItemAtPath(imagePath, error: &removeError)
        
        if ((completionBlock) != nil) {
         
          dispatch_async(dispatch_get_main_queue(), {
            completionBlock!(success: didRemoveItem, error:  removeError)
          })
        }
      })
    }
  }
  
  func cancelImageRequestForKey(cacheKey: String?) -> Void {
    
    if let imageKey: String = cacheKey {
      
      let requestOperation: NSOperation = self.imageRequestOperations[imageKey] as NSOperation!
      
      requestOperation.cancel()
    }
  }
  
  func cancellAllImageCacheRequest() -> Void {
    self.defaultImageRequestQueue.cancelAllOperations()
  }
  
  // MARK: Private Methods
  
  private func diskCachePath() -> String {
    
    /**
    * @see http://stackoverflow.com/questions/24696044/nsfilemanager-fileexistsatpathisdirectory-and-swift
    */
    
    var isDir : ObjCBool = false
    let imageCacheDirectory = NSFileManager.cachesDir().stringByAppendingPathComponent(self.cachePathName)
    let cachePathExists: Bool = NSFileManager.defaultManager().fileExistsAtPath(imageCacheDirectory, isDirectory: &isDir)
    
    if (cachePathExists == false) {
      
      var createDirectoryError: NSError?
      NSFileManager.defaultManager().createDirectoryAtPath(imageCacheDirectory, withIntermediateDirectories: true, attributes: nil, error: &createDirectoryError)
      
      println("create directory error \(createDirectoryError)")
    }
    
    return imageCacheDirectory
  }
  
  private func cachePathForKey(keyPath: String, path: String) -> String {

    let uuid:NSUUID = NSUUID(UUIDString: keyPath)
    
    return path.stringByAppendingPathComponent(uuid.UUIDString)
  }

  private func imageFromMemoryCacheForKey(cacheKey: String) -> UIImage? {
    
    let image: UIImage? = self.memCache.objectForKey(cacheKey) as? UIImage
    
    return image
  }
  
  private func diskImageForKey(cacheKey: String) -> UIImage? {

    var dataForKey: (String) -> NSData? = { (cacheKey: String) -> NSData? in

      let imagePath: String = self.cachePathForKey(cacheKey, path: self.diskCachePath())
      let data: NSData = NSData(contentsOfFile: imagePath)
      
      return data
    }
    
    if let imageData: NSData = dataForKey(cacheKey) {
      
      let image: UIImage = UIImage(data: imageData, scale: UIScreen.mainScreen().scale)
      
      return image
    }
     
    return nil
  }

  private func isCacheRequestRunningForKey(cacheKey:String) -> Bool {
    
    if let requestOperation: NSOperation = self.imageRequestOperations[cacheKey] {
      
      return requestOperation.executing ? true : false
    }
    
    return false
  }
  
  private func clearDiskCacheWithCompletionBlock(completionBlock:Void -> Void?) -> Void {
    
    dispatch_async(self.diskOperationDispatchQueue, {
      
      self.fileManager.removeItemAtPath(self.diskCachePath(), error: nil)
      
      if let block: Void = completionBlock() {
        
        dispatch_async(dispatch_get_main_queue(), {
          completionBlock()!
        })
      }
    })
  }
  
  private func clearMemoryCache() -> Void {
    self.memCache.removeAllObjects()
  }

  private func clearDiskCacheWithBackgroundTask() -> Void {
    
    let application: UIApplication = UIApplication.sharedApplication()
    let taskID = self.beginBackgroundUpdateTask()
    
    self.clearDiskCacheWithCompletionBlock({
      self.endBackgroundUpdateTask(taskID)
    })
  }

  private func clearDisk() -> Void {
    self.clearDiskCacheWithCompletionBlock({Void in Void})
  }
  
  /**
   * Should this be in a private struct?
   * Seems weird to have it in the class
   */
  
  private func beginBackgroundUpdateTask() -> UIBackgroundTaskIdentifier {
    return UIApplication.sharedApplication().beginBackgroundTaskWithExpirationHandler({})
  }
  
  private func endBackgroundUpdateTask(taskID: UIBackgroundTaskIdentifier) {
    UIApplication.sharedApplication().endBackgroundTask(taskID)
  }
    
  private func fetchImageFromCache(imageKey: String!, completionBlock:((image: UIImage?, cacheType:String!) -> Void)?) -> Void {
    
    if ((completionBlock) == nil) {
      return
    }
    
   /**
    * If for some reason the request operation is still running then we don't
    * need to queue it again.
    */
    
    if (self.isCacheRequestRunningForKey(imageKey!)) {
      return
    }
    
   /**
    * Step 1: Is the image cached in memory
    */
    
    if let memoryCachedImage: UIImage = self.imageFromMemoryCacheForKey(imageKey) as UIImage! {

      dispatch_async(dispatch_get_main_queue(), {
        completionBlock!(image: memoryCachedImage, cacheType: self.MSImageCacheTypeNone)
      })

      return
    }
    
    /**
     * Step 2: Is the image on disk
     */
    
    let imageCacheRequestOperation: NSBlockOperation = NSBlockOperation(block: {
      
      let diskImage: UIImage? = self.diskImageForKey(imageKey!)
      
      if (diskImage != nil) {

        let imageCost: Int = Int(diskImage!.size.height) * Int(diskImage!.size.width) * Int(diskImage!.scale)
        self.memCache.setObject(diskImage!, forKey: imageKey!, cost: imageCost)
      }
      
      NSOperationQueue.mainQueue().addOperationWithBlock({

        if let finishedOperation: NSOperation = self.imageRequestOperations[imageKey!] {

          self.imageRequestOperations.removeValueForKey(imageKey!)
        }

        completionBlock!(image: diskImage, cacheType: self.MSImageCacheTypeDisk)
      })

    })
    
    self.imageRequestOperations[imageKey!] = imageCacheRequestOperation
    self.defaultImageRequestQueue.addOperation(imageCacheRequestOperation)
  }
}