Example #1
0
        internal static byte[] ReadByteArray(BinaryReader reader)
        {
            var length = NumericSerializers.ReadVarUInt32Nullable(reader);

            if (length == null)
            {
                return(null);
            }
            return(reader.ReadBytes((int)length.Value));
        }
Example #2
0
        internal static string ReadString(BinaryReader reader, Encoding encoding)
        {
            uint?length = NumericSerializers.ReadVarUInt32Nullable(reader);

            if (length == null)
            {
                return(null);
            }
            else if (length == 0)
            {
                return(string.Empty);
            }
            else
            {
                var strBuff = reader.ReadBytes((int)length.Value);
                return(encoding.GetString(strBuff, 0, strBuff.Length));
            }
        }
Example #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 ");
            }
        }