mbrucedogs/mvm_core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'feature/kevin' into 'develop'

Browse Source 
Updated Swift Dictionary Extension

See merge request BPHV_MIPS/mvm_core!13
This commit is contained in:
Pfeil, Scott Robert 2019-05-13 10:56:35 -04:00
commit c5f1785923
1 changed files with 107 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

211
MVMCore/MVMCore/Categories/Dictionary+MFConvenience.swift
View File

@ -8,182 +8,185 @@
import Foundation
public extension Dictionary {
//-------------------------------------------------
// MARK:- Dictionary
//-------------------------------------------------
/// Returns a Dictionary using the specified chain. An empty dictionary is returned if a dictionary for the chain does not exist
func dictionaryWithChainOfKeysOrIndexes(_ keysOrIndexes: [Any]) -> [String : Any] {
func dictionaryWithChainOfKeysOrIndexes(_ keysOrIndexes: [Any]) -> [String: Any] {
guard let dictionary = optionalDictionaryWithChainOfKeysOrIndexes(keysOrIndexes) else {
return [:]
}
return dictionary
return optionalDictionaryWithChainOfKeysOrIndexes(keysOrIndexes) ?? [:]
}
/// Returns an optional Dictionary using the specified chain. Returns nil if a dictionary for the chain does not exist
func optionalDictionaryWithChainOfKeysOrIndexes (_ keysOrIndexes: [Any]) -> [String : Any]? {
func optionalDictionaryWithChainOfKeysOrIndexes(_ keysOrIndexes: [Any]) -> [String: Any]? {
return objectChainOfKeysOrIndexes(keysOrIndexes) as? [String: Any]
}
func optionalDictionaryForKey(_ key: String) -> [String : Any]? {
func optionalDictionaryForKey(_ key: String) -> [String: Any]? {
return objectChainOfKeysOrIndexes([key]) as? [String: Any]
guard let key = key as? Key, let dictionary = self[key] as? [String: Any] else { return nil }
return dictionary
}
/// Returns a String using the specified chain. An empty string is returned if a string for the chain does not exist
func stringWithChainOfKeysOrIndexes(_ keysOrIndexes:[Any]) -> String {
/// Returns a Dictionary after looking up the specified key. An empty dictionary is returned if a dictionary for the key does not exist
func dictionaryForKey(_ key: String) -> [String: Any] {
return optionalDictionaryForKey(key) ?? [:]
}
//-------------------------------------------------
// MARK:- String
//-------------------------------------------------
/// Returns a String after looking up the specified key. An empty string will be returned if a string for the key does not exist
func stringForkey(_ key: String) -> String {
return optionalStringForKey(key) ?? ""
}
/// Returns a String after looking up the specified key. Nil will be returned if a string for the key does not exist
func optionalStringForKey(_ key: String) -> String? {
guard let key = key as? Key, let string = self[key] as? String else { return nil }
guard let string = objectChainOfKeysOrIndexes(keysOrIndexes) as? String else {
return ""
}
return string
}
func stringOptionalWithChainOfKeysOrIndexes(_ keysOrIndexes:[Any]) -> String? {
/// Returns a String using the specified chain. An empty string is returned if a string for the chain does not exist
func stringWithChainOfKeysOrIndexes(_ keysOrIndexes: [Any]) -> String {
return objectChainOfKeysOrIndexes(keysOrIndexes) as? String ?? ""
}
func stringOptionalWithChainOfKeysOrIndexes(_ keysOrIndexes: [Any]) -> String? {
return objectChainOfKeysOrIndexes(keysOrIndexes) as? String
}
//-------------------------------------------------
// MARK:- Array
//-------------------------------------------------
/// Returns an Array after looking up the specified key. An empty array will be returned if an array for the key does not exist
func arrayForKey(_ key: String) -> [Any] {
return optionalArrayForKey(key) ?? []
}
func optionalArrayForKey(_ key: String) -> [Any]? {
guard let key = key as? Key, let array = self[key] as? [Any] else { return nil }
return array
}
/// Returns an Array using the specified chain. Returns an empty array if an array for the chain does not exist
func arrayForChainOfKeysOrIndexes(_ keysOrIndexes: [Any]) -> [Any] {
guard let array = objectChainOfKeysOrIndexes(keysOrIndexes) as? [Any] else {
return []
}
return array
return objectChainOfKeysOrIndexes(keysOrIndexes) as? [Any] ?? []
}
func optionalArrayForChainOfKeysOrIndexes(_ keysOrIndexes: [Any]) -> [Any]? {
return objectChainOfKeysOrIndexes(keysOrIndexes) as? [Any]
}
/// Returns a Dictionary after looking up the specified key. An empty dictionary is returned if a dictionary for the key does not exist
func dictionaryForKey(_ key : String) -> [String : Any] {
//-------------------------------------------------
// MARK:- Bool
//-------------------------------------------------
/// Return a Bool after looking up the specified key. This will return false if the key does not exist
func boolForKey(_ key: String) -> Bool {
return dictionaryWithChainOfKeysOrIndexes([key])
}
/// Returns a String after looking up the specified key. An empty string will be returned if a string for the key does not exist
func stringForkey(_ key: String) -> String {
return stringWithChainOfKeysOrIndexes([key])
}
/// Returns a String after looking up the specified key. Nil will be returned if a string for the key does not exist
func optionalStringForKey(_ key: String) -> String? {
return objectChainOfKeysOrIndexes([key]) as? String
}
/// Returns an Array after looking up the specified key. An empty array will be returned if an array for the key does not exist
func arrayForKey(_ key : String) -> [Any] {
return arrayForChainOfKeysOrIndexes([key])
}
func optionalArrayForKey(_ key : String) -> [Any]? {
guard let key = key as? Key else {
return nil
}
return self[key] as? [Any]
return optionalBoolForKey(key) ?? false
}
/// Return a Bool after looking up the specified key. This will return false if the key does not exist
func boolForKey(_ key : String) -> Bool {
func optionalBoolForKey(_ key: String) -> Bool? {
guard let bool = objectChainOfKeysOrIndexes([key]) as? Bool else {
return false
}
return bool
}
/// Return a Bool after looking up the specified key. This will return false if the key does not exist
func optionalBoolForKey(_ key : String) -> Bool? {
guard let key = key as? Key, let bool = self[key] as? Bool else { return nil }
guard let bool = objectChainOfKeysOrIndexes([key]) as? Bool else {
return nil
}
return bool
}
func lenientBoolForKey(_ key: String) -> Bool {
guard let key = key as? Key, let object = self[key] else {
return false
}
guard let key = key as? Key, let object = self[key] else { return false }
if let object = object as? NSNumber {
return object.boolValue
} else if let object = object as? NSString {
return object.boolValue
}
return false
}
func boolForChainOfKeysOrIndexes(_ keysOrIndexes:[Any])-> Bool {
guard let bool = objectChainOfKeysOrIndexes(keysOrIndexes) as? Bool else {
return false
}
return bool
func boolForChainOfKeysOrIndexes(_ keysOrIndexes: [Any]) -> Bool {
return objectChainOfKeysOrIndexes(keysOrIndexes) as? Bool ?? false
}
//-------------------------------------------------
// MARK:- Float
//-------------------------------------------------
/// Return a float from a string created by looking up the specified key. This will return 0.0 if the key does not exist
func floatForKey(_ key: String) -> Float {
guard let floatValue = objectChainOfKeysOrIndexes([key]) as? Float else {
return 0.0
}
guard let key = key as? Key, let float = self[key] as? Float else { return 0.0 }
return float
}
return floatValue
func floatFromStringForKey(_ key: String) -> Float {
return Float(stringForkey(key)) ?? 0.0
}
func optionalCGFloatForKey(_ key: String) -> CGFloat? {
guard let key = key as? Key else {
return nil
}
return self[key] as? CGFloat
guard let key = key as? Key, let float = self[key] as? CGFloat else { return nil }
return float
}
func floatFromStringForKey(_ key:String) -> Float {
//-------------------------------------------------
// MARK:- Int
//-------------------------------------------------
func int32ForKey(_ key: String) -> Int32 {
let stringValue = stringForkey(key)
guard let key = key as? Key, let integer = self[key] as? Int32 else { return 0 }
guard let floatValue = Float(stringValue) else {
return 0.0
}
return floatValue
return integer
}
//-------------------------------------------------
// MARK:- Drill-Down to Key or Index
//-------------------------------------------------
func int32ForKey(_ key:String) -> Int32 {
private func objectChainOfKeysOrIndexes(_ keysOrIndexes: [Any]) -> Any? {
guard let intValue = objectChainOfKeysOrIndexes([key]) as? Int32 else {
return 0
}
return intValue
}
private func objectChainOfKeysOrIndexes(_ keysOrIndexes:[Any]) -> Any? {
var previousObject : Any? = self
var previousObject: Any? = self
for keyOrIndex in keysOrIndexes {
if let nextDictionary = previousObject as? [String:Any],
if let nextDictionary = previousObject as? [String: Any],
let keyOrIndex = keyOrIndex as? String {
previousObject = nextDictionary[keyOrIndex]
continue
}
else if let nextArray = previousObject as? [Any],
} else if let nextArray = previousObject as? [Any],
let keyOrIndex = keyOrIndex as? Int {
previousObject = nextArray[keyOrIndex]
continue
}
else {
previousObject = nil
break
} else {
return nil
}
}