public void NodeLiteralLanguageSpecifierCase1()
        {
            NodeFactory  factory = new NodeFactory();
            ILiteralNode lcase   = factory.CreateLiteralNode("example", "en-gb");
            ILiteralNode ucase   = factory.CreateLiteralNode("example", "en-GB");

            Assert.True(EqualityHelper.AreLiteralsEqual(lcase, ucase));
        }
Example #2
0
 /// <summary>
 /// Determines whether this Node is equal to a Graph Literal Node
 /// </summary>
 /// <param name="other">Graph Literal Node</param>
 /// <returns></returns>
 public override bool Equals(IGraphLiteralNode other)
 {
     if (ReferenceEquals(this, other))
     {
         return(true);
     }
     return(EqualityHelper.AreGraphLiteralsEqual(this, other));
 }
Example #3
0
        public void NodeAsValuedTimeSpan()
        {
            INode       orig   = new TimeSpan(1, 0, 0).ToLiteral(_graph);
            IValuedNode valued = orig.AsValuedNode();

            Assert.AreEqual(((ILiteralNode)orig).Value, ((ILiteralNode)valued).Value);
            Assert.IsTrue(EqualityHelper.AreUrisEqual(((ILiteralNode)orig).DataType, ((ILiteralNode)valued).DataType));
            Assert.AreEqual(typeof(TimeSpanNode), valued.GetType());
        }
Example #4
0
        /// <summary>
        /// Determines whether this Node is equal to a Literal Node
        /// </summary>
        /// <param name="other">Literal Node</param>
        /// <returns></returns>
        public override bool Equals(ILiteralNode other)
        {
            if (ReferenceEquals(this, other))
            {
                return(true);
            }
            if (other == null)
            {
                return(false);
            }

            return(EqualityHelper.AreLiteralsEqual(this, other));
        }
Example #5
0
        /// <summary>
        /// Determines whether this Node is equal to a URI Node.
        /// </summary>
        /// <param name="other">URI Node.</param>
        /// <returns></returns>
        public override bool Equals(IUriNode other)
        {
            if ((Object)other == null)
            {
                return(false);
            }

            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            return(EqualityHelper.AreUrisEqual(_uri, other.Uri));
        }
Example #6
0
        /// <summary>
        /// Determines whether this Node is equal to a Variable Node
        /// </summary>
        /// <param name="other">Variable Node</param>
        /// <returns></returns>
        public override bool Equals(IVariableNode other)
        {
            if ((Object)other == null)
            {
                return(false);
            }

            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            return(EqualityHelper.AreVariablesEqual(this, other));
        }
        /// <summary>
        /// Determines whether two URIs are equal
        /// </summary>
        /// <param name="a">First URI Node</param>
        /// <param name="b">Second URI Node</param>
        /// <returns></returns>
        public static bool AreUrisEqual(IUriNode a, IUriNode b)
        {
            if (ReferenceEquals(a, b))
            {
                return(true);
            }
            if (a == null)
            {
                if (b == null)
                {
                    return(true);
                }
                return(false);
            }
            else if (b == null)
            {
                return(false);
            }

            return(EqualityHelper.AreUrisEqual(a.Uri, b.Uri));
        }
Example #8
0
        /// <summary>
        /// Implementation of the Equals method for Graph Literal Nodes.  Graph Literals are considered Equal if their respective Subgraphs are equal
        /// </summary>
        /// <param name="other">Object to compare the Node with</param>
        /// <returns></returns>
        public override bool Equals(INode other)
        {
            if ((Object)other == null)
            {
                return(false);
            }

            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            if (other.NodeType == NodeType.GraphLiteral)
            {
                return(EqualityHelper.AreGraphLiteralsEqual(this, (IGraphLiteralNode)other));
            }
            else
            {
                //Can only be equal to a Graph Literal Node
                return(false);
            }
        }
Example #9
0
        /// <summary>
        /// Gets whether this Node is equal to some other Node
        /// </summary>
        /// <param name="other">Node to test</param>
        /// <returns></returns>
        public override bool Equals(INode other)
        {
            if ((Object)other == null)
            {
                return(false);
            }

            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            if (other.NodeType == NodeType.Variable)
            {
                return(EqualityHelper.AreVariablesEqual(this, (IVariableNode)other));
            }
            else
            {
                // Can only be equal to other Variables
                return(false);
            }
        }
Example #10
0
        /// <summary>
        /// Implementation of Equality for Uri Nodes.
        /// </summary>
        /// <param name="other">Object to compare with.</param>
        /// <returns></returns>
        /// <remarks>
        /// URI Nodes are considered equal if the string form of their URIs match using Ordinal string comparison.
        /// </remarks>
        public override bool Equals(INode other)
        {
            if ((Object)other == null)
            {
                return(false);
            }

            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            if (other.NodeType == NodeType.Uri)
            {
                Uri temp = ((IUriNode)other).Uri;

                return(EqualityHelper.AreUrisEqual(_uri, temp));
            }
            else
            {
                // Can only be equal to UriNodes
                return(false);
            }
        }
Example #11
0
        /// <summary>
        /// Implementation of Equals for Blank Nodes.
        /// </summary>
        /// <param name="other">Object to compare with the Blank Node.</param>
        /// <returns></returns>
        /// <remarks>
        /// Blank Nodes are considered equal if their internal IDs match precisely and they originate from the same Graph.
        /// </remarks>
        public override bool Equals(INode other)
        {
            if ((Object)other == null)
            {
                return(false);
            }

            if (ReferenceEquals(this, other))
            {
                return(true);
            }

            if (other.NodeType == NodeType.Blank)
            {
                IBlankNode temp = (IBlankNode)other;

                return(EqualityHelper.AreBlankNodesEqual(this, temp));
            }
            else
            {
                // Can only be equal to Blank Nodes
                return(false);
            }
        }
Example #12
0
        /// <summary>
        /// Compares two Literal Nodes.
        /// </summary>
        /// <param name="a">First Literal Node.</param>
        /// <param name="b">Second Literal Node.</param>
        /// <param name="culture">Culture to use for lexical string comparisons where more natural comparisons are not possible/applicable.</param>
        /// <param name="comparisonOptions">String Comparison options used for lexical string comparisons where more natural comparisons are not possible/applicable.</param>
        /// <returns></returns>
        public static int CompareLiterals(ILiteralNode a, ILiteralNode b, CultureInfo culture, CompareOptions comparisonOptions)
        {
            if (ReferenceEquals(a, b))
            {
                return(0);
            }
            if (a == null)
            {
                if (b == null)
                {
                    return(0);
                }
                return(-1);
            }
            else if (b == null)
            {
                return(1);
            }

            // initialize required culture and comparison options
            if (culture == null)
            {
                culture = Options.DefaultCulture;
            }
            if (comparisonOptions == CompareOptions.None)
            {
                comparisonOptions = Options.DefaultComparisonOptions;
            }

            // 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)
            {
                return(culture.CompareInfo.Compare(a.Value, b.Value, comparisonOptions));
            }
            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 specified order on the value
                    return(culture.CompareInfo.Compare(a.Value, b.Value, comparisonOptions));
                }
                else
                {
                    try
                    {
                        switch (type)
                        {
                        case XmlSpecsHelper.XmlSchemaDataTypeBoolean:
                            // Can use Lexical ordering for this so use specified order on the value
                            bool aBool, bBool;
                            if (Boolean.TryParse(a.Value, out aBool))
                            {
                                if (Boolean.TryParse(b.Value, out bBool))
                                {
                                    return(aBool.CompareTo(bBool));
                                }
                                else
                                {
                                    return(-1);
                                }
                            }
                            else
                            {
                                if (Boolean.TryParse(b.Value, out bBool))
                                {
                                    return(1);
                                }
                                goto default;
                            }

                        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, NumberStyles.Any, CultureInfo.InvariantCulture, 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, NumberStyles.Any, CultureInfo.InvariantCulture, 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, NumberStyles.HexNumber, null, out aHex))
                            {
                                if (Int64.TryParse(b.Value, NumberStyles.HexNumber, null, out bHex))
                                {
                                    return(aHex.CompareTo(bHex));
                                }
                                else
                                {
                                    return(-1);
                                }
                            }
                            else
                            {
                                if (Int64.TryParse(b.Value, 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(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 ordering on the value
                            // return String.Compare(a.Value, b.Value, culture, comparisonOptions);
                            return(culture.CompareInfo.Compare(a.Value, b.Value, comparisonOptions));
                        }
                    }
                    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 on the value
                        // return String.Compare(a.Value, b.Value, culture, comparisonOptions);
                        return(culture.CompareInfo.Compare(a.Value, b.Value, comparisonOptions));
                    }
                }
            }
            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(CompareUris(a.DataType, b.DataType));
            }
        }
Example #13
0
 /// <summary>
 /// Determines whether two URIs are equal.
 /// </summary>
 /// <param name="x">URI.</param>
 /// <param name="y">URI.</param>
 /// <returns></returns>
 public bool Equals(Uri x, Uri y)
 {
     return(EqualityHelper.AreUrisEqual(x, y));
 }
Example #14
0
        internal void Discard()
        {
            try
            {
                _persisting = true;
                _removedGraphs.Clear();

                // Read-Only managers have no persistence
                if (_manager.IsReadOnly)
                {
                    return;
                }

                // No actions mean no persistence necessary
                if (_actions.Count == 0)
                {
                    return;
                }

                // Important - For discard we reverse the list of actions so that we
                // rollback the actions in appropriate order
                _actions.Reverse();

                if (_manager.UpdateSupported)
                {
                    // Persist based on Triple level actions
                    // First group Triple together based on Graph URI
                    while (_actions.Count > 0)
                    {
                        TripleStorePersistenceAction action = _actions[0];

                        if (action.IsTripleAction)
                        {
                            Queue <TriplePersistenceAction> actions = new Queue <TriplePersistenceAction>();
                            Uri currUri = _actions[0].TripleAction.Triple.GraphUri;
                            actions.Enqueue(_actions[0].TripleAction);
                            _actions.RemoveAt(0);

                            // Find all the Triple actions related to this Graph up to the next non-Triple action
                            for (int i = 0; i < _actions.Count && _actions[i].IsTripleAction; i++)
                            {
                                if (EqualityHelper.AreUrisEqual(currUri, _actions[i].TripleAction.Triple.GraphUri))
                                {
                                    actions.Enqueue(_actions[i].TripleAction);
                                    _actions.RemoveAt(i);
                                    i--;
                                }
                            }

                            // Split the Triples for this Graph into batches of adds and deletes to ensure
                            // accurate persistence of the actions
                            bool          toDelete = false;
                            List <Triple> batch    = new List <Triple>();
                            while (actions.Count > 0)
                            {
                                TriplePersistenceAction next = actions.Dequeue();
                                if (next.IsDelete != toDelete)
                                {
                                    if (batch.Count > 0)
                                    {
                                        // Process a batch whenever we find a switch between additions and removals
                                        // This ensures that regardless of the logic in UpdateGraph() we force
                                        // additions and removals to happen in the order we care about

                                        // Important - For discard we flip the actions in order to reverse them
                                        // i.e. additions become removals and vice versa
                                        // Also for discard we only need to alter the in-memory state not actually
                                        // do any persistence since the actions will never have been persisted
                                        if (toDelete)
                                        {
                                            this[currUri].Assert(batch);
                                        }
                                        else
                                        {
                                            this[currUri].Retract(batch);
                                        }
                                        batch.Clear();
                                    }
                                    toDelete = next.IsDelete;
                                }
                                batch.Add(next.Triple);
                            }
                            // Ensure the final batch (if any) gets processed
                            if (batch.Count > 0)
                            {
                                // Important - For discard we flip the actions in order to reverse them
                                // i.e. additions become removals and vice versa
                                // Also for discard we only need to alter the in-memory state not actually
                                // do any persistence since the actions will never have been persisted
                                if (toDelete)
                                {
                                    this[currUri].Assert(batch);
                                }
                                else
                                {
                                    this[currUri].Retract(batch);
                                }
                            }
                        }
                        else
                        {
                            switch (action.GraphAction.Action)
                            {
                            case GraphPersistenceActionType.Added:
                                // Need to remove from being in-memory
                                Remove(action.GraphAction.Graph.BaseUri);
                                break;

                            case GraphPersistenceActionType.Deleted:
                                // Need to add back into memory
                                Add(action.GraphAction.Graph, false);
                                break;
                            }
                            _actions.RemoveAt(0);
                        }
                    }
                }
                else
                {
                    // Persist based on Graph level actions
                    foreach (TripleStorePersistenceAction action in _actions)
                    {
                        // Important - For discard we flip the actions in order to reverse them
                        // i.e. additions become removals and vice versa

                        if (action.IsGraphAction)
                        {
                            if (action.GraphAction.Action == GraphPersistenceActionType.Added)
                            {
                                Remove(action.GraphAction.Graph.BaseUri);
                            }
                            else if (action.GraphAction.Action == GraphPersistenceActionType.Deleted)
                            {
                                Add(action.GraphAction.Graph, false);
                            }
                        }
                    }
                }
            }
            finally
            {
                _persisting = false;
            }
        }
Example #15
0
        internal void Flush()
        {
            try
            {
                _persisting = true;
                _removedGraphs.Clear();

                // Read-Only managers have no persistence
                if (_manager.IsReadOnly)
                {
                    return;
                }

                // No actions means no persistence necessary
                if (_actions.Count == 0)
                {
                    return;
                }

                if (_manager.UpdateSupported)
                {
                    // Persist based on Triple level actions
                    // First group Triple together based on Graph URI
                    while (_actions.Count > 0)
                    {
                        TripleStorePersistenceAction action = _actions[0];

                        if (action.IsTripleAction)
                        {
                            Queue <TriplePersistenceAction> actions = new Queue <TriplePersistenceAction>();
                            Uri currUri = action.TripleAction.Triple.GraphUri;
                            actions.Enqueue(_actions[0].TripleAction);
                            _actions.RemoveAt(0);

                            // Find all the Triple actions related to this Graph up to the next non-Triple action
                            for (int i = 0; i < _actions.Count && _actions[i].IsTripleAction; i++)
                            {
                                if (EqualityHelper.AreUrisEqual(currUri, _actions[i].TripleAction.Triple.GraphUri))
                                {
                                    actions.Enqueue(_actions[i].TripleAction);
                                    _actions.RemoveAt(i);
                                    i--;
                                }
                            }

                            // Split the Triple Actions for this Graph into batches of adds and deletes to ensure
                            // accurate persistence of the actions
                            bool          toDelete = false;
                            List <Triple> batch    = new List <Triple>();
                            while (actions.Count > 0)
                            {
                                TriplePersistenceAction next = actions.Dequeue();
                                if (next.IsDelete != toDelete)
                                {
                                    if (batch.Count > 0)
                                    {
                                        // Process a batch whenever we find a switch between additions and removals
                                        // This ensures that regardless of the logic in UpdateGraph() we force
                                        // additions and removals to happen in the order we care about
                                        if (toDelete)
                                        {
                                            _manager.UpdateGraph(currUri, null, batch);
                                        }
                                        else
                                        {
                                            _manager.UpdateGraph(currUri, batch, null);
                                        }
                                        batch.Clear();
                                    }
                                    toDelete = next.IsDelete;
                                }
                                batch.Add(next.Triple);
                            }
                            // Ensure the final batch (if any) gets processed
                            if (batch.Count > 0)
                            {
                                if (toDelete)
                                {
                                    _manager.UpdateGraph(currUri, null, batch);
                                }
                                else
                                {
                                    _manager.UpdateGraph(currUri, batch, null);
                                }
                            }
                        }
                        else
                        {
                            switch (action.GraphAction.Action)
                            {
                            case GraphPersistenceActionType.Added:
                                // No need to do anything in-memory as will be in the graph collection
                                // Call SaveGraph() with an empty graph to create the relevant graph
                                // If Triples were added these will be persisted separately with
                                // TriplePersistenceActions
                                Graph g = new Graph();
                                g.BaseUri = action.GraphAction.Graph.BaseUri;
                                _manager.SaveGraph(g);
                                break;

                            case GraphPersistenceActionType.Deleted:
                                // No need to do anything in-memory as won't be in the graph collection
                                // If DeleteGraph() is supported call it to delete the relevant graph
                                if (_manager.DeleteSupported)
                                {
                                    _manager.DeleteGraph(action.GraphAction.Graph.BaseUri);
                                }
                                break;
                            }
                            _actions.RemoveAt(0);
                        }
                    }
                }
                else
                {
                    // Persist based on Graph level actions
                    foreach (TripleStorePersistenceAction action in _actions)
                    {
                        if (action.IsGraphAction)
                        {
                            if (action.GraphAction.Action == GraphPersistenceActionType.Added)
                            {
                                _manager.SaveGraph(action.GraphAction.Graph);
                            }
                            else if (action.GraphAction.Action == GraphPersistenceActionType.Deleted && _manager.DeleteSupported)
                            {
                                // Can only delete graphs if deletion is supported
                                _manager.DeleteGraph(action.GraphAction.Graph.BaseUri);
                            }
                        }
                    }
                }
            }
            finally
            {
                _persisting = false;
            }
        }
Example #16
0
 /// <summary>
 /// Determines whether this Node is equal to another.
 /// </summary>
 /// <param name="other">Other Blank Node.</param>
 /// <returns></returns>
 public override bool Equals(IBlankNode other)
 {
     return(EqualityHelper.AreBlankNodesEqual(this, other));
 }
Example #17
0
        /// <summary>
        /// Determines whether two Literals are equal
        /// </summary>
        /// <param name="a">First Literal</param>
        /// <param name="b">Second Literal</param>
        /// <returns></returns>
        public static bool AreLiteralsEqual(ILiteralNode a, ILiteralNode b)
        {
            if (ReferenceEquals(a, b))
            {
                return(true);
            }
            if (a == null)
            {
                if (b == null)
                {
                    return(true);
                }
                return(false);
            }
            else if (b == null)
            {
                return(false);
            }

            //Language Tags must be equal (if present)
            //If they don't have language tags then they'll both be set to String.Empty which will give true
            if (a.Language.Equals(b.Language, StringComparison.OrdinalIgnoreCase))
            {
                //Datatypes must be equal (if present)
                //If they don't have Data Types then they'll both be null
                //Otherwise the URIs must be equal
                if (a.DataType == null && b.DataType == null)
                {
                    //Use String equality to get the result
                    return(a.Value.Equals(b.Value, StringComparison.Ordinal));
                }
                else if (a.DataType == null)
                {
                    //We have a Null DataType but the other Node doesn't so can't be equal
                    return(false);
                }
                else if (b.DataType == null)
                {
                    //The other Node has a Null DataType but we don't so can't be equal
                    return(false);
                }
                else if (EqualityHelper.AreUrisEqual(a.DataType, b.DataType))
                {
                    //We have equal DataTypes so use String Equality to evaluate
                    if (Options.LiteralEqualityMode == LiteralEqualityMode.Strict)
                    {
                        //Strict Equality Mode uses Ordinal Lexical Comparison for Equality as per W3C RDF Spec
                        return(a.Value.Equals(b.Value, StringComparison.Ordinal));
                    }
                    else
                    {
                        //Loose Equality Mode uses Value Based Comparison for Equality of Typed Nodes
                        return(a.CompareTo(b) == 0);
                    }
                }
                else
                {
                    //Data Types didn't match
                    return(false);
                }
            }
            else
            {
                //Language Tags didn't match
                return(false);
            }
        }