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