public static Dictionary <string, string> ParseStringDictionary(string value)
{
var index = VerifyAndGetStartIndex(value, typeof(Dictionary <string, string>));
var result = new Dictionary <string, string>();
if (value == JsWriter.EmptyMap)
{
return(result);
}
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 = Serializer.ParseString(keyValue);
var mapValue = Serializer.ParseString(elementValue);
result[mapKey] = mapValue;
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
return(result);
}
public static JsonObject ParseJsonObject(string value)
{
var index = VerifyAndGetStartIndex(value, typeof(JsonObject));
var result = new JsonObject();
if (value == JsWriter.EmptyMap)
{
return(result);
}
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 = keyValue;
var mapValue = elementValue;
result[mapKey] = mapValue;
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
return(result);
}
public static List <string> ParseStringList(StringSegment value)
{
if (!(value = StripList(value)).HasValue)
{
return(null);
}
if (value.Length == 0)
{
return(new List <string>());
}
var to = new List <string>();
var valueLength = value.Length;
var i = 0;
while (i < valueLength)
{
var elementValue = Serializer.EatValue(value, ref i);
var listValue = Serializer.UnescapeString(elementValue);
to.Add(listValue.Value);
if (Serializer.EatItemSeperatorOrMapEndChar(value, ref i) && i == valueLength)
{
// If we ate a separator and we are at the end of the value,
// it means the last element is empty => add default
to.Add(null);
}
}
return(to);
}
public static Type ExtractType(string strType)
{
var typeAttrInObject = Serializer.TypeAttrInObject;
if (strType != null &&
strType.Length > typeAttrInObject.Length &&
strType.Substring(0, typeAttrInObject.Length) == typeAttrInObject)
{
var propIndex = typeAttrInObject.Length;
var typeName = Serializer.UnescapeSafeString(Serializer.EatValue(strType, ref propIndex));
var type = JsConfig.TypeFinder.Invoke(typeName);
if (type == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + typeName);
return(null);
}
if (type.IsInterface || type.IsAbstract)
{
#if !SILVERLIGHT && !MONOTOUCH && !NETCF
return(DynamicProxy.GetInstanceFor(type).GetType());
#else
throw new NotImplementedException("Deserialization from Interface and Abstract type does not supported");
#endif
}
return(type);
}
return(null);
}
public static Type ExtractType(ITypeSerializer Serializer, string strType)
{
if (strType == null || strType.Length <= 1)
{
return((Type)null);
}
if (((IEnumerable <char>)JsonUtils.WhiteSpaceChars).Contains <char>(strType[1]))
{
int startIndex = strType.IndexOf('"');
if (startIndex >= 0)
{
strType = "{" + strType.Substring(startIndex);
}
}
string typeAttrInObject = Serializer.TypeAttrInObject;
if (strType.Length <= typeAttrInObject.Length || !(strType.Substring(0, typeAttrInObject.Length) == typeAttrInObject))
{
return((Type)null);
}
int length = typeAttrInObject.Length;
string str = Serializer.EatValue(strType, ref length);
Type type = JsConfig.TypeFinder(str);
if (!(type == (Type)null))
{
return(type);
}
Tracer.Instance.WriteWarning("Could not find type: " + str);
return(type);
}
public static Type ExtractType(string strType)
{
if (strType != null &&
strType.Length > TypeAttrInObject.Length &&
strType.Substring(0, TypeAttrInObject.Length) == TypeAttrInObject)
{
var propIndex = TypeAttrInObject.Length;
var typeName = Serializer.UnescapeSafeString(Serializer.EatValue(strType, ref propIndex));
var type = AssemblyUtils.FindType(typeName);
if (type == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + typeName);
return(null);
}
if (type.IsInterface || type.IsAbstract)
{
return(DynamicProxy.GetInstanceFor(type).GetType());
}
return(type);
}
return(null);
}
public static Type ExtractType(string strType)
{
var typeAttrInObject = Serializer.TypeAttrInObject;
if (strType != null &&
strType.Length > typeAttrInObject.Length &&
strType.Substring(0, typeAttrInObject.Length) == typeAttrInObject)
{
var propIndex = typeAttrInObject.Length;
var typeName = Serializer.UnescapeSafeString(Serializer.EatValue(strType, ref propIndex));
var type = JsConfig.TypeFinder.Invoke(typeName);
if (type == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + typeName);
return(null);
}
#if !SILVERLIGHT && !MONOTOUCH
if (type.IsInterface || type.IsAbstract)
{
return(DynamicProxy.GetInstanceFor(type).GetType());
}
#endif
return(type);
}
return(null);
}
public static List <string> ParseStringList(string value)
{
if ((value = StripList(value)) == null)
{
return(null);
}
if (value == string.Empty)
{
return(new List <string>());
}
var to = new List <string>();
var valueLength = value.Length;
var i = 0;
while (i < valueLength)
{
var elementValue = Serializer.EatValue(value, ref i);
var listValue = Serializer.ParseString(elementValue);
to.Add(listValue);
Serializer.EatItemSeperatorOrMapEndChar(value, ref i);
}
return(to);
}
public static object Parse(Type tupleType, string value)
{
var index = 0;
Serializer.EatMapStartChar(value, ref index);
if (JsonTypeSerializer.IsEmptyMap(value, index))
{
return(Activator.CreateInstance(tupleType));
}
var genericArgs = tupleType.GetGenericArguments();
var argValues = new object[genericArgs.Length];
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);
if (keyValue == null)
{
continue;
}
var keyIndex = int.Parse(keyValue.Substring(4)) - 1;
argValues[keyIndex] = Serializer.GetParseFn(genericArgs[keyIndex]).Invoke(elementValue);
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
return(tupleType.GetConstructors().First(x => x.GetParameters().Length == genericArgs.Length).Invoke(argValues));
}
public static Type ExtractType(string strType)
{
if (strType != null &&
strType.Length > TypeAttrInObject.Length &&
strType.Substring(0, TypeAttrInObject.Length) == TypeAttrInObject)
{
var propIndex = TypeAttrInObject.Length;
var typeName = Serializer.EatValue(strType, ref propIndex);
typeName = Serializer.ParseString(typeName);
var type = AssemblyUtils.FindType(typeName);
if (type == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + typeName);
}
return(type);
}
return(null);
}
private static object StringToType(Type type, string strType,
EmptyCtorDelegate ctorFn,
IDictionary <string, SetPropertyDelegate> setterMap,
IDictionary <string, ParseStringDelegate> parseStringFnMap)
{
var index = 0;
if (!Serializer.EatMapStartChar(strType, ref index))
{
throw new SerializationException(string.Format(
"Type definitions should start with a '{0}', expecting serialized type '{1}', got string starting with: {2}",
JsWriter.MapStartChar, type.Name, strType.Substring(0, strType.Length < 50 ? strType.Length : 50)));
}
var instance = ctorFn();
string propertyName;
ParseStringDelegate parseStringFn;
SetPropertyDelegate setterFn;
if (strType == JsWriter.EmptyMap)
{
return(instance);
}
var strTypeLength = strType.Length;
while (index < strTypeLength)
{
propertyName = Serializer.EatMapKey(strType, ref index);
Serializer.EatMapKeySeperator(strType, ref index);
var propertyValueString = Serializer.EatValue(strType, ref index);
parseStringFnMap.TryGetValue(propertyName, out parseStringFn);
if (parseStringFn != null)
{
var propertyValue = parseStringFn(propertyValueString);
setterMap.TryGetValue(propertyName, out setterFn);
if (setterFn != null)
{
setterFn(instance, propertyValue);
}
}
Serializer.EatItemSeperatorOrMapEndChar(strType, ref index);
}
return(instance);
}
/// <summary>
/// Parses the json object.
/// </summary>
/// <param name="value">The value.</param>
/// <returns>JsonObject.</returns>
public static JsonObject ParseJsonObject(ReadOnlySpan <char> value)
{
if (value.Length == 0)
{
return(null);
}
var index = VerifyAndGetStartIndex(value, typeof(JsonObject));
var result = new JsonObject();
if (Json.JsonTypeSerializer.IsEmptyMap(value, index))
{
return(result);
}
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);
if (keyValue.IsEmpty)
{
continue;
}
var mapKey = keyValue.ToString();
var mapValue = elementValue.Value();
result[mapKey] = mapValue;
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
return(result);
}
public static IDynamicMetaObjectProvider ParseDynamic(StringSegment value)
{
var index = VerifyAndGetStartIndex(value, typeof(ExpandoObject));
var result = new ExpandoObject();
if (JsonTypeSerializer.IsEmptyMap(value))
{
return(result);
}
var container = (IDictionary <string, object>)result;
var tryToParsePrimitiveTypes = JsConfig.TryToParsePrimitiveTypeValues;
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 = Serializer.UnescapeString(keyValue).Value;
if (JsonUtils.IsJsObject(elementValue))
{
container[mapKey] = ParseDynamic(elementValue);
}
else if (JsonUtils.IsJsArray(elementValue))
{
container[mapKey] = DeserializeList <List <object>, TSerializer> .ParseStringSegment(elementValue);
}
else if (tryToParsePrimitiveTypes)
{
container[mapKey] = DeserializeType <TSerializer> .ParsePrimitive(elementValue)
?? Serializer.UnescapeString(elementValue);
}
else
{
container[mapKey] = Serializer.UnescapeString(elementValue);
}
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
return(result);
}
public static Type ExtractType(string strType)
{
var typeAttrInObject = Serializer.TypeAttrInObject;
if (strType == null || strType.Length <= 1)
{
return(null);
}
var hasWhitespace = JsonUtils.WhiteSpaceChars.Contains(strType[1]);
if (hasWhitespace)
{
var pos = strType.IndexOf('"');
if (pos >= 0)
{
strType = "{" + strType.Substring(pos);
}
}
if (strType.Length > typeAttrInObject.Length &&
strType.Substring(0, typeAttrInObject.Length) == typeAttrInObject)
{
var propIndex = typeAttrInObject.Length;
var typeName = Serializer.UnescapeSafeString(Serializer.EatValue(strType, ref propIndex));
var type = JsConfig.TypeFinder.Invoke(typeName);
if (type == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + typeName);
return(null);
}
#if !SILVERLIGHT && !MONOTOUCH
if (type.IsInterface || type.IsAbstract)
{
return(DynamicProxy.GetInstanceFor(type).GetType());
}
#endif
return(type);
}
return(null);
}
public static List <string> ParseFields(string line)
{
var to = new List <string>();
if (string.IsNullOrEmpty(line))
{
return(to);
}
var i = -1;
var len = line.Length;
while (++i <= len)
{
var value = Serializer.EatValue(line, ref i);
to.Add(value.FromCsvField());
}
return(to);
}
// TODO: optimize ExtractType
public static Type ExtractType(StringSegment strType)
{
if (!strType.HasValue || strType.Length <= 1)
{
return(null);
}
var hasWhitespace = Json.JsonUtils.WhiteSpaceChars.Contains(strType.GetChar(1));
if (hasWhitespace)
{
var pos = strType.IndexOf('"');
if (pos >= 0)
{
strType = new StringSegment($"{{{strType.Substring(pos, strType.Length - pos)}");
}
}
var typeAttrInObject = Serializer.TypeAttrInObject;
if (strType.Length > typeAttrInObject.Length &&
strType.Substring(0, typeAttrInObject.Length) == typeAttrInObject)
{
var propIndex = typeAttrInObject.Length;
var typeName = Serializer.UnescapeSafeString(Serializer.EatValue(strType, ref propIndex)).Value;
var type = JsConfig.TypeFinder(typeName);
JsWriter.AssertAllowedRuntimeType(type);
if (type == null)
{
Tracer.Instance.WriteWarning($"Could not find type: {typeName}");
return(null);
}
return(PclExport.Instance.UseType(type));
}
return(null);
}
public static Type ExtractType(ITypeSerializer Serializer, string strType)
{
var typeAttrInObject = Serializer.TypeAttrInObject;
if (strType != null &&
strType.Length > typeAttrInObject.Length &&
strType.Substring(0, typeAttrInObject.Length) == typeAttrInObject)
{
var propIndex = typeAttrInObject.Length;
var typeName = Serializer.EatValue(strType, ref propIndex);
var type = JsConfig.TypeFinder.Invoke(typeName);
if (type == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + typeName);
}
return(type);
}
return(null);
}
//TODO: optimize ExtractType
public static Type ExtractType(ReadOnlySpan <char> strType)
{
if (strType.IsEmpty || strType.Length <= 1)
{
return(null);
}
var hasWhitespace = Json.JsonUtils.WhiteSpaceChars.Contains(strType[1]);
if (hasWhitespace)
{
var pos = strType.IndexOf('"');
if (pos >= 0)
{
strType = ("{" + strType.Substring(pos, strType.Length - pos)).AsSpan();
}
}
var typeAttrInObject = Serializer.TypeAttrInObject;
if (strType.Length > typeAttrInObject.Length &&
strType.Slice(0, typeAttrInObject.Length).EqualsOrdinal(typeAttrInObject))
{
var propIndex = typeAttrInObject.Length;
var typeName = Serializer.UnescapeSafeString(Serializer.EatValue(strType, ref propIndex)).ToString();
var type = JsConfig.TypeFinder(typeName);
JsWriter.AssertAllowedRuntimeType(type);
if (type == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + typeName);
return(null);
}
return(ReflectionOptimizer.Instance.UseType(type));
}
return(null);
}
public static Type ExtractType(string strType)
{
if (strType == null || strType.Length <= 1)
{
return(null);
}
var hasWhitespace = JsonUtils.WhiteSpaceChars.Contains(strType[1]);
if (hasWhitespace)
{
var pos = strType.IndexOf('"');
if (pos >= 0)
{
strType = "{" + strType.Substring(pos);
}
}
var typeAttrInObject = Serializer.TypeAttrInObject;
if (strType.Length > typeAttrInObject.Length &&
strType.Substring(0, typeAttrInObject.Length) == typeAttrInObject)
{
var propIndex = typeAttrInObject.Length;
var typeName = Serializer.UnescapeSafeString(Serializer.EatValue(strType, ref propIndex));
var type = JsConfig.TypeFinder(typeName);
if (type == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + typeName);
return(null);
}
return(PclExport.Instance.UseType(type));
}
return(null);
}
public static Hashtable ParseHashtable(StringSegment value)
{
if (!value.HasValue)
{
return(null);
}
var index = VerifyAndGetStartIndex(value, typeof(Hashtable));
var result = new Hashtable();
if (JsonTypeSerializer.IsEmptyMap(value, index))
{
return(result);
}
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);
if (!keyValue.HasValue)
{
continue;
}
var mapKey = keyValue.Value;
var mapValue = elementValue.Value;
result[mapKey] = mapValue;
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
return(result);
}
public static object ParseTuple(Type tupleType, StringSegment value)
{
var index = 0;
Serializer.EatMapStartChar(value, ref index);
if (JsonTypeSerializer.IsEmptyMap(value, index))
{
//return tupleType.CreateInstance();
return(ActivatorUtils.FastCreateInstance(tupleType));
}
var genericArgs = tupleType.GetGenericArguments();
var argValues = new object[genericArgs.Length];
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);
if (!keyValue.HasValue)
{
continue;
}
var keyIndex = keyValue.Substring("Item".Length).ToInt() - 1;
var parseFn = Serializer.GetParseStringSegmentFn(genericArgs[keyIndex]);
argValues[keyIndex] = parseFn(elementValue);
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
var ctor = tupleType.GetConstructors()
.First(x => x.GetParameters().Length == genericArgs.Length);
return(ctor.Invoke(argValues));
}
public static Type ExtractType(ITypeSerializer Serializer, StringSegment strType)
{
if (!strType.HasValue || strType.Length <= 1)
{
return(null);
}
var hasWhitespace = Json.JsonUtils.WhiteSpaceChars.Contains(strType.GetChar(1));
if (hasWhitespace)
{
var pos = strType.IndexOf('"');
if (pos >= 0)
{
strType = new StringSegment("{" + strType.Substring(pos));
}
}
var typeAttrInObject = Serializer.TypeAttrInObject;
if (strType.Length > typeAttrInObject.Length &&
strType.Substring(0, typeAttrInObject.Length) == typeAttrInObject)
{
var propIndex = typeAttrInObject.Length;
var typeName = Serializer.EatValue(strType, ref propIndex).Value;
var type = JsConfig.TypeFinder(typeName);
if (type == null)
{
Tracer.Instance.WriteWarning("Could not find type: " + typeName);
}
return(type);
}
return(null);
}
/// <summary>
/// Parses the tuple.
/// </summary>
/// <param name="tupleType">Type of the tuple.</param>
/// <param name="value">The value.</param>
/// <returns>System.Object.</returns>
public static object ParseTuple(Type tupleType, ReadOnlySpan <char> value)
{
var index = 0;
Serializer.EatMapStartChar(value, ref index);
if (JsonTypeSerializer.IsEmptyMap(value, index))
{
return(tupleType.CreateInstance());
}
var genericArgs = tupleType.GetGenericArguments();
var argValues = new object[genericArgs.Length];
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);
if (keyValue.IsEmpty)
{
continue;
}
var keyIndex = keyValue.Slice("Item".Length).ParseInt32() - 1;
var parseFn = Serializer.GetParseStringSpanFn(genericArgs[keyIndex]);
argValues[keyIndex] = parseFn(elementValue);
Serializer.EatItemSeperatorOrMapEndChar(value, ref index);
}
var ctor = tupleType.GetConstructors()
.First(x => x.GetParameters().Length == genericArgs.Length);
return(ctor.Invoke(argValues));
}
