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));
}
