private void CheckLength(long length, ReadValueResult type) { if (length > Int32.MaxValue) { this.ThrowTooLongLengthException(length, type); } }
public async void SendLightbulbSocketUpdate() { Request request = new Request(); request.command = "LightbulbUpdate"; ReadValueResult onOff = await this.OnOff.ReadValueAsync(); ReadValueResult brightness = await this.Brightness.ReadValueAsync(); ReadValueResult colorTemperature = await this.ColorTemperature.ReadValueAsync(); ReadValueResult hue = await this.Hue.ReadValueAsync(); ReadValueResult saturation = await this.Saturation.ReadValueAsync(); request.parameters = new Hashtable(); request.parameters.Add("IsOnOff", onOff.Value); request.parameters.Add("Brightness", brightness.Value); request.parameters.Add("ColorTemperature", colorTemperature.Value); request.parameters.Add("Hue", hue.Value); request.parameters.Add("IsColor", (UInt32)saturation.Value > UInt32.MinValue); ControlerService.Instance.SendRequest(request); }
private static void ThrowUnexpectedExtCodeException(ReadValueResult type) { #if DEBUG && !UNITY Contract.Assert(false, "Unexpected ext-code type:" + type); #endif // DEBUG && !UNITY // ReSharper disable once HeuristicUnreachableCode throw new NotSupportedException("Unexpeded ext-code type. " + type); }
private void ThrowTooLongLengthException(long length, ReadValueResult type) { string message; long offsetOrPosition; var isRealOffset = this.GetPreviousPosition(out offsetOrPosition); switch (type) { case ReadValueResult.ArrayLength: { message = isRealOffset ? "MessagePack for CLI cannot handle large array (0x{0:X} elements) which has more than Int32.MaxValue elements, at position {1:#,0}" : "MessagePack for CLI cannot handle large array (0x{0:X} elements) which has more than Int32.MaxValue elements, at offset {1:#,0}"; break; } case ReadValueResult.MapLength: { message = isRealOffset ? "MessagePack for CLI cannot handle large map (0x{0:X} entries) which has more than Int32.MaxValue entries, at position {1:#,0}" : "MessagePack for CLI cannot handle large map (0x{0:X} entries) which has more than Int32.MaxValue entries, at offset {1:#,0}"; break; } default: { message = isRealOffset ? "MessagePack for CLI cannot handle large binary or string (0x{0:X} bytes) which has more than Int32.MaxValue bytes, at position {1:#,0}" : "MessagePack for CLI cannot handle large binary or string (0x{0:X} bytes) which has more than Int32.MaxValue bytes, at offset {1:#,0}"; break; } } throw new MessageNotSupportedException( String.Format( CultureInfo.CurrentCulture, message, length, offsetOrPosition ) ); }
private void ThrowUnexpectedExtCodeException(ReadValueResult type) { #if DEBUG Contract.Assert(false, "Unexpected ext-code type:" + type); #endif // DEBUG // ReSharper disable HeuristicUnreachableCode long offsetOrPosition; var isRealOffset = this.GetPreviousPosition(out offsetOrPosition); throw new NotSupportedException( String.Format( CultureInfo.CurrentCulture, isRealOffset ? "Unexpeded ext-code type {0} at position {1:#,0}" : "Unexpeded ext-code type {0} at offset {1:#,0}", type, offsetOrPosition ) ); // ReSharper restore HeuristicUnreachableCode }
private async Task<MessagePackExtendedTypeObject> ReadMessagePackExtendedTypeObjectAsyncCore( ReadValueResult type, CancellationToken cancellationToken ) { byte typeCode; uint length; switch ( type ) { case ReadValueResult.FixExt1: { typeCode = await this.ReadByteStrictAsync( cancellationToken ).ConfigureAwait( false ); length = 1; break; } case ReadValueResult.FixExt2: { typeCode = await this.ReadByteStrictAsync( cancellationToken ).ConfigureAwait( false ); length = 2; break; } case ReadValueResult.FixExt4: { typeCode = await this.ReadByteStrictAsync( cancellationToken ).ConfigureAwait( false ); length = 4; break; } case ReadValueResult.FixExt8: { typeCode = await this.ReadByteStrictAsync( cancellationToken ).ConfigureAwait( false ); length = 8; break; } case ReadValueResult.FixExt16: { typeCode = await this.ReadByteStrictAsync( cancellationToken ).ConfigureAwait( false ); length = 16; break; } case ReadValueResult.Ext8: { await this.ReadStrictAsync( this._scalarBuffer, sizeof( byte ), cancellationToken ).ConfigureAwait( false ); length = BigEndianBinary.ToByte( this._scalarBuffer, 0 ); typeCode = this.ReadByteStrict(); break; } case ReadValueResult.Ext16: { await this.ReadStrictAsync( this._scalarBuffer, sizeof( ushort ), cancellationToken ).ConfigureAwait( false ); length = BigEndianBinary.ToUInt16( this._scalarBuffer, 0 ); typeCode = this.ReadByteStrict(); break; } case ReadValueResult.Ext32: { await this.ReadStrictAsync( this._scalarBuffer, sizeof( uint ), cancellationToken ).ConfigureAwait( false ); length = BigEndianBinary.ToUInt32( this._scalarBuffer, 0 ); typeCode = this.ReadByteStrict(); break; } default: { this.ThrowUnexpectedExtCodeException( type ); return default( MessagePackExtendedTypeObject ); // Never reach } } var data = new byte[ length ]; await this.ReadStrictAsync( data, data.Length, cancellationToken ).ConfigureAwait( false ); this.InternalCollectionType = CollectionType.None; return new MessagePackExtendedTypeObject( typeCode, data ); }
private MessagePackExtendedTypeObject ReadMessagePackExtendedTypeObjectCore( ReadValueResult type ) { byte typeCode; uint length; switch ( type ) { case ReadValueResult.FixExt1: { typeCode = this.ReadByteStrict(); length = 1; break; } case ReadValueResult.FixExt2: { typeCode = this.ReadByteStrict(); length = 2; break; } case ReadValueResult.FixExt4: { typeCode = this.ReadByteStrict(); length = 4; break; } case ReadValueResult.FixExt8: { typeCode = this.ReadByteStrict(); length = 8; break; } case ReadValueResult.FixExt16: { typeCode = this.ReadByteStrict(); length = 16; break; } case ReadValueResult.Ext8: { this.ReadStrict( this._scalarBuffer, sizeof( byte ) ); length = BigEndianBinary.ToByte( this._scalarBuffer, 0 ); typeCode = this.ReadByteStrict(); break; } case ReadValueResult.Ext16: { this.ReadStrict( this._scalarBuffer, sizeof( ushort ) ); length = BigEndianBinary.ToUInt16( this._scalarBuffer, 0 ); typeCode = this.ReadByteStrict(); break; } case ReadValueResult.Ext32: { this.ReadStrict( this._scalarBuffer, sizeof( uint ) ); length = BigEndianBinary.ToUInt32( this._scalarBuffer, 0 ); typeCode = this.ReadByteStrict(); break; } default: { this.ThrowUnexpectedExtCodeException( type ); return default( MessagePackExtendedTypeObject ); // Never reach } } var data = new byte[ length ]; this.ReadStrict( data, data.Length ); this.InternalCollectionType = CollectionType.None; return new MessagePackExtendedTypeObject( typeCode, data ); }
public static byte ToByte(this ReadValueResult source) { switch (source) { case ReadValueResult.Nil: { return(( byte )MessagePackCode.NilValue); } case ReadValueResult.True: { return(( byte )MessagePackCode.TrueValue); } case ReadValueResult.False: { return(( byte )MessagePackCode.FalseValue); } case ReadValueResult.InvalidCode: { return(0xC1); } } if ((source & ReadValueResult.FlagsAndTypeCodeMask) == 0) { return(( byte )(( int )(source & ReadValueResult.ValueOrLengthMask))); } if ((source & ReadValueResult.ArrayTypeMask) == ReadValueResult.ArrayTypeMask) { var length = ( int )(source & ReadValueResult.LengthOfLengthMask) >> 8; switch (length) { case 0: { return(( byte )(MessagePackCode.MinimumFixedArray | ( int )(source & ReadValueResult.ValueOrLengthMask))); } case 2: { return(( byte )MessagePackCode.Array16); } default: { #if DEBUG Contract.Assert(length == 4, length + " == 4"); #endif // DEBUG return(( byte )MessagePackCode.Array32); } } } if ((source & ReadValueResult.MapTypeMask) == ReadValueResult.MapTypeMask) { var length = ( int )(source & ReadValueResult.LengthOfLengthMask) >> 8; switch (length) { case 0: { return(( byte )(MessagePackCode.MinimumFixedMap | ( int )(source & ReadValueResult.ValueOrLengthMask))); } case 2: { return(( byte )MessagePackCode.Map16); } default: { #if DEBUG Contract.Assert(length == 4, length + " == 4"); #endif // DEBUG return(( byte )MessagePackCode.Map32); } } } if ((source & ReadValueResult.RawTypeMask) == ReadValueResult.RawTypeMask) { var isBin = (source & ReadValueResult.BinTypeMask) == ReadValueResult.BinTypeMask; var length = ( int )(source & ReadValueResult.LengthOfLengthMask) >> 8; switch (length) { case 0: { return(( byte )(MessagePackCode.MinimumFixedRaw | ( int )(source & ReadValueResult.ValueOrLengthMask))); } case 1: { return(( byte )(isBin ? MessagePackCode.Bin8 : MessagePackCode.Str8)); } case 2: { return(( byte )(isBin ? MessagePackCode.Bin16 : MessagePackCode.Str16)); } default: { #if DEBUG Contract.Assert(length == 4, length + " == 4"); #endif // DEBUG return(( byte )(isBin ? MessagePackCode.Bin32 : MessagePackCode.Str32)); } } } if ((source & ReadValueResult.ExtTypeMask) == ReadValueResult.ExtTypeMask) { var length = ( int )(source & ReadValueResult.LengthOfLengthMask) >> 8; switch (length) { case 0: { switch (( int )(source & ReadValueResult.ValueOrLengthMask)) { case 1: { return(( byte )MessagePackCode.FixExt1); } case 2: { return(( byte )MessagePackCode.FixExt2); } case 4: { return(( byte )MessagePackCode.FixExt4); } case 8: { return(( byte )MessagePackCode.FixExt8); } default: { #if DEBUG Contract.Assert(( int )(source & ReadValueResult.ValueOrLengthMask) == 16, ( int )(source & ReadValueResult.ValueOrLengthMask) + " == 16"); #endif // DEBUG return(( byte )MessagePackCode.FixExt16); } } } case 1: { return(( byte )MessagePackCode.Ext8); } case 2: { return(( byte )MessagePackCode.Ext16); } default: { #if DEBUG Contract.Assert(length == 4, length + " == 4"); #endif // DEBUG return(( byte )MessagePackCode.Ext32); } } } switch (source & ReadValueResult.TypeCodeMask) { case ReadValueResult.Int8Type: { return(( byte )MessagePackCode.SignedInt8); } case ReadValueResult.Int16Type: { return(( byte )MessagePackCode.SignedInt16); } case ReadValueResult.Int32Type: { return(( byte )MessagePackCode.SignedInt32); } case ReadValueResult.Int64Type: { return(( byte )MessagePackCode.SignedInt64); } case ReadValueResult.UInt8Type: { return(( byte )MessagePackCode.UnsignedInt8); } case ReadValueResult.UInt16Type: { return(( byte )MessagePackCode.UnsignedInt16); } case ReadValueResult.UInt32Type: { return(( byte )MessagePackCode.UnsignedInt32); } case ReadValueResult.UInt64Type: { return(( byte )MessagePackCode.UnsignedInt64); } case ReadValueResult.Real32Type: { return(( byte )MessagePackCode.Real32); } default: { #if DEBUG Contract.Assert((source & ReadValueResult.TypeCodeMask) == ReadValueResult.Real64Type, (source & ReadValueResult.TypeCodeMask) + " == ReadValueResult.Real64Type"); #endif // DEBUG return(( byte )MessagePackCode.Real64); } } }
private async Task <MessagePackExtendedTypeObject> ReadMessagePackExtendedTypeObjectAsyncCore(ReadValueResult type, CancellationToken cancellationToken) { byte typeCode; uint length; switch (type) { case ReadValueResult.FixExt1: { typeCode = await this.ReadByteStrictAsync(cancellationToken).ConfigureAwait(false); length = 1; break; } case ReadValueResult.FixExt2: { typeCode = await this.ReadByteStrictAsync(cancellationToken).ConfigureAwait(false); length = 2; break; } case ReadValueResult.FixExt4: { typeCode = await this.ReadByteStrictAsync(cancellationToken).ConfigureAwait(false); length = 4; break; } case ReadValueResult.FixExt8: { typeCode = await this.ReadByteStrictAsync(cancellationToken).ConfigureAwait(false); length = 8; break; } case ReadValueResult.FixExt16: { typeCode = await this.ReadByteStrictAsync(cancellationToken).ConfigureAwait(false); length = 16; break; } case ReadValueResult.Ext8: { await this.ReadStrictAsync(this._scalarBuffer, sizeof(byte), cancellationToken).ConfigureAwait(false); length = BigEndianBinary.ToByte(this._scalarBuffer, 0); typeCode = this.ReadByteStrict(); break; } case ReadValueResult.Ext16: { await this.ReadStrictAsync(this._scalarBuffer, sizeof(ushort), cancellationToken).ConfigureAwait(false); length = BigEndianBinary.ToUInt16(this._scalarBuffer, 0); typeCode = this.ReadByteStrict(); break; } case ReadValueResult.Ext32: { await this.ReadStrictAsync(this._scalarBuffer, sizeof(uint), cancellationToken).ConfigureAwait(false); length = BigEndianBinary.ToUInt32(this._scalarBuffer, 0); typeCode = this.ReadByteStrict(); break; } default: { this.ThrowUnexpectedExtCodeException(type); return(default(MessagePackExtendedTypeObject)); // Never reach } } var data = new byte[length]; await this.ReadStrictAsync(data, data.Length, cancellationToken).ConfigureAwait(false); this.InternalCollectionType = CollectionType.None; return(new MessagePackExtendedTypeObject(typeCode, data)); }
private void ThrowTooLongLengthException( long length, ReadValueResult type ) { string message; long offsetOrPosition; var isRealOffset = this.GetPreviousPosition( out offsetOrPosition ); switch ( type ) { case ReadValueResult.ArrayLength: { message = isRealOffset ? "MessagePack for CLI cannot handle large array (0x{0:X} elements) which has more than Int32.MaxValue elements, at position {1:#,0}" : "MessagePack for CLI cannot handle large array (0x{0:X} elements) which has more than Int32.MaxValue elements, at offset {1:#,0}"; break; } case ReadValueResult.MapLength: { message = isRealOffset ? "MessagePack for CLI cannot handle large map (0x{0:X} entries) which has more than Int32.MaxValue entries, at position {1:#,0}" : "MessagePack for CLI cannot handle large map (0x{0:X} entries) which has more than Int32.MaxValue entries, at offset {1:#,0}"; break; } default: { message = isRealOffset ? "MessagePack for CLI cannot handle large binary or string (0x{0:X} bytes) which has more than Int32.MaxValue bytes, at position {1:#,0}" : "MessagePack for CLI cannot handle large binary or string (0x{0:X} bytes) which has more than Int32.MaxValue bytes, at offset {1:#,0}"; break; } } throw new MessageNotSupportedException( String.Format( CultureInfo.CurrentCulture, message, length, offsetOrPosition ) ); }
private void CheckLength( long length, ReadValueResult type ) { if ( length > Int32.MaxValue ) { this.ThrowTooLongLengthException( length, type ); } }
private void ThrowUnexpectedExtCodeException( ReadValueResult type ) { #if DEBUG Contract.Assert( false, "Unexpected ext-code type:" + type ); #endif // DEBUG // ReSharper disable HeuristicUnreachableCode long offsetOrPosition; var isRealOffset = this.GetPreviousPosition( out offsetOrPosition ); throw new NotSupportedException( String.Format( CultureInfo.CurrentCulture, isRealOffset ? "Unexpeded ext-code type {0} at position {1:#,0}" : "Unexpeded ext-code type {0} at offset {1:#,0}", type, offsetOrPosition ) ); // ReSharper restore HeuristicUnreachableCode }
private static void ThrowUnexpectedExtCodeException( ReadValueResult type ) { #if DEBUG && !UNITY Contract.Assert( false, "Unexpected ext-code type:" + type ); #endif // DEBUG && !UNITY // ReSharper disable once HeuristicUnreachableCode throw new NotSupportedException( "Unexpeded ext-code type. " + type ); }
private MessagePackExtendedTypeObject ReadMessagePackExtendedTypeObjectCore(ReadValueResult type) { byte typeCode; uint length; switch (type) { case ReadValueResult.FixExt1: { typeCode = this.ReadByteStrict(); length = 1; break; } case ReadValueResult.FixExt2: { typeCode = this.ReadByteStrict(); length = 2; break; } case ReadValueResult.FixExt4: { typeCode = this.ReadByteStrict(); length = 4; break; } case ReadValueResult.FixExt8: { typeCode = this.ReadByteStrict(); length = 8; break; } case ReadValueResult.FixExt16: { typeCode = this.ReadByteStrict(); length = 16; break; } case ReadValueResult.Ext8: { this.ReadStrict(this._scalarBuffer, sizeof(byte)); length = BigEndianBinary.ToByte(this._scalarBuffer, 0); typeCode = this.ReadByteStrict(); break; } case ReadValueResult.Ext16: { this.ReadStrict(this._scalarBuffer, sizeof(ushort)); length = BigEndianBinary.ToUInt16(this._scalarBuffer, 0); typeCode = this.ReadByteStrict(); break; } case ReadValueResult.Ext32: { this.ReadStrict(this._scalarBuffer, sizeof(uint)); length = BigEndianBinary.ToUInt32(this._scalarBuffer, 0); typeCode = this.ReadByteStrict(); break; } default: { ThrowUnexpectedExtCodeException(type); return(default(MessagePackExtendedTypeObject)); // Never reach } } var data = new byte[length]; this.ReadStrict(data, data.Length); this.InternalCollectionType = CollectionType.None; return(new MessagePackExtendedTypeObject(typeCode, data)); }