Пример #1
0
        internal static bool?ReadBooleanNullable(BinaryReader reader)
        {
            var value = NumericSerializers.ReadVarByteNullable(reader);

            if (value == null)
            {
                return(null);
            }
            return(value.Value != 0);
        }
Пример #2
0
        internal static DateTime?ReadDateTimeNullable(BinaryReader reader)
        {
            var kind = NumericSerializers.ReadVarByteNullable(reader);

            if (kind == null)
            {
                return(null);
            }

            var ticks = NumericSerializers.ReadVarInt64(reader);

            if (ticks == 0L)
            {
                return(DateTime.MinValue);
            }
            if (ticks == 1L)
            {
                return(DateTime.MaxValue);
            }

            return(new DateTime(ticks, (DateTimeKind)kind.Value));
        }
Пример #3
0
        internal static Enum ReadEnum(BinaryReader reader, Type type)
        {
            var enumType = BoisTypeCache.GetEnumType(type);

            if (enumType == null)
            {
                throw new Exception($"Cannot determine the type of enum '{type.Name}'");
            }

            switch (enumType.KnownType)
            {
            case EnBasicEnumType.Int32:
                if (enumType.IsNullable)
                {
                    var val = NumericSerializers.ReadVarInt32Nullable(reader);
                    if (val == null)
                    {
                        return(null);
                    }
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }
                else
                {
                    var val = NumericSerializers.ReadVarInt32(reader);
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }

            case EnBasicEnumType.Byte:
                if (enumType.IsNullable)
                {
                    var val = NumericSerializers.ReadVarByteNullable(reader);
                    if (val == null)
                    {
                        return(null);
                    }
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }
                else
                {
                    var val = reader.ReadByte();
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }

            case EnBasicEnumType.Int16:
                if (enumType.IsNullable)
                {
                    var val = NumericSerializers.ReadVarInt16Nullable(reader);
                    if (val == null)
                    {
                        return(null);
                    }
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }
                else
                {
                    var val = NumericSerializers.ReadVarInt16(reader);
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }

            case EnBasicEnumType.Int64:
                if (enumType.IsNullable)
                {
                    var val = NumericSerializers.ReadVarInt64Nullable(reader);
                    if (val == null)
                    {
                        return(null);
                    }
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }
                else
                {
                    var val = NumericSerializers.ReadVarInt64(reader);
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }

            case EnBasicEnumType.UInt16:
                if (enumType.IsNullable)
                {
                    var val = NumericSerializers.ReadVarUInt16Nullable(reader);
                    if (val == null)
                    {
                        return(null);
                    }
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }
                else
                {
                    var val = NumericSerializers.ReadVarUInt16(reader);
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }

            case EnBasicEnumType.UInt32:
                if (enumType.IsNullable)
                {
                    var val = NumericSerializers.ReadVarUInt32Nullable(reader);
                    if (val == null)
                    {
                        return(null);
                    }
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }
                else
                {
                    var val = NumericSerializers.ReadVarUInt32(reader);
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }

            case EnBasicEnumType.UInt64:
                if (enumType.IsNullable)
                {
                    var val = NumericSerializers.ReadVarUInt64Nullable(reader);
                    if (val == null)
                    {
                        return(null);
                    }
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }
                else
                {
                    var val = NumericSerializers.ReadVarUInt64(reader);
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }

            case EnBasicEnumType.SByte:
                if (enumType.IsNullable)
                {
                    var val = NumericSerializers.ReadVarSByteNullable(reader);
                    if (val == null)
                    {
                        return(null);
                    }
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }
                else
                {
                    var val = reader.ReadSByte();
                    return((Enum)Enum.ToObject(enumType.BareType, val));
                }

            default:
                throw new Exception($"Enum type not supported '{type.Name}'. Contact the author please https://github.com/salarcode/Bois/issues ");
            }
        }