/// <summary>
        ///
        /// </summary>
        /// <param name="ms"></param>
        /// <returns></returns>
        internal ulong ReadContentLength(SuperStream stream)
        {
            switch (this.Type)
            {
            case LengthType.Byte:
                return((byte)stream.ReadByte());

            case LengthType.UInt16:
                return(stream.ReadUInt16());

            default:
            case LengthType.UInt32:
                return(stream.ReadUInt32());
            }
        }
Esempio n. 2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="ms"></param>
        /// <returns></returns>
        internal ulong ReadContentLength(SuperStream stream)
        {
            var countType = this.Attributes.FirstOrDefault(a => a is StreamDataCollectionLengthAttribute) as StreamDataCollectionLengthAttribute;

            if (countType == null)
            {
                return(this.Entries);
            }

            switch (countType.Type)
            {
            case LengthType.Byte:
                return((byte)stream.ReadByte());

            case LengthType.UInt16:
                return(stream.ReadUInt16());

            default:
            case LengthType.UInt32:
                return(stream.ReadUInt32());
            }
        }
        private bool GetValue(Type dataType, SuperStream stream, out object value)
        {
            if (dataType == typeof(Byte))
            {
                value = (byte)stream.ReadByte();
                return(true);
            }

            if (dataType == typeof(Int64))
            {
                value = stream.ReadInt64();
                return(true);
            }
            if (dataType == typeof(UInt64))
            {
                value = stream.ReadUInt64();
                return(true);
            }

            if (dataType == typeof(Int32))
            {
                value = stream.ReadInt32();
                return(true);
            }
            if (dataType == typeof(UInt32))
            {
                value = stream.ReadUInt32();
                return(true);
            }

            if (dataType == typeof(Int16))
            {
                value = stream.ReadInt16();
                return(true);
            }
            if (dataType == typeof(UInt16))
            {
                value = stream.ReadUInt16();
                return(true);
            }

            if (dataType == typeof(Single))
            {
                value = stream.ReadSingle();
                return(true);
            }

            if (dataType == typeof(Double))
            {
                value = stream.ReadDouble();
                return(true);
            }

            if (dataType == typeof(bool))
            {
                var val = stream.ReadUInt32();
                if (val == 0)
                {
                    value = false;
                    return(true);
                }
                else if (val == 1)
                {
                    value = true;
                    return(true);
                }
                else
                {
                    throw new Exception("Parsing type bool: Expected value to be either 0 or 1, but it was " + val.ToString());
                }
            }

            if (dataType.IsEnum)
            {
                object readValue;
                // Read the enums underlying type
                if (!this.GetValue(Enum.GetUnderlyingType(dataType), stream, out readValue))
                {
                    value = null;
                    return(false);
                }
                // Parse enum using the read value.
                value = Enum.ToObject(dataType, readValue);
                return(true);
            }

            // Test if type has StreamDataAttribute on properties.
            // This allows nesting of StreamData-aware task.DataTypes
            var props = StreamDataInfo.GetProperties(dataType);

            if (props.Length == 0)
            {
                value = null;
                return(false);
            }

            value = StreamData.Create(dataType, stream);
            if (value == null)
            {
                return(false);
            }
            return(true);
        }