|
public static NewValueTypeCannotBeNull ( |
||
| type | The target type. | |
| return | ||
/// <summary>
/// Deserialize object with specified <see cref="Unpacker"/>.
/// </summary>
/// <param name="unpacker"><see cref="Unpacker"/> which unpacks values of resulting object tree.</param>
/// <returns>Deserialized object.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="unpacker"/> is <c>null</c>.
/// </exception>
/// <exception cref="SerializationException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
/// <exception cref="MessageTypeException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
/// <exception cref="InvalidMessagePackStreamException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
/// <exception cref="NotSupportedException">
/// <typeparamref name="T"/> is abstract type.
/// </exception>
public T UnpackFrom(Unpacker unpacker)
{
// TODO: Hot-Path-Optimization
if (unpacker == null)
{
throw new ArgumentNullException("unpacker");
}
if (!unpacker.Data.HasValue)
{
throw SerializationExceptions.NewEmptyOrUnstartedUnpacker();
}
if (unpacker.Data.GetValueOrDefault().IsNil)
{
if (_isNullable)
{
// null
return(default(T));
}
else
{
throw SerializationExceptions.NewValueTypeCannotBeNull(typeof(T));
}
}
return(this.UnpackFromCore(unpacker));
}
void IMessagePackSerializer.PackTo(Packer packer, object objectTree)
{
// TODO: Hot-Path-Optimization
if (packer == null)
{
throw new ArgumentNullException("packer");
}
if (objectTree == null)
{
if (typeof(T).GetIsValueType())
{
if (!(typeof(T).GetIsGenericType() && typeof(T).GetGenericTypeDefinition() == typeof(Nullable <>)))
{
throw SerializationExceptions.NewValueTypeCannotBeNull(typeof(T));
}
}
packer.PackNull();
return;
}
else
{
if (!(objectTree is T))
{
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, "'{0}' is not compatible for '{1}'.", objectTree.GetType(), typeof(T)), "objectTree");
}
}
this.PackToCore(packer, ( T )objectTree);
}
/// <summary>
/// Deserialize object with specified <see cref="Unpacker"/>.
/// </summary>
/// <param name="unpacker"><see cref="Unpacker"/> which unpacks values of resulting object tree.</param>
/// <returns>Deserialized object.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="unpacker"/> is <c>null</c>.
/// </exception>
/// <exception cref="SerializationException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
/// <exception cref="MessageTypeException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
/// <exception cref="InvalidMessagePackStreamException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
/// <exception cref="NotSupportedException">
/// <typeparamref name="T"/> is abstract type.
/// </exception>
public object UnpackFrom(Unpacker unpacker)
{
// TODO: Hot-Path-Optimization
if (unpacker == null)
{
throw new ArgumentNullException("unpacker");
}
if (unpacker.LastReadData.IsNil)
{
if (_isNullable)
{
// null
if (_type.IsValueType)
{
return(Activator.CreateInstance(_type));
}
else
{
return(null);
};
}
else
{
throw SerializationExceptions.NewValueTypeCannotBeNull(_type);
}
}
return(this.UnpackFromCore(unpacker));
}
public static T ConvertWithEnsuringNotNull <T>(object boxed, string name, Type targetType)
{
if ((typeof(T).GetIsValueType() && (boxed == null)) && (Nullable.GetUnderlyingType(typeof(T)) == null))
{
throw SerializationExceptions.NewValueTypeCannotBeNull(name, typeof(T), targetType);
}
return((T)boxed);
}
/// <summary>
/// Unpacks the nil value.
/// </summary>
/// <returns>
/// A valid value of <typeparamref name="T"/> which represents 'null' state.
/// </returns>
/// <remarks>
/// <para>
/// This method is invoked from <see cref="UnpackFrom"/> method when the current <see cref="Unpacker.LastReadData"/> is <see cref="MessagePackObject.IsNil">nil</see>.
/// </para>
/// <para>
/// The implementation of this class returns <c>null</c> for nullable types (that is, all reference types and <see cref="Nullable{T}"/>); otherwise, throws <see cref="SerializationException"/>.
/// </para>
/// <para>
/// Custom serializers can override this method to provide custom nil representation. For example, built-in <see cref="DBNull"/> serializer overrides this method to return <see cref="DBNull.Value"/> instead of <c>null</c>.
/// </para>
/// </remarks>
protected internal virtual T UnpackNil()
{
if (_isNullable)
{
// null
return(default(T));
}
else
{
throw SerializationExceptions.NewValueTypeCannotBeNull(typeof(T));
}
}
public T UnpackFrom(Unpacker unpacker)
{
if (unpacker == null)
{
throw new ArgumentNullException("unpacker");
}
if (!unpacker.Data.HasValue)
{
throw SerializationExceptions.NewEmptyOrUnstartedUnpacker();
}
if (unpacker.Data.GetValueOrDefault().IsNil)
{
if (!MessagePackSerializer <T> ._isNullable)
{
throw SerializationExceptions.NewValueTypeCannotBeNull(typeof(T));
}
return(default(T));
}
return(this.UnpackFromCore(unpacker));
}
private static void VerifyNilImplication(Type type, IEnumerable <SerializingMember> entries)
{
foreach (var serializingMember in entries)
{
if (serializingMember.Contract.NilImplication == NilImplication.Null)
{
var itemType = serializingMember.Member.GetMemberValueType();
if (itemType != typeof(MessagePackObject) &&
itemType.GetIsValueType() &&
Nullable.GetUnderlyingType(itemType) == null)
{
throw SerializationExceptions.NewValueTypeCannotBeNull(serializingMember.Member.ToString(), itemType, type);
}
bool isReadOnly;
FieldInfo asField;
PropertyInfo asProperty;
if ((asField = serializingMember.Member as FieldInfo) != null)
{
isReadOnly = asField.IsInitOnly;
}
else
{
asProperty = serializingMember.Member as PropertyInfo;
// 20150616 applibot modify
//#if DEBUG && !UNITY_IPHONE && !UNITY_ANDROID
#if DEBUG && !UNITY_IPHONE && !UNITY_ANDROID && !UNITY
Contract.Assert(asProperty != null, serializingMember.Member.ToString());
#endif
isReadOnly = asProperty.GetSetMethod() == null;
}
if (isReadOnly)
{
throw SerializationExceptions.NewNullIsProhibited(serializingMember.Member.ToString());
}
}
}
}
/// <summary>
/// Deserializes object with specified <see cref="Unpacker"/>.
/// </summary>
/// <param name="unpacker"><see cref="Unpacker"/> which unpacks values of resulting object tree.</param>
/// <returns>Deserialized object.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="unpacker"/> is <c>null</c>.
/// </exception>
/// <exception cref="SerializationException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
/// <exception cref="MessageTypeException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
/// <exception cref="InvalidMessagePackStreamException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
public object UnpackFrom(Unpacker unpacker)
{
// TODO: Hot-Path-Optimization
if (unpacker == null)
{
throw new ArgumentNullException("unpacker");
}
if (unpacker.LastReadData.IsNil)
{
if (this._isNullable)
{
// null
return(null);
}
else
{
throw SerializationExceptions.NewValueTypeCannotBeNull(this._targetType);
}
}
return(this.UnpackFromCore(unpacker));
}
/// <summary>
/// Deserializes object with specified <see cref="Unpacker"/>.
/// </summary>
/// <param name="unpacker"><see cref="Unpacker"/> which unpacks values of resulting object tree.</param>
/// <returns>Deserialized object.</returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="unpacker"/> is <c>null</c>.
/// </exception>
/// <exception cref="SerializationException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
/// <exception cref="MessageTypeException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
/// <exception cref="InvalidMessagePackStreamException">
/// Failed to deserialize object due to invalid unpacker state, stream content, or so.
/// </exception>
/// <exception cref="NotSupportedException">
/// <typeparamref name="T"/> is abstract type.
/// </exception>
public T UnpackFrom(Unpacker unpacker)
{
// TODO: Hot-Path-Optimization
if (unpacker == null)
{
throw new ArgumentNullException("unpacker");
}
if (unpacker.LastReadData.IsNil)
{
if (_isNullable)
{
// null
return(default(T));
}
// ReSharper disable once RedundantIfElseBlock
else
{
throw SerializationExceptions.NewValueTypeCannotBeNull(typeof(T));
}
}
return(this.UnpackFromCore(unpacker));
}