private void WriteCast(Expression Expression) { CastExpression cast = (CastExpression)Expression; if (_context.OutputTypeInformation && !(cast.Expression is ReferenceExpression)) _jsonWriter.WriteCast(cast.ResultType); Write(cast.Expression); }
/// <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 = (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; }
/// <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 = Context.GetTypeHandler(existingObject.GetType()); ObjectExpression objectExpression = (ObjectExpression)expression; foreach (KeyValueExpression Item in objectExpression.Properties) { // evaluate the item and let it assign itself? IPropertyData hndlr = typeHandler.FindProperty(Item.Key); if (hndlr == null) { throw new Exception(string.Format("Could not find property {0} for type {1}", Item.Key, typeHandler.ForType)); } if (hndlr.Ignored) { switch (Context.IgnoredPropertyAction) { case SerializationContext.IgnoredPropertyOption.Ignore: continue; case SerializationContext.IgnoredPropertyOption.SetIfPossible: if (!hndlr.CanWrite) continue; break; case SerializationContext.IgnoredPropertyOption.ThrowException: throw new Exception(string.Format("Can not set property {0} for type {1} because it is ignored and IgnorePropertyAction is set to ThrowException", Item.Key, typeHandler.ForType)); } } Expression valueExpression = Item.ValueExpression; valueExpression.ResultType = hndlr.PropertyType; object result = null; TypeConverterExpressionHandler converterHandler = null; IJsonTypeConverter converter = null; if (hndlr.HasConverter) { converterHandler = (TypeConverterExpressionHandler) Context.ExpressionHandlers.Find(typeof(TypeConverterExpressionHandler)); converter = hndlr.TypeConverter; } if (!hndlr.CanWrite) { result = hndlr.GetValue(existingObject); if (converterHandler != null) { converterHandler.Evaluate(valueExpression, result, deserializer, converter); } else { deserializer.Evaluate(valueExpression, result); } } else { if (hndlr.HasConverter) hndlr.SetValue(existingObject, converterHandler.Evaluate(valueExpression,deserializer,converter)); else hndlr.SetValue(existingObject, deserializer.Evaluate(valueExpression)); } } return existingObject; }
public Expression Execute(Expression root) { IList<ReferenceExpression> references = CollectReferences(root); foreach (ReferenceExpression reference in references) ResolveReference(reference, root); return root; }
/// <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((ObjectExpression)expression, deserializer); value = Evaluate(expression, value, deserializer); if (value is IDeserializationCallback) ((IDeserializationCallback)value).OnAfterDeserialization(); return value; }
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; }
private void WriteList(Expression Expression) { ArrayExpression list = (ArrayExpression)Expression; _jsonWriter.WriteArrayStart(); foreach (Expression item in list.Items) Write(item); _jsonWriter.WriteArrayEnd(); }
public override object Evaluate(Expression Expression, object existingObject, IDeserializerHandler deserializer) { Expression.OnObjectConstructed(existingObject); Type itemType = GetItemType(existingObject.GetType()); EvaluateItems((ArrayExpression) Expression, existingObject, itemType, deserializer); if (existingObject is IDeserializationCallback) ((IDeserializationCallback)existingObject).OnAfterDeserialization(); return existingObject; }
/// <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; }
public override object Evaluate(Expression expression, IDeserializerHandler deserializer) { ValueExpression value = (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> /// 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 = Context.TypeHandlerFactory[sourceType]; IJsonTypeConverter converter; if (typeof(IJsonTypeConverter).IsAssignableFrom(sourceType)) { converter = (IJsonTypeConverter) Activator.CreateInstance(sourceType); } else { converter = handler.TypeConverter; } return Evaluate(expression, deserializer, converter); }
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; } }
/// <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); object result = converter.ConvertTo(tempResult, sourceType, Context); expression.OnObjectConstructed(result); if (result is IDeserializationCallback) { ((IDeserializationCallback)result).OnAfterDeserialization(); } return result; }
public override object Evaluate(Expression Expression, IDeserializerHandler deserializer) { object collection = ConstructCollection((ArrayExpression)Expression, deserializer); return Evaluate(Expression, collection, deserializer); }
private void WriteBoolean(Expression expression) { _jsonWriter.WriteValue((bool)((BooleanExpression)expression).Value); }
public void Write(Expression expression) { _actions[expression.GetType()](expression); }
public static void Write(IJsonWriter writer, SerializationContext context, Expression expression) { new ExpressionWriter(writer, context).Write(expression); }
private void WriteValue(Expression expression) { ValueExpression value = (ValueExpression)expression; _jsonWriter.WriteQuotedValue(value.StringValue); }
/// <summary> /// Checks to see if this handler is able to convert the expression back into an object. /// </summary> /// <param name="expression">the expression that will be deserialized</param> /// <returns>true if this handler can handle the expression</returns> public virtual bool CanHandle(Expression expression) { return false; }
/// <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; }
private void WriteNull(Expression expression) { if (!(expression is NullExpression)) throw new ArgumentException("Expression should be a NullExpression"); _jsonWriter.WriteSpecialValue("null"); }
/// <summary> /// This method is invalid for TypeConverterExpressionHandler /// </summary> /// <exception cref="NotSupportedException">Evaluating an existing object is not supported by TypeConverterExpressionHandler</exception> public void Evaluate(Expression valueExpression, object result, IDeserializerHandler deserializer, IJsonTypeConverter converter) { //TODO: possibly allow this if the type implements IJsonTypeConverter itself throw new NotSupportedException("Cannot convert an existing object."); }
/// <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); }
public void Add(Expression item) { _items.Add(item); item.Parent = this; }
/// <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 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: case TypeCode.UInt64: _jsonWriter.WriteSpecialValue(string.Format("{0}", value)); break; default: _jsonWriter.WriteValue((long)Convert.ChangeType(value, typeof(long), CultureInfo.InvariantCulture)); break; } }
public override object Evaluate(Expression expression, IDeserializerHandler deserializer) { ValueExpression valueExpr = (ValueExpression)expression; return DateTime.ParseExact(valueExpr.StringValue, dateFormat, Culture, dateTimeStyle); }
private void WriteObject(Expression Expression) { ObjectExpression obj = (ObjectExpression)Expression; bool hasConstructor = false; if (obj.ConstructorArguments.Count > 0) { hasConstructor = true; _jsonWriter.WriteConstructorStart(obj.ResultType); _jsonWriter.WriteConstructorArgsStart(); foreach (Expression ctorArg in obj.ConstructorArguments) { Write(ctorArg); } _jsonWriter.WriteConstructorArgsEnd(); } if (!hasConstructor || obj.Properties.Count > 0) { _jsonWriter.WriteObjectStart(); foreach (KeyValueExpression keyValue in obj.Properties) { _jsonWriter.WriteKey(keyValue.Key); Write(keyValue.ValueExpression); } _jsonWriter.WriteObjectEnd(); } if (hasConstructor) _jsonWriter.WriteConstructorEnd(); }
/// <summary> /// Convert the expression into an object by populating an existing object with any necessary values. /// The existingObject will usually come from the get method of a property on an object that doesn't /// allow writing to the property. /// </summary> /// <param name="expression">the epxression to deserialize</param> /// <param name="existingObject">an existing object to populate</param> /// <param name="deserializer">deserializer instance to use to deserialize any child expressions</param> /// <returns>a fully deserialized object</returns> public abstract object Evaluate(Expression expression, object existingObject, IDeserializerHandler deserializer);
private void WriteReference(Expression Expression) { ReferenceExpression refExpr = (ReferenceExpression)Expression; _jsonWriter.WriteSpecialValue(refExpr.Path.ToString()); }