public void RootCollectionTest() { ArrayExpression rootAsList = new ArrayExpression(); Expression result = ResolveReference(rootAsList, JsonPath.Root); Assert.AreSame(rootAsList, result, "Resolve reference for this should return root"); }
public void Visit(ArrayExpression list) { VisitComplex(list); foreach (Expression item in list.Items) Visit(item); }
public virtual void Visit(ArrayExpression expression) { OnArrayStart(expression); Visit((ComplexExpressionBase)expression); foreach (Expression item in expression.Items) item.Accept(this); OnArrayEnd(expression); }
protected virtual void EvaluateItems(ArrayExpression Expression, object Collection, Type ItemType, IDeserializerHandler deserializer) { foreach (Expression item in Expression.Items) { item.ResultType = ItemType; object itemResult = deserializer.Evaluate(item); AddItem(Collection, itemResult); } }
protected virtual Expression GetColumnsExpression(DataTable table, JsonPath currentPath, IExpressionBuilder serializer) { ArrayExpression columns = new ArrayExpression(); int colCount = 0; foreach (DataColumn dc in table.Columns) { columns.Add(GetColumnExpression(dc, currentPath.Append(colCount), serializer)); colCount++; } return columns; }
public void ResolveCollectionItemTest() { ArrayExpression root = new ArrayExpression(); ObjectExpression child1 = new ObjectExpression(); ObjectExpression child2 = new ObjectExpression(); root.Add(child1); root.Add(child2); Expression actual = ResolveReference(root, "$[1]"); Assert.AreSame(child2, actual, "$[1] did not resolve correctly"); }
/// <summary> /// Resolve a reference to an item within the collection /// </summary> /// <param name="refID">the reference to resolve</param> /// <returns>the referenced expression</returns> public void VisitListExpression(ArrayExpression expression) { Visit(typeof(ComplexExpressionBase), expression); if (_expr != null) return; // found it int index = _refID.TopAsInt; if (index < 0 || index >= expression.Items.Count) { throw new ArgumentOutOfRangeException("Reference to collection item out of range: " + _refID); } Expression expr = expression.Items[index]; Visit(expr); }
protected virtual Expression GetRowsExpression(DataTable table, JsonPath currentPath, IExpressionBuilder serializer) { ArrayExpression rowsExpr = new ArrayExpression(); for (int i = 0; i < table.Rows.Count; i++) { DataRow row = table.Rows[i]; object[] values = row.ItemArray; JsonPath rowPath = currentPath.Append(i); ArrayExpression rowExpr = new ArrayExpression(); for (int j = 0; j < values.Length; j++) { rowExpr.Add(serializer.Serialize(values[j], rowPath.Append(j))); } rowsExpr.Add(rowExpr); } return rowsExpr; }
protected virtual Expression GetExpression(IEnumerable Items, Type ItemType, JsonPath CurrentPath, ISerializerHandler serializer) { int index = 0; ArrayExpression expression = new ArrayExpression(); foreach (object value in Items) { Expression itemExpr = serializer.Serialize(value, CurrentPath.Append(index)); if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), ItemType)) { itemExpr = new CastExpression(value.GetType(), itemExpr); } expression.Add(itemExpr); index++; } return expression; }
/// <summary> /// Serializes the data into a json array expression. /// </summary> /// <param name="data">the data to serialize</param> /// <param name="currentPath">the current path to the data</param> /// <param name="serializer">serializer instance to use to serialize list items</param> /// <returns>a json array expression representation</returns> public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer) { TypeData handler = Config.GetTypeHandler(data.GetType()); CollectionHandler collectionHandler = handler.CollectionHandler; Type elemType = collectionHandler.GetItemType(handler.ForType); int index = 0; ArrayExpression expression = new ArrayExpression(); foreach (object value in collectionHandler.GetEnumerable(data)) { Expression itemExpr = serializer.Serialize(value, currentPath.Append(index)); if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), elemType)) { itemExpr = new CastExpression(value.GetType(), itemExpr); } expression.Add(itemExpr); index++; } return expression; }
/// <summary> /// Evaluates the items in the expression and assigns them to the collection using the builder /// </summary> /// <param name="expression">the expression to evaluate</param> /// <param name="builder">builder used to build the collection</param> /// <param name="itemType">the type of the collection's elements</param> /// <param name="deserializer">deserializer instance to deserialize items</param> /// <returns>evaluated collection object</returns> protected virtual object EvaluateItems(ArrayExpression expression, ICollectionBuilder builder, Type itemType, IDeserializerHandler deserializer) { object result = null; bool constructedEventSent = false; try { result = builder.GetReference(); expression.OnObjectConstructed(result); constructedEventSent = true; } catch { // this might fail if the builder's not ready } foreach (Expression item in expression.Items) { item.ResultType = itemType; object itemResult = deserializer.Evaluate(item); builder.Add(itemResult); } result = builder.GetResult(); if (!constructedEventSent) expression.OnObjectConstructed(result); return result; }
protected virtual void EvaluateColumns(DataTable table, ArrayExpression columnsExpression, IDeserializerHandler deserializer) { foreach (Expression colExpr in columnsExpression.Items) { table.Columns.Add(EvaluateColumn(colExpr, deserializer)); } }
protected virtual void EvaluateRows(DataTable table, ArrayExpression rowsExpression, IDeserializerHandler deserializer) { for (int i = 0; i < rowsExpression.Items.Count; i++) { ArrayExpression rowExpr = (ArrayExpression) rowsExpression.Items[i]; for (int j = 0; j < rowExpr.Items.Count; j++) { rowExpr.Items[j] = new CastExpression(table.Columns[j].DataType, rowExpr.Items[j]); } rowExpr.ResultType = typeof(object[]); DataRow dr = table.NewRow(); dr.ItemArray = (object[]) deserializer.Evaluate(rowExpr); table.Rows.Add(dr); } }
/// <summary> /// Parses a javascript array /// </summary> /// <returns></returns> private ArrayExpression ParseCollection() { Token tok = ReadToken(); Debug.Assert(tok == LSquareToken); ArrayExpression value = new ArrayExpression(); Expression item; bool first = true; while (ReadAhead(CommaToken, RSquareToken, new ExpressionMethod(ParseExpression), out item, ref first)) { value.Add(item); } return value; }
protected virtual object ConstructCollection(ArrayExpression Expression, IDeserializerHandler deserializer) { object result = Activator.CreateInstance(Expression.ResultType); return result; }
/// <summary> /// Called on an array expression after the items are visited /// </summary> /// <param name="expression"></param> public virtual void OnArrayEnd(ArrayExpression expression) { }
/// <summary> /// Called on an array expression before the items are visited /// </summary> /// <param name="expression"></param> public virtual void OnArrayStart(ArrayExpression expression) { }
public void ResolveNestedCollectionTest() { ArrayExpression root = new ArrayExpression(); ArrayExpression child1 = new ArrayExpression(); ArrayExpression child2 = new ArrayExpression(); root.Add(child1); root.Add(child2); ObjectExpression childA = new ObjectExpression(); child1.Add(childA); ObjectExpression childB = new ObjectExpression(); child1.Add(childB); Expression actual = ResolveReference(root, "$[0][1]"); Assert.AreSame(childB, actual, "$[0][1] did not resolve correctly"); }
/// <summary> /// Constructs a builder used to build the deserialized collection /// </summary> /// <param name="collection">an existing collection object or null for a new collection</param> /// <param name="list">the list expression</param> /// <param name="itemType">the type of the items</param> /// <returns>collection builder</returns> protected virtual ICollectionBuilder ConstructBuilder(object collection, ArrayExpression list, out Type itemType) { Type listType = collection != null ? collection.GetType() : list.ResultType; TypeData typeHandler = Config.GetTypeHandler(listType); CollectionHandler collHandler = typeHandler.CollectionHandler; itemType = collHandler.GetItemType(listType); if (itemType == null) throw new Exception("Null item type returned from " + collHandler.GetType() + " for Collection type: " + listType); if (collection != null) return collHandler.ConstructBuilder(collection); else return collHandler.ConstructBuilder(listType, list.Items.Count); }