internal static string Unpack_String(MsgPackReader reader)
{
if (!reader.Read() || !reader.IsRaw())
{
UnpackFailed();
}
return(reader.ReadRawString());
}
public object Unpack(MsgPackReader reader)
{
//IL_0260: Unknown result type (might be due to invalid IL or missing references)
//IL_029b: Unknown result type (might be due to invalid IL or missing references)
//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
if (reader.Read())
{
switch (reader.Type)
{
case TypePrefixes.PositiveFixNum:
case TypePrefixes.Int32:
case TypePrefixes.NegativeFixNum:
return(reader.ValueSigned);
case TypePrefixes.Int8:
return((sbyte)reader.ValueSigned);
case TypePrefixes.Int16:
return((short)reader.ValueSigned);
case TypePrefixes.Int64:
return(reader.ValueSigned64);
case TypePrefixes.UInt8:
return((byte)reader.ValueUnsigned);
case TypePrefixes.UInt16:
return((ushort)reader.ValueUnsigned);
case TypePrefixes.UInt32:
return(reader.ValueUnsigned);
case TypePrefixes.UInt64:
return(reader.ValueUnsigned64);
case TypePrefixes.True:
return(true);
case TypePrefixes.False:
return(false);
case TypePrefixes.Float:
return(reader.ValueFloat);
case TypePrefixes.Double:
return(reader.ValueDouble);
case TypePrefixes.Nil:
return(null);
case TypePrefixes.FixRaw:
case TypePrefixes.Raw8:
case TypePrefixes.Raw16:
case TypePrefixes.Raw32:
return(reader.ReadRawString());
case TypePrefixes.Bin8:
case TypePrefixes.Bin16:
case TypePrefixes.Bin32:
{
byte[] array3 = new byte[reader.Length];
reader.ReadValueRaw(array3, 0, array3.Length);
return(array3);
}
case TypePrefixes.FixArray:
case TypePrefixes.Array16:
case TypePrefixes.Array32:
{
object[] array2 = new object[reader.Length];
for (int j = 0; j < array2.Length; j++)
{
array2[j] = Unpack(reader);
}
return(array2);
}
case TypePrefixes.FixMap:
case TypePrefixes.Map16:
case TypePrefixes.Map32:
{
IDictionary <object, object> dictionary = new Dictionary <object, object>((int)reader.Length);
int length = (int)reader.Length;
for (int i = 0; i < length; i++)
{
object key = Unpack(reader);
object value = Unpack(reader);
dictionary.Add(key, value);
}
return(dictionary);
}
case TypePrefixes.Ext8:
case TypePrefixes.Ext16:
case TypePrefixes.Ext32:
{
sbyte b = reader.ReadExtType();
switch (b)
{
case 81:
if (reader.Length == 16)
{
float num3 = reader.ReadSingle();
float num4 = reader.ReadSingle();
float num5 = reader.ReadSingle();
float num6 = reader.ReadSingle();
return(new Quaternion(num3, num4, num5, num6));
}
break;
case 86:
if (reader.Length == 12)
{
float num7 = reader.ReadSingle();
float num8 = reader.ReadSingle();
float num9 = reader.ReadSingle();
return(new Vector3(num7, num8, num9));
}
break;
case 87:
if (reader.Length == 8)
{
float num = reader.ReadSingle();
float num2 = reader.ReadSingle();
return(new Vector2(num, num2));
}
break;
}
byte[] array = new byte[reader.Length];
reader.ReadValueRaw(array, 0, (int)reader.Length);
return(new Ext(b, array));
}
default:
throw new FormatException();
}
}
throw new FormatException();
}
static object StringUnpacker(ObjectPacker packer, MsgPackReader reader)
{
return((object)reader.ReadRawString());
}
static object DateTimeOffsetUnpacker(ObjectPacker packer, MsgPackReader reader)
{
return(DateTimeOffset.Parse(reader.ReadRawString()));
}
object Unpack(MsgPackReader reader, string name, Type type)
{
if (!reader.Read())
{
throw GenerateFormatException(type, name);
}
if (reader.Type == TypePrefixes.Nil)
{
return(null);
}
if (type.IsPrimitive)
{
return(ValueAsPrimitive(reader, type));
}
if (type.IsEnum)
{
return(ValueAsPrimitive(reader, typeof(int)));
}
Type nullableType = Nullable.GetUnderlyingType(type);
if (nullableType != null && nullableType.IsPrimitive)
{
return(ValueAsPrimitive(reader, nullableType));
}
if (type.IsArray)
{
if ((!reader.IsArray()))
{
throw GenerateFormatException(type, name);
}
Type elementType = type.GetElementType();
Array array = Array.CreateInstance(elementType, (int)reader.Length);
for (int i = 0; i < array.Length; i++)
{
array.SetValue(Unpack(reader, name, elementType), i);
}
return(array);
}
if (type.IsInterface)
{
if (reader.Type != TypePrefixes.FixArray && reader.Length != 2)
{
throw GenerateFormatException(type, name);
}
if (!reader.Read() || !reader.IsRaw())
{
throw GenerateFormatException(type, name);
}
var nextType = Type.GetType(reader.ReadRawString());
return(Unpack(reader, name, nextType));
}
if (reader.IsMap())
{
object obj = FormatterServices.GetUninitializedObject(type);
ReflectionCacheEntry entry = ReflectionCache.Lookup(type);
int members = (int)reader.Length;
for (int i = 0; i < members; i++)
{
if (!reader.Read() || !reader.IsRaw())
{
throw GenerateFormatException(type, name);
}
FieldInfo fieldInfo;
string nextFieldName = reader.ReadRawString();
if (!entry.FieldMap.TryGetValue(nextFieldName, out fieldInfo))
{
reader.Skip(); // skip to next if field name is missing.
continue;
}
fieldInfo.SetValue(obj, Unpack(reader, nextFieldName, fieldInfo.FieldType));
}
return(obj);
}
UnpackDelegate unpacker;
if (UnpackerMapping.TryGetValue(type, out unpacker))
{
return(unpacker(this, reader));
}
throw GenerateFormatException(type, name);
}
