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