private unsafe T[] UnboxArray <T>(Type expectedArrayElementType) where T : struct
{
Array array = this._data as Array;
if (array == null || this._data.GetType().GetElementType() != expectedArrayElementType)
{
throw new InvalidCastException(Environment.GetResourceString("InvalidCast_WinRTIPropertyValueElement", new object[]
{
this._data.GetType(),
expectedArrayElementType.MakeArrayType().Name
}), -2147316576);
}
T[] array2 = new T[array.Length];
if (array2.Length != 0)
{
fixed(byte *ptr = &JitHelpers.GetPinningHelper(array).m_data)
{
fixed(byte *ptr2 = &JitHelpers.GetPinningHelper(array2).m_data)
{
byte *src = (byte *)((void *)Marshal.UnsafeAddrOfPinnedArrayElement(array, 0));
byte *dest = (byte *)((void *)Marshal.UnsafeAddrOfPinnedArrayElement <T>(array2, 0));
Buffer.Memcpy(dest, src, checked (Marshal.SizeOf(typeof(T)) * array2.Length));
}
}
}
return(array2);
}
private unsafe T[] UnboxArray <T>(Type expectedArrayElementType) where T : struct
{
Contract.Requires(expectedArrayElementType != null);
Contract.Requires(Marshal.SizeOf(expectedArrayElementType) == Marshal.SizeOf(typeof(T)));
Array dataArray = _data as Array;
if (dataArray == null || _data.GetType().GetElementType() != expectedArrayElementType)
{
throw new InvalidCastException(Environment.GetResourceString("InvalidCast_WinRTIPropertyValueElement", _data.GetType(), expectedArrayElementType.MakeArrayType().Name), __HResults.TYPE_E_TYPEMISMATCH);
}
T[] converted = new T[dataArray.Length];
if (converted.Length > 0)
{
fixed(byte *dataPin = &JitHelpers.GetPinningHelper(dataArray).m_data)
{
fixed(byte *convertedPin = &JitHelpers.GetPinningHelper(converted).m_data)
{
byte *pData = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(dataArray, 0);
byte *pConverted = (byte *)Marshal.UnsafeAddrOfPinnedArrayElement(converted, 0);
Buffer.Memcpy(pConverted, pData, checked (Marshal.SizeOf(typeof(T)) * converted.Length));
}
}
}
return(converted);
}
private unsafe string InternalFormattedHexString()
{
fixed(void *pValue = &JitHelpers.GetPinningHelper(this).m_data)
{
switch (InternalGetCorElementType())
{
case CorElementType.I1:
case CorElementType.U1:
return((*(byte *)pValue).ToString("X2", null));
case CorElementType.Boolean:
// direct cast from bool to byte is not allowed
return(Convert.ToByte(*(bool *)pValue).ToString("X2", null));
case CorElementType.I2:
case CorElementType.U2:
case CorElementType.Char:
return((*(ushort *)pValue).ToString("X4", null));
case CorElementType.I4:
case CorElementType.U4:
return((*(uint *)pValue).ToString("X8", null));
case CorElementType.I8:
case CorElementType.U8:
return((*(ulong *)pValue).ToString("X16", null));
default:
throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType);
}
}
}
public override unsafe int GetHashCode()
{
// CONTRACT with the runtime: GetHashCode of enum types is implemented as GetHashCode of the underlying type.
// The runtime can bypass calls to Enum::GetHashCode and call the underlying type's GetHashCode directly
// to avoid boxing the enum.
fixed(void *pValue = &JitHelpers.GetPinningHelper(this).m_data)
{
switch (InternalGetCorElementType())
{
case CorElementType.I1:
return((*(sbyte *)pValue).GetHashCode());
case CorElementType.U1:
return((*(byte *)pValue).GetHashCode());
case CorElementType.Boolean:
return((*(bool *)pValue).GetHashCode());
case CorElementType.I2:
return((*(short *)pValue).GetHashCode());
case CorElementType.U2:
return((*(ushort *)pValue).GetHashCode());
case CorElementType.Char:
return((*(char *)pValue).GetHashCode());
case CorElementType.I4:
return((*(int *)pValue).GetHashCode());
case CorElementType.U4:
return((*(uint *)pValue).GetHashCode());
case CorElementType.R4:
return((*(float *)pValue).GetHashCode());
case CorElementType.I8:
return((*(long *)pValue).GetHashCode());
case CorElementType.U8:
return((*(ulong *)pValue).GetHashCode());
case CorElementType.R8:
return((*(double *)pValue).GetHashCode());
case CorElementType.I:
return((*(IntPtr *)pValue).GetHashCode());
case CorElementType.U:
return((*(UIntPtr *)pValue).GetHashCode());
default:
Debug.Fail("Invalid primitive type");
return(0);
}
}
}
internal unsafe Object GetValue()
{
#if MONO
return(get_value());
#else
fixed(void *pValue = &JitHelpers.GetPinningHelper(this).m_data)
{
switch (InternalGetCorElementType())
{
case CorElementType.I1:
return(*(sbyte *)pValue);
case CorElementType.U1:
return(*(byte *)pValue);
case CorElementType.Boolean:
return(*(bool *)pValue);
case CorElementType.I2:
return(*(short *)pValue);
case CorElementType.U2:
return(*(ushort *)pValue);
case CorElementType.Char:
return(*(char *)pValue);
case CorElementType.I4:
return(*(int *)pValue);
case CorElementType.U4:
return(*(uint *)pValue);
case CorElementType.R4:
return(*(float *)pValue);
case CorElementType.I8:
return(*(long *)pValue);
case CorElementType.U8:
return(*(ulong *)pValue);
case CorElementType.R8:
return(*(double *)pValue);
case CorElementType.I:
return(*(IntPtr *)pValue);
case CorElementType.U:
return(*(UIntPtr *)pValue);
default:
Contract.Assert(false, "Invalid primitive type");
return(null);
}
}
#endif
}
public override unsafe int GetHashCode()
{
// Avoid boxing by inlining GetValue()
// return GetValue().GetHashCode();
fixed(void *pValue = &JitHelpers.GetPinningHelper(this).m_data)
{
switch (InternalGetCorElementType())
{
case CorElementType.I1:
return((*(sbyte *)pValue).GetHashCode());
case CorElementType.U1:
return((*(byte *)pValue).GetHashCode());
case CorElementType.Boolean:
return((*(bool *)pValue).GetHashCode());
case CorElementType.I2:
return((*(short *)pValue).GetHashCode());
case CorElementType.U2:
return((*(ushort *)pValue).GetHashCode());
case CorElementType.Char:
return((*(char *)pValue).GetHashCode());
case CorElementType.I4:
return((*(int *)pValue).GetHashCode());
case CorElementType.U4:
return((*(uint *)pValue).GetHashCode());
case CorElementType.R4:
return((*(float *)pValue).GetHashCode());
case CorElementType.I8:
return((*(long *)pValue).GetHashCode());
case CorElementType.U8:
return((*(ulong *)pValue).GetHashCode());
case CorElementType.R8:
return((*(double *)pValue).GetHashCode());
case CorElementType.I:
return((*(IntPtr *)pValue).GetHashCode());
case CorElementType.U:
return((*(UIntPtr *)pValue).GetHashCode());
default:
Contract.Assert(false, "Invalid primitive type");
return(0);
}
}
}
internal unsafe object GetValue()
{
fixed(void *pValue = &JitHelpers.GetPinningHelper(this).m_data)
{
switch (InternalGetCorElementType())
{
case CorElementType.I1:
return(*(sbyte *)pValue);
case CorElementType.U1:
return(*(byte *)pValue);
case CorElementType.Boolean:
return(*(bool *)pValue);
case CorElementType.I2:
return(*(short *)pValue);
case CorElementType.U2:
return(*(ushort *)pValue);
case CorElementType.Char:
return(*(char *)pValue);
case CorElementType.I4:
return(*(int *)pValue);
case CorElementType.U4:
return(*(uint *)pValue);
case CorElementType.R4:
return(*(float *)pValue);
case CorElementType.I8:
return(*(long *)pValue);
case CorElementType.U8:
return(*(ulong *)pValue);
case CorElementType.R8:
return(*(double *)pValue);
case CorElementType.I:
return(*(IntPtr *)pValue);
case CorElementType.U:
return(*(UIntPtr *)pValue);
default:
Debug.Fail("Invalid primitive type");
return(null);
}
}
}
private unsafe T Unbox <T>(System.Type expectedBoxedType) where T : struct
{
if (this._data.GetType() != expectedBoxedType)
{
throw new InvalidCastException(Environment.GetResourceString("InvalidCast_WinRTIPropertyValueElement", (object)this._data.GetType(), (object)expectedBoxedType.Name), -2147316576);
}
T instance = Activator.CreateInstance <T>();
fixed(byte *src = &JitHelpers.GetPinningHelper(this._data).m_data)
Buffer.Memcpy((byte *)(void *)JitHelpers.UnsafeCastToStackPointer <T>(ref instance), src, Marshal.SizeOf <T>(instance));
return(instance);
}
private unsafe T Unbox <T>(Type expectedBoxedType) where T : struct
{
Contract.Requires(expectedBoxedType != null);
Contract.Requires(Marshal.SizeOf(expectedBoxedType) == Marshal.SizeOf(typeof(T)));
if (_data.GetType() != expectedBoxedType)
{
throw new InvalidCastException(Environment.GetResourceString("InvalidCast_WinRTIPropertyValueElement", _data.GetType(), expectedBoxedType.Name), __HResults.TYPE_E_TYPEMISMATCH);
}
T unboxed = new T();
fixed(byte *pData = &JitHelpers.GetPinningHelper(_data).m_data)
{
byte *pUnboxed = (byte *)JitHelpers.UnsafeCastToStackPointer(ref unboxed);
Buffer.Memcpy(pUnboxed, pData, Marshal.SizeOf(unboxed));
}
return(unboxed);
}
// Unbox the data stored in the property value to a structurally equivilent type
private unsafe T Unbox <T>(Type expectedBoxedType) where T : struct
{
Debug.Assert(expectedBoxedType != null);
Debug.Assert(Marshal.SizeOf(expectedBoxedType) == Marshal.SizeOf(typeof(T)));
if (_data.GetType() != expectedBoxedType)
{
throw new InvalidCastException(SR.Format(SR.InvalidCast_WinRTIPropertyValueElement, _data.GetType(), expectedBoxedType.Name), HResults.TYPE_E_TYPEMISMATCH);
}
T unboxed = new T();
fixed(byte *pData = &JitHelpers.GetPinningHelper(_data).m_data)
{
byte *pUnboxed = (byte *)JitHelpers.UnsafeCastToStackPointer(ref unboxed);
Buffer.Memcpy(pUnboxed, pData, Marshal.SizeOf(unboxed));
}
return(unboxed);
}
private unsafe T Unbox <T>(Type expectedBoxedType) where T : struct
{
if (this._data.GetType() != expectedBoxedType)
{
throw new InvalidCastException(Environment.GetResourceString("InvalidCast_WinRTIPropertyValueElement", new object[]
{
this._data.GetType(),
expectedBoxedType.Name
}), -2147316576);
}
T t = Activator.CreateInstance <T>();
fixed(byte *ptr = &JitHelpers.GetPinningHelper(this._data).m_data)
{
byte *dest = (byte *)((void *)JitHelpers.UnsafeCastToStackPointer <T>(ref t));
Buffer.Memcpy(dest, ptr, Marshal.SizeOf <T>(t));
}
return(t);
}
private unsafe T[] UnboxArray <T>(System.Type expectedArrayElementType) where T : struct
{
Array arr1 = this._data as Array;
if (arr1 == null || this._data.GetType().GetElementType() != expectedArrayElementType)
{
throw new InvalidCastException(Environment.GetResourceString("InvalidCast_WinRTIPropertyValueElement", (object)this._data.GetType(), (object)expectedArrayElementType.MakeArrayType().Name), -2147316576);
}
T[] arr2 = new T[arr1.Length];
if (arr2.Length != 0)
{
fixed(byte *numPtr1 = &JitHelpers.GetPinningHelper((object)arr1).m_data)
fixed(byte *numPtr2 = &JitHelpers.GetPinningHelper((object)arr2).m_data)
{
byte *src = (byte *)(void *)Marshal.UnsafeAddrOfPinnedArrayElement(arr1, 0);
Buffer.Memcpy((byte *)(void *)Marshal.UnsafeAddrOfPinnedArrayElement <T>(arr2, 0), src, checked (Marshal.SizeOf(typeof(T)) * arr2.Length));
}
}
return(arr2);
}
private unsafe ulong ToUInt64()
{
fixed(void *pValue = &JitHelpers.GetPinningHelper(this).m_data)
{
switch (InternalGetCorElementType())
{
case CorElementType.I1:
return((ulong)*(sbyte *)pValue);
case CorElementType.U1:
return(*(byte *)pValue);
case CorElementType.Boolean:
return(Convert.ToUInt64(*(bool *)pValue, CultureInfo.InvariantCulture));
case CorElementType.I2:
return((ulong)*(short *)pValue);
case CorElementType.U2:
case CorElementType.Char:
return(*(ushort *)pValue);
case CorElementType.I4:
return((ulong)*(int *)pValue);
case CorElementType.U4:
case CorElementType.R4:
return(*(uint *)pValue);
case CorElementType.I8:
return((ulong)*(long *)pValue);
case CorElementType.U8:
case CorElementType.R8:
return(*(ulong *)pValue);
case CorElementType.I:
if (IntPtr.Size == 8)
{
return(*(ulong *)pValue);
}
else
{
return((ulong)*(int *)pValue);
}
case CorElementType.U:
if (IntPtr.Size == 8)
{
return(*(ulong *)pValue);
}
else
{
return(*(uint *)pValue);
}
default:
Debug.Fail("Invalid primitive type");
return(0);
}
}
}
