firebase log level

Pods/PromisesSwift/Sources/Promises/Promise+Wrap.swift

@@ -0,0 +1,163 @@
+// Copyright 2018 Google Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at:
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Dispatch
+
+/// Provides a convenient way to convert methods that use common callback patterns into `Promise`s.
+
+/// Creates a new promise to be resolved when completion handler gets invoked.
+/// - parameter work: A block to execute asynchronously to invoke some API that requires
+///                   a completion handler with no arguments.
+/// - returns: A new pending promise to be resolved with `nil` when completion handler finishes.
+public func wrap(
+  on queue: DispatchQueue = .promises,
+  _ work: @escaping (@escaping () -> Void) throws -> Void
+) -> Promise<Any?> {
+  return Promise<Any?>(on: queue) { fulfill, _ in
+    try work { fulfill(nil) }
+  }
+}
+
+/// Creates a new promise to be resolved when completion handler gets invoked.
+/// - parameter work: A block to execute asynchronously to invoke some API that requires
+///                   a completion handler with one argument of generic `Value` type.
+/// - returns: A new pending promise to be resolved with the value provided by completion handler
+///            when it finishes.
+public func wrap<Value>(
+  on queue: DispatchQueue = .promises,
+  _ work: @escaping (@escaping (Value) -> Void) throws -> Void
+) -> Promise<Value> {
+  return Promise<Value>(on: queue) { fulfill, _ in
+    try work { fulfill($0) }
+  }
+}
+
+/// Creates a new promise to be resolved when completion handler gets invoked.
+/// - parameter work: A block to execute asynchronously to invoke some API that requires
+///                   a completion handler with one argument of optional generic `Value` type.
+/// - returns: A new pending promise to be resolved with the value or error provided by completion
+///            handler when it finishes.
+public func wrap<Value>(
+  on queue: DispatchQueue = .promises,
+  _ work: @escaping (@escaping (Value?) -> Void) throws -> Void
+) -> Promise<Value?> {
+  return Promise<Value?>(on: queue) { fulfill, _ in
+    try work { fulfill($0) }
+  }
+}
+
+/// Creates a new promise to be resolved when completion handler gets invoked.
+/// - parameter work: A block to execute asynchronously to invoke some API that requires
+///                   a completion handler with two arguments: a generic of `Value` type and
+///                   an optional `Error`.
+/// - returns: A new pending promise to be resolved with the value or error provided by completion
+///            handler when it finishes.
+public func wrap<Value>(
+  on queue: DispatchQueue = .promises,
+  _ work: @escaping (@escaping (Value, Error?) -> Void) throws -> Void
+) -> Promise<Value> {
+  return Promise<Value>(on: queue) { fulfill, reject in
+    try work { value, error in
+      if let error = error {
+        reject(error)
+      } else {
+        fulfill(value)
+      }
+    }
+  }
+}
+
+/// Creates a new promise to be resolved when completion handler gets invoked.
+/// - parameter work: A block to execute asynchronously to invoke some API that requires
+///                   a completion handler with two arguments: an optional `Error` and a generic of
+///                   `Value` type.
+/// - returns: A new pending promise to be resolved with the error or value provided by completion
+///            handler when it finishes.
+public func wrap<Value>(
+  on queue: DispatchQueue = .promises,
+  _ work: @escaping (@escaping (Error?, Value) -> Void) throws -> Void
+) -> Promise<Value> {
+  return Promise<Value>(on: queue) { fulfill, reject in
+    try work { error, value in
+      if let error = error {
+        reject(error)
+      } else {
+        fulfill(value)
+      }
+    }
+  }
+}
+
+/// Creates a new promise to be resolved when completion handler gets invoked.
+/// - parameter work: A block to execute asynchronously to invoke some API that requires
+///                   a completion handler with two arguments: an optional generic of `Value` type
+///                   and an optional `Error`.
+/// - returns: A new pending promise to be resolved with the value or error provided by completion
+///            handler when it finishes.
+public func wrap<Value>(
+  on queue: DispatchQueue = .promises,
+  _ work: @escaping (@escaping (Value?, Error?) -> Void) throws -> Void
+) -> Promise<Value?> {
+  return Promise<Value?>(on: queue) { fulfill, reject in
+    try work { value, error in
+      if let error = error {
+        reject(error)
+      } else {
+        fulfill(value)
+      }
+    }
+  }
+}
+
+/// Creates a new promise to be resolved when completion handler gets invoked.
+/// - parameter work: A block to execute asynchronously to invoke some API that requires
+///                   a completion handler with two arguments: an optional `Error` and an optional
+///                   generic of `Value` type.
+/// - returns: A new pending promise to be resolved with the error or value provided by completion
+///            handler when it finishes.
+public func wrap<Value>(
+  on queue: DispatchQueue = .promises,
+  _ work: @escaping (@escaping (Error?, Value?) -> Void) throws -> Void
+) -> Promise<Value?> {
+  return Promise<Value?>(on: queue) { fulfill, reject in
+    try work { error, value in
+      if let error = error {
+        reject(error)
+      } else {
+        fulfill(value)
+      }
+    }
+  }
+}
+
+/// Creates a new promise to be resolved when completion handler gets invoked.
+/// - parameter work: A block to execute asynchronously to invoke some API that requires
+///                   a completion handler with three arguments: two optionals of `Any` type
+///                   and an optional `Error`.
+/// - returns: A new pending promise to be resolved with a tuple of optional values or an error
+///            provided by completion handler when it finishes.
+public func wrap<Value1, Value2>(
+  on queue: DispatchQueue = .promises,
+  _ work: @escaping (@escaping (Value1?, Value2?, Error?) -> Void) throws -> Void
+) -> Promise<(Value1?, Value2?)> {
+  return Promise<(Value1?, Value2?)>(on: queue) { fulfill, reject in
+    try work { value1, value2, error in
+      if let error = error {
+        reject(error)
+      } else {
+        fulfill((value1, value2))
+      }
+    }
+  }
+}