     // Or you might want to delete all the data from your plist file
     
     /*
-    SwiftyPlistManager.shared.removeAllKeyValuePairs(fromPlistWithName: dataPlistName) { (err) in
-      if err == nil {
-        print("-------------> Successfully removed all Key-Value pairs from '\(dataPlistName).plist'")
-      }
-    }*/
+     SwiftyPlistManager.shared.removeAllKeyValuePairs(fromPlistWithName: dataPlistName) { (err) in
+     if err == nil {
+     print("-------------> Successfully removed all Key-Value pairs from '\(dataPlistName).plist'")
+     }
+     }*/
     
     // Of course, if this line is executed several times 'SwiftyPlistManager' realises that the plist
     // is empty and cancels the operation. Try it out.

    // fileUnavailable
    
    /*
    SwiftyPlistManager.shared.addNew(helloNewValue, key: newKey, toPlistWithName: nonExistentPlistName) { (err) in
      if err != nil {
        logSwiftyPlistManager(err)
      }
    }*/
    
    ////////////////////////////////////////////////////////////////////////////////////
    // fileAlreadyEmpty
    
    /*
    SwiftyPlistManager.shared.removeAllKeyValuePairs(fromPlistWithName: dataPlistName) { (err) in
      if err != nil {
        logSwiftyPlistManager(err)
      }
    }*/
    
    ////////////////////////////////////////////////////////////////////////////////////
    // keyValuePairAlreadyExists
    
    /*
    SwiftyPlistManager.shared.addNew(rebeloperValue, key: firstKey, toPlistWithName: dataPlistName) { (err) in
      if err != nil {
        logSwiftyPlistManager(err)
      } else {
        print("-------------> Value '\(rebeloperValue)' successfully added at Key '\(firstKey)' into '\(dataPlistName).plist'")
      }
    }
    
    SwiftyPlistManager.shared.addNew(rebeloperValue, key: firstKey, toPlistWithName: dataPlistName) { (err) in
      if err != nil {
        logSwiftyPlistManager(err)
      }
    }*/
    
    ////////////////////////////////////////////////////////////////////////////////////
    // keyValuePairDoesNotExist
    
    /*
    SwiftyPlistManager.shared.getValue(for: nonExistentKey, fromPlistWithName: dataPlistName) { (result, err) in
      if err != nil {
        logSwiftyPlistManager(err)
      }
    }*/
    
    ////////////////////////////////////////////////////////////////////////////////////
 
  }

  override func didReceiveMemoryWarning() {
    super.didReceiveMemoryWarning()
    // Dispose of any resources that can be recreated.
  }


}


    // value. Comment out the call below.
    
    /*
     SwiftyPlistManager.shared.getValue(for: newKey, fromPlistWithName: dataPlistName) { (result, err) in
     if err == nil {
     print("-------------> The Value for Key '\(newKey)' actually exists. It is: '\(result!)'")
     }
     }*/
    
    // Build & Run and take a look at the Log. Stop. Comment back the lines from above.
    // Note that the value you get back is an optional. Retrieveng it with the 'bang operator' (!) is quite risky
    // because you might get back nil and that would crash your app! My suggestion is to never ever use the
    // 'bang operator'. It's risky, crash-prone and shouts that you are a lazy, clueless (or both) developer.
    // There are better ways to write code. For a start let's add a default value.
    
    /*
     SwiftyPlistManager.shared.getValue(for: newKey, fromPlistWithName: dataPlistName) { (result, err) in
     if err == nil {
     print("-------------> The Value for Key '\(newKey)' actually exists. It is: '\(result ?? "No Value")'")
     }
     }*/
    
    
    // Build & Run and take a look at the Log. Stop. Comment back the lines from above.
    // At this point the optional value will default to the "No Value" Sting. I personally hate working with default
    // values because they might pop up and would ruin the user experience of any app. To enhance your code let's
    // unwrap the 'result' with a guard-let statement.
    
    /*
     SwiftyPlistManager.shared.getValue(for: newKey, fromPlistWithName: dataPlistName) { (result, err) in
     if err == nil {
     guard let result = result else {
     print("-------------> The Value for Key '\(newKey)' does not exists.")
     return
     }
     print("-------------> The Value for Key '\(newKey)' actually exists. It is: '\(result)'")
     }
     }*/
    
    // Or you can unwrap it with an if-let statement if you do not wish to return from the completion handler right away
    
    /*
     SwiftyPlistManager.shared.getValue(for: newKey, fromPlistWithName: dataPlistName) { (result, err) in
     if err == nil {
     
     if let result = result {
     print("-------------> The Value for Key '\(newKey)' actually exists. It is: '\(result)'")
     } else {
     print("-------------> The Value for Key '\(newKey)' does not exists.")
     }
     
     print("-------------> This line will be printed out regardless if the Value for Key '\(newKey)' exists or not.")
     
     }
     }*/
    
    // Congratulations! You have learned how and when to use (or not to use) the 'bang operator', 'guard-let statements'
    // and 'if-let' statements. You now have solid knowledge of how to deal with optionals.
    
    // Most of the times you want to cast your result into a constant right away and not wait for the
    // completion handler to finish. You can use the following call to do just that. For this example we'll
    // unwrap it with a guard-let statement.
    
    /*
     guard let fetchedValue = SwiftyPlistManager.shared.fetchValue(for: newKey, fromPlistWithName: dataPlistName) else { return }
     print("-------------> The Fetched Value for Key '\(newKey)' actually exists. It is: '\(fetchedValue)'")*/
    
    ////////////////////////////////////////////////////////////////////////////////////
    // Of course if you try to fetch a value with a non-existent key, 'SwiftyPlistManager' has your back.
    // It will show a WARNING in the log that the key does not exist AND it will not crash the app. Sweet!
    
    /*
     guard let nonExistentValue = SwiftyPlistManager.shared.fetchValue(for: nonExistentKey, fromPlistWithName: dataPlistName) else {
     print("-------------> The Value does not exist so going to return now!")
     return
     }
     print("-------------> This line will never be executed because the Key is: '\(nonExistentKey)' so the Value is '\(nonExistentValue)'")*/
    
    ////////////////////////////////////////////////////////////////////////////////////
    // Now let's take a look at some other awesome powers that come with SwiftyPlistManager.
    // You can add a new key-value pair like so:
    
    /*
     SwiftyPlistManager.shared.addNew(rebeloperValue, key: firstKey, toPlistWithName: dataPlistName) { (err) in
     if err == nil {
     print("-------------> Value '\(rebeloperValue)' successfully added at Key '\(firstKey)' into '\(dataPlistName).plist'")
     }
     }*/
    
    // Now Build & Run your project... Congratulations! You have just created and saved your first
    // key-value pair into your plist file. Stop the project from running.
    
    ////////////////////////////////////////////////////////////////////////////////////
    // Now add a next value with an Int
    
    /*
     SwiftyPlistManager.shared.addNew(intValue, key: secondKey, toPlistWithName: dataPlistName) { (err) in
     if err == nil {
     print("-------------> Value '\(intValue)' successfully added at Key '\(secondKey)' into '\(dataPlistName).plist'")
     }
     }*/
    
    // Build  & Run again. Take a look at your progress in the Log. Stop.
    
