public Object Get(EventBean eventBean)
{
var asXml = eventBean.Underlying as XmlNode;
if (asXml == null)
{
throw new PropertyAccessException("Mismatched property getter to event bean type, " +
"the underlying data object is not of type Node");
}
var result = getter.GetValueAsNodeArray(asXml);
if (result == null)
{
return(null);
}
var array = Array.CreateInstance(componentType, result.Length);
for (int i = 0; i < result.Length; i++)
{
var text = result[i].InnerText;
if (string.IsNullOrEmpty(text))
{
continue;
}
var parseResult = parser.Invoke(text);
array.SetValue(parseResult, i);
}
return(array);
}
private static object GetParseTextValue(XmlNode node, SimpleTypeParser parser)
{
var text = node?.InnerText;
if (text == null)
{
return(null);
}
return(parser.Invoke(text));
}
public Object Get(EventBean eventBean)
{
var asXNode = eventBean.Underlying as XNode;
if (asXNode == null)
{
var asXml = eventBean.Underlying as XmlNode;
if (asXml == null)
{
throw new PropertyAccessException("Mismatched property getter to event bean type, " +
"the underlying data object is not of type Node");
}
XmlNode result = _getter.GetValueAsNode(asXml);
if (result == null)
{
return(null);
}
return(_parser.Invoke(result.InnerText));
}
else
{
XObject result = _getter.GetValueAsNode(asXNode);
if (result == null)
{
return(null);
}
if (result is XElement)
{
return(_parser.Invoke(((XElement)result).Value));
}
return(_parser.Invoke(result.ToString()));
}
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters.
/// </summary>
/// <param name="result">The result.</param>
/// <param name="componentType">Type of the component.</param>
/// <param name="parser">The parser.</param>
/// <returns></returns>
public static object GetDOMArrayFromNodes(object[] result, Type componentType, SimpleTypeParser parser)
{
var array = Array.CreateInstance(componentType, result.Length);
for (int i = 0; i < result.Length; i++)
{
var text = GetInnerText(result[i]);
if (string.IsNullOrEmpty(text))
{
continue;
}
var parseResult = parser.Invoke(text);
array.SetValue(parseResult, i);
}
return(array);
}
private static Object CastToArray(
XPathNodeIterator nodeIterator,
Type optionalCastToType,
SimpleTypeParser simpleTypeParser,
XPathExpression expression)
{
var itemList = new List <object>();
while (nodeIterator.MoveNext())
{
var item = nodeIterator.Current;
if (item != null)
{
try
{
if ((item.NodeType == XPathNodeType.Attribute) ||
(item.NodeType == XPathNodeType.Element))
{
var textContent = item.InnerXml;
itemList.Add(simpleTypeParser.Invoke(textContent));
}
}
catch
{
if (Log.IsInfoEnabled)
{
Log.Info("Parse error for text content {0} for expression {1}", item.InnerXml, expression);
}
}
}
}
var array = Array.CreateInstance(optionalCastToType, itemList.Count);
for (int ii = 0; ii < itemList.Count; ii++)
{
array.SetValue(itemList[ii], ii);
}
return(array);
}
private static Object CastToArray(
XmlNodeList nodeList,
Type optionalCastToType,
SimpleTypeParser simpleTypeParser,
XPathExpression expression)
{
var array = Array.CreateInstance(optionalCastToType, nodeList.Count);
for (int i = 0; i < nodeList.Count; i++)
{
Object arrayItem = null;
try
{
XmlNode item = nodeList.Item(i);
String textContent;
if ((item.NodeType == XmlNodeType.Attribute) ||
(item.NodeType == XmlNodeType.Element))
{
textContent = item.InnerText;
}
else
{
continue;
}
arrayItem = simpleTypeParser.Invoke(textContent);
}
catch
{
if (Log.IsInfoEnabled)
{
Log.Info("Parse error for text content {0} for expression {1}", nodeList[i].InnerText, expression);
}
}
array.SetValue(arrayItem, i);
}
return(array);
}
public void TestGetParser()
{
var tests = new[]
{
new Object[] { typeof(bool?), "TrUe", true },
new Object[] { typeof(bool?), "false", false },
new Object[] { typeof(bool), "false", false },
new Object[] { typeof(bool), "true", true },
new Object[] { typeof(int), "73737474 ", 73737474 },
new Object[] { typeof(int?), " -1 ", -1 },
new Object[] { typeof(long), "123456789001222L", 123456789001222L },
new Object[] { typeof(long?), " -2 ", -2L },
new Object[] { typeof(long?), " -2L ", -2L },
new Object[] { typeof(long?), " -2l ", -2L },
new Object[] { typeof(short?), " -3 ", (short)-3 },
new Object[] { typeof(short), "111", (short)111 },
new Object[] { typeof(double?), " -3d ", -3d },
new Object[] { typeof(double), "111.38373", 111.38373d },
new Object[] { typeof(double?), " -3.1D ", -3.1D },
new Object[] { typeof(float?), " -3f ", -3f },
new Object[] { typeof(float), "111.38373", 111.38373f },
new Object[] { typeof(float?), " -3.1F ", -3.1f },
new Object[] { typeof(sbyte?), " -3 ", (sbyte)-3 },
new Object[] { typeof(sbyte), " 1 ", (sbyte)1 },
new Object[] { typeof(char), "ABC", 'A' },
new Object[] { typeof(char?), " AB", ' ' },
new Object[] { typeof(string), "AB", "AB" },
new Object[] { typeof(string), " AB ", " AB " },
};
for (int i = 0; i < tests.Length; i++)
{
SimpleTypeParser parser = SimpleTypeParserFactory.GetParser((Type)tests[i][0]);
Assert.AreEqual(tests[i][2], parser.Invoke((String)tests[i][1]), "error in row:" + i);
}
}
public Object Compute(Object input, EvaluateParams evaluateParams)
{
return(_parser.Invoke(input.ToString()));
}
/// <summary>
/// NOTE: Code-generation-invoked method, method name and parameter order matters
/// </summary>
/// <param name="navigator">The navigator.</param>
/// <param name="expression">The expression.</param>
/// <param name="expressionText">The expression text.</param>
/// <param name="property">The property.</param>
/// <param name="optionalCastToType">Type of the optional cast to.</param>
/// <param name="resultType">Type of the result.</param>
/// <param name="isCastToArray">if set to <c>true</c> [is cast to array].</param>
/// <param name="simpleTypeParser">The simple type parser.</param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
/// <exception cref="PropertyAccessException">Error getting property " + property</exception>
public static Object EvaluateXPathGet(
XPathNavigator navigator,
XPathExpression expression,
String expressionText,
String property,
Type optionalCastToType,
XPathResultType resultType,
bool isCastToArray,
SimpleTypeParser simpleTypeParser)
{
try
{
var result = navigator.Evaluate(expression);
if (result == null)
{
return(null);
}
// if there is no parser, return xpath expression type
if (optionalCastToType == null)
{
var nodeIterator = result as XPathNodeIterator;
if (nodeIterator != null)
{
if (nodeIterator.Count == 0)
{
return(null);
}
if (nodeIterator.Count == 1)
{
nodeIterator.MoveNext();
switch (resultType)
{
case XPathResultType.Any:
return(((System.Xml.IHasXmlNode)nodeIterator.Current).GetNode());
case XPathResultType.String:
return(nodeIterator.Current.TypedValue);
case XPathResultType.Boolean:
return(nodeIterator.Current.ValueAsBoolean);
case XPathResultType.Number:
return(nodeIterator.Current.ValueAsDouble);
default:
return(nodeIterator.Current.TypedValue);
}
}
else
{
return(new XPathIteratorNodeList(nodeIterator));
}
}
return(result);
}
if (isCastToArray)
{
return(CastToArray(result, optionalCastToType, simpleTypeParser, expression));
}
if (result is XPathNodeIterator)
{
var nodeIterator = result as XPathNodeIterator;
if (nodeIterator.Count == 0)
{
return(null);
}
if (nodeIterator.Count == 1)
{
nodeIterator.MoveNext();
result = nodeIterator.Current.TypedValue;
}
else
{
if (simpleTypeParser == null)
{
var resultList = new List <object>();
while (nodeIterator.MoveNext())
{
result = nodeIterator.Current.TypedValue;
resultList.Add(result);
}
return(resultList.ToArray());
}
else
{
throw new NotImplementedException();
}
}
}
// string results get parsed
if (result is String)
{
try
{
return(simpleTypeParser.Invoke((string)result));
}
catch
{
Log.Warn("Error parsing XPath property named '" + property + "' expression result '" + result + " as type " + optionalCastToType.Name);
return(null);
}
}
// coercion
if (result is Double)
{
try
{
return(CoercerFactory.CoerceBoxed(result, optionalCastToType));
}
catch
{
Log.Warn("Error coercing XPath property named '" + property + "' expression result '" + result + " as type " + optionalCastToType.Name);
return(null);
}
}
// check bool type
if (result is Boolean)
{
if (optionalCastToType != typeof(bool?))
{
Log.Warn("Error coercing XPath property named '" + property + "' expression result '" + result + " as type " + optionalCastToType.Name);
return(null);
}
return(result);
}
Log.Warn("Error processing XPath property named '" + property + "' expression result '" + result + ", not a known type");
return(null);
}
catch (XPathException e)
{
throw new PropertyAccessException("Error getting property " + property, e);
}
}
public Object Get(EventBean eventBean)
{
var und = eventBean.Underlying;
if (und == null)
{
throw new PropertyAccessException("Unexpected null underlying event encountered, expecting System.Xml.XmlNode instance as underlying");
}
XPathNavigator navigator;
var xnode = und as XElement;
if (xnode == null)
{
var node = und as XmlNode;
if (node == null)
{
throw new PropertyAccessException("Unexpected underlying event of type '" + und.GetType().FullName +
"' encountered, expecting System.Xml.XmlNode as underlying");
}
if (Log.IsDebugEnabled)
{
Log.Debug(
"Running XPath '{0}' for property '{1}' against Node XML : {2}",
_expressionText,
_property,
SchemaUtil.Serialize((XmlNode)und));
}
navigator = node.CreateNavigator();
}
else
{
navigator = xnode.CreateNavigator();
}
try
{
var result = navigator.Evaluate(_expression);
if (result == null)
{
return(null);
}
// if there is no parser, return xpath expression type
if (_optionalCastToType == null)
{
var nodeIterator = result as XPathNodeIterator;
if (nodeIterator != null)
{
if (nodeIterator.Count == 0)
{
return(null);
}
if (nodeIterator.Count == 1)
{
nodeIterator.MoveNext();
switch (_resultType)
{
case XPathResultType.Any:
return(((System.Xml.IHasXmlNode)nodeIterator.Current).GetNode());
case XPathResultType.String:
return(nodeIterator.Current.TypedValue);
case XPathResultType.Boolean:
return(nodeIterator.Current.ValueAsBoolean);
case XPathResultType.Number:
return(nodeIterator.Current.ValueAsDouble);
default:
return(nodeIterator.Current.TypedValue);
}
}
else
{
return(new XPathIteratorNodeList(nodeIterator));
}
}
return(result);
}
if (_isCastToArray)
{
return(CastToArray(result));
}
if (result is XPathNodeIterator)
{
var nodeIterator = result as XPathNodeIterator;
if (nodeIterator.Count == 0)
{
return(null);
}
if (nodeIterator.Count == 1)
{
nodeIterator.MoveNext();
result = nodeIterator.Current.TypedValue;
}
else
{
if (_simpleTypeParser == null)
{
var resultList = new List <object>();
while (nodeIterator.MoveNext())
{
result = nodeIterator.Current.TypedValue;
resultList.Add(result);
}
return(resultList.ToArray());
}
else
{
throw new NotImplementedException();
}
}
}
// string results get parsed
if (result is String)
{
try
{
return(_simpleTypeParser.Invoke((string)result));
}
catch
{
Log.Warn("Error parsing XPath property named '" + _property + "' expression result '" + result + " as type " + _optionalCastToType.Name);
return(null);
}
}
// coercion
if (result is Double)
{
try
{
return(CoercerFactory.CoerceBoxed(result, _optionalCastToType));
}
catch
{
Log.Warn("Error coercing XPath property named '" + _property + "' expression result '" + result + " as type " + _optionalCastToType.Name);
return(null);
}
}
// check bool type
if (result is Boolean)
{
if (_optionalCastToType != typeof(bool?))
{
Log.Warn("Error coercing XPath property named '" + _property + "' expression result '" + result + " as type " + _optionalCastToType.Name);
return(null);
}
return(result);
}
Log.Warn("Error processing XPath property named '" + _property + "' expression result '" + result + ", not a known type");
return(null);
}
catch (XPathException e) {
throw new PropertyAccessException("Error getting property " + _property, e);
}
}
