internal ArrayOfPrimitivesInfo(Array obj, ISerializationContext ctx)
: base(obj, ctx)
{
_elementType = SerializeTypes.GetTypeEnum(obj.GetType().GetElementType());
_rank = obj.Rank;
_dimensions = new int[_rank];
for (int i = 0; i < _rank; i++)
{
_dimensions[i] = obj.GetLength(i);
}
int[] ind = new int[_rank];
int currDim = 0;
int count = 1;
for (int i = 0; i < _rank; i++)
{
count *= _dimensions[i];
}
this._values = new object[count];
for (int i = 0; i < count; i++)
{
ind = MySerializer.GetNewArrayIndexes(_rank, _dimensions, ind, ref currDim);
_values[i] = obj.GetValue(ind);
}
}
public override void Read(Stream stream)
{
_elementType = (SerializeTypeEnum)stream.ReadByte();
var elementType = SerializeTypes.GetType(_elementType);
_rank = stream.ReadInt32();
_dimensions = new int[_rank];
for (int i = 0; i < _rank; i++)
{
_dimensions[i] = stream.ReadInt32();
}
int currDim = 0;
int count = 1;
var ind = new int[_rank];
for (int i = 0; i < _rank; i++)
{
count *= _dimensions[i];
}
_values = new object[count];
for (int i = 0; i < count; i++)
{
ind = MySerializer.GetNewArrayIndexes(_rank, _dimensions, ind, ref currDim);
_values[i] = stream.ReadPrimitiveOrStringType(elementType);
}
}
private SerializeInstanceInfo GetUninitializedTypeInfo(SerializeTypeEnum type)
{
SerializeInstanceInfo info = null;
switch (type)
{
case SerializeTypeEnum.Null:
case SerializeTypeEnum.Byte:
case SerializeTypeEnum.Bool:
case SerializeTypeEnum.Int16:
case SerializeTypeEnum.Int32:
case SerializeTypeEnum.Int64:
case SerializeTypeEnum.UInt16:
case SerializeTypeEnum.UInt32:
case SerializeTypeEnum.UInt64:
case SerializeTypeEnum.Float:
case SerializeTypeEnum.Double:
case SerializeTypeEnum.String:
{
info = new PrimitiveTypeInfo(type, this);
}
break;
case SerializeTypeEnum.Enum:
{
info = new EnumInfo();
}
break;
case SerializeTypeEnum.ArrayOfPrimitives:
{
info = new ArrayOfPrimitivesInfo(this);
}
break;
case SerializeTypeEnum.ArrayOfByref:
{
info = new ArrayOfByRefInfo(this);
}
break;
case SerializeTypeEnum.Custom:
{
info = new CustomInfo(this);
}
break;
case SerializeTypeEnum.SerializedYet:
{
info = new SerializedYetInfo(-1);
}
break;
default:
break;
}
return(info);
}
/// <summary>
/// Initializes a new instance of the <see cref="Message"/> class.
/// </summary>
public Message(string messageId, object body, SerializeTypeEnum serializeType, MessageTypeEnum messageType)
{
this.Body = body;
BodyType = Body.GetType().AssemblyQualifiedName;
SerializeType = serializeType;
CorrelationId = Common.Common.GenerateGuid();
MessageId = messageId;
ObjectId = string.Empty;
MessageType = messageType;
CreatedDate = Extensions.GetCurrentDateUtc();
}
private static void WritePrimitiveData(Stream s, SerializeTypeEnum type, object val)
{
switch (type)
{
case SerializeTypeEnum.Bool:
s.WriteBool((bool)val);
break;
case SerializeTypeEnum.Byte:
s.WriteByte((byte)val);
break;
case SerializeTypeEnum.Double:
s.WriteDouble((Double)val);
break;
case SerializeTypeEnum.Float:
s.WriteFloat((float)val);
break;
case SerializeTypeEnum.Int16:
s.WriteInt16((Int16)val);
break;
case SerializeTypeEnum.Int32:
s.WriteInt32((Int32)val);
break;
case SerializeTypeEnum.Int64:
s.WriteInt64((Int64)val);
break;
case SerializeTypeEnum.UInt16:
s.WriteUInt16((UInt16)val);
break;
case SerializeTypeEnum.UInt32:
s.WriteUInt32((UInt32)val);
break;
case SerializeTypeEnum.UInt64:
s.WriteUInt64((UInt64)val);
break;
case SerializeTypeEnum.String:
s.WriteString((string)val, Encoding.ASCII);
break;
default:
throw new Exception();
}
}
public static Array ReadPrimitiveDataArray(Stream s, SerializeTypeEnum type, int length)
{
switch (type)
{
case SerializeTypeEnum.Bool:
return(s.ReadToArray <bool>(length));
case SerializeTypeEnum.Byte:
byte[] temp = new byte[length];
s.Read(temp, 0, length);
return(temp);
case SerializeTypeEnum.Double:
return(s.ReadToArray <double>(length));
case SerializeTypeEnum.Float:
return(s.ReadToArray <float>(length));
case SerializeTypeEnum.Int16:
return(s.ReadToArray <Int16>(length));
case SerializeTypeEnum.Int32:
return(s.ReadToArray <Int32>(length));
case SerializeTypeEnum.Int64:
return(s.ReadToArray <Int64>(length));
case SerializeTypeEnum.UInt16:
return(s.ReadToArray <UInt16>(length));
case SerializeTypeEnum.UInt32:
return(s.ReadToArray <UInt32>(length));
case SerializeTypeEnum.UInt64:
return(s.ReadToArray <UInt64>(length));
case SerializeTypeEnum.String:
var ary = new string[length];
for (var i = 0; i < length; i++)
{
ary[i] = s.ReadString(Encoding.UTF8);
}
return(ary);
default:
throw new Exception();
}
}
public void ApplyRawData(byte rawdata)
{
FieldActive = (rawdata & 0b10000000) > 0;
HasLabel = (rawdata & 0b01000000) > 0;
IsArray = (rawdata & 0b00100000) > 0;
IsPrimitive = (rawdata & 0b00010000) > 0;
byte typeIndex = (byte)(rawdata & 0b00001111);
if (IsPrimitive)
{
TypeEnum = (SerializeTypeEnum)typeIndex;
}
else
{
TypeEnum = SerializeTypeEnum.Custom;
CustomTypeIndex = typeIndex;
}
}
public object Deserialize(Stream stream)
{
_serializedInstances.Clear();
object o = null;
SerializeTypeEnum t = (SerializeTypeEnum)stream.ReadByte();
if (t is SerializeTypeEnum.Null)
{
o = null;
}
else
{
var info = this.GetUninitializedTypeInfo(t);
info.Read(stream);
o = info.Get(_serializedInstances);
}
return(o);
}
private static object ReadPrimitiveData(Stream s, SerializeTypeEnum type)
{
switch (type)
{
case SerializeTypeEnum.Bool:
return(s.ReadBool());
case SerializeTypeEnum.Byte:
return((byte)s.ReadByte());
case SerializeTypeEnum.Double:
return(s.ReadDouble());
case SerializeTypeEnum.Float:
return(s.ReadFloat());
case SerializeTypeEnum.Int16:
return(s.ReadInt16());
case SerializeTypeEnum.Int32:
return(s.ReadInt32());
case SerializeTypeEnum.Int64:
return(s.ReadInt64());
case SerializeTypeEnum.UInt16:
return(s.ReadUInt16());
case SerializeTypeEnum.UInt32:
return(s.ReadUInt32());
case SerializeTypeEnum.UInt64:
return(s.ReadUInt64());
case SerializeTypeEnum.String:
return(s.ReadString(Encoding.ASCII));
default:
throw new Exception();
}
}
private static void WritePrimitiveDataArray(Stream s, SerializeTypeEnum type, Array tval)
{
switch (type)
{
case SerializeTypeEnum.Bool:
{
var val = tval as bool[];
for (var i = 0; i < val.Length; i++)
{
s.WriteBool(val[i]);
}
}
break;
case SerializeTypeEnum.Byte:
{
var val = tval as byte[];
s.Write(val, 0, val.Length);
}
break;
case SerializeTypeEnum.Double:
{
var val = tval as double[];
for (var i = 0; i < val.Length; i++)
{
s.WriteDouble(val[i]);
}
}
break;
case SerializeTypeEnum.Float:
{
var val = tval as float[];
for (var i = 0; i < val.Length; i++)
{
s.WriteFloat(val[i]);
}
}
break;
case SerializeTypeEnum.Int16:
{
var val = tval as Int16[];
for (var i = 0; i < val.Length; i++)
{
s.WriteInt16(val[i]);
}
}
break;
case SerializeTypeEnum.Int32:
{
var val = tval as Int32[];
for (var i = 0; i < val.Length; i++)
{
s.WriteInt32(val[i]);
}
}
break;
case SerializeTypeEnum.Int64:
{
var val = tval as Int64[];
for (var i = 0; i < val.Length; i++)
{
s.WriteInt64(val[i]);
}
}
break;
case SerializeTypeEnum.UInt16:
{
var val = tval as UInt16[];
for (var i = 0; i < val.Length; i++)
{
s.WriteUInt16(val[i]);
}
}
break;
case SerializeTypeEnum.UInt32:
{
var val = tval as UInt32[];
for (var i = 0; i < val.Length; i++)
{
s.WriteUInt32(val[i]);
}
}
break;
case SerializeTypeEnum.UInt64:
{
var val = tval as UInt64[];
for (var i = 0; i < val.Length; i++)
{
s.WriteUInt64(val[i]);
}
}
break;
case SerializeTypeEnum.String:
{
var val = tval as string[];
for (var i = 0; i < val.Length; i++)
{
s.WriteString(val[i], Encoding.UTF8);
}
}
break;
default:
throw new Exception();
}
}
public static Type GetType(SerializeTypeEnum t)
{
return(_typeMap.FirstOrDefault(s => s.Value == t).Key);
}
internal PrimitiveTypeInfo(SerializeTypeEnum type, ISerializationContext ctx)
: base(ctx)
{
_type = SerializeTypes.GetType(type);
}
SerializeInstanceInfo ISerializationContext.GetUninitializedTypeInfo(SerializeTypeEnum type)
{
return(this.GetUninitializedTypeInfo(type));
}
