public void StaticParseMethod_will_not_throw_on_unstandard_usage()
{
ParseStringDelegate ret = null;
Assert.DoesNotThrow(() => ret = StaticParseMethod <DangerousText2> .Parse);
Assert.IsNull(ret);
}
public static object ParseKeyValuePairType(string value, Type createMapType, Type[] argTypes,
ParseStringDelegate keyParseFn, ParseStringDelegate valueParseFn)
{
ParseKeyValuePairDelegate parseDelegate;
var key = GetTypesKey(argTypes);
if (ParseDelegateCache.TryGetValue(key, out parseDelegate))
{
return(parseDelegate(value, createMapType, keyParseFn, valueParseFn));
}
var mi = typeof(DeserializeKeyValuePair <TSerializer>).GetPublicStaticMethod("ParseKeyValuePair");
var genericMi = mi.MakeGenericMethod(argTypes);
parseDelegate = (ParseKeyValuePairDelegate)genericMi.MakeDelegate(typeof(ParseKeyValuePairDelegate));
Dictionary <string, ParseKeyValuePairDelegate> snapshot, newCache;
do
{
snapshot = ParseDelegateCache;
newCache = new Dictionary <string, ParseKeyValuePairDelegate>(ParseDelegateCache);
newCache[key] = parseDelegate;
} while (!ReferenceEquals(
Interlocked.CompareExchange(ref ParseDelegateCache, newCache, snapshot), snapshot));
return(parseDelegate(value, createMapType, keyParseFn, valueParseFn));
}
public static Func <string, Type, ParseStringDelegate, object> GetListTypeParseFn(
Type createListType, Type elementType, ParseStringDelegate parseFn)
{
ParseListDelegate parseDelegate;
if (ParseDelegateCache.TryGetValue(elementType, out parseDelegate))
{
return(parseDelegate.Invoke);
}
var genericType = typeof(DeserializeListWithElements <,>).MakeGenericType(elementType, typeof(TSerializer));
var mi = genericType.GetMethod("ParseGenericList", BindingFlags.Static | BindingFlags.Public);
parseDelegate = (ParseListDelegate)Delegate.CreateDelegate(typeof(ParseListDelegate), mi);
Dictionary <Type, ParseListDelegate> snapshot, newCache;
do
{
snapshot = ParseDelegateCache;
newCache = new Dictionary <Type, ParseListDelegate>(ParseDelegateCache);
newCache[elementType] = parseDelegate;
} while (!ReferenceEquals(
Interlocked.CompareExchange(ref ParseDelegateCache, newCache, snapshot), snapshot));
return(parseDelegate.Invoke);
}
public static Func <string, Type, ParseStringDelegate, object> GetListTypeParseFn(
Type createListType, Type elementType, ParseStringDelegate parseFn)
{
var func = GetListTypeParseStringSegmentFn(createListType, elementType, v => parseFn(v.Value));
return((s, t, d) => func(new StringSegment(s), t, v => d(v.Value)));
}
public static IDictionary <TKey, TValue> ParseDictionary <TKey, TValue>(
string value, Type createMapType,
ParseStringDelegate parseKeyFn, ParseStringDelegate parseValueFn)
{
if (value == null)
{
return(null);
}
var tryToParseItemsAsDictionaries =
JsConfig.ConvertObjectTypesIntoStringDictionary && typeof(TValue) == typeof(object);
var index = VerifyAndGetStartIndex(value, createMapType);
var to = (createMapType == null)
? new Dictionary <TKey, TValue>()
: (IDictionary <TKey, TValue>)createMapType.CreateInstance();
if (value == JsWriter.EmptyMap)
{
return(to);
}
var valueLength = value.Length;
while (index < valueLength)
{
var keyValue = Serializer.EatMapKey(value, ref index);
Serializer.EatMapKeySeperator(value, ref index);
var elementValue = Serializer.EatValue(value, ref index);
var mapKey = (TKey)parseKeyFn(keyValue);
var mapValue = (TValue)parseValueFn(elementValue);
if (tryToParseItemsAsDictionaries)
{
var mapValueString = mapValue as string;
var tryParseValueAsDictionary = JsonUtils.IsJsObject(mapValueString);
if (tryParseValueAsDictionary)
{
var tmpMap = ParseDictionary <TKey, TValue>(mapValueString, createMapType, parseKeyFn, parseValueFn);
to[mapKey] = (tmpMap != null && tmpMap.Count > 0)
? (TValue)tmpMap
: to[mapKey] = mapValue;
}
else
{
to[mapKey] = mapValue;
}
}
else
{
to[mapKey] = mapValue;
}
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
return(to);
}
public static Func <string, Type, ParseStringDelegate, object> GetListTypeParseFn(
Type createListType, Type elementType, ParseStringDelegate parseFn)
{
ParseListDelegate parseDelegate;
if (ParseDelegateCache.TryGetValue(elementType, out parseDelegate))
{
return(parseDelegate.Invoke);
}
var genericType = typeof(DeserializeListWithElements <,>).MakeGenericType(elementType, typeof(TSerializer));
var mi = genericType.GetPublicStaticMethod("ParseGenericList");
parseDelegate = (ParseListDelegate)mi.MakeDelegate(typeof(ParseListDelegate));
Dictionary <Type, ParseListDelegate> snapshot, newCache;
do
{
snapshot = ParseDelegateCache;
newCache = new Dictionary <Type, ParseListDelegate>(ParseDelegateCache);
newCache[elementType] = parseDelegate;
} while (!ReferenceEquals(
#if PLATFORM_NO_USE_INTERLOCKED_COMPARE_EXCHANGE_T
Interlocked.CompareExchange(ref _parseDelegateCache, (object )newCache, (object )snapshot), snapshot));
#else
Interlocked.CompareExchange(ref ParseDelegateCache, newCache, snapshot), snapshot));
#endif
return(parseDelegate.Invoke);
}
public static Func <string, Type, ParseStringDelegate, object> GetListTypeParseFn(
Type createListType, Type elementType, ParseStringDelegate parseFn)
{
var func = GetListTypeParseStringSpanFn(createListType, elementType, v => parseFn(v.ToString()));
return((s, t, d) => func(s.AsSpan(), t, v => d(v.ToString())));
}
/// <summary>
/// Parses the dictionary.
/// </summary>
/// <typeparam name="TKey">The type of the t key.</typeparam>
/// <typeparam name="TValue">The type of the t value.</typeparam>
/// <param name="value">The value.</param>
/// <param name="createMapType">Type of the create map.</param>
/// <param name="parseKeyFn">The parse key function.</param>
/// <param name="parseValueFn">The parse value function.</param>
/// <returns>IDictionary<TKey, TValue>.</returns>
public static IDictionary <TKey, TValue> ParseDictionary <TKey, TValue>(
string value, Type createMapType,
ParseStringDelegate parseKeyFn, ParseStringDelegate parseValueFn)
{
return(ParseDictionary <TKey, TValue>(value.AsSpan(),
createMapType,
v => parseKeyFn(v.ToString()),
v => parseValueFn(v.ToString())
));
}
public static IDictionary <TKey, TValue> ParseDictionary <TKey, TValue>(
string value, Type createMapType,
ParseStringDelegate parseKeyFn, ParseStringDelegate parseValueFn)
{
return(ParseDictionary <TKey, TValue>(new StringSegment(value),
createMapType,
v => parseKeyFn(v.Value),
v => parseValueFn(v.Value)
));
}
/// <summary>Parse key value pair.</summary>
/// <exception cref="SerializationException">Thrown when a Serialization error condition occurs.</exception>
/// <typeparam name="TKey"> Type of the key.</typeparam>
/// <typeparam name="TValue">Type of the value.</typeparam>
/// <param name="value"> The value.</param>
/// <param name="createMapType">Type of the create map.</param>
/// <param name="parseKeyFn"> The parse key function.</param>
/// <param name="parseValueFn"> The parse value function.</param>
/// <returns>An object.</returns>
public static object ParseKeyValuePair <TKey, TValue>(
string value, Type createMapType,
ParseStringDelegate parseKeyFn, ParseStringDelegate parseValueFn)
{
if (value == null)
{
return(default(KeyValuePair <TKey, TValue>));
}
var index = VerifyAndGetStartIndex(value, createMapType);
if (JsonTypeSerializer.IsEmptyMap(value, index))
{
return(new KeyValuePair <TKey, TValue>());
}
var keyValue = default(TKey);
var valueValue = default(TValue);
var valueLength = value.Length;
while (index < valueLength)
{
var key = Serializer.EatMapKey(value, ref index);
Serializer.EatMapKeySeperator(value, ref index);
var keyElementValue = Serializer.EatTypeValue(value, ref index);
if (key.CompareIgnoreCase("key") == 0)
{
keyValue = (TKey)parseKeyFn(keyElementValue);
}
else if (key.CompareIgnoreCase("value") == 0)
{
valueValue = (TValue)parseValueFn(keyElementValue);
}
else
{
throw new SerializationException("Incorrect KeyValuePair property: " + key);
}
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
return(new KeyValuePair <TKey, TValue>(keyValue, valueValue));
}
public static object ParseDictionaryType(string value, Type createMapType, Type[] argTypes,
ParseStringDelegate keyParseFn, ParseStringDelegate valueParseFn)
{
var mi = typeof(DeserializeDictionary <TSerializer>)
.GetMethod("ParseDictionary", BindingFlags.Static | BindingFlags.Public);
ParseDictionaryDelegate parseDelegate;
var key = GetTypesKey(argTypes);
if (!ParseDelegateCache.TryGetValue(key, out parseDelegate))
{
var genericMi = mi.MakeGenericMethod(argTypes);
parseDelegate = (ParseDictionaryDelegate)Delegate.CreateDelegate(
typeof(ParseDictionaryDelegate), genericMi);
ParseDelegateCache[key] = parseDelegate;
}
return(parseDelegate(value, createMapType, keyParseFn, valueParseFn));
}
public static IDictionary <TKey, TValue> ParseDictionary <TKey, TValue>(
string value, Type createMapType,
ParseStringDelegate parseKeyFn, ParseStringDelegate parseValueFn)
{
if (value == null)
{
return(null);
}
var tryToParseItemsAsDictionaries =
JsConfig.ConvertObjectTypesIntoStringDictionary && typeof(TValue) == typeof(object);
var tryToParseItemsAsPrimitiveTypes =
JsConfig.TryToParsePrimitiveTypeValues && typeof(TValue) == typeof(object);
var index = VerifyAndGetStartIndex(value, createMapType);
var to = (createMapType == null)
? new Dictionary <TKey, TValue>()
#if !NETCF
: (IDictionary <TKey, TValue>)createMapType.CreateInstance();
public static Func <string, Type, ParseStringDelegate, object> GetListTypeParseFn(
Type createListType, Type elementType,
ParseStringDelegate parseFn)
{
ParseListDelegate parseDelegate;
if (!ParseDelegateCache.TryGetValue(elementType, out parseDelegate))
{
var genericType = typeof(DeserializeListWithElements <,>)
.MakeGenericType(elementType, typeof(TSerializer));
var mi = genericType.GetMethod("ParseGenericList",
BindingFlags.Static | BindingFlags.Public);
parseDelegate = (ParseListDelegate)Delegate.CreateDelegate(typeof(ParseListDelegate), mi);
ParseDelegateCache[elementType] = parseDelegate;
}
return(parseDelegate.Invoke);
}
public static object ParseDictionaryType(string value, Type createMapType, Type[] argTypes,
ParseStringDelegate keyParseFn, ParseStringDelegate valueParseFn) =>
ParseDictionaryType(new StringSegment(value), createMapType, argTypes,
v => keyParseFn(v.Value), v => valueParseFn(v.Value));
static DeserializeBuiltin()
{
CachedParseFn = GetParseFn();
}
static StaticParseMethod()
{
CacheFn = ParseMethodUtilities.GetParseFn <T>(ParseMethod);
CacheStringSegmentFn = ParseMethodUtilities.GetParseStringSegmentFn <T>(ParseMethod);
}
public static object ParseKeyValuePairType(string value, Type createMapType, Type[] argTypes,
ParseStringDelegate keyParseFn, ParseStringDelegate valueParseFn) =>
ParseKeyValuePairType(value.AsSpan(), createMapType, argTypes,
v => keyParseFn(v.ToString()), v => valueParseFn(v.ToString()));
public static object ParseKeyValuePair <TKey, TValue>(
string value, Type createMapType,
ParseStringDelegate parseKeyFn, ParseStringDelegate parseValueFn) =>
ParseKeyValuePair <TKey, TValue>(value.AsSpan(), createMapType,
v => parseKeyFn(v.ToString()), v => parseValueFn(v.ToString()));
public static IDictionary <TKey, TValue> ParseDictionary <TKey, TValue>(
string value, Type createMapType,
ParseStringDelegate parseKeyFn, ParseStringDelegate parseValueFn)
{
if (value == null)
{
return(null);
}
var tryToParseItemsAsDictionaries =
JsConfig.ConvertObjectTypesIntoStringDictionary && typeof(TValue) == typeof(object);
var tryToParseItemsAsPrimitiveTypes =
JsConfig.TryToParsePrimitiveTypeValues && typeof(TValue) == typeof(object);
var index = VerifyAndGetStartIndex(value, createMapType);
var to = (createMapType == null)
? new Dictionary <TKey, TValue>()
: (IDictionary <TKey, TValue>)createMapType.CreateInstance();
if (JsonTypeSerializer.IsEmptyMap(value, index))
{
return(to);
}
var valueLength = value.Length;
while (index < valueLength)
{
var keyValue = Serializer.EatMapKey(value, ref index);
Serializer.EatMapKeySeperator(value, ref index);
var elementStartIndex = index;
var elementValue = Serializer.EatTypeValue(value, ref index);
if (keyValue == null)
{
continue;
}
TKey mapKey = (TKey)parseKeyFn(keyValue);
if (tryToParseItemsAsDictionaries)
{
Serializer.EatWhitespace(value, ref elementStartIndex);
if (elementStartIndex < valueLength && value[elementStartIndex] == JsWriter.MapStartChar)
{
var tmpMap = ParseDictionary <TKey, TValue>(elementValue, createMapType, parseKeyFn, parseValueFn);
if (tmpMap != null && tmpMap.Count > 0)
{
to[mapKey] = (TValue)tmpMap;
}
}
else if (elementStartIndex < valueLength && value[elementStartIndex] == JsWriter.ListStartChar)
{
to[mapKey] = (TValue)DeserializeList <List <object>, TSerializer> .Parse(elementValue);
}
else
{
to[mapKey] = (TValue)(tryToParseItemsAsPrimitiveTypes && elementStartIndex < valueLength
? DeserializeType <TSerializer> .ParsePrimitive(elementValue, value[elementStartIndex])
: parseValueFn(elementValue));
}
}
else
{
if (tryToParseItemsAsPrimitiveTypes && elementStartIndex < valueLength)
{
Serializer.EatWhitespace(value, ref elementStartIndex);
to[mapKey] = (TValue)DeserializeType <TSerializer> .ParsePrimitive(elementValue, value[elementStartIndex]);
}
else
{
to[mapKey] = (TValue)parseValueFn(elementValue);
}
}
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
return(to);
}
static StaticParseRefTypeMethod()
{
CacheFn = ParseMethodUtilities.GetParseFn <T>(ParseMethod);
CacheStringSpanFn = ParseMethodUtilities.GetParseStringSpanFn <T>(ParseStringSpanMethod);
}
static DeserializeList()
{
CacheFn = GetParseFn();
}
public PropertySerializerEntry(SetPropertyDelegate propertySetFn, ParseStringDelegate propertyParseStringFn)
{
PropertySetFn = propertySetFn;
PropertyParseStringFn = propertyParseStringFn;
}
public static ICollection <T> ParseCollection <T>(string value, Type createType, ParseStringDelegate parseFn)
{
if (value == null)
{
return(null);
}
var items = DeserializeArrayWithElements <T, TSerializer> .ParseGenericArray(value, parseFn);
return(CollectionExtensions.CreateAndPopulate(createType, items));
}
public static object ParseCollectionType(string value, Type createType, Type elementType, ParseStringDelegate parseFn)
{
ParseCollectionDelegate parseDelegate;
if (ParseDelegateCache.TryGetValue(elementType, out parseDelegate))
{
return(parseDelegate(value, createType, parseFn));
}
var mi = typeof(DeserializeCollection <TSerializer>).GetPublicStaticMethod("ParseCollection");
var genericMi = mi.MakeGenericMethod(new[] { elementType });
parseDelegate = (ParseCollectionDelegate)genericMi.MakeDelegate(typeof(ParseCollectionDelegate));
Dictionary <Type, ParseCollectionDelegate> snapshot, newCache;
do
{
snapshot = ParseDelegateCache;
newCache = new Dictionary <Type, ParseCollectionDelegate>(ParseDelegateCache);
newCache[elementType] = parseDelegate;
} while (!ReferenceEquals(
Interlocked.CompareExchange(ref ParseDelegateCache, newCache, snapshot), snapshot));
return(parseDelegate(value, createType, parseFn));
}
static DeserializeDynamic()
{
CachedParseFn = ParseDynamic;
}
static DeserializeSpecializedCollections()
{
CacheFn = GetParseFn();
}
public static object ParseKeyValuePair <TKey, TValue>(
string value, Type createMapType,
ParseStringDelegate parseKeyFn, ParseStringDelegate parseValueFn) =>
ParseKeyValuePair <TKey, TValue>(new StringSegment(value), createMapType,
v => parseKeyFn(v.Value), v => parseValueFn(v.Value));
static DeserializeEnumerable()
{
CacheFn = GetParseFn();
}
public PropertySerializerEntry(SetPropertyDelegate propertySetFn, ParseStringDelegate propertyParseStringFn)
{
PropertySetFn = propertySetFn;
PropertyParseStringFn = propertyParseStringFn;
}
static StaticParseMethod()
{
CacheFn = GetParseFn();
}
/// <summary> /// Parses the collection. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="value">The value.</param> /// <param name="createType">Type of the create.</param> /// <param name="parseFn">The parse function.</param> /// <returns>ICollection<T>.</returns> public static ICollection <T> ParseCollection <T>(string value, Type createType, ParseStringDelegate parseFn) => ParseCollection <T>(value.AsSpan(), createType, v => parseFn(v.ToString()));
