public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer) { DataTable table = (DataTable) data; ObjectExpression tableExpr = new ObjectExpression(); tableExpr.Add("TableName", serializer.Serialize(table.TableName, currentPath.Append("TableName"))); tableExpr.Add("Columns", GetColumnsExpression(table, currentPath.Append("Columns"), serializer)); tableExpr.Add("Rows", GetRowsExpression(table, currentPath, serializer)); return tableExpr; }
/// <summary> /// Serialize an object implementing IDictionary. The serialized data is similar to a regular /// object, except that the keys of the dictionary are used instead of properties. /// </summary> /// <param name="data">the dictionary object</param> /// <param name="currentPath">object's path</param> /// <param name="serializer">the serializer instance, used to serialize keys and values</param> public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer) { IDictionary dictionary = (IDictionary)data; Type itemType = typeof(object); Type genericDictionary = null; if ((genericDictionary = dictionary.GetType().GetInterface(typeof(IDictionary<,>).Name)) != null) { itemType = genericDictionary.GetGenericArguments()[1]; } ObjectExpression expression = new ObjectExpression(); foreach (DictionaryEntry pair in dictionary) { //may not work in all cases object value = pair.Value; Expression valueExpr = serializer.Serialize(value, currentPath.Append(pair.Key.ToString())); if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), itemType)) { valueExpr = new CastExpression(value.GetType(), valueExpr); } expression.Add(pair.Key.ToString(), valueExpr); } return expression; }
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; }
protected virtual Expression GetColumnExpression(DataColumn dc, JsonPath jsonPath, IExpressionBuilder serializer) { ObjectExpression column = new ObjectExpression(); // just DataType and column for now column.Add("DataType", serializer.Serialize(dc.DataType, jsonPath.Append("DataType"))); column.Add("ColumnName", serializer.Serialize(dc.ColumnName, jsonPath.Append("ColumnName"))); return column; }
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; }
/// <summary> /// Generates an expression for an item and adds it to the object /// </summary> /// <param name="data">the item being serialized</param> /// <param name="currentPath">the current path to the object</param> /// <param name="serializer">serializer instance</param> /// <param name="expression">the object expression</param> /// <param name="prop">the property being serialized</param> protected virtual void GenerateItemExpression(object data, JsonPath currentPath, IExpressionBuilder serializer, ObjectExpression expression, IPropertyData prop) { object value = prop.GetValue(data); if (!prop.ShouldWriteValue(this.Config, value)) return; Expression valueExpr; if (prop.HasConverter) { valueExpr = serializer.Serialize(value, currentPath.Append(prop.Alias), prop.TypeConverter); } else { valueExpr = serializer.Serialize(value, currentPath.Append(prop.Alias)); } if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), prop.PropertyType)) { valueExpr = new CastExpression(value.GetType(), valueExpr); } expression.Add(prop.Alias, valueExpr); }
/// <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> /// Parses a reference to an object /// </summary> /// <returns></returns> private Expression ParseReference() { JsonPath refID = new JsonPath(); Token tok = ReadToken(); if (tok != ReferenceStartToken && tok != OldReferenceStartToken) throw new ParseException(string.Format("Invalid starting token for ParseReference at Line: {0}, Position: {1}, Expected: {2} or {3}, got: {4}", tok.linenumber, tok.position, ReferenceStartToken, OldReferenceStartToken, tok)); int line = tok.linenumber; int pos = tok.position; while (PeekToken() == PeriodToken || PeekToken() == LSquareToken) { tok = ReadToken(); // separator "." if (tok == PeriodToken) tok = ReadToken(); // type part if (tok == LSquareToken) { refID = refID.Append(ReadToken().value); // index ReadToken(); // ] } else if (tok.type == TokenType.Identifier) { refID = refID.Append(tok.value); } else { throw new ParseException(string.Format("Invalid Reference at Line: {0}, Position: {1}, must be an identifier or array value: {2}", tok.linenumber, tok.position, tok)); } } return new ReferenceExpression(refID) { LineNumber = line, CharacterPosition = pos }; }