/// <summary>
/// Evaluates the expression and populates an existing object with keys and values.
/// </summary>
/// <param name="expression">the expression to evaluate</param>
/// <param name="existingObject">the existing object to populate</param>
/// <param name="deserializer">the deserializer instance to use to deserialize other expressions</param>
/// <returns>a populated object</returns>
public override object Evaluate(Expression expression, object existingObject, IDeserializerHandler deserializer)
{
Type _dictionaryKeyType = typeof(string);
Type _dictionaryValueType = null;
Type genDict = existingObject.GetType().GetInterface(typeof(IDictionary<,>).Name);
// attempt to figure out what the types of the values are, if no type is set already
if (genDict != null)
{
Type[] genArgs = genDict.GetGenericArguments();
_dictionaryKeyType = genArgs[0];
_dictionaryValueType = genArgs[1];
}
ObjectExpression objectExpression = CastExpression<ObjectExpression>(expression);
foreach (KeyValueExpression keyValue in objectExpression.Properties)
{
// if no type set, set one
keyValue.KeyExpression.ResultType = _dictionaryKeyType;
if (_dictionaryValueType != null)
keyValue.ValueExpression.ResultType = _dictionaryValueType;
object keyObject = deserializer.Evaluate(keyValue.KeyExpression);
object result = deserializer.Evaluate(keyValue.ValueExpression);
((IDictionary)existingObject)[keyObject] = result;
}
return existingObject;
}
protected virtual void WriteCast(Expression Expression)
{
CastExpression cast = (CastExpression)Expression;
if (outputTypeInfo && !(cast.Expression is ReferenceExpression))
jsonWriter.WriteCast(cast.ResultType);
Write(cast.Expression);
}
public Expression Execute(Expression root)
{
IList<ReferenceExpression> references = CollectReferences(root);
foreach (ReferenceExpression reference in references)
ResolveReference(reference, root);
return root;
}
public KeyValueExpression(Expression key, Expression value)
{
_keyExpression = key;
_valueExpression = value;
this.LineNumber = key.LineNumber;
this.CharacterPosition = key.CharacterPosition;
}
private static void ResolveReference(ReferenceExpression reference, Expression root)
{
ReferenceVisitor visitor = new ReferenceVisitor(reference.Path);
visitor.Visit(root);
if (visitor.ReferencedExpression == null)
throw new ParseException("Unable to resolve reference to " + reference.Path);
reference.ReferencedExpression = visitor.ReferencedExpression;
}
/// <summary>
/// Evaluates the expression and deserializes it.
/// </summary>
/// <param name="expression">json object expression</param>
/// <param name="deserializer">deserializer for deserializing key values</param>
/// <returns>deserialized object</returns>
public override object Evaluate(Expression expression, IDeserializerHandler deserializer)
{
object value = ConstructObject(CastExpression<ObjectExpression>(expression), deserializer);
value = Evaluate(expression, value, deserializer);
if (value is IDeserializationCallback)
((IDeserializationCallback)value).OnAfterDeserialization();
return value;
}
protected virtual void WriteList(Expression Expression)
{
ArrayExpression list = (ArrayExpression)Expression;
jsonWriter.WriteArrayStart();
foreach (Expression item in list.Items)
Write(item);
jsonWriter.WriteArrayEnd();
}
/// <summary>
/// Evaluates an expression and applies the results to an existing object
/// </summary>
/// <param name="Expression">the expression to evaluate</param>
/// <param name="existingObject">the object to apply to</param>
/// <returns>the evaluated object</returns>
public object Evaluate(Expression expression, object existingObject)
{
Expression oldExpr = Current;
_currentExpression = expression;
IExpressionHandler handler = Config.ExpressionHandlers.GetHandler(expression);
object result = handler.Evaluate(expression, existingObject, this);
_currentExpression = oldExpr ?? _currentExpression;
return result;
}
/// <summary>
/// Evaluates the expression and populates an existing object with the expression's properties
/// </summary>
/// <param name="expression">json object expression</param>
/// <param name="existingObject">the existing object to populate</param>
/// <param name="deserializer">deserializer for deserializing key values</param>
/// <returns>deserialized object</returns>
public override object Evaluate(Expression expression, object existingObject, IDeserializerHandler deserializer)
{
TypeData typeHandler = Config.GetTypeHandler(existingObject.GetType());
ObjectExpression objectExpression = CastExpression<ObjectExpression>(expression);
foreach (KeyValueExpression Item in objectExpression.Properties)
{
EvaluateItem(existingObject, deserializer, typeHandler, Item);
}
return existingObject;
}
public override object Evaluate(Expression expression, IDeserializerHandler deserializer)
{
ValueExpression value = CastExpression<ValueExpression>(expression);
if (value.ResultType.IsEnum)
return Enum.Parse(value.ResultType, value.StringValue);
else if (value.ResultType == typeof(object))
return value.StringValue;
else if (value.ResultType == typeof(string))
return value.StringValue;
else
return Convert.ChangeType(value.Value, value.ResultType, CultureInfo.InvariantCulture);
}
/// <summary>
/// Deserializes an expression by populating an existing object collection with the expression's items.
/// </summary>
/// <param name="expression">the expression to deserialize</param>
/// <param name="existingObject">the collection to populate</param>
/// <param name="deserializer">deserializer to deserialize list items</param>
/// <returns>deserialized object</returns>
public override object Evaluate(Expression expression, object existingObject, IDeserializerHandler deserializer)
{
Type ItemType;
ArrayExpression list = (ArrayExpression)expression;
ICollectionBuilder builder = ConstructBuilder(existingObject, list, out ItemType);
object result = EvaluateItems(list, builder, ItemType, deserializer);
if (result is IDeserializationCallback)
{
((IDeserializationCallback)result).OnAfterDeserialization();
}
return result;
}
/// <summary>
/// Converts an expression to an object by first Evaluating the expression as its converted type and
/// then converting that result using the specified type converter.
/// </summary>
/// <param name="expression">the expression to convert</param>
/// <param name="deserializer">deserializer instance</param>
/// <param name="converter">the converter to use to convert the object</param>
/// <returns>an object created from the expression</returns>
public object Evaluate(Expression expression, IDeserializerHandler deserializer, IJsonTypeConverter converter)
{
Type sourceType = expression.ResultType;
Type destType = converter.GetSerializedType(sourceType);
expression.ResultType = destType;
object tempResult = deserializer.Evaluate(expression);
//TODO: Cast for now to avoid breaking compatibility
object result = converter.ConvertTo(tempResult, sourceType, (SerializationContext) Config);
expression.OnObjectConstructed(result);
if (result is IDeserializationCallback)
{
((IDeserializationCallback)result).OnAfterDeserialization();
}
return result;
}
/// <summary>
/// Converts an expression to an object by first Evaluating the expression as its converted type and
/// then converting that result using a type converter.
/// </summary>
/// <param name="expression">the expression to convert</param>
/// <param name="deserializer">deserializer instance</param>
/// <returns>an object created from the expression</returns>
public override object Evaluate(Expression expression, IDeserializerHandler deserializer)
{
Type sourceType = expression.ResultType;
TypeData handler = Config.TypeHandlerFactory[sourceType];
IJsonTypeConverter converter;
if (typeof(IJsonTypeConverter).IsAssignableFrom(sourceType))
{
converter = (IJsonTypeConverter) Activator.CreateInstance(sourceType);
}
else
{
converter = handler.TypeConverter;
}
return Evaluate(expression, deserializer, converter);
}
public override object Evaluate(Expression expression, IDeserializerHandler deserializer)
{
DataTable table = new DataTable();
ObjectExpression tableExpr = (ObjectExpression)expression;
EvaluateColumns(table, (ArrayExpression)tableExpr["Columns"], deserializer);
// remove the columns expression, it's been evaluated already
tableExpr.Properties.RemoveAt(tableExpr.IndexOf("Columns"));
// now the rows
EvaluateRows(table, (ArrayExpression)tableExpr["Rows"], deserializer);
// remove the rows expression, it's been evaluated already
tableExpr.Properties.RemoveAt(tableExpr.IndexOf("Rows"));
// fill in any remaining properties
return base.Evaluate(expression, table, deserializer);
}
public void VisitComplexBase(ComplexExpressionBase expression)
{
if (_refID.Top == JsonPath.Root)
{
if (expression.Parent != null)
{
throw new ArgumentException("Reference for this passed to object that is not at the root", "refID");
}
}
else
{
// have to assume that the parent checked that we were the right reference
// should only get here if we have a parent, if no parent we're not valid
if (expression.Parent == null)
throw new ArgumentException("Invalid reference", "refID");
}
// it is this object, check if we need to go further
_refID = _refID.ChildReference();
if (_refID.IsEmpty) {
_expr = expression;
}
}
private static List<ReferenceExpression> CollectReferences(Expression root)
{
CollectReferencesVisitor visitor = new CollectReferencesVisitor();
root.Accept(visitor);
return visitor.References;
}
/// <summary>
/// Add a property to this object
/// </summary>
/// <param name="key">the key for the property</param>
/// <param name="value">the value for the property</param>
/// <returns>KeyValueExpression that was added</returns>
public KeyValueExpression Add(string key, Expression value)
{
return Add(new ValueExpression(key), value);
}
/// <summary>
/// Converts the expression back into an object
/// </summary>
/// <param name="expression">the expression</param>
/// <param name="deserializer">the deserializer</param>
/// <returns>null</returns>
public override object Evaluate(Expression expression, IDeserializerHandler deserializer)
{
if (!(expression is NullExpression))
throw new ArgumentException("expression should be NullExpression");
return null;
}
/// <summary>
/// Evaluates an expression and populates an existing object with any necessary values
/// </summary>
/// <param name="expression">expression to evaluate</param>
/// <param name="existingObject">the object to populate</param>
/// <param name="deserializer">the deserializer instance</param>
/// <returns>constructed object</returns>
public override object Evaluate(Expression expression, object existingObject, IDeserializerHandler deserializer)
{
Expression innerExpression = ((CastExpression)expression).Expression;
innerExpression.ResultType = expression.ResultType;
return deserializer.Evaluate(innerExpression, existingObject);
}
protected virtual void WriteBoolean(Expression expression)
{
this.jsonWriter.WriteValue((bool)((BooleanExpression)expression).Value);
}
protected virtual DataColumn EvaluateColumn(Expression colExpr, IDeserializerHandler deserializer)
{
colExpr.ResultType = typeof(DataColumn);
return (DataColumn) deserializer.Evaluate(colExpr);
}
protected virtual void WriteNull(Expression expression)
{
if (!(expression is NullExpression))
throw new ArgumentException("Expression should be a NullExpression");
jsonWriter.WriteSpecialValue("null");
}
public CastExpression(Type CastedType, Expression Expression)
: this(CastedType)
{
_expression = Expression;
}
protected virtual void WriteNumeric(Expression expression)
{
NumericExpression numeric = (NumericExpression)expression;
object value = numeric.Value;
switch (Type.GetTypeCode(value.GetType()))
{
case TypeCode.Double:
jsonWriter.WriteValue((double)value);
break;
case TypeCode.Single:
jsonWriter.WriteValue((float)value);
break;
case TypeCode.Int64:
jsonWriter.WriteValue((long)value);
break;
case TypeCode.Decimal:
jsonWriter.WriteValue((decimal)value);
break;
case TypeCode.UInt64:
jsonWriter.WriteSpecialValue(string.Format(CultureInfo.InvariantCulture, "{0}", value));
break;
default:
jsonWriter.WriteValue((long)Convert.ChangeType(value, typeof(long), CultureInfo.InvariantCulture));
break;
}
}
/// <summary>
/// Determines whether this handler can deserialize a specific expression. The NullExpressionHandler
/// only handles NullExpressions.
/// </summary>
/// <param name="expression">the expression</param>
/// <returns>true if this handler handles the expression</returns>
public override bool CanHandle(Expression expression)
{
return (expression is NullExpression);
}
private static bool ExpressionEqual(Expression source, Expression target)
{
return source == target
|| source is CastExpression && ((CastExpression)source).Expression == target;
}
/// <summary>
/// Converts an existing object
/// </summary>
/// <param name="expression">the expression</param>
/// <param name="existingObject">an existing object</param>
/// <param name="deserializer">deserializer</param>
/// <returns>the existing object</returns>
public override object Evaluate(Expression expression, object existingObject, IDeserializerHandler deserializer)
{
return existingObject;
}
private static Expression GetRealExpression(Expression expression)
{
while (expression is CastExpression)
{
expression = ((CastExpression)expression).Expression;
}
return expression;
}
/// <summary>
/// Add a property to this object
/// </summary>
/// <param name="key">the key for the property</param>
/// <param name="value">the value for the property</param>
/// <returns>KeyValueExpression that was added</returns>
public KeyValueExpression Add(Expression key, Expression value)
{
return Add(new KeyValueExpression(key, value));
}
private JsonPath GetPath(Expression expression)
{
if (expression.Parent == null)
return new JsonPath();
Expression parent = GetRealExpression(expression.Parent);
if (parent is ComplexExpressionBase)
{
ComplexExpressionBase complexParent = (ComplexExpressionBase)parent;
JsonPath path = GetPath(parent);
if (parent is ArrayExpression)
{
ArrayExpression parentArray = (ArrayExpression)parent;
for (int i = 0; i < parentArray.Items.Count; i++)
{
if (ExpressionEqual(parentArray.Items[i], expression))
{
return path.Append(i);
}
}
}
else if (parent is ObjectExpression)
{
ObjectExpression parentObject = (ObjectExpression)parent;
foreach (KeyValueExpression kve in parentObject.Properties)
{
if (ExpressionEqual(kve.KeyExpression, expression)
|| ExpressionEqual(kve.ValueExpression, expression))
{
return path.Append(kve.Key);
}
}
}
for (int i = 0; i < complexParent.ConstructorArguments.Count; i++)
{
if (ExpressionEqual(complexParent.ConstructorArguments[i], expression))
{
return path.Append("carg" + i);
}
}
}
return null;
}
