/// <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 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;
}
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;
}
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;
}
/// <summary>
/// Creates an json object expression from object data.
/// </summary>
/// <param name="data">the data to serialize</param>
/// <param name="currentPath">current path to the object</param>
/// <param name="serializer">serializer instance used to serialize key values</param>
/// <returns>json object expression</returns>
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
TypeData handler = Config.GetTypeHandler(data.GetType());
ObjectExpression expression = new ObjectExpression();
foreach (IPropertyData prop in handler.Properties)
{
GenerateItemExpression(data, currentPath, serializer, expression, prop);
}
return expression;
}
/// <summary>
/// Serialize the given object at the current indent level. The path to the object is represented by
/// currentPath such as "this.name", etc. This is an internal method that can be called recursively.
/// </summary>
/// <param name="value">the object to serialize</param>
/// <param name="currentPath">the current path for reference writing</param>
public Expression Serialize(object value, JsonPath currentPath, IJsonTypeConverter converter)
{
if (value == null)
{
return new NullExpression();
}
else
{
IExpressionHandler objHandler;
bool isReferencable = _config.IsReferenceableType(value.GetType());
if (converter != null)
{
TypeConverterExpressionHandler converterHandler = (TypeConverterExpressionHandler)_config.ExpressionHandlers.Find(typeof(TypeConverterExpressionHandler));
isReferencable = converterHandler.IsReferenceable(value, converter);
objHandler = converterHandler;
}
else
{
objHandler = _config.ExpressionHandlers.GetHandler(value);
isReferencable = objHandler.IsReferenceable(value);
}
if (isReferencable)
{
Expression expr = HandleReference(value, currentPath);
if (expr != null)
return expr;
}
ISerializationCallback callback = value as ISerializationCallback;
if (callback != null)
callback.OnBeforeSerialization();
try
{
if (converter != null)
{
return ((TypeConverterExpressionHandler)objHandler).GetExpression(value, converter, currentPath, this);
}
else
{
SetCanReference(value);
return objHandler.GetExpression(value, currentPath, this);
}
}
finally
{
if (callback != null)
callback.OnAfterSerialization();
}
}
}
public void SelectEnumerableValuesUsingScalarPathFromJson_Expected_EnumerableValue()
{
string testData = Given();
IPath path = new JsonPath("Motto", "Motto");
JsonNavigator JsonNavigator = new JsonNavigator(testData);
string actual = string.Join("|", JsonNavigator.SelectEnumerable(path).Select(o => o.ToString().Trim()));
const string expected = "Eat lots of cake";
Assert.AreEqual(expected, actual);
}
public void Example9()
{
var input = "$..book[?(@.price<10)]";
var path = JsonPath.Parse(input);
var result = path.Evaluate(_instance);
Assert.IsNull(result.Error);
Assert.AreEqual(2, result.Matches.Count);
Assert.AreEqual("Sayings of the Century", result.Matches[0].Value.GetProperty("title").GetString());
Assert.AreEqual("Moby Dick", result.Matches[1].Value.GetProperty("title").GetString());
Assert.AreEqual(input, path.ToString());
}
public void SelectEnumerableValuesUsingEnumerablePathFromJson_Expected_EnumerableValue()
{
string testData = Given();
IPath path = new JsonPath("Departments().Name", "Departments.Name");
JsonNavigator JsonNavigator = new JsonNavigator(testData);
string actual = string.Join("|", JsonNavigator.SelectEnumerable(path).Select(o => o.ToString().Trim()));
const string expected = "Dev|Accounts";
Assert.AreEqual(expected, actual);
}
public void CreateEnumerablePathSegmentFromJProperty_Expected_EnumerableJsonPathSegment()
{
JProperty jProperty = new JProperty("EnumerableProperty", new JArray(
new JObject(new JProperty("ScalarProperty", "ScalarValue"),
new JProperty("ScalarProperty1", "ScalarValue1"))));
JsonPath path = new JsonPath();
IPathSegment segment = path.CreatePathSegment(jProperty);
const bool expected = true;
bool actual = segment.IsEnumarable;
Assert.AreEqual(expected, actual);
}
public void FilterOnBooks_ReturnsCorrectResult(string path, params string[] expected)
{
string input = TestDataLoader.Store();
IReadOnlyList <JsonElement> result = JsonPath.ExecutePath(path, input);
Assert.Equal(expected.Length, result.Count);
string[] resultJsons = result.Select(x => JsonSerializer.Serialize(x)).Select(x => x.RemoveWhiteSpace()).ToArray();
foreach (string e in expected)
{
Assert.Contains(_bookJsons[e], resultJsons);
}
}
public void SelectScalarValueUsingScalarPathFromJson_Expected_ScalarValue()
{
var testData = Given();
IPath namePath = new JsonPath("Name", "Name");
var JsonNavigator = new JsonNavigator(testData);
var actual = JsonNavigator.SelectScalar(namePath).ToString();
const string expected = "Dev2";
Assert.AreEqual(expected, actual);
}
public void RecordsetListHelper_SplitRecordsetAndFieldNames_WhenPathContainsScalar_SingleLevel_ShouldConvertToField()
{
//------------Setup for test--------------------------
var jsonPath = new JsonPath();
jsonPath.ActualPath = "ScalarValue";
//------------Execute Test---------------------------
var splitRecordsetAndFieldNames = RecordsetListHelper.SplitRecordsetAndFieldNames(jsonPath);
//------------Assert Results-------------------------
Assert.AreEqual("", splitRecordsetAndFieldNames.Item1);
Assert.AreEqual("ScalarValue", splitRecordsetAndFieldNames.Item2);
}
public void RecordsetListHelper_SplitRecordsetAndFieldNames_WhenPathContainsEndingField_MultiLevel_ShouldConvertToField()
{
//------------Setup for test--------------------------
var jsonPath = new JsonPath();
jsonPath.ActualPath = "OneRecordset().AnotherRecset().AndAnotherRecset";
//------------Execute Test---------------------------
var splitRecordsetAndFieldNames = RecordsetListHelper.SplitRecordsetAndFieldNames(jsonPath);
//------------Assert Results-------------------------
Assert.AreEqual("OneRecordset_AnotherRecset", splitRecordsetAndFieldNames.Item1);
Assert.AreEqual("AndAnotherRecset", splitRecordsetAndFieldNames.Item2);
}
public void Example3()
{
var input = "$.store.*";
var path = JsonPath.Parse(input);
var result = path.Evaluate(_instance);
Assert.IsNull(result.Error);
Assert.AreEqual(2, result.Matches.Count);
Assert.AreEqual(4, result.Matches[0].Value.EnumerateArray().Count());
Assert.AreEqual(2, result.Matches[1].Value.EnumerateObject().Count());
Assert.AreEqual(input, path.ToString());
}
public void SelectEnumerableValuesUsingEnumerablePathFromJson_WherePathMapsToPrimitiveEnumerable_Expected_EnumerableValue()
{
string testData = Given();
IPath path = new JsonPath("PrimitiveRecordset()", "PrimitiveRecordset");
JsonNavigator JsonNavigator = new JsonNavigator(testData);
string actual = string.Join("|", JsonNavigator.SelectEnumerable(path).Select(o => o.ToString().Trim()));
const string expected = "RandomData|RandomData1";
Assert.AreEqual(expected, actual);
}
public void SelectEnumerableValuesUsingEnumerablePathFromJson_WherePathMapsThroughNestedEnumerables_Expected_EnumerableValue()
{
var testData = Given();
IPath path = new JsonPath("Departments().Employees().Name", "Departments.Employees.Name");
var JsonNavigator = new JsonNavigator(testData);
var actual = string.Join("|", JsonNavigator.SelectEnumerable(path).Select(o => o.ToString().Trim()));
const string expected = "Brendon|Jayd|Bob|Joe";
Assert.AreEqual(expected, actual);
}
public void SelectScalarValueUsingEnumerablePathFromJson_Expected_ScalarValue()
{
string testData = Given();
IPath namePath = new JsonPath("Departments().Employees().Name", "Departments.Employees.Name");
JsonNavigator JsonNavigator = new JsonNavigator(testData);
string actual = JsonNavigator.SelectScalar(namePath).ToString();
const string expected = "Joe";
Assert.AreEqual(expected, actual);
}
public void SelectScalarValueUsingEnumerablePathFromJson_WherePathMapsToPrimitiveEnumerable_Expected_ScalarValue()
{
string testData = Given();
IPath namePath = new JsonPath("PrimitiveRecordset()", "PrimitiveRecordset");
JsonNavigator JsonNavigator = new JsonNavigator(testData);
string actual = JsonNavigator.SelectScalar(namePath).ToString().Trim();
const string expected = "RandomData1";
Assert.AreEqual(expected, actual);
}
public Expression HandleReference(object value, JsonPath CurrentPath)
{
if (!IsReferenceable(value))
{
return(null);
}
ReferenceInfo refInfo = null;
if (_refs.ContainsKey(value))
{
/*
* This object has already been seen by the serializer so
* determine what to do with it. If its part of the current path
* then its a circular reference and an error needs to be thrown or it should
* be ignored depending on the option. Otherwise write a reference to it
*/
refInfo = _refs[value];
JsonPath refPath = refInfo.Path;
switch (_context.ReferenceWritingType)
{
case SerializationContext.ReferenceOption.WriteIdentifier:
if (!refInfo.CanReference)
{
throw new InvalidOperationException("Can't reference object: " + refPath + " from " + CurrentPath + ", either it is a collection, or it has not been converted yet");
}
return(new ReferenceExpression(refPath));
case SerializationContext.ReferenceOption.IgnoreCircularReferences:
if (CurrentPath.StartsWith(refPath))
{
return(new NullExpression());
}
break;
case SerializationContext.ReferenceOption.ErrorCircularReferences:
if (CurrentPath.StartsWith(refPath))
{
throw new InvalidOperationException("Circular reference detected. Current path: " + CurrentPath + ", reference to: " + refPath);
}
break;
}
}
else
{
refInfo = new ReferenceInfo(CurrentPath);
_refs[value] = refInfo;
}
return(null);
}
public void FromJson(JsonValue json, JsonSerializer serializer)
{
Path = JsonPath.Parse(json.Object["path"].String);
var result = json.Object["result"];
if (result.Type == JsonValueType.Boolean && !result.Boolean)
{
Result = new JsonArray();
}
else
{
Result = result.Array;
}
}
public void SelectScalarValue_WithEnumerableSymbolAndSeperatorSymbol_Expected_PrimitiveRecordset()
{
IPath namePath = new JsonPath("().", "().");
var JsonNavigator = new JsonNavigator(testData);
var actual = JsonNavigator.SelectScalar(namePath).ToString();
const string expected = @"""PrimitiveRecordset"": [
""\r\n RandomData\r\n "",
""\r\n RandomData1\r\n ""
]";
Assert.AreEqual(expected, actual);
}
public JsonNode Put(string path, object entitySrc)
{
dynamic entity = getEntity(entitySrc);
JsonPath jPath = new JsonPath(path);
JsonNode node = read(jPath.ParentPathParts, true);
if (entity != null && entity.GetType() == OBJ_TYPE)
{
entity["$key"] = jPath.Key;
}
node.Value()[jPath.Key] = entity;
Save();
return(read(jPath.PathParts));
}
protected override void Execute(CodeActivityContext context)
{
var workflowContext = context.GetExtension <IWorkflowContext>();
if (!string.IsNullOrEmpty(JsonString.Get <string>(context)) && !string.IsNullOrEmpty(JsonPath.Get <string>(context)))
{
JObject jsonObject = JObject.Parse(JsonString.Get <string>(context));
JToken token = jsonObject.SelectToken(JsonPath.Get <string>(context));
if (token != null)
{
string value = (string)token;
Result_Text.Set(context, value);
Guid id = new Guid();
if (Guid.TryParse(value, out id))
{
this.Result_Guid.Set(context, value);
}
DateTime dateTime = new DateTime();
if (DateTime.TryParse(value, out dateTime))
{
this.Result_DateTime.Set(context, dateTime);
}
decimal decimalValue = new decimal();
if (decimal.TryParse(value, out decimalValue))
{
this.Result_Decimal.Set(context, decimalValue);
try
{
this.Result_Money.Set(context, new Money(decimalValue));
}
catch { }
}
double doubleValue = new double();
if (double.TryParse(value, out doubleValue))
{
this.Result_Double.Set(context, doubleValue);
}
int intValue = 0;
if (int.TryParse(value, out intValue))
{
this.Result_WholeNumber.Set(context, intValue);
}
}
}
}
public void RecursiveFilterAndWildcardArrayFilter_ReturnsCorrectResult(string path, params string[] expected)
{
string input = TestDataLoader.Store();
IReadOnlyList <JsonElement> result = JsonPath.ExecutePath(path, input);
Assert.Equal(expected.Length, result.Count);
foreach (JsonElement r in result)
{
Assert.Equal(JsonValueKind.String, r.ValueKind);
string rString = r.GetString();
Assert.Contains(rString, expected);
}
}
public void Example2()
{
var input = "$..author";
var path = JsonPath.Parse(input);
var result = path.Evaluate(_instance);
Assert.IsNull(result.Error);
Assert.AreEqual(4, result.Matches.Count);
Assert.AreEqual("Nigel Rees", result.Matches[0].Value.GetString());
Assert.AreEqual("Evelyn Waugh", result.Matches[1].Value.GetString());
Assert.AreEqual("Herman Melville", result.Matches[2].Value.GetString());
Assert.AreEqual("J. R. R. Tolkien", result.Matches[3].Value.GetString());
Assert.AreEqual(input, path.ToString());
}
// Test with these:
// OBSOLETE DATA:
// http://localhost:51080/ArtistVideo/Get/
// http://localhost:51080/ArtistVideo/Get/Artist%200
// http://localhost:51080/ArtistVideo/Get/?title=Video%201%201%20title
public string Get(string[] id = null)
{
// Instantiate my homemade JSONPath Services object. It does all the work:
JsonPath jsonPathServices = new JsonPath();
// Get the arguments from the command line URL and prepare them for usage. Pass
// them to the JSONPath query and execute it. Return the result in JSON form:
string response = jsonPathServices.QueryJsonPathMain((HttpRequestWrapper)Request);
// NOTE: The core JSON Path module has a bug for this data-type only. Rather than
// open that can of worms, I will simply patch the JSON:
response = response.Replace("}]},", "},");
return(response);
}
public static void Run(string text)
{
Assert.Throws <JsonPathSyntaxException>(() =>
{
try
{
Console.WriteLine($"\n{JsonPath.Parse(text)}");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
});
}
public void GoessnerExample3Parsed()
{
var path = JsonPath.Parse("$.store.*");
var expected = new JsonArray
{
new JsonArray
{
new JsonObject
{
{ "category", "reference" },
{ "author", "Nigel Rees" },
{ "title", "Sayings of the Century" },
{ "price", 8.95 }
},
new JsonObject
{
{ "category", "fiction" },
{ "author", "Evelyn Waugh" },
{ "title", "Sword of Honour" },
{ "price", 12.99 }
},
new JsonObject
{
{ "category", "fiction" },
{ "author", "Herman Melville" },
{ "title", "Moby Dick" },
{ "isbn", "0-553-21311-3" },
{ "price", 8.99 }
},
new JsonObject
{
{ "category", "fiction" },
{ "author", "J. R. R. Tolkien" },
{ "title", "The Lord of the Rings" },
{ "isbn", "0-395-19395-8" },
{ "price", 22.99 }
}
},
new JsonObject
{
{ "color", "red" },
{ "price", 19.95 }
}
};
var actual = path.Evaluate(GoessnerData);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Check to see if an expectation is met.
/// </summary>
/// <param name="key">The name of the expectation being checked.</param>
/// <param name="actualValue">The value for the expectation to check.</param>
/// <param name="expectedValues">Can either be a single value or an array of values that are considered valid.</param>
/// <param name="detectedErrors">A collection of validation errors that will be added to when errors are found.</param>
/// <returns></returns>
private static bool ExpectationSatisfied(string key, object actualValue, object expectedValues, List <ValidationError> detectedErrors)
{
if (null == key)
{
throw new ArgumentNullException("key");
}
if (null == detectedErrors)
{
throw new ArgumentNullException("detectedErrors");
}
if (actualValue == null && expectedValues != null)
{
detectedErrors.Add(new ValidationError(ValidationErrorCode.ExpectationConditionFailed, null, "Expectation {0}={1} failed. Actual value was null and a value was expected.", key, expectedValues));
return(false);
}
if (expectedValues == null)
{
return(true);
}
if (null != (expectedValues as IList <JToken>))
{
if (((IList <JToken>)expectedValues).Any(possibleValue => JsonPath.TokenEquals(possibleValue, actualValue)))
{
return(true);
}
}
else
{
var token = expectedValues as JToken;
if (token != null)
{
if (JsonPath.TokenEquals(token, actualValue))
{
return(true);
}
}
else if (actualValue.Equals(expectedValues))
{
return(true);
}
}
detectedErrors.Add(new ValidationError(ValidationErrorCode.ExpectationConditionFailed, null, "Expectation {0} = {1} failed. Actual value: {2}", key, expectedValues, actualValue));
return(false);
}
private void TestJson()
{
try
{
IReadOnlyList <JsonElement> result = JsonPath.ExecutePath(Model.Expression, Model.Data);
Model.Result = JsonSerializer.Serialize(result, new JsonSerializerOptions {
WriteIndented = true
});
}
catch (Exception e)
{
var msg = $"Failed to apply Json path: {e.Message}";
Logger.Error(msg);
Model.Result = msg;
}
}
public void SelectEnumerableValuesAsRelatedUsingEnumerablePathFromJson_Where_PathsContainASinglePathWhichIsScalar_Expected_FlattenedDataWithValueFromScalarPath()
{
IPath path = new JsonPath("Name", "Name");
var paths = new List <IPath> {
path
};
var JsonNavigator = new JsonNavigator(testData);
var data = JsonNavigator.SelectEnumerablesAsRelated(paths);
const string expected = "Dev2";
var actual = string.Join("|", data[path].Select(s => s.ToString().Trim()));
Assert.AreEqual(expected, actual);
}
public void SelectEnumerableValuesAsRelatedUsingEnumerablePathFromJson_Where_PathsContainASinglePathWhichIsEnumerable_Expected_FlattenedDataWithValuesFromEnumerablePath()
{
IPath path = new JsonPath("Departments().Employees().Name", "Departments.Employees.Name");
var paths = new List <IPath> {
path
};
var JsonNavigator = new JsonNavigator(testData);
var data = JsonNavigator.SelectEnumerablesAsRelated(paths);
const string expected = "Brendon|Jayd|Bob|Joe";
var actual = string.Join("|", data[path].Select(s => s.ToString().Trim()));
Assert.AreEqual(expected, actual);
}
public void LessThanOrEqualFilterOnIntWithDecimal_ReturnsCorrectResult()
{
string input = @"
{
""object"": {
""arrays"": [ { ""amount"": 10 } ]
}
}
";
ExpressionList expression = ExpressionList.TokenizeAndParse("$.object.arrays[?(@.amount >= 10.0)]");
IReadOnlyList <JsonElement> result = JsonPath.ExecutePath(expression, input);
Assert.Equal(1, result.Count);
}
public void Example4()
{
var input = "$.store..price";
var path = JsonPath.Parse(input);
var result = path.Evaluate(_instance);
Assert.IsNull(result.Error);
Assert.AreEqual(5, result.Matches.Count);
Assert.AreEqual(8.95m, result.Matches[0].Value.GetDecimal());
Assert.AreEqual(12.99m, result.Matches[1].Value.GetDecimal());
Assert.AreEqual(8.99m, result.Matches[2].Value.GetDecimal());
Assert.AreEqual(22.99m, result.Matches[3].Value.GetDecimal());
Assert.AreEqual(19.95m, result.Matches[4].Value.GetDecimal());
Assert.AreEqual(input, path.ToString());
}
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;
}
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;
}
public string TryParse(string source, ref int index, ref JsonPath path)
{
if (path == null)
{
return("Start token not found.");
}
var error = source.GetSlices(ref index, out var slices);
if (error != null)
{
return(error);
}
path = path.Array(slices.ToArray());
return(null);
}
public Expression HandleReference(object value, JsonPath CurrentPath)
{
if (!IsReferenceable(value))
return null;
ReferenceInfo refInfo = null;
if (_refs.ContainsKey(value))
{
/*
* This object has already been seen by the serializer so
* determine what to do with it. If its part of the current path
* then its a circular reference and an error needs to be thrown or it should
* be ignored depending on the option. Otherwise write a reference to it
*/
refInfo = _refs[value];
JsonPath refPath = refInfo.Path;
switch (_context.ReferenceWritingType)
{
case SerializationContext.ReferenceOption.WriteIdentifier:
if (!refInfo.CanReference)
throw new InvalidOperationException("Can't reference object: " + refPath + " from " + CurrentPath + ", either it is a collection, or it has not been converted yet");
return new ReferenceExpression(refPath);
case SerializationContext.ReferenceOption.IgnoreCircularReferences:
if (CurrentPath.StartsWith(refPath))
{
return new NullExpression();
}
break;
case SerializationContext.ReferenceOption.ErrorCircularReferences:
if (CurrentPath.StartsWith(refPath))
{
throw new InvalidOperationException("Circular reference detected. Current path: " + CurrentPath + ", reference to: " + refPath);
}
break;
}
}
else
{
refInfo = new ReferenceInfo(CurrentPath);
_refs[value] = refInfo;
}
return null;
}
/// <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;
}
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
string value = ((DateTime)data).ToString(dateFormat, Culture);
return new ValueExpression(value);
}
/// <summary>
/// Creates an json object expression from object data.
/// </summary>
/// <param name="data">the data to serialize</param>
/// <param name="currentPath">current path to the object</param>
/// <param name="serializer">serializer instance used to serialize key values</param>
/// <returns>json object expression</returns>
public override Expression GetExpression(object data, JsonPath currentPath, ISerializerHandler serializer)
{
TypeData handler = Context.GetTypeHandler(data.GetType());
ObjectExpression expression = new ObjectExpression();
foreach (IPropertyData prop in handler.Properties)
{
object value = prop.GetValue(data);
Expression valueExpr;
if (prop.HasConverter)
{
valueExpr = serializer.Serialize(value, currentPath.Append(prop.Name), prop.TypeConverter);
}
else
{
valueExpr = serializer.Serialize(value, currentPath.Append(prop.Name));
}
if (value != null && !ReflectionUtils.AreEquivalentTypes(value.GetType(), prop.PropertyType))
{
valueExpr = new CastExpression(value.GetType(), valueExpr);
}
expression.Add(prop.Name, valueExpr);
}
return expression;
}
/// <summary> /// Take an object and convert it to an expression to be serialized. Child names/indexes should be appended to the /// currentPath before serializing child objects. /// </summary> /// <param name="data">the object to convert</param> /// <param name="CurrentPath">the current path to this object from the root, used for tracking references</param> /// <param name="serializer">serializer instance for serializing child objects</param> /// <returns>an expression which represents a json structure</returns> public abstract Expression GetExpression(object data, JsonPath currentPath, ISerializerHandler serializer);
public Expression Serialize(object value, JsonPath currentPath)
{
return Serialize(value, currentPath, null);
}
/// <summary>
/// Gets an expression for a value by first converting it with its registered type converter and then calling Serialize
/// </summary>
/// <param name="value">the value to generate an expression for</param>
/// <param name="currentPath">the current path to the value</param>
/// <param name="serializer">serializer instance</param>
/// <returns>an expression for the value</returns>
public override Expression GetExpression(object value, JsonPath currentPath, ISerializerHandler serializer)
{
TypeData handler = Context.TypeHandlerFactory[value.GetType()];
IJsonTypeConverter converter = (handler.HasConverter ? handler.TypeConverter : (IJsonTypeConverter)value);
return GetExpression(value, converter, currentPath, serializer);
}
public ReferenceExpression(string ReferencePath)
{
this._path = new JsonPath(ReferencePath);
}
public ReferenceVisitor(JsonPath RefID)
{
_refID = RefID;
}
/// <summary>
/// Converts a boolean value into a BooleanExpression
/// </summary>
/// <param name="data">the data to convert to an expression</param>
/// <param name="currentPath">the current path to the object, ignored for BooleanExpression</param>
/// <param name="serializer">serializer instance, ignored</param>
/// <returns>a BooleanExpression</returns>
public override Expression GetExpression(object data, JsonPath currentPath, ISerializerHandler serializer)
{
return new BooleanExpression(data);
}
/// <summary>
/// Returns a reference expression to the current data
/// </summary>
/// <param name="data">the object data</param>
/// <param name="currentPath">current path to this object</param>
/// <param name="serializer">serializer instance</param>
/// <returns>reference expression</returns>
public override Expression GetExpression(object data, JsonPath currentPath, ISerializerHandler serializer)
{
return serializer.HandleReference(data, currentPath);
}
public ReferenceInfo(JsonPath Path)
{
this.Path = Path;
}
/// <summary>
/// Serialize the given object at the current indent level. The path to the object is represented by
/// currentPath such as "this.name", etc. This is an internal method that can be called recursively.
/// </summary>
/// <param name="value">the object to serialize</param>
/// <param name="currentPath">the current path for reference writing</param>
public Expression Serialize(object value, JsonPath currentPath, IJsonTypeConverter converter)
{
if (value == null)
{
return new NullExpression();
}
else
{
Expression expr = HandleReference(value, currentPath);
if (expr != null)
return expr;
ISerializationCallback callback = value as ISerializationCallback;
if (callback != null)
callback.OnBeforeSerialization();
try
{
//TODO: this is too early for converters
SetCanReference(value); // regular object, can reference at any time
IExpressionHandler objHandler;
if (converter != null)
{
TypeConverterExpressionHandler converterHandler = (TypeConverterExpressionHandler)_context.ExpressionHandlers.Find(typeof(TypeConverterExpressionHandler));
//TODO: make sure it exists
return converterHandler.GetExpression(value, converter, currentPath, this);
}
objHandler = _context.ExpressionHandlers.GetHandler(value);
return objHandler.GetExpression(value, currentPath, this);
}
finally
{
if (callback != null)
callback.OnAfterSerialization();
}
}
}
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>
/// 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, Expected: {0} or {1}, got: {2}", ReferenceStartToken, OldReferenceStartToken,tok));
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("Invalid Reference, must be an identifier or array value: " + tok);
}
}
return new ReferenceExpression(refID);
}
public ReferenceExpression(JsonPath ReferencePath)
{
this._path = ReferencePath;
}
/// <summary>
/// GetExpression is not valid for a CastExpression. CastExpressions should be created directly
/// during serialization whenever type information is needed.
/// </summary>
/// <param name="data">data to serialize</param>
/// <param name="currentPath">the current path to the object</param>
/// <param name="serializer">serializer instance</param>
/// <returns>expression</returns>
/// <exception cref="InvalidOperationException">This will throw an exception if called</exception>
public override Expression GetExpression(object data, JsonPath currentPath, ISerializerHandler serializer)
{
throw new InvalidOperationException("CastObjectHandler should not be called during Serialization");
}
/// <summary>
/// Gets an expression for a value by first converting it with a specific type converter and then calling Serialize. This
/// method can be called directly when using a Property Converter
/// </summary>
/// <param name="value">the value to generate an expression for</param>
/// <param name="converter">the type converter to use for conversion</param>
/// <param name="currentPath">the current path to the value</param>
/// <param name="serializer">serializer instance</param>
/// <returns>an expression for the value</returns>
public Expression GetExpression(object value, IJsonTypeConverter converter, JsonPath currentPath, ISerializerHandler serializer)
{
object convertedObject = converter.ConvertFrom(value, Context);
// call serialize again in case the new type has a converter
Expression expr = serializer.Serialize(convertedObject, currentPath, null);
serializer.SetCanReference(value); // can't reference inside the object
return expr;
}
public override Expression GetExpression(object data, JsonPath CurrentPath, ISerializerHandler serializer)
{
return GetExpression((IEnumerable)data, GetItemType(data.GetType()), CurrentPath, serializer);
}
/// <summary>
/// Creates a null expression
/// </summary>
/// <param name="data">the data</param>
/// <param name="currentPath">current path</param>
/// <param name="serializer">serializer instance</param>
/// <returns>NullExpression</returns>
public override Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer)
{
return new NullExpression();
}
/// <summary> /// Take an object and convert it to an expression to be serialized. Child names/indexes should be appended to the /// currentPath before serializing child objects. /// </summary> /// <param name="data">the object to convert</param> /// <param name="CurrentPath">the current path to this object from the root, used for tracking references</param> /// <param name="serializer">serializer instance for serializing child objects</param> /// <returns>an expression which represents a json structure</returns> public abstract Expression GetExpression(object data, JsonPath currentPath, IExpressionBuilder serializer);