public void TestGetParser() { object[][] tests = new object[][] { 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(byte), " 1 ", (byte)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.Parse((string)tests[i][1]), "error in row:" + i); } }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// </summary> /// <param name="node">node</param> /// <param name="parser">parser</param> /// <returns>value</returns> /// <throws>PropertyAccessException exception</throws> public static object GetParseTextValue( XmlNode node, SimpleTypeParser parser) { var text = node?.InnerText; if (text == null) { return null; } return parser.Parse(text); }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// </summary> /// <param name="result">nodes</param> /// <param name="componentType">type</param> /// <param name="parser">parser</param> /// <returns>result</returns> public static object GetDOMArrayFromNodes( XmlNode[] result, Type componentType, SimpleTypeParser parser) { var array = Arrays.CreateInstanceChecked(componentType, result.Length); for (var i = 0; i < result.Length; i++) { var text = result[i].InnerText; if (text == null || text.Length == 0) { continue; } var parseResult = parser.Parse(text); array.SetValue(parseResult, i); } return array; }
private static object CastToArray( object result, Type optionalCastToType, SimpleTypeParser simpleTypeParser, XPathExpression expression) { if (result is XPathNodeIterator nodeIterator) { if (nodeIterator.Count == 0) { return null; } var array = Arrays.CreateInstanceChecked(optionalCastToType, nodeIterator.Count); for (var i = 0; nodeIterator.MoveNext(); i++) { var nodeCurrent = nodeIterator.Current; object arrayItem = null; try { if ((nodeCurrent.NodeType == XPathNodeType.Attribute) || (nodeCurrent.NodeType == XPathNodeType.Element)) { var textContent = nodeCurrent.Value; arrayItem = simpleTypeParser.Parse(textContent); } } catch (Exception) { if (Log.IsInfoEnabled) { Log.Info( "Parse error for text content " + nodeCurrent.InnerXml + " for expression " + expression); } } array.SetValue(arrayItem, i); } return array; } if (result is XmlNodeList) { var nodeList = (XmlNodeList) result; var array = Arrays.CreateInstanceChecked(optionalCastToType, nodeList.Count); for (var i = 0; i < nodeList.Count; i++) { object arrayItem = null; try { var item = nodeList.Item(i); string textContent; if (item.NodeType == XmlNodeType.Attribute || item.NodeType == XmlNodeType.Element) { textContent = item.InnerText; } else { continue; } arrayItem = simpleTypeParser.Parse(textContent); } catch (Exception) { if (Log.IsInfoEnabled) { Log.Info( "Parse error for text content " + nodeList.Item(i).InnerText + " for expression " + expression); } } array.SetValue(arrayItem, i); } return array; } return null; }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// </summary> /// <param name="navigator">the xpath navigator</param> /// <param name="expression">xpath</param> /// <param name="expressionText">text</param> /// <param name="property">prop</param> /// <param name="optionalCastToType">type or null</param> /// <param name="resultType">result xpath type</param> /// <param name="isCastToArray">array indicator</param> /// <param name="simpleTypeParser">parse</param> /// <returns>value</returns> 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.Parse((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 TypeHelper.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 bool) { if (optionalCastToType.GetBoxedType() != 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); } }