public MySerializeInfo(MyObjectFlags flags, MyPrimitiveFlags primitiveFlags, ushort fixedLength, DynamicSerializerDelegate dynamicSerializer, MySerializeInfo keyInfo, MySerializeInfo itemInfo) { Flags = flags; PrimitiveFlags = primitiveFlags; FixedLength = fixedLength; KeyInfo = keyInfo; ItemInfo = itemInfo; DynamicSerializer = dynamicSerializer; }
public MySerializeInfo(SerializeAttribute attribute, MySerializeInfo keyInfo, MySerializeInfo itemInfo) { if (attribute != null) { Flags = attribute.Flags; PrimitiveFlags = attribute.PrimitiveFlags; FixedLength = attribute.FixedLength; if (IsDynamic) { Debug.Assert(attribute.DynamicSerializerType != null, "DynamicSerializerType must be set when serializing dynamically!"); DynamicSerializer = ((IDynamicResolver)Activator.CreateInstance(attribute.DynamicSerializerType)).Serialize; } } KeyInfo = keyInfo; ItemInfo = itemInfo; }
public override void Write(Library.Collections.BitStream stream, ref TItem[] value, MySerializeInfo info) { stream.WriteVariant((uint)value.Length); for (int i = 0; i < value.Length; i++) { MySerializationHelpers.Write <TItem>(stream, ref value[i], m_itemSerializer, info.ItemInfo ?? MySerializeInfo.Default); } }
public override void Write(Library.Collections.BitStream stream, ref float value, MySerializeInfo info) { if (info.IsNormalized && info.IsFixed8) { stream.WriteByte((byte)(value * 255.0f)); } else if (info.IsNormalized && info.IsFixed16) { stream.WriteUInt16((ushort)(value * 65535.0f)); } else { stream.WriteFloat(value); } }
public override void Write(Library.Collections.BitStream stream, ref TEnum value, MySerializeInfo info) { ulong val = MyEnum <TEnum> .GetValue(value); if (m_valueCount == 2) { stream.WriteBool(val == m_firstUlong); } else if (m_valueCount > 2) { if (HasNegativeValues) { stream.WriteVariantSigned((long)val); } else { stream.WriteUInt64(val, m_bitCount); } } }
public override void Write(Library.Collections.BitStream stream, ref Color value, MySerializeInfo info) { stream.WriteUInt32(value.PackedValue); }
public override void Write(BitStream stream, ref BitReaderWriter value, MySerializeInfo info) { value.Write(stream); }
public abstract void Write(BitStream stream, object obj, MySerializeInfo info);
public abstract void Init(MemberInfo memberInfo, MySerializeInfo info);
public static MySerializeInfo CreateInfo(MemberInfo member) { return(MySerializeInfo.Create(member)); }
public override void Write(BitStream stream, ref Dictionary <TKey, TValue> obj, MySerializeInfo info) { TKey key; TValue value; int num = obj.Count; stream.WriteVariant((uint)num); foreach (var item in obj) { key = item.Key; value = item.Value; MySerializationHelpers.Write(stream, ref key, m_keySerializer, info.KeyInfo ?? MySerializeInfo.Default); MySerializationHelpers.Write(stream, ref value, m_valueSerializer, info.ItemInfo ?? MySerializeInfo.Default); } }
public override void Read(BitStream stream, out Dictionary <TKey, TValue> obj, MySerializeInfo info) { TKey key; TValue value; int num = (int)stream.ReadUInt32Variant(); obj = new Dictionary <TKey, TValue>(num); for (int i = 0; i < num; i++) { MySerializationHelpers.CreateAndRead(stream, out key, m_keySerializer, info.KeyInfo ?? MySerializeInfo.Default); MySerializationHelpers.CreateAndRead(stream, out value, m_valueSerializer, info.ItemInfo ?? MySerializeInfo.Default); obj.Add(key, value); } }
public override void Write(Library.Collections.BitStream stream, ref Guid value, MySerializeInfo info) { string s = value.ToString(); stream.WritePrefixLengthString(s, 0, s.Length, info.Encoding); }
public override void Read(Library.Collections.BitStream stream, out Guid value, MySerializeInfo info) { string s = stream.ReadPrefixLengthString(info.Encoding); value = new Guid(s); }
public override void Write(Library.Collections.BitStream stream, ref UInt64 value, MySerializeInfo info) { if (info.IsVariant || info.IsVariantSigned) { stream.WriteVariant(value); } else { stream.WriteUInt64(value); } }
public override void Write(Library.Collections.BitStream stream, ref Int16 value, MySerializeInfo info) { if (info.IsVariant) { stream.WriteVariant((UInt16)value); } else if (info.IsVariantSigned) { stream.WriteVariantSigned(value); } else { stream.WriteInt16(value); } }
public override void Read(BitStream stream, out BitReaderWriter value, MySerializeInfo info) { value = BitReaderWriter.ReadFrom(stream); }
public override void Read(Library.Collections.BitStream stream, out Color value, MySerializeInfo info) { value.PackedValue = stream.ReadUInt32(); }
public abstract void Read(BitStream stream, out T value, MySerializeInfo info);
public abstract void Write(BitStream stream, ref T value, MySerializeInfo info);
public override void Read(Library.Collections.BitStream stream, out TEnum value, MySerializeInfo info) { if (m_valueCount == 1) { value = m_firstValue; } else if (m_valueCount == 2) { value = stream.ReadBool() ? m_firstValue : m_secondValue; } else if (m_valueCount > 2) { if (HasNegativeValues) { value = MyEnum <TEnum> .SetValue((ulong)stream.ReadInt64Variant()); } else { value = MyEnum <TEnum> .SetValue(stream.ReadUInt64(m_bitCount)); } } else { value = default(TEnum); } }
protected sealed internal override void Read(BitStream stream, out object value, MySerializeInfo info) { T obj; Read(stream, out obj, info); value = obj; }
public override void Read(Library.Collections.BitStream stream, out float value, MySerializeInfo info) { if (info.IsNormalized && info.IsFixed8) { value = stream.ReadByte() / 255.0f; } else if (info.IsNormalized && info.IsFixed16) { value = stream.ReadUInt16() / 65535.0f; } else { value = stream.ReadFloat(); } }
protected sealed internal override void Write(BitStream stream, object value, MySerializeInfo info) { T obj = (T)value; Write(stream, ref obj, info); }
public override void Read(Library.Collections.BitStream stream, out TItem[] value, MySerializeInfo info) { int num = (int)stream.ReadUInt32Variant(); value = new TItem[num]; for (int i = 0; i < value.Length; i++) { MySerializationHelpers.CreateAndRead <TItem>(stream, out value[i], m_itemSerializer, info.ItemInfo ?? MySerializeInfo.Default); } }
public override void Read(Library.Collections.BitStream stream, out Half value, MySerializeInfo info) { if (info.IsNormalized && info.IsFixed8) { value = stream.ReadByte() / 255.0f; } else { value = stream.ReadHalf(); } }
public override void Read(Library.Collections.BitStream stream, out UInt64 value, MySerializeInfo info) { if (info.IsVariant || info.IsVariantSigned) { value = stream.ReadUInt64Variant(); } else { value = stream.ReadUInt64(); } }
public override void Write(Library.Collections.BitStream stream, ref Half value, MySerializeInfo info) { if (info.IsNormalized && info.IsFixed8) { stream.WriteByte((byte)(value * 255.0f)); } else { stream.WriteHalf(value); } }
public override void Write(Library.Collections.BitStream stream, ref T?value, MySerializeInfo info) { if (value.HasValue) { T val = value.Value; stream.WriteBool(true); m_serializer.Write(stream, ref val, info); } else { stream.WriteBool(false); } }
public override void Read(Library.Collections.BitStream stream, out Int16 value, MySerializeInfo info) { if (info.IsVariant) { value = (Int16)stream.ReadUInt32Variant(); } else if (info.IsVariantSigned) { value = (Int16)stream.ReadInt32Variant(); } else { value = stream.ReadInt16(); } }