Made ParseClient.ConvertTo() a public API.

richardjrossiii · richardjrossiii · commit 5f0c45a8641f · 2015-12-11T17:04:33.000-08:00
ConvertTo's functionality is useful for external developers if they ever have to deal with CloudCode, or coercing other types return from the SDK. Fixes #67.
diff --git a/Parse/Internal/Cloud/Controller/ParseCloudCodeController.cs b/Parse/Internal/Cloud/Controller/ParseCloudCodeController.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using Parse.Utilities;
 
 namespace Parse.Internal {
   internal class ParseCloudCodeController : IParseCloudCodeController {
@@ -27,7 +28,7 @@ public Task<T> CallFunctionAsync<T>(String name,
         if (!decoded.ContainsKey("result")) {
           return default(T);
         }
-        return (T)ParseClient.ConvertTo<T>(decoded["result"]);
+        return (T)Conversion.ConvertTo<T>(decoded["result"]);
       });
     }
   }
diff --git a/Parse/Internal/Encoding/ParseDecoder.cs b/Parse/Internal/Encoding/ParseDecoder.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Collections.Generic;
 using System.Globalization;
+using Parse.Utilities;
 
 namespace Parse.Internal {
   internal class ParseDecoder {
@@ -59,8 +60,8 @@ public object Decode(object data) {
         }
 
         if (typeString == "GeoPoint") {
-          return new ParseGeoPoint((double)ParseClient.ConvertTo<double>(dict["latitude"]),
-              (double)ParseClient.ConvertTo<double>(dict["longitude"]));
+          return new ParseGeoPoint((double)Conversion.ConvertTo<double>(dict["latitude"]),
+              (double)Conversion.ConvertTo<double>(dict["longitude"]));
         }
 
         if (typeString == "Object") {
diff --git a/Parse/Internal/Encoding/ParseEncoder.cs b/Parse/Internal/Encoding/ParseEncoder.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using Parse.Utilities;
 
 namespace Parse.Internal {
   /// <summary>
@@ -23,8 +24,8 @@ value is ParseGeoPoint ||
           value is ParseRelationBase ||
           value is DateTime ||
           value is byte[] ||
-          ParseClient.ConvertTo<IDictionary<string, object>>(value) is IDictionary<string, object> ||
-          ParseClient.ConvertTo<IList<object>>(value) is IList<object>;
+          Conversion.ConvertTo<IDictionary<string, object>>(value) is IDictionary<string, object> ||
+          Conversion.ConvertTo<IList<object>>(value) is IList<object>;
     }
 
     public object Encode(object value) {
@@ -55,7 +56,7 @@ public object Encode(object value) {
         return jsonConvertible.ToJSON();
       }
 
-      var dict = ParseClient.ConvertTo<IDictionary<string, object>>(value) as IDictionary<string, object>;
+      var dict = Conversion.ConvertTo<IDictionary<string, object>>(value) as IDictionary<string, object>;
       if (dict != null) {
         var json = new Dictionary<string, object>();
         foreach (var pair in dict) {
@@ -64,7 +65,7 @@ public object Encode(object value) {
         return json;
       }
 
-      var list = ParseClient.ConvertTo<IList<object>>(value) as IList<object>;
+      var list = Conversion.ConvertTo<IList<object>>(value) as IList<object>;
       if (list != null) {
         return EncodeList(list);
       }
diff --git a/Parse/Internal/Object/Controller/ParseObjectController.cs b/Parse/Internal/Object/Controller/ParseObjectController.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using Parse.Utilities;
 
 namespace Parse.Internal {
   internal class ParseObjectController : IParseObjectController {
@@ -163,7 +164,7 @@ private IList<Task<IDictionary<string, object>>> ExecuteBatchRequest(IList<Parse
           return;
         }
 
-        var resultsArray = ParseClient.As<IList<object>>(t.Result.Item2["results"]);
+        var resultsArray = Conversion.As<IList<object>>(t.Result.Item2["results"]);
         int resultLength = resultsArray.Count;
         if (resultLength != batchSize) {
           foreach (var tcs in tcss) {
diff --git a/Parse/Internal/Operation/ParseAddOperation.cs b/Parse/Internal/Operation/ParseAddOperation.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using Parse.Utilities;
 
 namespace Parse.Internal {
   class ParseAddOperation : IParseFieldOperation {
@@ -28,7 +29,7 @@ public IParseFieldOperation MergeWithPrevious(IParseFieldOperation previous) {
       }
       if (previous is ParseSetOperation) {
         var setOp = (ParseSetOperation)previous;
-        var oldList = (IList<object>)ParseClient.ConvertTo<IList<object>>(setOp.Value);
+        var oldList = (IList<object>)Conversion.ConvertTo<IList<object>>(setOp.Value);
         return new ParseSetOperation(oldList.Concat(objects).ToList());
       }
       if (previous is ParseAddOperation) {
@@ -41,7 +42,7 @@ public object Apply(object oldValue, string key) {
       if (oldValue == null) {
         return objects.ToList();
       }
-      var oldList = (IList<object>)ParseClient.ConvertTo<IList<object>>(oldValue);
+      var oldList = (IList<object>)Conversion.ConvertTo<IList<object>>(oldValue);
       return oldList.Concat(objects).ToList();
     }
 
diff --git a/Parse/Internal/Operation/ParseAddUniqueOperation.cs b/Parse/Internal/Operation/ParseAddUniqueOperation.cs
@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
+using Parse.Utilities;
 
 namespace Parse.Internal {
   class ParseAddUniqueOperation : IParseFieldOperation {
@@ -28,7 +29,7 @@ public IParseFieldOperation MergeWithPrevious(IParseFieldOperation previous) {
       }
       if (previous is ParseSetOperation) {
         var setOp = (ParseSetOperation)previous;
-        var oldList = (IList<object>)ParseClient.ConvertTo<IList<object>>(setOp.Value);
+        var oldList = (IList<object>)Conversion.ConvertTo<IList<object>>(setOp.Value);
         var result = this.Apply(oldList, null);
         return new ParseSetOperation(result);
       }
@@ -43,7 +44,7 @@ public object Apply(object oldValue, string key) {
       if (oldValue == null) {
         return objects.ToList();
       }
-      var newList = ((IList<object>)ParseClient.ConvertTo<IList<object>>(oldValue)).ToList();
+      var newList = ((IList<object>)Conversion.ConvertTo<IList<object>>(oldValue)).ToList();
       var comparer = ParseFieldOperations.ParseObjectComparer;
       foreach (var objToAdd in objects) {
         if (objToAdd is ParseObject) {
diff --git a/Parse/Internal/Operation/ParseRemoveOperation.cs b/Parse/Internal/Operation/ParseRemoveOperation.cs
@@ -5,6 +5,8 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 
+using Parse.Utilities;
+
 namespace Parse.Internal {
   class ParseRemoveOperation : IParseFieldOperation {
     private ReadOnlyCollection<object> objects;
@@ -28,7 +30,7 @@ public IParseFieldOperation MergeWithPrevious(IParseFieldOperation previous) {
       }
       if (previous is ParseSetOperation) {
         var setOp = (ParseSetOperation)previous;
-        var oldList = (IList<object>)ParseClient.ConvertTo<IList<object>>(setOp.Value);
+        var oldList = Conversion.As<IList<object>>(setOp.Value);
         return new ParseSetOperation(this.Apply(oldList, null));
       }
       if (previous is ParseRemoveOperation) {
@@ -42,7 +44,7 @@ public object Apply(object oldValue,string key) {
       if (oldValue == null) {
         return new List<object>();
       }
-      var oldList = (IList<object>)ParseClient.ConvertTo<IList<object>>(oldValue);
+      var oldList = Conversion.As<IList<object>>(oldValue);
       return oldList.Except(objects, ParseFieldOperations.ParseObjectComparer).ToList();
     }
 
diff --git a/Parse/Internal/Utilities/FlexibleDictionaryWrapper.cs b/Parse/Internal/Utilities/FlexibleDictionaryWrapper.cs
@@ -2,6 +2,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using Parse.Utilities;
 
 #if IOS
 using PreserveAttribute = Foundation.PreserveAttribute;
@@ -27,7 +28,7 @@ public FlexibleDictionaryWrapper(IDictionary<string, TIn> toWrap) {
     }
 
     public void Add(string key, TOut value) {
-      toWrap.Add(key, (TIn)ParseClient.ConvertTo<TIn>(value));
+      toWrap.Add(key, (TIn)Conversion.ConvertTo<TIn>(value));
     }
 
     public bool ContainsKey(string key) {
@@ -45,29 +46,29 @@ public bool Remove(string key) {
     public bool TryGetValue(string key, out TOut value) {
       TIn outValue;
       bool result = toWrap.TryGetValue(key, out outValue);
-      value = (TOut)ParseClient.ConvertTo<TOut>(outValue);
+      value = (TOut)Conversion.ConvertTo<TOut>(outValue);
       return result;
     }
 
     public ICollection<TOut> Values {
       get {
         return toWrap.Values
-            .Select(item => (TOut)ParseClient.ConvertTo<TOut>(item)).ToList();
+            .Select(item => (TOut)Conversion.ConvertTo<TOut>(item)).ToList();
       }
     }
 
     public TOut this[string key] {
       get {
-        return (TOut)ParseClient.ConvertTo<TOut>(toWrap[key]);
+        return (TOut)Conversion.ConvertTo<TOut>(toWrap[key]);
       }
       set {
-        toWrap[key] = (TIn)ParseClient.ConvertTo<TIn>(value);
+        toWrap[key] = (TIn)Conversion.ConvertTo<TIn>(value);
       }
     }
 
     public void Add(KeyValuePair<string, TOut> item) {
       toWrap.Add(new KeyValuePair<string, TIn>(item.Key,
-          (TIn)ParseClient.ConvertTo<TIn>(item.Value)));
+          (TIn)Conversion.ConvertTo<TIn>(item.Value)));
     }
 
     public void Clear() {
@@ -76,13 +77,13 @@ public void Clear() {
 
     public bool Contains(KeyValuePair<string, TOut> item) {
       return toWrap.Contains(new KeyValuePair<string, TIn>(item.Key,
-          (TIn)ParseClient.ConvertTo<TIn>(item.Value)));
+          (TIn)Conversion.ConvertTo<TIn>(item.Value)));
     }
 
     public void CopyTo(KeyValuePair<string, TOut>[] array, int arrayIndex) {
       var converted = from pair in toWrap
                       select new KeyValuePair<string, TOut>(pair.Key,
-                          (TOut)ParseClient.ConvertTo<TOut>(pair.Value));
+                          (TOut)Conversion.ConvertTo<TOut>(pair.Value));
       converted.ToList().CopyTo(array, arrayIndex);
     }
 
@@ -96,13 +97,13 @@ public bool IsReadOnly {
 
     public bool Remove(KeyValuePair<string, TOut> item) {
       return toWrap.Remove(new KeyValuePair<string, TIn>(item.Key,
-          (TIn)ParseClient.ConvertTo<TIn>(item.Value)));
+          (TIn)Conversion.ConvertTo<TIn>(item.Value)));
     }
 
     public IEnumerator<KeyValuePair<string, TOut>> GetEnumerator() {
       foreach (var pair in toWrap) {
         yield return new KeyValuePair<string, TOut>(pair.Key,
-            (TOut)ParseClient.ConvertTo<TOut>(pair.Value));
+            (TOut)Conversion.ConvertTo<TOut>(pair.Value));
       }
     }
 
diff --git a/Parse/Internal/Utilities/FlexibleListWrapper.cs b/Parse/Internal/Utilities/FlexibleListWrapper.cs
@@ -3,6 +3,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using Parse.Utilities;
 
 #if IOS
 using PreserveAttribute = Foundation.PreserveAttribute;
@@ -28,11 +29,11 @@ public FlexibleListWrapper(IList<TIn> toWrap) {
     }
 
     public int IndexOf(TOut item) {
-      return toWrap.IndexOf((TIn)ParseClient.ConvertTo<TIn>(item));
+      return toWrap.IndexOf((TIn)Conversion.ConvertTo<TIn>(item));
     }
 
     public void Insert(int index, TOut item) {
-      toWrap.Insert(index, (TIn)ParseClient.ConvertTo<TIn>(item));
+      toWrap.Insert(index, (TIn)Conversion.ConvertTo<TIn>(item));
     }
 
     public void RemoveAt(int index) {
@@ -41,27 +42,27 @@ public void RemoveAt(int index) {
 
     public TOut this[int index] {
       get {
-        return (TOut)ParseClient.ConvertTo<TOut>(toWrap[index]);
+        return (TOut)Conversion.ConvertTo<TOut>(toWrap[index]);
       }
       set {
-        toWrap[index] = (TIn)ParseClient.ConvertTo<TIn>(value);
+        toWrap[index] = (TIn)Conversion.ConvertTo<TIn>(value);
       }
     }
 
     public void Add(TOut item) {
-      toWrap.Add((TIn)ParseClient.ConvertTo<TIn>(item));
+      toWrap.Add((TIn)Conversion.ConvertTo<TIn>(item));
     }
 
     public void Clear() {
       toWrap.Clear();
     }
 
     public bool Contains(TOut item) {
-      return toWrap.Contains((TIn)ParseClient.ConvertTo<TIn>(item));
+      return toWrap.Contains((TIn)Conversion.ConvertTo<TIn>(item));
     }
 
     public void CopyTo(TOut[] array, int arrayIndex) {
-      toWrap.Select(item => (TOut)ParseClient.ConvertTo<TOut>(item))
+      toWrap.Select(item => (TOut)Conversion.ConvertTo<TOut>(item))
           .ToList().CopyTo(array, arrayIndex);
     }
 
@@ -74,12 +75,12 @@ public bool IsReadOnly {
     }
 
     public bool Remove(TOut item) {
-      return toWrap.Remove((TIn)ParseClient.ConvertTo<TIn>(item));
+      return toWrap.Remove((TIn)Conversion.ConvertTo<TIn>(item));
     }
 
     public IEnumerator<TOut> GetEnumerator() {
       foreach (var item in (IEnumerable)toWrap) {
-        yield return (TOut)ParseClient.ConvertTo<TOut>(item);
+        yield return (TOut)Conversion.ConvertTo<TOut>(item);
       }
     }
 
diff --git a/Parse/Public/ParseClient.cs b/Parse/Public/ParseClient.cs
diff --git a/Parse/Public/ParseConfig.cs b/Parse/Public/ParseConfig.cs
diff --git a/Parse/Public/ParseObject.cs b/Parse/Public/ParseObject.cs
diff --git a/Parse/Public/Utilities/Conversion.cs b/Parse/Public/Utilities/Conversion.cs

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.Collections.Generic;`
`5`	`5`	`using System.Threading;`
`6`	`6`	`using System.Threading.Tasks;`
	`7`	`+using Parse.Utilities;`
`7`	`8`
`8`	`9`	`namespace Parse.Internal {`
`9`	`10`	`internal class ParseCloudCodeController : IParseCloudCodeController {`
`@@ -27,7 +28,7 @@ public Task<T> CallFunctionAsync<T>(String name,`
`27`	`28`	`if (!decoded.ContainsKey("result")) {`
`28`	`29`	`return default(T);`
`29`	`30`	`}`
`30`		`- return (T)ParseClient.ConvertTo<T>(decoded["result"]);`
	`31`	`+ return (T)Conversion.ConvertTo<T>(decoded["result"]);`
`31`	`32`	`});`
`32`	`33`	`}`
`33`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.Collections.Generic;`
`5`	`5`	`using System.Collections.ObjectModel;`
`6`	`6`	`using System.Linq;`
	`7`	`+using Parse.Utilities;`
`7`	`8`
`8`	`9`	`namespace Parse.Internal {`
`9`	`10`	`class ParseAddOperation : IParseFieldOperation {`
`@@ -28,7 +29,7 @@ public IParseFieldOperation MergeWithPrevious(IParseFieldOperation previous) {`
`28`	`29`	`}`
`29`	`30`	`if (previous is ParseSetOperation) {`
`30`	`31`	`var setOp = (ParseSetOperation)previous;`
`31`		`- var oldList = (IList<object>)ParseClient.ConvertTo<IList<object>>(setOp.Value);`
	`32`	`+ var oldList = (IList<object>)Conversion.ConvertTo<IList<object>>(setOp.Value);`
`32`	`33`	`return new ParseSetOperation(oldList.Concat(objects).ToList());`
`33`	`34`	`}`
`34`	`35`	`if (previous is ParseAddOperation) {`
`@@ -41,7 +42,7 @@ public object Apply(object oldValue, string key) {`
`41`	`42`	`if (oldValue == null) {`
`42`	`43`	`return objects.ToList();`
`43`	`44`	`}`
`44`		`- var oldList = (IList<object>)ParseClient.ConvertTo<IList<object>>(oldValue);`
	`45`	`+ var oldList = (IList<object>)Conversion.ConvertTo<IList<object>>(oldValue);`
`45`	`46`	`return oldList.Concat(objects).ToList();`
`46`	`47`	`}`
`47`	`48`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,8 @@`
`5`	`5`	`using System.Collections.ObjectModel;`
`6`	`6`	`using System.Linq;`
`7`	`7`
	`8`	`+using Parse.Utilities;`
	`9`	`+`
`8`	`10`	`namespace Parse.Internal {`
`9`	`11`	`class ParseRemoveOperation : IParseFieldOperation {`
`10`	`12`	`private ReadOnlyCollection<object> objects;`
`@@ -28,7 +30,7 @@ public IParseFieldOperation MergeWithPrevious(IParseFieldOperation previous) {`
`28`	`30`	`}`
`29`	`31`	`if (previous is ParseSetOperation) {`
`30`	`32`	`var setOp = (ParseSetOperation)previous;`
`31`		`- var oldList = (IList<object>)ParseClient.ConvertTo<IList<object>>(setOp.Value);`
	`33`	`+ var oldList = Conversion.As<IList<object>>(setOp.Value);`
`32`	`34`	`return new ParseSetOperation(this.Apply(oldList, null));`
`33`	`35`	`}`
`34`	`36`	`if (previous is ParseRemoveOperation) {`
`@@ -42,7 +44,7 @@ public object Apply(object oldValue,string key) {`
`42`	`44`	`if (oldValue == null) {`
`43`	`45`	`return new List<object>();`
`44`	`46`	`}`
`45`		`- var oldList = (IList<object>)ParseClient.ConvertTo<IList<object>>(oldValue);`
	`47`	`+ var oldList = Conversion.As<IList<object>>(oldValue);`
`46`	`48`	`return oldList.Except(objects, ParseFieldOperations.ParseObjectComparer).ToList();`
`47`	`49`	`}`
`48`	`50`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using System.Linq;`
	`5`	`+using Parse.Utilities;`
`5`	`6`
`6`	`7`	`#if IOS`
`7`	`8`	`using PreserveAttribute = Foundation.PreserveAttribute;`
`@@ -27,7 +28,7 @@ public FlexibleDictionaryWrapper(IDictionary<string, TIn> toWrap) {`
`27`	`28`	`}`
`28`	`29`
`29`	`30`	`public void Add(string key, TOut value) {`
`30`		`- toWrap.Add(key, (TIn)ParseClient.ConvertTo<TIn>(value));`
	`31`	`+ toWrap.Add(key, (TIn)Conversion.ConvertTo<TIn>(value));`
`31`	`32`	`}`
`32`	`33`
`33`	`34`	`public bool ContainsKey(string key) {`
`@@ -45,29 +46,29 @@ public bool Remove(string key) {`
`45`	`46`	`public bool TryGetValue(string key, out TOut value) {`
`46`	`47`	`TIn outValue;`
`47`	`48`	`bool result = toWrap.TryGetValue(key, out outValue);`
`48`		`- value = (TOut)ParseClient.ConvertTo<TOut>(outValue);`
	`49`	`+ value = (TOut)Conversion.ConvertTo<TOut>(outValue);`
`49`	`50`	`return result;`
`50`	`51`	`}`
`51`	`52`
`52`	`53`	`public ICollection<TOut> Values {`
`53`	`54`	`get {`
`54`	`55`	`return toWrap.Values`
`55`		`- .Select(item => (TOut)ParseClient.ConvertTo<TOut>(item)).ToList();`
	`56`	`+ .Select(item => (TOut)Conversion.ConvertTo<TOut>(item)).ToList();`
`56`	`57`	`}`
`57`	`58`	`}`
`58`	`59`
`59`	`60`	`public TOut this[string key] {`
`60`	`61`	`get {`
`61`		`- return (TOut)ParseClient.ConvertTo<TOut>(toWrap[key]);`
	`62`	`+ return (TOut)Conversion.ConvertTo<TOut>(toWrap[key]);`
`62`	`63`	`}`
`63`	`64`	`set {`
`64`		`- toWrap[key] = (TIn)ParseClient.ConvertTo<TIn>(value);`
	`65`	`+ toWrap[key] = (TIn)Conversion.ConvertTo<TIn>(value);`
`65`	`66`	`}`
`66`	`67`	`}`
`67`	`68`
`68`	`69`	`public void Add(KeyValuePair<string, TOut> item) {`
`69`	`70`	`toWrap.Add(new KeyValuePair<string, TIn>(item.Key,`
`70`		`- (TIn)ParseClient.ConvertTo<TIn>(item.Value)));`
	`71`	`+ (TIn)Conversion.ConvertTo<TIn>(item.Value)));`
`71`	`72`	`}`
`72`	`73`
`73`	`74`	`public void Clear() {`
`@@ -76,13 +77,13 @@ public void Clear() {`
`76`	`77`
`77`	`78`	`public bool Contains(KeyValuePair<string, TOut> item) {`
`78`	`79`	`return toWrap.Contains(new KeyValuePair<string, TIn>(item.Key,`
`79`		`- (TIn)ParseClient.ConvertTo<TIn>(item.Value)));`
	`80`	`+ (TIn)Conversion.ConvertTo<TIn>(item.Value)));`
`80`	`81`	`}`
`81`	`82`
`82`	`83`	`public void CopyTo(KeyValuePair<string, TOut>[] array, int arrayIndex) {`
`83`	`84`	`var converted = from pair in toWrap`
`84`	`85`	`select new KeyValuePair<string, TOut>(pair.Key,`
`85`		`- (TOut)ParseClient.ConvertTo<TOut>(pair.Value));`
	`86`	`+ (TOut)Conversion.ConvertTo<TOut>(pair.Value));`
`86`	`87`	`converted.ToList().CopyTo(array, arrayIndex);`
`87`	`88`	`}`
`88`	`89`
`@@ -96,13 +97,13 @@ public bool IsReadOnly {`
`96`	`97`
`97`	`98`	`public bool Remove(KeyValuePair<string, TOut> item) {`
`98`	`99`	`return toWrap.Remove(new KeyValuePair<string, TIn>(item.Key,`
`99`		`- (TIn)ParseClient.ConvertTo<TIn>(item.Value)));`
	`100`	`+ (TIn)Conversion.ConvertTo<TIn>(item.Value)));`
`100`	`101`	`}`
`101`	`102`
`102`	`103`	`public IEnumerator<KeyValuePair<string, TOut>> GetEnumerator() {`
`103`	`104`	`foreach (var pair in toWrap) {`
`104`	`105`	`yield return new KeyValuePair<string, TOut>(pair.Key,`
`105`		`- (TOut)ParseClient.ConvertTo<TOut>(pair.Value));`
	`106`	`+ (TOut)Conversion.ConvertTo<TOut>(pair.Value));`
`106`	`107`	`}`
`107`	`108`	`}`
`108`	`109`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using System.Collections;`
`4`	`4`	`using System.Collections.Generic;`
`5`	`5`	`using System.Linq;`
	`6`	`+using Parse.Utilities;`
`6`	`7`
`7`	`8`	`#if IOS`
`8`	`9`	`using PreserveAttribute = Foundation.PreserveAttribute;`
`@@ -28,11 +29,11 @@ public FlexibleListWrapper(IList<TIn> toWrap) {`
`28`	`29`	`}`
`29`	`30`
`30`	`31`	`public int IndexOf(TOut item) {`
`31`		`- return toWrap.IndexOf((TIn)ParseClient.ConvertTo<TIn>(item));`
	`32`	`+ return toWrap.IndexOf((TIn)Conversion.ConvertTo<TIn>(item));`
`32`	`33`	`}`
`33`	`34`
`34`	`35`	`public void Insert(int index, TOut item) {`
`35`		`- toWrap.Insert(index, (TIn)ParseClient.ConvertTo<TIn>(item));`
	`36`	`+ toWrap.Insert(index, (TIn)Conversion.ConvertTo<TIn>(item));`
`36`	`37`	`}`
`37`	`38`
`38`	`39`	`public void RemoveAt(int index) {`
`@@ -41,27 +42,27 @@ public void RemoveAt(int index) {`
`41`	`42`
`42`	`43`	`public TOut this[int index] {`
`43`	`44`	`get {`
`44`		`- return (TOut)ParseClient.ConvertTo<TOut>(toWrap[index]);`
	`45`	`+ return (TOut)Conversion.ConvertTo<TOut>(toWrap[index]);`
`45`	`46`	`}`
`46`	`47`	`set {`
`47`		`- toWrap[index] = (TIn)ParseClient.ConvertTo<TIn>(value);`
	`48`	`+ toWrap[index] = (TIn)Conversion.ConvertTo<TIn>(value);`
`48`	`49`	`}`
`49`	`50`	`}`
`50`	`51`
`51`	`52`	`public void Add(TOut item) {`
`52`		`- toWrap.Add((TIn)ParseClient.ConvertTo<TIn>(item));`
	`53`	`+ toWrap.Add((TIn)Conversion.ConvertTo<TIn>(item));`
`53`	`54`	`}`
`54`	`55`
`55`	`56`	`public void Clear() {`
`56`	`57`	`toWrap.Clear();`
`57`	`58`	`}`
`58`	`59`
`59`	`60`	`public bool Contains(TOut item) {`
`60`		`- return toWrap.Contains((TIn)ParseClient.ConvertTo<TIn>(item));`
	`61`	`+ return toWrap.Contains((TIn)Conversion.ConvertTo<TIn>(item));`
`61`	`62`	`}`
`62`	`63`
`63`	`64`	`public void CopyTo(TOut[] array, int arrayIndex) {`
`64`		`- toWrap.Select(item => (TOut)ParseClient.ConvertTo<TOut>(item))`
	`65`	`+ toWrap.Select(item => (TOut)Conversion.ConvertTo<TOut>(item))`
`65`	`66`	`.ToList().CopyTo(array, arrayIndex);`
`66`	`67`	`}`
`67`	`68`
`@@ -74,12 +75,12 @@ public bool IsReadOnly {`
`74`	`75`	`}`
`75`	`76`
`76`	`77`	`public bool Remove(TOut item) {`
`77`		`- return toWrap.Remove((TIn)ParseClient.ConvertTo<TIn>(item));`
	`78`	`+ return toWrap.Remove((TIn)Conversion.ConvertTo<TIn>(item));`
`78`	`79`	`}`
`79`	`80`
`80`	`81`	`public IEnumerator<TOut> GetEnumerator() {`
`81`	`82`	`foreach (var item in (IEnumerable)toWrap) {`
`82`		`- yield return (TOut)ParseClient.ConvertTo<TOut>(item);`
	`83`	`+ yield return (TOut)Conversion.ConvertTo<TOut>(item);`
`83`	`84`	`}`
`84`	`85`	`}`
`85`	`86`