Added alternate encode/decode functions that use [String:Any].

These just coerce the dictionaries at the moment, which isn't efficient. In theory we could have parallel implementations for both NSDictionary and Swift-dictionaries.

Sources/DictionaryCoding/DictionaryDecoder.swift

@@ -177,6 +177,7 @@ open class DictionaryDecoder {
     public init() {}
 
     // MARK: - Decoding Values
+
     /// Decodes a top-level value of the given type from the given Dictionary representation.
     ///
     /// - parameter type: The type of the value to decode.
@@ -192,6 +193,23 @@ open class DictionaryDecoder {
 
         return value
     }
+
+  /// Decodes a top-level value of the given type from the given Dictionary representation.
+  ///
+  /// - parameter type: The type of the value to decode.
+  /// - parameter data: The data to decode from.
+  /// - returns: A value of the requested type.
+  /// - throws: `DecodingError.dataCorrupted` if values requested from the payload are corrupted, or if the given data is not valid Dictionary.
+  /// - throws: An error if any value throws an error during decoding.
+  open func decode<T : Decodable>(_ type: T.Type, from dictionary: [String:Any]) throws -> T {
+    let decoder = _DictionaryDecoder(referencing: dictionary, options: self.options)
+    guard let value = try decoder.unbox(dictionary, as: type) else {
+      throw DecodingError.valueNotFound(type, DecodingError.Context(codingPath: [], debugDescription: "The given data did not contain a top-level value."))
+    }
+
+    return value
+  }
+
 }
 
 // MARK: - _DictionaryDecoder

Sources/DictionaryCoding/DictionaryEncoder.swift

@@ -213,6 +213,32 @@ open class DictionaryEncoder {
 
       return topLevel as! NSDictionary
     }
+
+  // MARK: - Encoding Values
+  /// Encodes the given top-level value and returns its Dictionary representation.
+  ///
+  /// - parameter value: The value to encode.
+  /// - returns: A new `Data` value containing the encoded Dictionary data.
+  /// - throws: `EncodingError.invalidValue` if a non-conforming floating-point value is encountered during encoding, and the encoding strategy is `.throw`.
+  /// - throws: An error if any value throws an error during encoding.
+  open func encode<T : Encodable>(_ value: T) throws -> [String:Any] {
+    let encoder = _DictionaryEncoder(options: self.options)
+
+    guard let topLevel = try encoder.box_(value) else {
+      throw EncodingError.invalidValue(value, EncodingError.Context(codingPath: [], debugDescription: "Top-level \(T.self) did not encode any values."))
+    }
+
+    if topLevel is NSNull {
+      throw EncodingError.invalidValue(value, EncodingError.Context(codingPath: [], debugDescription: "Top-level \(T.self) encoded as null Dictionary fragment."))
+    } else if topLevel is NSNumber {
+      throw EncodingError.invalidValue(value, EncodingError.Context(codingPath: [], debugDescription: "Top-level \(T.self) encoded as number Dictionary fragment."))
+    } else if topLevel is NSString {
+      throw EncodingError.invalidValue(value, EncodingError.Context(codingPath: [], debugDescription: "Top-level \(T.self) encoded as string Dictionary fragment."))
+    }
+
+    return topLevel as! [String:Any]
+  }
+
 }
 
 // MARK: - _DictionaryEncoder