-Added TypeNameAssemblyFormat property to JsonSerializer. Property controls whether .NET type names are written with a full or partial assembly name -Added TypeNameHandling to JsonProperty attribute. Allows a type names to be included on an individual property basis -Fixed serializing HashSet<T> -Additional permission demands added to DynamicCodeGeneration flag
399 lines
13 KiB
C#
399 lines
13 KiB
C#
#region License
|
|
// Copyright (c) 2007 James Newton-King
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person
|
|
// obtaining a copy of this software and associated documentation
|
|
// files (the "Software"), to deal in the Software without
|
|
// restriction, including without limitation the rights to use,
|
|
// copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the
|
|
// Software is furnished to do so, subject to the following
|
|
// conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
// OTHER DEALINGS IN THE SOFTWARE.
|
|
#endregion
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Newtonsoft.Json.Utilities;
|
|
using System.Globalization;
|
|
|
|
namespace Newtonsoft.Json.Linq
|
|
{
|
|
/// <summary>
|
|
/// Represents a value in JSON (string, integer, date, etc).
|
|
/// </summary>
|
|
public class JValue : JToken, IEquatable<JValue>
|
|
{
|
|
private JTokenType _valueType;
|
|
private object _value;
|
|
|
|
internal JValue(object value, JTokenType type)
|
|
{
|
|
_value = value;
|
|
_valueType = type;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="JValue"/> class from another <see cref="JValue"/> object.
|
|
/// </summary>
|
|
/// <param name="other">A <see cref="JValue"/> object to copy from.</param>
|
|
public JValue(JValue other)
|
|
: this(other.Value, other.Type)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="JValue"/> class with the given value.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
public JValue(long value)
|
|
: this(value, JTokenType.Integer)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="JValue"/> class with the given value.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
public JValue(ulong value)
|
|
: this(value, JTokenType.Integer)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="JValue"/> class with the given value.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
public JValue(double value)
|
|
: this(value, JTokenType.Float)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="JValue"/> class with the given value.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
public JValue(DateTime value)
|
|
: this(value, JTokenType.Date)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="JValue"/> class with the given value.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
public JValue(bool value)
|
|
: this(value, JTokenType.Boolean)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="JValue"/> class with the given value.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
public JValue(string value)
|
|
: this(value, JTokenType.String)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="JValue"/> class with the given value.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
public JValue(object value)
|
|
: this(value, GetValueType(null, value))
|
|
{
|
|
}
|
|
|
|
internal override bool DeepEquals(JToken node)
|
|
{
|
|
JValue other = node as JValue;
|
|
if (other == null)
|
|
return false;
|
|
|
|
return ValuesEquals(this, other);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a value indicating whether this token has childen tokens.
|
|
/// </summary>
|
|
/// <value>
|
|
/// <c>true</c> if this token has child values; otherwise, <c>false</c>.
|
|
/// </value>
|
|
public override bool HasValues
|
|
{
|
|
get { return false; }
|
|
}
|
|
|
|
private static bool Compare(JTokenType valueType, object objA, object objB)
|
|
{
|
|
if (objA == null && objB == null)
|
|
return true;
|
|
if (objA == null || objB == null)
|
|
return false;
|
|
|
|
switch (valueType)
|
|
{
|
|
case JTokenType.Integer:
|
|
if (objA is ulong || objB is ulong)
|
|
return Convert.ToDecimal(objA, CultureInfo.InvariantCulture).Equals(Convert.ToDecimal(objB, CultureInfo.InvariantCulture));
|
|
else
|
|
return Convert.ToInt64(objA, CultureInfo.InvariantCulture).Equals(Convert.ToInt64(objB, CultureInfo.InvariantCulture));
|
|
case JTokenType.Float:
|
|
return Convert.ToDouble(objA, CultureInfo.InvariantCulture).Equals(Convert.ToDouble(objB, CultureInfo.InvariantCulture));
|
|
case JTokenType.Comment:
|
|
case JTokenType.String:
|
|
case JTokenType.Boolean:
|
|
case JTokenType.Raw:
|
|
return objA.Equals(objB);
|
|
case JTokenType.Date:
|
|
return objA.Equals(objB);
|
|
case JTokenType.Bytes:
|
|
byte[] b1 = objA as byte[];
|
|
byte[] b2 = objB as byte[];
|
|
if (b1 == null || b2 == null)
|
|
return false;
|
|
|
|
return MiscellaneousUtils.ByteArrayCompare(b1, b2);
|
|
default:
|
|
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("valueType", valueType, "Unexpected value type: {0}".FormatWith(CultureInfo.InvariantCulture, valueType));
|
|
}
|
|
}
|
|
|
|
internal override JToken CloneToken()
|
|
{
|
|
return new JValue(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a <see cref="JValue"/> comment with the given value.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
/// <returns>A <see cref="JValue"/> comment with the given value.</returns>
|
|
public static JValue CreateComment(string value)
|
|
{
|
|
return new JValue(value, JTokenType.Comment);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a <see cref="JValue"/> string with the given value.
|
|
/// </summary>
|
|
/// <param name="value">The value.</param>
|
|
/// <returns>A <see cref="JValue"/> string with the given value.</returns>
|
|
public static JValue CreateString(string value)
|
|
{
|
|
return new JValue(value, JTokenType.String);
|
|
}
|
|
|
|
private static JTokenType GetValueType(JTokenType? current, object value)
|
|
{
|
|
if (value == null)
|
|
return JTokenType.Null;
|
|
else if (value == DBNull.Value)
|
|
return JTokenType.Null;
|
|
else if (value is string)
|
|
return GetStringValueType(current);
|
|
else if (value is long || value is int || value is short || value is sbyte
|
|
|| value is ulong || value is uint || value is ushort || value is byte)
|
|
return JTokenType.Integer;
|
|
else if (value is Enum)
|
|
return JTokenType.Integer;
|
|
else if (value is double || value is float || value is decimal)
|
|
return JTokenType.Float;
|
|
else if (value is DateTime)
|
|
return JTokenType.Date;
|
|
#if !PocketPC && !NET20
|
|
else if (value is DateTimeOffset)
|
|
return JTokenType.Date;
|
|
#endif
|
|
else if (value is byte[])
|
|
return JTokenType.Bytes;
|
|
else if (value is bool)
|
|
return JTokenType.Boolean;
|
|
|
|
throw new ArgumentException("Could not determine JSON object type for type {0}.".FormatWith(CultureInfo.InvariantCulture, value.GetType()));
|
|
}
|
|
|
|
private static JTokenType GetStringValueType(JTokenType? current)
|
|
{
|
|
if (current == null)
|
|
return JTokenType.String;
|
|
|
|
switch (current.Value)
|
|
{
|
|
case JTokenType.Comment:
|
|
case JTokenType.String:
|
|
case JTokenType.Raw:
|
|
return current.Value;
|
|
default:
|
|
return JTokenType.String;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the node type for this <see cref="JToken"/>.
|
|
/// </summary>
|
|
/// <value>The type.</value>
|
|
public override JTokenType Type
|
|
{
|
|
get { return _valueType; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the underlying token value.
|
|
/// </summary>
|
|
/// <value>The underlying token value.</value>
|
|
public object Value
|
|
{
|
|
get { return _value; }
|
|
set
|
|
{
|
|
Type currentType = (_value != null) ? _value.GetType() : null;
|
|
Type newType = (value != null) ? value.GetType() : null;
|
|
|
|
if (currentType != newType)
|
|
_valueType = GetValueType(_valueType, value);
|
|
|
|
_value = value;
|
|
}
|
|
}
|
|
|
|
private static void WriteConvertableValue(JsonWriter writer, IList<JsonConverter> converters, Action<object> defaultWrite, object value)
|
|
{
|
|
JsonConverter matchingConverter;
|
|
|
|
if (value != null && ((matchingConverter = JsonSerializer.GetMatchingConverter(converters, value.GetType())) != null))
|
|
matchingConverter.WriteJson(writer, value, new JsonSerializer());
|
|
else
|
|
defaultWrite(value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes this token to a <see cref="JsonWriter"/>.
|
|
/// </summary>
|
|
/// <param name="writer">A <see cref="JsonWriter"/> into which this method will write.</param>
|
|
/// <param name="converters">A collection of <see cref="JsonConverter"/> which will be used when writing the token.</param>
|
|
public override void WriteTo(JsonWriter writer, params JsonConverter[] converters)
|
|
{
|
|
switch (_valueType)
|
|
{
|
|
case JTokenType.Comment:
|
|
writer.WriteComment(_value.ToString());
|
|
break;
|
|
case JTokenType.Integer:
|
|
WriteConvertableValue(writer, converters, v => writer.WriteValue(Convert.ToInt64(v, CultureInfo.InvariantCulture)), _value);
|
|
break;
|
|
case JTokenType.Float:
|
|
WriteConvertableValue(writer, converters, v => writer.WriteValue(Convert.ToDouble(v, CultureInfo.InvariantCulture)), _value);
|
|
break;
|
|
case JTokenType.String:
|
|
WriteConvertableValue(writer, converters, v => writer.WriteValue((v != null) ? v.ToString() : null), _value);
|
|
break;
|
|
case JTokenType.Boolean:
|
|
WriteConvertableValue(writer, converters, v => writer.WriteValue(Convert.ToBoolean(v, CultureInfo.InvariantCulture)), _value);
|
|
break;
|
|
case JTokenType.Date:
|
|
WriteConvertableValue(writer, converters, v =>
|
|
{
|
|
#if !PocketPC && !NET20
|
|
if (v is DateTimeOffset)
|
|
writer.WriteValue((DateTimeOffset)v);
|
|
else
|
|
#endif
|
|
writer.WriteValue(Convert.ToDateTime(v, CultureInfo.InvariantCulture));
|
|
}, _value);
|
|
break;
|
|
case JTokenType.Raw:
|
|
writer.WriteRawValue((_value != null) ? _value.ToString() : null);
|
|
break;
|
|
case JTokenType.Bytes:
|
|
WriteConvertableValue(writer, converters, v => writer.WriteValue((byte[])v), _value);
|
|
break;
|
|
case JTokenType.Null:
|
|
writer.WriteNull();
|
|
break;
|
|
case JTokenType.Undefined:
|
|
writer.WriteUndefined();
|
|
break;
|
|
default:
|
|
throw MiscellaneousUtils.CreateArgumentOutOfRangeException("TokenType", _valueType, "Unexpected token type.");
|
|
}
|
|
}
|
|
|
|
internal override int GetDeepHashCode()
|
|
{
|
|
int valueHashCode = (_value != null) ? _value.GetHashCode() : 0;
|
|
|
|
return _valueType.GetHashCode() ^ valueHashCode;
|
|
}
|
|
|
|
private static bool ValuesEquals(JValue v1, JValue v2)
|
|
{
|
|
return (v1 == v2|| (v1._valueType == v2._valueType && Compare(v1._valueType, v1._value, v2._value)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates whether the current object is equal to another object of the same type.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// true if the current object is equal to the <paramref name="other"/> parameter; otherwise, false.
|
|
/// </returns>
|
|
/// <param name="other">An object to compare with this object.</param>
|
|
public bool Equals(JValue other)
|
|
{
|
|
if (other == null)
|
|
return false;
|
|
|
|
return ValuesEquals(this, other);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Determines whether the specified <see cref="T:System.Object"/> is equal to the current <see cref="T:System.Object"/>.
|
|
/// </summary>
|
|
/// <param name="obj">The <see cref="T:System.Object"/> to compare with the current <see cref="T:System.Object"/>.</param>
|
|
/// <returns>
|
|
/// true if the specified <see cref="T:System.Object"/> is equal to the current <see cref="T:System.Object"/>; otherwise, false.
|
|
/// </returns>
|
|
/// <exception cref="T:System.NullReferenceException">
|
|
/// The <paramref name="obj"/> parameter is null.
|
|
/// </exception>
|
|
public override bool Equals(object obj)
|
|
{
|
|
if (obj == null)
|
|
return false;
|
|
|
|
JValue otherValue = obj as JValue;
|
|
if (otherValue != null)
|
|
return Equals(otherValue);
|
|
|
|
return base.Equals(obj);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serves as a hash function for a particular type.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// A hash code for the current <see cref="T:System.Object"/>.
|
|
/// </returns>
|
|
public override int GetHashCode()
|
|
{
|
|
if (_value == null)
|
|
return 0;
|
|
|
|
return _value.GetHashCode();
|
|
}
|
|
}
|
|
} |