Namespace VDS.RDF
Classes
Marker that will be passed to your callback in the event that an async error occurs, provides access to the error and any state that you passed in originally.
Abstract Base Class for Blank Nodes.
A decorator for graph collections that allows for graphs to be loaded on demand if they don't exist in the underlying graph collection.
Abstract Base class for HTTP endpoints.
Abstract Base Implementation of the IGraph interface.
Abstract Base Class for Graph Collections.
Abstract Base Class for Graph Literal Nodes.
Abstract Base Class for Literal Nodes.
Abstract Class for Nodes, implements the two basic properties of the INode Interface.
Abstract Base Class for Triple Collections.
Abstract base class for Triple Comparers which provide for comparisons using different node comparers.
Abstract Base Class for a Triple Store.
Abstract Base Class for URI Nodes.
Abstract Base Class for Variable Nodes.
Class which implements a very basic Triple Context.
Class for representing Blank RDF Nodes.
Mapper class which creates Blank Node IDs and ensures that auto-assigned and user specified IDs don't collide.
Mapper class which remaps Blank Node IDs which aren't valid as-is in a given serialization to a new ID.
Event Arguments for Events regarding Graphs which may be cancelled.
Static Helper class containing standard implementations of Comparison between various Node types.
A decorator for graph collection where graphs not in the underlying graph collection can be loaded on-demand from the Files on Disk as needed.
Class for representing Triple Stores which are collections of RDF Graphs.
Static Helper class containing standard implementations of Equality between various Node types.
Provides useful Extension Methods for use elsewhere in the Library.
A Node Comparer which does faster comparisons since it only does lexical comparisons for literals rather than value comparisons.
A Node Comparer which does faster comparisons since it only does lexical comparisons for literals rather than value comparisons,
and it compares virtual nodes on their VirtualID where possible.
The File Graph Persistence Wrapper is a wrapper around another Graph that will be persisted to a file.
Triple comparer which compares on subjects, then predicates and finally objects.
Class for representing RDF Graphs.
Wrapper class for Graph Collections.
Implementation of a Graph Difference algorithm for RDF Graphs.
Represents the Differences between 2 Graphs.
Event Arguments for Events regarding Graphs.
Provides useful Extension Methods for working with Graphs.
A Graph Factory provides access to consistent Graph References so that Nodes and Triples can be instantiated in the correct Graphs.
Class for representing Graph Literal Nodes which are supported in highly expressive RDF syntaxes like Notation 3.
Implements a Graph Isomorphism Algorithm.
Represents a Graph that is queued for persistence (added/modified/removed).
The Graph Persistence Wrapper is a wrapper around another Graph that can be used to batch persistence actions with the ability to Flush/Discard changes as desired.
A Comparer for Graphs which compares based on number of Triples.
Helper Class for indexing related operations.
Provides extension methods for converting primitive types into appropriately typed Literal Nodes.
Class for representing Literal Nodes.
Represents the definition of a MIME Type including mappings to relevant readers and writers.
Selector used in selecting which MIME type to use.
Helper Class containing definitions of MIME Types for the various RDF Concrete Syntaxes and Content Negotation Methods.
Class for representing Mappings between Prefixes and Namespace URIs.
A Namespace Mapper which has an explicit notion of Nesting.
A default implementation of a Node Factory which generates Nodes unrelated to Graphs (wherever possible we suggest using a Graph based implementation instead).
Class for representing RDF Graphs when you don't want Indexing.
A Thread Safe version of the Graph class.
Triple comparer which compares only on objects.
Triple comparer which compares on objects and then subjects.
Configures Global Static Options for the Library.
Represents an in-memory view of a triple store provided by an IStorageProvider instance where changes to the in-memory view get reflected in the persisted view.
Triple comparer which compares only on predicates.
Triple comparer which compares on predicates and then objects.
Represents a mapping from a URI to a QName.
Class for representing Mappings from URIs to QNames.
Class for representing Graphs which can be directly queried using SPARQL.
Class for representing errors with RDF.
The Store Graph Persistence Wrapper is a wrapper around another Graph that will be persisted to an underlying store via a provided IStorageProvider implementation.
A collection of cross-target extensions to the string class.
Triple comparer which compares only on subjects.
Triple comparer which compares on subjects and then objects.
Triple comparer which compares on subjects and then predicates.
An indexed triple collection that uses our VDS.Common.Collections.MultiDictionary<TKey, TValue> and VDS.Common.Trees.BinaryTree`2 implementations under the hood for the index structures.
A Thread Safe version of the Graph class.
Thread Safe decorator around a Graph collection.
Thread Safe decorator for triple collections.
Tools class which contains a number of utility methods which are declared as static methods.
An indexed triple collection that uses our VDS.Common.Collections.MultiDictionary<TKey, TValue> and VDS.Common.Trees.BinaryTree`2 implementations under the hood for the index structures.
Class for representing RDF Triples in memory.
Basic Triple Collection which is not indexed.
Compares triples for equality.
Event Arguments for Events regarding the assertion and retraction of Triples.
Represents a Triple that is queued for persistence (either insertion/deletion).
Class for representing Triple Stores which are collections of RDF Graphs.
Event Arguments for Events regarding Graphs.
Provides useful Extension Methods for working with Triple Stores.
Represents an action on a Triple Store that is queued for persistence.
A Graph which represents the Union of several Graphs.
Represents a union of multiple Triple Collections.
Class for errors in mapping an IRdfWriter instance to its associated MIME type for HTTP interactions.
Equality comparer that compares URIs.
A static helper class for interning URIs to reduce memory usage.
Class for representing URI Nodes.
Represents the Variable Context for Triples.
Class representing Variable Nodes (only used for N3).
A decorator for graph collections where graphs not in the underlying graph collection can be loaded on-demand from the Web as needed.
Class for representing Triple Stores which are collections of RDF Graphs.
Abstract decorator for Graphs to make it easier to layer functionality on top of existing implementations.
Abstract decorator for Graph Collections to make it easier to add new functionality to existing implementations.
Abstract decorator for Nodes to make it easier to layer functionality on top of existing implementations.
Abstract decorator for Triple Collections to make it easier to add additional functionality to existing collections.
Abstract decorator for Triple Stores to make it easier to add new functionality on top of existing implementations.
Interfaces
Interface for Blank Nodes.
Interface for RDF Graphs.
Interface for Graph Literal Nodes.
Interface for Triple Stores which can be queried in memory using method calls or the SPARQL implementation contained in this library.
Interface for Literal Nodes.
Interface for Namespace Maps which provide mappings between Namespace Prefixes and Namespace URIs.
Interface for Triple Stores which can be queried natively i.e. the Stores provide their own SPARQL implementations.
A Namespace Mapper which has an explicit notion of Nesting.
Interface for classes which can create Nodes.
Interface for parsers that generate objects of some sort.
Interface for Handlers which handle the RDF produced by parsers.
Interface to be implemented by RDF Readers which parse Concrete RDF Syntax.
Interface to be implemented by RDF Writers which generate RDF Concrete Syntax.
Interface for Handlers which handle the SPARQL Results produced by parsers.
Interface for Reader Classes which parser Sparql Result Set syntaxes into Result Set objects.
Interface for Writer classes which serialize Sparql Result Sets into concrete results set syntaxes.
Interface to be implemented by Triple Store Readers.
Interface to be implemented by Triple Store Writers.
Interface for RDF Graphs which provide Transactions i.e. changes to them can be Flushed (committed) or Discard (rolled back) as desired.
Interface for Triple Stores which are backed by some storage layer that may delay persistence and thus require flushing to ensure changes are persisted to the backing store, as a by product such stores will typically have some notion of transactionality.
An Interface for classes which provide Context Information for Triples thus allowing you to create Quads with arbitrary extra information attached to Triples via your Context Objects.
Interface for Triple Stores.
Interface for Triple Stores which support SPARQL Update as per the SPARQL 1.1 specifications.
Interface for Variable Nodes.
Interface for Handlers which wrap other Handlers.
Enums
Possible Types of Graph Persistence Actions.
Possible Literal Equality Mode Settings.
Possible Triple Index types.
Possible Variable Context Types.
Delegates
Delegate Type for Graph events raised by Graphs where event handlers may set a Cancel flag to cancel the subsequent operation.
Callback for methods that return a IGraph asynchronously.
Delegate Type for Graph events raised by Graphs.
Callback for methods that return a Namespace Map.
Delegate Type for the Events of the Namespace Mapper.
Callbacks for methods that return a list of nodes.
Callbacks for methods that may process the results with either an RDF or a SPARQL Results Handler.
Callbacks for methods that process the resulting triples with an RDF Handler asynchronously.
Delegate Type for Warning Messages raised by RDF Readers.
Delegate Type for Warning Messages raised by RDF Writers.
Callbacks for methods that process the results with an SPARQL Results Handler asynchronously.
Delegate Type for Warning Events raised by SPARQL Readers and Writers for Queries, Updates and Results.
Delegate Type for Warning Events raised by RDF Dataset Readers.
Delegate Type for Warning Events raised by RDF Dataset Writers.
Delegate Type for Triple events raised by Graphs.
Callback for methods that return a ITripleStore asynchronously.
Delegate Type for Triple Store events raised by Triple Stores.
Callbacks for methods that perform SPARQL Updates.