/// <summary>
/// Compares two Literal Nodes
/// </summary>
/// <param name="a">First Literal Node</param>
/// <param name="b">Second Literal Node</param>
/// <returns></returns>
public static int CompareLiterals(ILiteralNode a, ILiteralNode b)
{
if (ReferenceEquals(a, b))
{
return(0);
}
if (a == null)
{
if (b == null)
{
return(0);
}
return(-1);
}
else if (b == null)
{
return(1);
}
//Literal Nodes are ordered based on Type and lexical form
if (a.DataType == null && b.DataType != null)
{
//Untyped Literals are less than Typed Literals
//Return a -1 to indicate this
return(-1);
}
else if (a.DataType != null && b.DataType == null)
{
//Typed Literals are greater than Untyped Literals
//Return a 1 to indicate this
return(1);
}
else if (a.DataType == null && b.DataType == null)
{
//If neither are typed use Lexical Ordering on the value
return(String.CompareOrdinal(a.Value, b.Value));
}
else if (EqualityHelper.AreUrisEqual(a.DataType, b.DataType))
{
//Are we using a known and orderable DataType?
String type = a.DataType.AbsoluteUri;
if (!XmlSpecsHelper.IsSupportedType(type))
{
//Don't know how to order so use lexical order on the value
return(String.CompareOrdinal(a.Value, b.Value));
}
else
{
try
{
switch (type)
{
case XmlSpecsHelper.XmlSchemaDataTypeBoolean:
//Can use Lexical ordering for this
return(String.Compare(a.Value.ToLower(), b.Value.ToLower(), StringComparison.Ordinal));
case XmlSpecsHelper.XmlSchemaDataTypeByte:
//Remember that xsd:byte is actually equivalent to SByte in .Net
//Extract the Byte Values and compare
sbyte aSByte, bSByte;
if (SByte.TryParse(a.Value, out aSByte))
{
if (SByte.TryParse(b.Value, out bSByte))
{
return(aSByte.CompareTo(bSByte));
}
else
{
return(-1);
}
}
else
{
if (SByte.TryParse(b.Value, out bSByte))
{
return(1);
}
goto default;
}
case XmlSpecsHelper.XmlSchemaDataTypeUnsignedByte:
//Remember that xsd:unsignedByte is equivalent to Byte in .Net
//Extract the Byte Values and compare
byte aByte, bByte;
if (Byte.TryParse(a.Value, out aByte))
{
if (Byte.TryParse(b.Value, out bByte))
{
return(aByte.CompareTo(bByte));
}
else
{
return(-1);
}
}
else
{
if (Byte.TryParse(b.Value, out bByte))
{
return(1);
}
else
{
goto default;
}
}
case XmlSpecsHelper.XmlSchemaDataTypeInt:
case XmlSpecsHelper.XmlSchemaDataTypeInteger:
case XmlSpecsHelper.XmlSchemaDataTypeLong:
case XmlSpecsHelper.XmlSchemaDataTypeShort:
//Extract the Integer Values and compare
long aInt64, bInt64;
if (Int64.TryParse(a.Value, out aInt64))
{
if (Int64.TryParse(b.Value, out bInt64))
{
return(aInt64.CompareTo(bInt64));
}
else
{
return(-1);
}
}
else
{
if (Int64.TryParse(b.Value, out bInt64))
{
return(1);
}
else
{
goto default;
}
}
case XmlSpecsHelper.XmlSchemaDataTypeNegativeInteger:
case XmlSpecsHelper.XmlSchemaDataTypeNonPositiveInteger:
//Extract the Integer Values, ensure negative and compare
long aNegInt, bNegInt;
if (Int64.TryParse(a.Value, out aNegInt))
{
if (Int64.TryParse(b.Value, out bNegInt))
{
if (aNegInt >= 0)
{
if (bNegInt >= 0)
{
goto default;
}
else
{
return(1);
}
}
else if (bNegInt >= 0)
{
return(-1);
}
else
{
return(aNegInt.CompareTo(bNegInt));
}
}
else if (aNegInt >= 0)
{
goto default;
}
else
{
return(-1);
}
}
else
{
if (Int64.TryParse(b.Value, out bNegInt))
{
if (bNegInt >= 0)
{
goto default;
}
else
{
return(1);
}
}
else
{
goto default;
}
}
case XmlSpecsHelper.XmlSchemaDataTypeUnsignedInt:
case XmlSpecsHelper.XmlSchemaDataTypeUnsignedLong:
case XmlSpecsHelper.XmlSchemaDataTypeUnsignedShort:
case XmlSpecsHelper.XmlSchemaDataTypeNonNegativeInteger:
case XmlSpecsHelper.XmlSchemaDataTypePositiveInteger:
//Unsigned Integers
//Note that for NonNegativeInteger and PositiveInteger we don't need to do the
//same checking we have to do for their inverse types since parsing into an
//Unsigned Long ensures that they must be positive
ulong aUInt64, bUInt64;
if (UInt64.TryParse(a.Value, out aUInt64))
{
if (UInt64.TryParse(b.Value, out bUInt64))
{
return(aUInt64.CompareTo(bUInt64));
}
else
{
return(-1);
}
}
else
{
if (UInt64.TryParse(b.Value, out bUInt64))
{
return(1);
}
else
{
goto default;
}
}
case XmlSpecsHelper.XmlSchemaDataTypeDouble:
//Extract the Double Values and compare
double aDouble, bDouble;
if (Double.TryParse(a.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out aDouble))
{
if (Double.TryParse(b.Value, out bDouble))
{
return(aDouble.CompareTo(bDouble));
}
else
{
return(-1);
}
}
else
{
if (Double.TryParse(b.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out bDouble))
{
return(1);
}
else
{
goto default;
}
}
case XmlSpecsHelper.XmlSchemaDataTypeDecimal:
//Extract the Decimal Values and compare
decimal aDecimal, bDecimal;
if (decimal.TryParse(a.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out aDecimal))
{
if (decimal.TryParse(b.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out bDecimal))
{
return(aDecimal.CompareTo(bDecimal));
}
else
{
return(-1);
}
}
else
{
if (decimal.TryParse(b.Value, out bDecimal))
{
return(1);
}
else
{
goto default;
}
}
case XmlSpecsHelper.XmlSchemaDataTypeFloat:
//Extract the Float Values and compare
float aFloat, bFloat;
if (Single.TryParse(a.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out aFloat))
{
if (Single.TryParse(b.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out bFloat))
{
return(aFloat.CompareTo(bFloat));
}
else
{
return(-1);
}
}
else
{
if (Single.TryParse(b.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out bFloat))
{
return(1);
}
else
{
goto default;
}
}
case XmlSpecsHelper.XmlSchemaDataTypeHexBinary:
//Extract the numeric value of the Hex encoded Binary and compare
long aHex, bHex;
if (Int64.TryParse(a.Value, System.Globalization.NumberStyles.HexNumber, null, out aHex))
{
if (Int64.TryParse(b.Value, System.Globalization.NumberStyles.HexNumber, null, out bHex))
{
return(aHex.CompareTo(bHex));
}
else
{
return(-1);
}
}
else
{
if (Int64.TryParse(b.Value, System.Globalization.NumberStyles.HexNumber, null, out bHex))
{
return(1);
}
else
{
goto default;
}
}
case XmlSpecsHelper.XmlSchemaDataTypeBase64Binary:
//Extract the numeric value of the Base 64 encoded Binary and compare
byte[] aBin, bBin;
try
{
aBin = Convert.FromBase64String(a.Value);
try
{
bBin = Convert.FromBase64String(b.Value);
if (aBin.Length > bBin.Length)
{
return(1);
}
else if (aBin.Length < bBin.Length)
{
return(-1);
}
else
{
for (int i = 0; i < aBin.Length; i++)
{
if (aBin[i] != bBin[i])
{
return(aBin[i].CompareTo(bBin[i]));
}
}
return(0);
}
}
catch
{
return(-1);
}
}
catch
{
try
{
bBin = Convert.FromBase64String(b.Value);
return(1);
}
catch
{
goto default;
}
}
case XmlSpecsHelper.XmlSchemaDataTypeString:
//String Type
//Can use Lexical Ordering for thisgoto default;
case XmlSpecsHelper.XmlSchemaDataTypeAnyUri:
//Uri Type
//Try and convert to a URI and use lexical ordering
Uri aUri, bUri;
try
{
aUri = UriFactory.Create(a.Value);
try
{
bUri = UriFactory.Create(b.Value);
return(ComparisonHelper.CompareUris(aUri, bUri));
}
catch
{
return(-1);
}
}
catch
{
try
{
bUri = UriFactory.Create(b.Value);
return(1);
}
catch
{
goto default;
}
}
case XmlSpecsHelper.XmlSchemaDataTypeDate:
case XmlSpecsHelper.XmlSchemaDataTypeDateTime:
//Extract the Date Times and compare
DateTimeOffset aDateTimeOffset, bDateTimeOffset;
if (DateTimeOffset.TryParse(a.Value, out aDateTimeOffset))
{
if (DateTimeOffset.TryParse(b.Value, out bDateTimeOffset))
{
return(aDateTimeOffset.CompareTo(bDateTimeOffset));
}
else
{
return(-1);
}
}
else
{
if (DateTimeOffset.TryParse(b.Value, out bDateTimeOffset))
{
return(1);
}
else
{
goto default;
}
}
case XmlSpecsHelper.XmlSchemaDataTypeDuration:
case XmlSpecsHelper.XmlSchemaDataTypeDayTimeDuration:
//Extract the TimeSpan's and compare
TimeSpan aTimeSpan, bTimeSpan;
try
{
aTimeSpan = XmlConvert.ToTimeSpan(a.Value);
try
{
bTimeSpan = XmlConvert.ToTimeSpan(b.Value);
return(aTimeSpan.CompareTo(bTimeSpan));
}
catch
{
return(-1);
}
}
catch
{
try
{
bTimeSpan = XmlConvert.ToTimeSpan(b.Value);
return(1);
}
catch
{
goto default;
}
}
default:
//Don't know how to order so use lexical order
return(String.CompareOrdinal(a.Value, b.Value));
}
}
catch
{
//There was some error suggesting a non-valid value for a type
//e.g. "example"^^xsd:integer
//In this case just use Lexical Ordering
return(String.CompareOrdinal(a.Value, b.Value));
}
}
}
else
{
//No way of ordering by value if the Data Types are different
//Order by Data Type Uri
//This is required or the Value ordering between types won't occur correctly
return(ComparisonHelper.CompareUris(a.DataType, b.DataType));
}
}
/// <summary>
/// Returns an Integer indicating the Ordering of this Node compared to another Node
/// </summary>
/// <param name="other">Node to test against</param>
/// <returns></returns>
public override int CompareTo(IGraphLiteralNode other)
{
return(ComparisonHelper.CompareGraphLiterals(this, (IGraphLiteralNode)other));
}
/// <summary>
/// Compares two Nodes.
/// </summary>
/// <param name="x">Node.</param>
/// <param name="y">Node.</param>
/// <returns></returns>
public int Compare(INode x, INode y)
{
if (ReferenceEquals(x, y))
{
return(0);
}
if (x == null)
{
if (y == null)
{
return(0);
}
else
{
return(-1);
}
}
else if (y == null)
{
return(1);
}
if (x is IVirtualIdComparable && y is IVirtualIdComparable)
{
if ((x as IVirtualIdComparable).TryCompareVirtualId(y, out int result))
{
return(result);
}
}
if (x.NodeType == NodeType.Literal && y.NodeType == NodeType.Literal)
{
// Use faster comparison for literals - standard comparison is valued based
// and so gets slower as amount of nodes to compare gets larger
// Sort order for literals is as follows
// plain literals < language spec'd literals < typed literals
// Within a category ordering is lexical on modifier, then lexical on lexical value
ILiteralNode a = (ILiteralNode)x;
ILiteralNode b = (ILiteralNode)y;
if (a.DataType != null)
{
if (b.DataType != null)
{
// Compare datatypes
int c = ComparisonHelper.CompareUris(a.DataType, b.DataType);
if (c == 0)
{
// Same datatype so compare lexical values
return(a.Value.CompareTo(b.Value));
}
// Different datatypes
return(c);
}
else
{
// y is untyped literal so x is greater than y
return(1);
}
}
else if (!a.Language.Equals(string.Empty))
{
if (!b.Language.Equals(string.Empty))
{
// Compare language specifiers
int c = a.Language.CompareTo(b.Language);
if (c == 0)
{
// Same language so compare lexical values
return(a.Value.CompareTo(b.Value));
}
// Different language specifiers
return(c);
}
else
{
// y in plain literal so x is greater then y
return(1);
}
}
else
{
// Plain literals so just compare lexical value
return(a.Value.CompareTo(b.Value));
}
}
else
{
// Non-literal nodes use their normal IComparable implementations
return(x.CompareTo(y));
}
}
/// <summary>
/// Compares two URIs
/// </summary>
/// <param name="x">URI</param>
/// <param name="y">URI</param>
/// <returns></returns>
public int Compare(Uri x, Uri y)
{
return(ComparisonHelper.CompareUris(x, y));
}
