Exemple #1
0
        internal ulong WriteContentLength(SuperStream stream, ulong length)
        {
            var countType = this.Attributes.FirstOrDefault(a => a is StreamDataCollectionLengthAttribute) as StreamDataCollectionLengthAttribute;

            if (countType == null)
            {
                return(this.Entries);
            }
            switch (countType.Type)
            {
            case LengthType.Byte:
                stream.WriteByte((byte)length);
                break;

            case LengthType.UInt16:
                stream.WriteUInt16((ushort)length);
                break;

            default:
            case LengthType.UInt32:
                stream.WriteUInt32((uint)length);
                break;
            }
            return(length);
        }
        internal void WriteContentLength(SuperStream stream, ulong length)
        {
            switch (this.Type)
            {
            case LengthType.Byte:
                stream.WriteByte((byte)length);
                break;

            case LengthType.UInt16:
                stream.WriteUInt16((ushort)length);
                break;

            default:
            case LengthType.UInt32:
                stream.WriteUInt32((uint)length);
                break;
            }
        }
        private bool WriteValue(Type dataType, SuperStream stream, object value)
        {
            if (dataType == typeof(Byte))
            {
                stream.WriteByte((byte)value);
                return(true);
            }

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

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

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

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

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

            if (dataType == typeof(bool))
            {
                // If bool is true, write 1. Otherwise, write 0.
                int val = ((bool)value) ? 1 : 0;
                stream.WriteInt32(val);
            }

            if (dataType.IsEnum)
            {
                dynamic storeValue = Convert.ChangeType(value, Enum.GetUnderlyingType(dataType));
                return(this.WriteValue(storeValue.GetType(), stream, storeValue));
            }

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

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

            StreamData.Serialize(value, stream);
            // Need to add error condition here.
            return(true);
        }