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); } }