public static object DecodeMap(this MapSchema schema, JToken value)
{
var jobject = value as JObject;
if (jobject != null)
{
var valueSchema = schema.ValueSchema;
var valueType = GetNativeType(valueSchema);
var valueDict = typeof(IDictionary <,>)
.MakeGenericType(typeof(string), valueType)
.GetConstructor(new Type[0])
.Invoke(null);
var magicDict = MagicMarker.GetStringDictionaryFactory(valueType).Invoke(valueDict);
foreach (var property in jobject.Properties())
{
magicDict[property.Name] = DecodeAny(valueSchema, property.Value);
}
return(valueDict);
}
throw new ArgumentException("invalid value type: " + value.GetType().FullName);
}
public static bool IsExistsIndexedValue(Object value, int index)
{
if (value == null)
{
return(false);
}
var asArray = value as Array;
if (asArray != null)
{
return(asArray.Length > index);
}
var asString = value as string;
if (asString != null)
{
return(asString.Length > index);
}
var asType = value.GetType();
var asGenericList = asType.FindGenericInterface(typeof(IList <>));
if (asGenericList != null)
{
var asList = MagicMarker.GetListFactory(value.GetType()).Invoke(value);
return(asList.Count > index);
}
return(false);
}
public Object GetBeanPropInternal(Object @object, Object key)
{
try {
var result = _field.GetValue(@object);
if (result == null) {
return null;
}
if (result is Map) {
return ((Map) result).Get(key);
}
var resultType = result.GetType();
if (resultType.IsGenericDictionary()) {
return MagicMarker
.GetDictionaryFactory(resultType)
.Invoke(result)
.Get(key);
}
return null;
}
catch (PropertyAccessException) {
throw;
}
catch (InvalidCastException e) {
throw PropertyUtility.GetMismatchException(_field, @object, e);
}
catch (ArgumentException e) {
throw PropertyUtility.GetIllegalArgumentException(_field, e);
}
catch (Exception e) {
throw PropertyUtility.GetAccessExceptionField(_field, e);
}
}
public Object GetBeanPropInternal(Object @object, Object key)
{
try {
var result = _fastMethod.Invoke(@object, null);
if (result == null) {
return null;
}
if (result is Map) {
return ((Map) result).Get(key);
}
if (result.GetType().IsGenericDictionary()) {
return MagicMarker
.GetDictionaryFactory(result.GetType())
.Invoke(result)
.Get(key);
}
return null;
}
catch (PropertyAccessException) {
throw;
}
catch (InvalidCastException e) {
throw PropertyUtility.GetMismatchException(_fastMethod.Target, @object, e);
}
catch (TargetInvocationException e) {
throw PropertyUtility.GetInvocationTargetException(_fastMethod.Target, e);
}
catch (Exception e) {
throw PropertyUtility.GetAccessExceptionMethod(_fastMethod.Target, e);
}
}
public static Object GetMappedValue(object map, string key)
{
if (map == null)
{
return null;
}
var magicMap = MagicMarker.GetStringDictionary(map);
return magicMap.Get(key);
}
protected override Object Call(DynamicPropertyDescriptor descriptor, Object underlying)
{
try
{
if (descriptor.HasParameters)
{
return(descriptor.GetMethod().Invoke(underlying, _paramList));
}
var result = descriptor.GetMethod().Invoke(underlying, null);
if (result == null)
{
return(null);
}
if (result is DataMap)
{
var resultDictionary = (DataMap)result;
return(resultDictionary.Get(_paramList[0]));
}
Func <object, DataMap> resultFactory = null;
var resultType = result.GetType();
if (ReferenceEquals(resultType, _lastResultType))
{
resultFactory = _lastResultFactory;
}
else
{
_lastResultFactory = resultFactory = MagicMarker.GetStringDictionaryFactory(resultType);
_lastResultType = resultType;
}
if (resultFactory != null)
{
var resultDictionary = resultFactory.Invoke(result);
return(resultDictionary.Get(_paramList[0]));
}
return(null);
}
catch (InvalidCastException e)
{
throw PropertyUtility.GetMismatchException(descriptor.GetMethod().Target, underlying, e);
}
catch (PropertyAccessException)
{
throw;
}
catch (Exception e)
{
throw new PropertyAccessException(e);
}
}
public void Add(ICollection<Object> constants, Object value)
{
IEnumerable<object> mapKeys;
if (value.GetType().IsGenericDictionary())
mapKeys = MagicMarker.GetDictionaryFactory(value.GetType()).Invoke(value).Keys;
else
throw new ArgumentException("invalid value", nameof(value));
constants.AddAll(mapKeys);
}
public static IDictionary <string, object> UnwrapStringDictionary(this object value)
{
if (value == null)
{
return(null);
}
if (value is IDictionary <string, object> )
{
return((IDictionary <string, object>)value);
}
var valueType = value.GetType();
if (valueType.IsGenericStringDictionary())
{
return(MagicMarker.GetStringDictionaryFactory(valueType).Invoke(value));
}
if (value is IEnumerable <KeyValuePair <string, object> > )
{
var valueDataMap = new Dictionary <string, object>();
foreach (var valueKeyValuePair in (IEnumerable <KeyValuePair <string, object> >)value)
{
valueDataMap[valueKeyValuePair.Key] = valueKeyValuePair.Value;
}
return(valueDataMap);
}
if (value is KeyValuePair <string, object> )
{
var valueDataMap = new Dictionary <string, object>();
var valueKeyValuePair = (KeyValuePair <string, object>)value;
valueDataMap[valueKeyValuePair.Key] = valueKeyValuePair.Value;
return(valueDataMap);
}
// use this sparingly since its more expensive... we may need to write
// a more generalized method if this becomes commonplace.
var dictType = valueType.FindGenericInterface(typeof(IDictionary <,>));
if (dictType != null)
{
var magicDictionary = MagicMarker.GetDictionaryFactory(valueType).Invoke(value);
return(magicDictionary.Transform(
ki => Convert.ToString(ki),
ke => ke));
}
throw new ArgumentException("unable to convert input to string dictionary");
}
public void Add(ICollection<Object> constants, Object value)
{
ICollection<object> collection;
if (value is ICollection<object>)
collection = (ICollection<object>)value;
else if (value.GetType().IsGenericCollection())
collection = MagicMarker.GetCollectionFactory(value.GetType()).Invoke(value);
else
throw new ArgumentException("invalid value", nameof(value));
constants.AddAll(collection);
}
private JObject EncodeMap(MapSchema schema, object value)
{
var valueType = schema.ValueSchema;
var valueDict = MagicMarker.GetStringDictionary(value);
var jvalue = new JObject();
foreach (var valueKeyPair in valueDict)
{
jvalue.Add(new JProperty(valueKeyPair.Key, Encode(valueType, valueKeyPair.Value)));
}
return(jvalue);
}
public static Object GetIndexedValue(Object value, int index)
{
if (value == null)
{
return(null);
}
var asArray = value as Array;
if (asArray != null)
{
if (asArray.Length <= index)
{
return(null);
}
return(asArray.GetValue(index));
}
var asString = value as string;
if (asString != null)
{
if (asString.Length <= index)
{
return(null);
}
return(asString[index]);
}
var asType = value.GetType();
var asGenericList = asType.FindGenericInterface(typeof(IList <>));
if (asGenericList != null)
{
var asList = MagicMarker.GetListFactory(value.GetType()).Invoke(value);
if (asList.Count <= index)
{
return(null);
}
return(asList[index]);
}
return(null);
}
public static bool GetMappedPropertyExists(Object value, String key)
{
if (value == null)
{
return(false);
}
if (value is DataMap)
{
return(((DataMap)value).ContainsKey(key));
}
if (value.GetType().IsGenericStringDictionary())
{
return(MagicMarker.GetStringDictionary(value).ContainsKey(key));
}
return(false);
}
public static Object GetMappedPropertyValue(Object value, String key)
{
if (value == null)
{
return(null);
}
if (value is DataMap)
{
return(((DataMap)value).Get(key));
}
if (value.GetType().IsGenericStringDictionary())
{
return(MagicMarker.GetStringDictionary(value).Get(key));
}
return(null);
}
public static IDictionary <string, object> AsStringDictionary(this object value)
{
if (value == null)
{
return(null);
}
if (value is IDictionary <string, object> )
{
return((IDictionary <string, object>)value);
}
if (value.GetType().IsGenericDictionary())
{
return(MagicMarker.GetStringDictionary(value));
}
throw new ArgumentException("invalid value for string dictionary", "value");
}
public static IList <object> AsObjectList(this object value)
{
if (value == null)
{
return(null);
}
else if (value is IList <object> asList)
{
return(asList);
}
else if (value.GetType().IsGenericList())
{
return(MagicMarker
.GetListFactory(value.GetType())
.Invoke(value));
}
throw new ArgumentException("invalid value for object list");
}
public static IDictionary <string, object> UnwrapDictionary(this object value)
{
var valueDataMap = value as IDictionary <string, object>;
if (valueDataMap == null)
{
var valueType = value.GetType();
if (valueType.IsGenericStringDictionary())
{
valueDataMap = MagicMarker.GetStringDictionaryFactory(valueType).Invoke(value);
}
else
{
throw new ArgumentException("unable to convert input to string dictionary");
}
}
return(valueDataMap);
}
public static string Render <K, V>(this IEnumerable <KeyValuePair <K, V> > source)
{
var fieldDelimiter = string.Empty;
var builder = new StringBuilder();
builder.Append('[');
if (source != null)
{
foreach (var current in source)
{
builder.Append(fieldDelimiter);
builder.Append(RenderAny(current.Key));
builder.Append('=');
if (ReferenceEquals(current.Value, null))
{
builder.Append("null");
}
else if (current.Value.GetType().IsGenericDictionary())
{
builder.Append(MagicMarker.GetDictionaryFactory(current.Value.GetType()).Invoke(current.Value));
}
else if (current.Value is string)
{
builder.Append(RenderAny(current.Value));
}
else if (current.Value is IEnumerable)
{
builder.Append(Render((IEnumerable)current.Value));
}
else
{
builder.Append(RenderAny(current.Value));
}
fieldDelimiter = ", ";
}
}
builder.Append(']');
return(builder.ToString());
}
public static IDictionary <object, object> UnwrapDictionary(this object value)
{
if (value == null)
{
return(null);
}
if (value is IDictionary <object, object> )
{
return((IDictionary <object, object>)value);
}
var valueType = value.GetType();
if (valueType.IsGenericDictionary())
{
return(MagicMarker.GetDictionaryFactory(valueType).Invoke(value));
}
if (value is IEnumerable <KeyValuePair <object, object> > )
{
var valueDataMap = new Dictionary <object, object>();
foreach (var valueKeyValuePair in (IEnumerable <KeyValuePair <string, object> >)value)
{
valueDataMap[valueKeyValuePair.Key] = valueKeyValuePair.Value;
}
return(valueDataMap);
}
if (value is KeyValuePair <object, object> )
{
var valueDataMap = new Dictionary <object, object>();
var valueKeyValuePair = (KeyValuePair <object, object>)value;
valueDataMap[valueKeyValuePair.Key] = valueKeyValuePair.Value;
return(valueDataMap);
}
throw new ArgumentException("unable to convert input to string dictionary");
}
private static bool AreCollectionsEqual(Object expected, Object actual)
{
var magicExpected = MagicMarker.GetCollectionFactory(expected.GetType())
.Invoke(expected);
var magicActual = MagicMarker.GetCollectionFactory(actual.GetType())
.Invoke(actual);
if (magicExpected.Count == magicActual.Count)
{
using (var magicExpectedEnum = magicExpected.GetEnumerator())
{
using (var magicActualEnum = magicActual.GetEnumerator())
{
while (true)
{
var mvExpected = magicExpectedEnum.MoveNext();
var mvActual = magicActualEnum.MoveNext();
if (mvExpected && mvActual)
{
if (!Equals(magicExpectedEnum.Current, magicActualEnum.Current))
{
break;
}
}
else if (!mvExpected && !mvActual)
{
return(true);
}
else
{
throw new IllegalStateException("collection has been modified");
}
}
}
}
}
return(false);
}
public ICollection <object> Convert(Object result)
{
if (result == null)
{
return(null);
}
if (result is ICollection <object> )
{
return((ICollection <object>)result);
}
if (result.GetType().IsGenericCollection())
{
return(MagicMarker.GetCollectionFactory(result.GetType()).Invoke(result));
}
if (result is ICollection)
{
return(((ICollection)result).Cast <object>().ToList());
}
Log.Warn("Expected collection-type input from method '{0}' but received {1}", _methodName,
result.GetType().FullName);
return(null);
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
// Must have 2 child nodes
var childNodes = ChildNodes;
if (childNodes.Count < 1)
{
throw new IllegalStateException("Group relational op node must have 1 or more parameters");
}
_evaluators = ExprNodeUtility.GetEvaluators(childNodes);
var typeOne = _evaluators[0].ReturnType.GetBoxedType();
// collections, array or map not supported
if ((typeOne.IsArray) ||
(typeOne.IsGenericCollection()) ||
(typeOne.IsGenericDictionary()))
{
throw new ExprValidationException(
"Collection or array comparison is not allowed for the IN, ANY, SOME or ALL keywords");
}
_transformList = new Func <object, object> [childNodes.Count];
var comparedTypes = new List <Type>();
comparedTypes.Add(typeOne);
_hasCollectionOrArray = false;
for (int i = 1; i < childNodes.Count; i++)
{
var propType = _evaluators[i].ReturnType;
if (propType.IsArray)
{
_hasCollectionOrArray = true;
if (propType.GetElementType() != typeof(Object))
{
comparedTypes.Add(propType.GetElementType());
}
}
else if (propType.IsGenericDictionary())
{
var baseTransform = MagicMarker.GetDictionaryFactory(propType);
_transformList[i] = o => baseTransform(o);
_hasCollectionOrArray = true;
}
else if (propType.IsGenericCollection())
{
var baseTransform = MagicMarker.GetCollectionFactory(propType);
_transformList[i] = o => baseTransform(o);
_hasCollectionOrArray = true;
}
else
{
comparedTypes.Add(propType);
}
}
// Determine common denominator type
Type coercionType;
try
{
coercionType = TypeHelper.GetCommonCoercionType(comparedTypes.ToArray());
}
catch (CoercionException ex)
{
throw new ExprValidationException("Implicit conversion not allowed: " + ex.Message);
}
// Must be either numeric or string
if (coercionType != typeof(String))
{
if (!coercionType.IsNumeric())
{
throw new ExprValidationException(string.Format("Implicit conversion from datatype '{0}' to numeric is not allowed", Name.Clean(coercionType)));
}
}
_computer = _relationalOp.GetComputer(coercionType, coercionType, coercionType);
return(null);
}
public void ValidateWithoutContext()
{
if (ChildNodes.Length < 2)
{
throw new ExprValidationException("The IN operator requires at least 2 child expressions");
}
_evaluators = ExprNodeUtility.GetEvaluators(ChildNodes);
// Must be the same boxed type returned by expressions under this
var typeOne = _evaluators[0].ReturnType.GetBoxedType();
// collections, array or map not supported
if ((typeOne.IsArray) ||
(typeOne.IsGenericCollection()) ||
(typeOne.IsGenericDictionary()))
{
throw new ExprValidationException("Collection or array comparison is not allowed for the IN, ANY, SOME or ALL keywords");
}
_transformList = new Func <object, object> [_evaluators.Length];
var comparedTypes = new List <Type> {
typeOne
};
_hasCollectionOrArray = false;
var length = ChildNodes.Length - 1;
for (int i = 1; i <= length; i++)
{
var propType = _evaluators[i].ReturnType;
if (propType == null)
{
continue;
}
if (propType.IsArray)
{
_hasCollectionOrArray = true;
if (propType.GetElementType() != typeof(Object))
{
comparedTypes.Add(propType.GetElementType());
}
}
else if (propType.IsGenericDictionary())
{
var baseTransform = MagicMarker.GetDictionaryFactory(propType);
_transformList[i] = o => baseTransform(o);
_hasCollectionOrArray = true;
}
else if (propType.IsGenericCollection())
{
var baseTransform = MagicMarker.GetCollectionFactory(propType);
_transformList[i] = o => baseTransform(o);
_hasCollectionOrArray = true;
}
else
{
comparedTypes.Add(propType);
}
}
// Determine common denominator type
Type coercionType;
try {
coercionType = TypeHelper.GetCommonCoercionType(comparedTypes);
}
catch (CoercionException ex)
{
throw new ExprValidationException("Implicit conversion not allowed: " + ex.Message);
}
// Check if we need to coerce
_mustCoerce = false;
if (coercionType.IsNumeric())
{
foreach (Type compareType in comparedTypes)
{
if (coercionType != compareType.GetBoxedType())
{
_mustCoerce = true;
}
}
if (_mustCoerce)
{
_coercer = CoercerFactory.GetCoercer(null, coercionType.GetBoxedType());
}
}
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
// Must have 2 child nodes
var childNodes = ChildNodes;
if (childNodes.Length < 1)
{
throw new IllegalStateException("Equals group node does not have 1 or more parameters");
}
_evaluators = ExprNodeUtility.GetEvaluators(ChildNodes);
// Must be the same boxed type returned by expressions under this
Type typeOne = _evaluators[0].ReturnType.GetBoxedType();
// collections, array or map not supported
if ((typeOne.IsArray) ||
(typeOne.IsGenericCollection()) ||
(typeOne.IsGenericDictionary()))
{
throw new ExprValidationException(
"Collection or array comparison is not allowed for the IN, ANY, SOME or ALL keywords");
}
_transformList = new Func <object, object> [childNodes.Length];
var comparedTypes = new List <Type>();
comparedTypes.Add(typeOne);
_hasCollectionOrArray = false;
for (int i = 1; i < childNodes.Length; i++)
{
Type propType = _evaluators[i].ReturnType;
if (propType.IsArray)
{
_hasCollectionOrArray = true;
if (propType.GetElementType() != typeof(Object))
{
comparedTypes.Add(propType.GetElementType());
}
}
else if (propType.IsGenericDictionary())
{
var baseTransform = MagicMarker.GetDictionaryFactory(propType);
_transformList[i] = o => baseTransform(o);
_hasCollectionOrArray = true;
}
else if (propType.IsGenericCollection())
{
var baseTransform = MagicMarker.GetCollectionFactory(propType);
_transformList[i] = o => baseTransform(o);
_hasCollectionOrArray = true;
}
else
{
comparedTypes.Add(propType);
}
}
// Determine common denominator type
Type coercionType;
try
{
coercionType = TypeHelper.GetCommonCoercionType(comparedTypes);
}
catch (CoercionException ex)
{
throw new ExprValidationException("Implicit conversion not allowed: " + ex.Message);
}
// Check if we need to coerce
_mustCoerce = false;
if (coercionType.IsNumeric())
{
foreach (Type compareType in comparedTypes)
{
if (coercionType != compareType.GetBoxedType())
{
_mustCoerce = true;
}
}
if (_mustCoerce)
{
_coercer = CoercerFactory.GetCoercer(null, coercionType.GetBoxedType());
}
}
return(null);
}
private static void RecursiveRender(EventBean theEvent, StringBuilder buf, int level, RendererMeta meta, RendererMetaOptions rendererOptions)
{
var delimiter = "";
var renderActions = new SortedList <string, Action>();
// simple properties
var simpleProps = meta.SimpleProperties;
if (rendererOptions.Renderer == null)
{
foreach (var simpleProp in simpleProps.OrderBy(prop => prop.Name))
{
var name = simpleProp.Name;
var value = simpleProp.Getter.Get(theEvent);
renderActions.Add(name, () =>
{
WriteDelimitedIndentedProp(buf, delimiter, level, name);
simpleProp.Output.Render(value, buf);
delimiter = COMMA_DELIMITER_NEWLINE;
});
}
}
else
{
var context = rendererOptions.RendererContext;
context.SetStringBuilderAndReset(buf);
foreach (var simpleProp in simpleProps.OrderBy(prop => prop.Name))
{
var name = simpleProp.Name;
var value = simpleProp.Getter.Get(theEvent);
renderActions.Add(name, () =>
{
WriteDelimitedIndentedProp(buf, delimiter, level, simpleProp.Name);
context.DefaultRenderer = simpleProp.Output;
context.PropertyName = simpleProp.Name;
context.PropertyValue = value;
rendererOptions.Renderer.Render(context);
delimiter = COMMA_DELIMITER_NEWLINE;
});
}
}
var indexProps = meta.IndexProperties;
foreach (var indexProp in indexProps.OrderBy(prop => prop.Name))
{
var name = indexProp.Name;
renderActions.Add(
name, () =>
{
WriteDelimitedIndentedProp(buf, delimiter, level, name);
var value = indexProp.Getter.Get(theEvent);
if (value == null)
{
buf.Append("null");
}
else if (value is string)
{
if (rendererOptions.Renderer == null)
{
indexProp.Output.Render(value, buf);
}
else
{
var context = rendererOptions.RendererContext;
context.SetStringBuilderAndReset(buf);
context.DefaultRenderer = indexProp.Output;
context.PropertyName = name;
context.PropertyValue = value;
rendererOptions.Renderer.Render(context);
}
}
else
{
var asArray = value as Array;
if (asArray == null)
{
buf.Append("[]");
}
else
{
buf.Append('[');
var arrayDelimiter = "";
if (rendererOptions.Renderer == null)
{
for (var i = 0; i < asArray.Length; i++)
{
var arrayItem = asArray.GetValue(i);
buf.Append(arrayDelimiter);
indexProp.Output.Render(arrayItem, buf);
arrayDelimiter = ", ";
}
}
else
{
var context = rendererOptions.RendererContext;
context.SetStringBuilderAndReset(buf);
for (var i = 0; i < asArray.Length; i++)
{
var arrayItem = asArray.GetValue(i);
buf.Append(arrayDelimiter);
context.PropertyName = indexProp.Name;
context.PropertyValue = arrayItem;
context.IndexedPropertyIndex = i;
context.DefaultRenderer = indexProp.Output;
rendererOptions.Renderer.Render(context);
arrayDelimiter = ", ";
}
}
buf.Append(']');
}
}
delimiter = COMMA_DELIMITER_NEWLINE;
});
}
var mappedProps = meta.MappedProperties;
foreach (var mappedProp in mappedProps.OrderBy(prop => prop.Name))
{
var name = mappedProp.Name;
var value = mappedProp.Getter.Get(theEvent);
if ((value != null) && (!(value.GetType().IsGenericStringDictionary())))
{
Log.Warn("Property '" + mappedProp.Name + "' expected to return Map and returned " + value.GetType() + " instead");
continue;
}
renderActions.Add(
name, () =>
{
WriteDelimitedIndentedProp(buf, delimiter, level, mappedProp.Name);
if (value == null)
{
buf.Append("null");
buf.Append(NEWLINE);
}
else
{
var map = MagicMarker.GetStringDictionary(value);
if (map.IsEmpty())
{
buf.Append("{}");
buf.Append(NEWLINE);
}
else
{
buf.Append('{');
buf.Append(NEWLINE);
var localDelimiter = "";
foreach (var entry in map)
{
if (entry.Key == null)
{
continue;
}
buf.Append(localDelimiter);
Ident(buf, level + 1);
buf.Append('\"');
buf.Append(entry.Key);
buf.Append("\": ");
if (entry.Value == null)
{
buf.Append("null");
}
else
{
var outRenderer =
OutputValueRendererFactory.GetOutputValueRenderer(
entry.Value.GetType(), rendererOptions);
if (rendererOptions.Renderer == null)
{
outRenderer.Render(entry.Value, buf);
}
else
{
var context = rendererOptions.RendererContext;
context.SetStringBuilderAndReset(buf);
context.PropertyName = mappedProp.Name;
context.PropertyValue = entry.Value;
context.MappedPropertyKey = entry.Key;
context.DefaultRenderer = outRenderer;
rendererOptions.Renderer.Render(context);
}
}
localDelimiter = COMMA_DELIMITER_NEWLINE;
}
buf.Append(NEWLINE);
Ident(buf, level);
buf.Append('}');
}
}
delimiter = COMMA_DELIMITER_NEWLINE;
});
}
var nestedProps = meta.NestedProperties;
foreach (var nestedProp in nestedProps.OrderBy(prop => prop.Name))
{
var name = nestedProp.Name;
var value = nestedProp.Getter.GetFragment(theEvent);
renderActions.Add(
name, () =>
{
WriteDelimitedIndentedProp(buf, delimiter, level, nestedProp.Name);
if (value == null)
{
buf.Append("null");
}
else if (!nestedProp.IsArray)
{
if (!(value is EventBean))
{
Log.Warn(
"Property '" + nestedProp.Name + "' expected to return EventBean and returned " +
value.GetType() + " instead");
buf.Append("null");
return;
}
var nestedEventBean = (EventBean)value;
buf.Append('{');
buf.Append(NEWLINE);
RecursiveRender(nestedEventBean, buf, level + 1, nestedProp.Metadata, rendererOptions);
Ident(buf, level);
buf.Append('}');
}
else
{
if (!(value is EventBean[]))
{
Log.Warn(
"Property '" + nestedProp.Name + "' expected to return EventBean[] and returned " +
value.GetType() + " instead");
buf.Append("null");
return;
}
var arrayDelimiterBuf = new StringBuilder();
arrayDelimiterBuf.Append(',');
arrayDelimiterBuf.Append(NEWLINE);
Ident(arrayDelimiterBuf, level + 1);
var nestedEventArray = (EventBean[])value;
var arrayDelimiter = "";
buf.Append('[');
for (var i = 0; i < nestedEventArray.Length; i++)
{
var arrayItem = nestedEventArray[i];
buf.Append(arrayDelimiter);
arrayDelimiter = arrayDelimiterBuf.ToString();
buf.Append('{');
buf.Append(NEWLINE);
RecursiveRender(arrayItem, buf, level + 2, nestedProp.Metadata, rendererOptions);
Ident(buf, level + 1);
buf.Append('}');
}
buf.Append(']');
}
delimiter = COMMA_DELIMITER_NEWLINE;
});
}
foreach (var entry in renderActions)
{
entry.Value.Invoke();
}
buf.Append(NEWLINE);
}
