public override void Deserialize(IPrimitiveReader reader)
{
IsEmpty = reader.ReadBoolean();
Code = reader.ReadString();
TitaAppId = reader.ReadInt32();
TenantId = reader.ReadInt32();
UserId = reader.ReadInt32();
State = (QrCodeLoginState)reader.ReadInt16();
}
/// <summary>
/// Reads a <see cref="TypeInfo"/> object from the specified reader.
/// </summary>
/// <param name="reader">The reader to read from.</param>
/// <returns>
/// <para>The <see cref="TypeInfo"/> read from <paramref name="reader"/>.</para>
/// </returns>
/// <exception cref="InvalidDataException">
/// <para>Unexpected data is encountered in the stream.</para>
/// </exception>
public static TypeInfo ReadFrom(IPrimitiveReader reader)
{
var mode = (Mode)reader.ReadByte();
switch (mode)
{
case Mode.Id:
return(Get(reader.ReadInt16()));
case Mode.Name:
return(_typeInfoByTypeName(reader.ReadString()));
}
throw new InvalidDataException(string.Format("Unexpected mode encountered {0}", (byte)mode));
}
public void Deserialize(IPrimitiveReader reader, int version)
{
if (version >= 1)
{
MessageType = (MessageType)reader.ReadInt32();
PayloadLength = reader.ReadInt32();
int bytesLength = reader.ReadInt32();
if (bytesLength > -1)
{
byte[] bytes = reader.ReadBytes(bytesLength);
MessageStream = new MemoryStream(bytes);
}
}
if (version >= 2)
{
TypeId = reader.ReadInt16();
}
}
/// <summary>
/// Deserializes a <see cref="RelayPayload"/> from an <see cref="IPrimitiveReader"/>.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="version">The version of the <paramref name="reader"/> data.</param>
public void Deserialize(IPrimitiveReader reader, int version)
{
this.TypeId = reader.ReadInt16();
this.Id = reader.ReadInt32();
this.LastUpdatedTicks = reader.ReadInt64();
this.Compressed = reader.ReadBoolean();
this.ttl = reader.ReadInt32();
this.expirationTicks = reader.ReadInt64();
int byteLength = reader.ReadInt32();
if (byteLength > 0)
{
this.ByteArray = reader.ReadBytes(byteLength);
}
if (version > 1)
{
int keyLength = reader.ReadInt32();
this.ExtendedId = reader.ReadBytes(keyLength);
}
}
/// <summary>
/// Reads the serialized header
/// </summary>
/// <param name="reader"></param>
public void Read(IPrimitiveReader reader)
{
this.headerPosition = reader.BaseStream.Position;
this.headerVersion = reader.ReadByte();
this.headerLength = reader.ReadInt16();
this.flags = (TypeSerializationHeaderFlags)reader.ReadByte();
this.dataVersion = reader.ReadByte();
this.dataMinVersion = reader.ReadByte();
this.dataLength = reader.ReadInt32();
this.dataPosition = this.headerPosition + this.headerLength;
if (this.headerVersion > CurrentHeaderVersion)
{
throw new ApplicationException("This object was serialized with a newer version of the serialization framework");
}
if ((this.flags & ~TypeSerializationHeaderFlags.KnownFlags) != 0)
{
throw new ApplicationException("This object was serialized with features that are not supported in this version of the serialization framework");
}
reader.BaseStream.Seek(this.dataPosition, System.IO.SeekOrigin.Begin);
}
/// <summary>
/// Reads the serialized header
/// </summary>
/// <param name="reader"></param>
public void Read(IPrimitiveReader reader)
{
this.headerPosition = reader.BaseStream.Position;
this.headerVersion = reader.ReadByte();
this.headerLength = reader.ReadInt16();
this.flags = (TypeSerializationHeaderFlags)reader.ReadByte();
this.dataVersion = reader.ReadByte();
this.dataMinVersion = reader.ReadByte();
this.dataLength = reader.ReadInt32();
this.dataPosition = this.headerPosition + this.headerLength;
if (this.headerVersion > CurrentHeaderVersion)
{
throw new ApplicationException("This object was serialized with a newer version of the serialization framework");
}
if ((this.flags & ~TypeSerializationHeaderFlags.KnownFlags) != 0)
{
throw new ApplicationException("This object was serialized with features that are not supported in this version of the serialization framework");
}
reader.BaseStream.Seek(this.dataPosition, System.IO.SeekOrigin.Begin);
}
internal object ReadImpl(ReadArgs args)
{
// check id first
ulong oid = 0;
if (args.TypeData.IsReference)
{
oid = input.ReadVUInt();
if (TryGetObject(oid, out var result))
return result;
}
// if expected is not final
if (args.TypeData.IsReference && !args.TypeData.IsSealed)
args = new ReadArgs((TypeData)ReadImpl(AType), args.TypeHint, args.Instance);
object ReturnRegister(object value)
{
if (oid != 0)
Register(oid, value);
return value;
}
// only proceed further if type is supported
if (!args.TypeData.IsSupported)
return ReturnRegister(new ObjectData(args.TypeData));
// dispatch to appropriate read method
if (args.TypeData.Surrogate != null)
{
return ReturnRegister(ReadSurrogate(args));
}
else if (args.TypeData.HasConverter && !settings.IgnoreTypeConverter)
{
return ReturnRegister(ReadConverter(args));
}
else if (args.TypeData.IsISerializable && !settings.IgnoreISerializable)
{
return ReturnRegister(ReadISerializable(args));
}
else
{
switch (args.TypeData.Kind)
{
default:
case PrimitiveType.None:
throw new InvalidOperationException("shouldn't be there");
case PrimitiveType.Object:
if (args.TypeData.IsArray)
{
return ReadArray(args, oid);
}
else if (args.TypeData.IsNullable)
{
object o = null;
var isNotNull = input.ReadBool();
if (isNotNull)
o = ReadImpl(new ReadArgs(args.TypeData.GenericParameters[0]));
return ReturnRegister(o);
}
else if (args.TypeData.IsEnum)
{
var val = ReadImpl(new ReadArgs(args.TypeData.Element));
var eType = args.InstanceType(readRaw);
if (eType != null)
{
val = Enum.ToObject(eType.Type, val);
}
else
{
// leave it as is?
// or return an ObjectData?
}
return ReturnRegister(val);
}
else
{
return ReturnRegister(ReadObject(args, oid));
}
case PrimitiveType.Type:
{
var result = new TypeData();
ReturnRegister(result);
result.Read(this, input);
return result;
}
case PrimitiveType.String:
return ReturnRegister(input.ReadString());
case PrimitiveType.Bytes:
return ReturnRegister(input.ReadBytes());
case PrimitiveType.Guid:
return ReturnRegister(input.ReadGuid());
case PrimitiveType.Bool:
return ReturnRegister(input.ReadBool());
case PrimitiveType.Char:
return ReturnRegister(input.ReadChar());
case PrimitiveType.Byte:
return ReturnRegister(input.ReadByte());
case PrimitiveType.SByte:
return ReturnRegister(input.ReadSByte());
case PrimitiveType.Int16:
return ReturnRegister(input.ReadInt16());
case PrimitiveType.UInt16:
return ReturnRegister(input.ReadUInt16());
case PrimitiveType.Int32:
return ReturnRegister(input.ReadInt32());
case PrimitiveType.UInt32:
return ReturnRegister(input.ReadUInt32());
case PrimitiveType.Int64:
return ReturnRegister(input.ReadInt64());
case PrimitiveType.UInt64:
return ReturnRegister(input.ReadUInt64());
case PrimitiveType.Single:
return ReturnRegister(input.ReadSingle());
case PrimitiveType.Double:
return ReturnRegister(input.ReadDouble());
case PrimitiveType.Decimal:
return ReturnRegister(input.ReadDecimal());
}
}
}
//***************************************************************
//
// Deserialize
//
/// <summary>
/// Determines if the stream contains a name table and loads it if it exists
/// </summary>
/// <param name="reader"></param>
public void Deserialize(IPrimitiveReader reader, TypeSerializationHeader header)
{
long oldPosition = reader.BaseStream.Position;
long endPosition = 0;
short size = 0;
short signature = 0;
byte assemblyCount = 0;
byte typeCount = 0;
byte index = 0;
string assemblyName = null;
string[] assemblyNames = null;
string typeName = null;
string namespaceName = null;
string[] namespaceNames = null;
byte namespaceCount = 0;
// Determine if the stream contains a name table
if ((reader.BaseStream.Length - oldPosition) < HeaderLength)
{
return;
}
endPosition = reader.BaseStream.Seek(-HeaderLength, System.IO.SeekOrigin.End);
size = reader.ReadInt16();
signature = reader.ReadInt16();
if (signature == Signature)
{
reader.BaseStream.Seek(endPosition - size, System.IO.SeekOrigin.Begin);
// Load assembly names
assemblyCount = reader.ReadByte();
assemblyNames = new string[assemblyCount];
for (index = 0; index < assemblyCount; index++)
{
assemblyNames[index] = reader.ReadString();
}
// Load namespace names
namespaceCount = reader.ReadByte();
namespaceNames = new string[namespaceCount];
for (index = 0; index < namespaceCount; index++)
{
namespaceNames[index] = reader.ReadString();
}
// Load types
typeCount = reader.ReadByte();
this.resolvedTypeTable = new TypeInfo[typeCount];
for (index = 0; index < typeCount; index++)
{
TypeInfo rti = new TypeInfo();
if ((header != null) && (header.HeaderVersion >= 1))
{
rti.Version = reader.ReadByte();
}
assemblyName = assemblyNames[reader.ReadByte()];
namespaceName = namespaceNames[reader.ReadByte()];
typeName = reader.ReadString();
rti.TypeName = string.Format("{1}.{0},{2}", typeName, namespaceName, assemblyName);
this.resolvedTypeTable[index] = rti;
}
}
// Reset stream position
reader.BaseStream.Seek(oldPosition, System.IO.SeekOrigin.Begin);
}
/// <summary>
/// Am even faster way to et known value type, using strongly typed accessor on platform supporting it.
/// </summary>
/// <param name="reader">The source of the value</param>
/// <param name="instance">The instance which member would be set</param>
/// <returns>Whether the value could be set. If not the <paramref name="reader"/> won't be read.</returns>
public bool TryFastReadSet(IPrimitiveReader reader, object instance)
{
#if __NET__ || __NETCORE__
if (hasFastSetter && instance != null)
{
switch (Type.Kind)
{
case PrimitiveType.Guid:
setterGuid(instance, reader.ReadGuid());
break;
case PrimitiveType.Bool:
setterBool(instance, reader.ReadBool());
break;
case PrimitiveType.Char:
setterChar(instance, reader.ReadChar());
break;
case PrimitiveType.Byte:
setterByte(instance, reader.ReadByte());
break;
case PrimitiveType.SByte:
setterSByte(instance, reader.ReadSByte());
break;
case PrimitiveType.Int16:
setterInt16(instance, reader.ReadInt16());
break;
case PrimitiveType.UInt16:
setterUInt16(instance, reader.ReadUInt16());
break;
case PrimitiveType.Int32:
setterInt32(instance, reader.ReadInt32());
break;
case PrimitiveType.UInt32:
setterUInt32(instance, reader.ReadUInt32());
break;
case PrimitiveType.Int64:
setterInt64(instance, reader.ReadInt64());
break;
case PrimitiveType.UInt64:
setterUInt64(instance, reader.ReadUInt64());
break;
case PrimitiveType.Single:
setterSingle(instance, reader.ReadSingle());
break;
case PrimitiveType.Double:
setterDouble(instance, reader.ReadDouble());
break;
case PrimitiveType.Decimal:
setterDecimal(instance, reader.ReadDecimal());
break;
}
return(true);
}
#endif
return(false);
}
