                 canExecuteClosure = true
             } else {
                 let debounceInfo = DebounceInfo(key: key, threshold: threshold, atBegin: atBegin, closure: closure)
-                // TODO: use constant for "rateLimitInfo"
-                let timer = NSTimer.scheduledTimerWithTimeInterval(threshold, target: self, selector: #selector(RateLimit.throttleTimerFired2(_:)), userInfo: ["rateLimitInfo" : debounceInfo], repeats: false)
-                self.setRateLimitInfoForKey2(RateLimitInfo2(timer: timer, debounceInfo: debounceInfo), forKey: key)
+                let timer = NSTimer.scheduledTimerWithTimeInterval(threshold, target: self, selector: #selector(RateLimit.debounceTimerFired(_:)), userInfo: ["rateLimitInfo" : debounceInfo], repeats: false)
+                self.setDebounceInfoForKey(DebounceExecutionInfo(timer: timer, debounceInfo: debounceInfo), forKey: key)
             }
         }
         if canExecuteClosure {
             let debounceInfo = DebounceInfo(key: key, threshold: threshold, atBegin: atBegin, closure: closure)
-            // TODO: use constant for "rateLimitInfo"
-            let timer = NSTimer.scheduledTimerWithTimeInterval(threshold, target: self, selector: #selector(RateLimit.throttleTimerFired2(_:)), userInfo: ["rateLimitInfo" : debounceInfo], repeats: false)
-            self.setRateLimitInfoForKey2(RateLimitInfo2(timer: timer, debounceInfo: debounceInfo), forKey: key)
+            let timer = NSTimer.scheduledTimerWithTimeInterval(threshold, target: self, selector: #selector(RateLimit.debounceTimerFired(_:)), userInfo: ["rateLimitInfo" : debounceInfo], repeats: false)
+            self.setDebounceInfoForKey(DebounceExecutionInfo(timer: timer, debounceInfo: debounceInfo), forKey: key)
             closure()
         }
     }
 
-    // TODO: Rename method
-    @objc private static func throttleTimerFired2(timer: NSTimer)
-    {
-        // TODO: use constant for "rateLimitInfo"
+    @objc private static func debounceTimerFired(timer: NSTimer)
+    {
         if let userInfo = timer.userInfo as? [String : AnyObject], debounceInfo = userInfo["rateLimitInfo"] as? DebounceInfo where !debounceInfo.atBegin  {
             debounceInfo.closure()
         }
     }
 
+    /**
+     Reset rate limit information for both bouncing and throlling
+     */
     public static func resetAllRateLimit()
     {
-        dispatch_sync(debounceQueue) {
-            for key in self.rateLimitDictionary.keys {
-                if let rateLimitInfo = self.rateLimitDictionary[key], let timer = rateLimitInfo.timer where timer.valid {
+        dispatch_sync(queue) {
+            for key in self.throttleExecutionDictionary.keys {
+                if let rateLimitInfo = self.throttleExecutionDictionary[key], let timer = rateLimitInfo.timer where timer.valid {
                     timer.invalidate()
                 }
-                self.rateLimitDictionary[key] = nil
-            }
-            for key in self.rateLimitDictionary2.keys {
-                if let rateLimitInfo = self.rateLimitDictionary2[key], let timer = rateLimitInfo.timer where timer.valid {
+                self.throttleExecutionDictionary[key] = nil
+            }
+            for key in self.debounceExecutionDictionary.keys {
+                if let rateLimitInfo = self.debounceExecutionDictionary[key], let timer = rateLimitInfo.timer where timer.valid {
                     timer.invalidate()
                 }
-                self.rateLimitDictionary2[key] = nil
-            }
-        }
-    }
-
+                self.debounceExecutionDictionary[key] = nil
+            }
+        }
+    }
+
+    /**
+     Reset rate limit information for both bouncing and throlling for a specific key
+     */
     public static func resetRateLimitForKey(key: String)
     {
-        dispatch_sync(debounceQueue) {
-            if let rateLimitInfo = self.rateLimitDictionary[key], let timer = rateLimitInfo.timer where timer.valid {
+        dispatch_sync(queue) {
+            if let rateLimitInfo = self.throttleExecutionDictionary[key], let timer = rateLimitInfo.timer where timer.valid {
                 timer.invalidate()
             }
-            self.rateLimitDictionary[key] = nil
-            if let rateLimitInfo = self.rateLimitDictionary2[key], let timer = rateLimitInfo.timer where timer.valid {
+            self.throttleExecutionDictionary[key] = nil
+            if let rateLimitInfo = self.debounceExecutionDictionary[key], let timer = rateLimitInfo.timer where timer.valid {
                 timer.invalidate()
             }
-            self.rateLimitDictionary2[key] = nil
-        }
-    }
-
-    // TODO: merge rateLimitInfoForKey with rateLimitInfoForKey2
-    private static func rateLimitInfoForKey(key: String) -> RateLimitInfo?
-    {
-        var rateLimitInfo: RateLimitInfo?
-        dispatch_sync(debounceQueue) {
-            rateLimitInfo = self.rateLimitDictionary[key]
+            self.debounceExecutionDictionary[key] = nil
+        }
+    }
+
+    private static func throttleInfoForKey(key: String) -> ThrottleExecutionInfo?
+    {
+        var rateLimitInfo: ThrottleExecutionInfo?
+        dispatch_sync(queue) {
+            rateLimitInfo = self.throttleExecutionDictionary[key]
         }
         return rateLimitInfo
     }
 
-    // TODO: merge rateLimitInfoForKey with rateLimitInfoForKey2
-    private static func rateLimitInfoForKey2(key: String) -> RateLimitInfo2?
-    {
-        var rateLimitInfo: RateLimitInfo2?
-        dispatch_sync(debounceQueue) {
-            rateLimitInfo = self.rateLimitDictionary2[key]
+    private static func setThrottleInfoForKey(rateLimitInfo: ThrottleExecutionInfo, forKey key: String)
+    {
+        dispatch_sync(queue) {
+            self.throttleExecutionDictionary[key] = rateLimitInfo
+        }
+    }
+
+    private static func debounceInfoForKey(key: String) -> DebounceExecutionInfo?
+    {
+        var rateLimitInfo: DebounceExecutionInfo?
+        dispatch_sync(queue) {
+            rateLimitInfo = self.debounceExecutionDictionary[key]
         }
         return rateLimitInfo
     }
 
-    // TODO: merge setRateLimitInfoForKey with setRateLimitInfoForKey2
-    private static func setRateLimitInfoForKey(rateLimitInfo: RateLimitInfo, forKey key: String)
-    {
-        dispatch_sync(debounceQueue) {
-            self.rateLimitDictionary[key] = rateLimitInfo
-        }
-    }
-
-    // TODO: merge setRateLimitInfoForKey with setRateLimitInfoForKey2
-    private static func setRateLimitInfoForKey2(rateLimitInfo: RateLimitInfo2, forKey key: String)
-    {
-        dispatch_sync(debounceQueue) {
-            self.rateLimitDictionary2[key] = rateLimitInfo
-        }
-    }
-}
+    private static func setDebounceInfoForKey(rateLimitInfo: DebounceExecutionInfo, forKey key: String)
+    {
+        dispatch_sync(queue) {
+            self.debounceExecutionDictionary[key] = rateLimitInfo
+        }
+    }
+}

        self.threshold = threshold
        self.trailing = trailing
        self.closure = closure
        super.init()
    }
}

// TODO: Merge ThrottleInfo with DebounceInfo
class DebounceInfo: NSObject {
    let key: String
    let threshold: NSTimeInterval
    let atBegin: Bool


import Foundation

class ThrottleInfo {
    let key: String
    let threshold: NSTimeInterval
    let trailing: Bool
