public int Compare(object x, object y)
{
switch (_dataType)
{
case XmlDataType.Text:
string s1 = Convert.ToString(x, _cinfo);
string s2 = Convert.ToString(y, _cinfo);
int result = _cinfo.CompareInfo.Compare(s1, s2, _caseOrder != XmlCaseOrder.None ? CompareOptions.IgnoreCase : CompareOptions.None);
if (result != 0 || _caseOrder == XmlCaseOrder.None)
{
return((_order == XmlSortOrder.Ascending) ? result : -result);
}
// If we came this far, it means that strings s1 and s2 are
// equal to each other when case is ignored. Now it's time to check
// and see if they differ in case only and take into account the user
// requested case order for sorting purposes.
result = _cinfo.CompareInfo.Compare(s1, s2);
return((_caseOrder == XmlCaseOrder.LowerFirst) ? result : -result);
case XmlDataType.Number:
double r1 = XmlConvertEx.ToXPathDouble(x);
double r2 = XmlConvertEx.ToXPathDouble(y);
result = r1.CompareTo(r2);
return((_order == XmlSortOrder.Ascending) ? result : -result);
default:
// dataType doesn't support any other value
throw new InvalidOperationException(SR.Xml_InvalidOperation);
}
} // Compare ()
public override object Evaluate(XPathNodeIterator nodeIterator)
{
return(GetValue(_op,
XmlConvertEx.ToXPathDouble(_opnd1.Evaluate(nodeIterator)),
XmlConvertEx.ToXPathDouble(_opnd2.Evaluate(nodeIterator))
));
}
private double Number(XPathNodeIterator nodeIterator)
{
if (arg == null)
{
return(XmlConvertEx.ToXPathDouble(nodeIterator.Current.Value));
}
object argVal = arg.Evaluate(nodeIterator);
switch (GetXPathType(argVal))
{
case XPathResultType.NodeSet:
XPathNavigator value = arg.Advance();
if (value != null)
{
return(Number(value.Value));
}
break;
case XPathResultType.String:
return(Number((string)argVal));
case XPathResultType.Boolean:
return(Number((bool)argVal));
case XPathResultType.Number:
return((double)argVal);
case XPathResultType_Navigator:
return(Number(((XPathNavigator)argVal).Value));
}
return(double.NaN);
}
private string Normalize(XPathNodeIterator nodeIterator)
{
string str1;
if (argList.Count > 0)
{
str1 = argList[0].Evaluate(nodeIterator).ToString();
}
else
{
str1 = nodeIterator.Current.Value;
}
str1 = XmlConvertEx.TrimString(str1);
int count = 0;
StringBuilder str2 = new StringBuilder();
bool FirstSpace = true;
XmlCharType xmlCharType = XmlCharType.Instance;
while (count < str1.Length)
{
if (!xmlCharType.IsWhiteSpace(str1[count]))
{
FirstSpace = true;
str2.Append(str1[count]);
}
else if (FirstSpace)
{
FirstSpace = false;
str2.Append(' ');
}
count++;
}
return(str2.ToString());
}
void ProcessIds(XPathNavigator contextNode, string val)
{
string[] ids = XmlConvertEx.SplitString(val);
for (int idx = 0; idx < ids.Length; idx++)
{
if (contextNode.MoveToId(ids[idx]))
{
Insert(outputBuffer, contextNode);
}
}
}
private double ScanFraction()
{
Debug.Assert(XmlCharType.IsDigit(this.CurrentChar));
int start = _xpathExprIndex - 2;
Debug.Assert(0 <= start && _xpathExpr[start] == '.');
int len = 1; // '.'
while (XmlCharType.IsDigit(this.CurrentChar))
{
NextChar(); len++;
}
return(XmlConvertEx.ToXPathDouble(_xpathExpr.Substring(start, len)));
}
private static T ReadValue <T>(string value, bool ignoreCase = false)
{
var type = typeof(T);
if (type == typeof(Uri))
{
return((T)(object)new Uri(value));
}
type = Nullable.GetUnderlyingType(type) ?? type;
if (type.GetTypeInfo().IsEnum)
{
return((T)EnumEx.Parse(type, value, ignoreCase));
}
return(XmlConvertEx.FromString <T>(value));
}
private double ScanNumber()
{
Debug.Assert(this.CurrentChar == '.' || XmlCharType.IsDigit(this.CurrentChar));
int start = _xpathExprIndex - 1;
int len = 0;
while (XmlCharType.IsDigit(this.CurrentChar))
{
NextChar(); len++;
}
if (this.CurrentChar == '.')
{
NextChar(); len++;
while (XmlCharType.IsDigit(this.CurrentChar))
{
NextChar(); len++;
}
}
return(XmlConvertEx.ToXPathDouble(_xpathExpr.Substring(start, len)));
}
private string Substring(XPathNodeIterator nodeIterator)
{
string str1 = argList[0].Evaluate(nodeIterator).ToString();
double num = XmlConvertEx.XPathRound(XmlConvertEx.ToXPathDouble(argList[1].Evaluate(nodeIterator))) - 1;
if (Double.IsNaN(num) || str1.Length <= num)
{
return(string.Empty);
}
if (argList.Count == 3)
{
double num1 = XmlConvertEx.XPathRound(XmlConvertEx.ToXPathDouble(argList[2].Evaluate(nodeIterator)));
if (Double.IsNaN(num1))
{
return(string.Empty);
}
if (num < 0 || num1 < 0)
{
num1 = num + num1;
// NOTE: condition is true for NaN
if (!(num1 > 0))
{
return(string.Empty);
}
num = 0;
}
double maxlength = str1.Length - num;
if (num1 > maxlength)
{
num1 = maxlength;
}
return(str1.Substring((int)num, (int)num1));
}
if (num < 0)
{
num = 0;
}
return(str1.Substring((int)num));
}
internal static double Number(string arg)
{
return(XmlConvertEx.ToXPathDouble(arg));
}
private double Round(XPathNodeIterator nodeIterator)
{
double n = XmlConvertEx.ToXPathDouble(arg.Evaluate(nodeIterator));
return(XmlConvertEx.XPathRound(n));
}
public static object ChangeType(string value, Type destinationType, IXmlNamespaceResolver nsResolver)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (destinationType == null)
{
throw new ArgumentNullException(nameof(destinationType));
}
if (destinationType == BooleanType)
{
return(XmlConvert.ToBoolean((string)value));
}
if (destinationType == ByteType)
{
return(Int32ToByte(XmlConvert.ToInt32((string)value)));
}
if (destinationType == ByteArrayType)
{
return(StringToBase64Binary((string)value));
}
if (destinationType == DateTimeType)
{
return(UntypedAtomicToDateTime((string)value));
}
if (destinationType == DateTimeOffsetType)
{
return(XmlConvert.ToDateTimeOffset((string)value));
}
if (destinationType == DecimalType)
{
return(XmlConvert.ToDecimal((string)value));
}
if (destinationType == DoubleType)
{
return(XmlConvert.ToDouble((string)value));
}
if (destinationType == Int16Type)
{
return(Int32ToInt16(XmlConvert.ToInt32((string)value)));
}
if (destinationType == Int32Type)
{
return(XmlConvert.ToInt32((string)value));
}
if (destinationType == Int64Type)
{
return(XmlConvert.ToInt64((string)value));
}
if (destinationType == SByteType)
{
return(Int32ToSByte(XmlConvert.ToInt32((string)value)));
}
if (destinationType == SingleType)
{
return(XmlConvert.ToSingle((string)value));
}
if (destinationType == TimeSpanType)
{
return(XmlConvert.ToTimeSpan((string)value));
}
if (destinationType == UInt16Type)
{
return(Int32ToUInt16(XmlConvert.ToInt32((string)value)));
}
if (destinationType == UInt32Type)
{
return(Int64ToUInt32(XmlConvert.ToInt64((string)value)));
}
if (destinationType == UInt64Type)
{
return(DecimalToUInt64(XmlConvert.ToDecimal((string)value)));
}
if (destinationType == UriType)
{
return(XmlConvertEx.ToUri((string)value));
}
if (destinationType == XmlQualifiedNameType)
{
return(StringToQName((string)value, nsResolver));
}
if (destinationType == StringType)
{
return((string)value);
}
throw new InvalidCastException(SR.Format(SR.XmlConvert_TypeFromString, destinationType.Name));
}
private static byte[] StringToBase64Binary(string value)
{
return(Convert.FromBase64String(XmlConvertEx.TrimString(value)));
}
