Namespace VDS.RDF

Classes

AbstractIndexedTripleCollection

An abstract base class for triple collections with a lookup index.

AsyncError

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.

BaseDemandGraphCollection

A decorator for graph collections that allows for graphs to be loaded on demand if they don't exist in the underlying graph collection.

BaseGraph

Abstract Base Implementation of the IGraph interface.

BaseGraphCollection

Abstract Base Class for Graph Collections.

BaseGraphLiteralNode

Abstract Base Class for Graph Literal Nodes.

BaseNode

Abstract Class for Nodes, implements the two basic properties of the INode Interface.

BaseTripleCollection

Abstract Base Class for Triple Collections.

BaseTripleComparer

Abstract base class for Triple Comparers which provide for comparisons using different node comparers.

BasicTripleContext

Class which implements a very basic Triple Context.

BlankNodeMapper

Mapper class which creates Blank Node IDs and ensures that auto-assigned and user specified IDs don't collide.

BlankNodeOutputMapper

Mapper class which remaps Blank Node IDs which aren't valid as-is in a given serialization to a new ID.

CachingUriFactory

The default implementation of IUriFactory which caches the URI instances it creates when InternUris is set to true.

CancellableGraphEventArgs

Event Arguments for Events regarding Graphs which may be cancelled.

ComparisonHelper

Static Helper class containing standard implementations of Comparison between various Node types.

DiskDemandGraphCollection

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.

DiskDemandTripleStore

Class for representing Triple Stores which are collections of RDF Graphs.

EqualityHelper

Static Helper class containing standard implementations of Equality between various Node types.

Extensions

Provides useful Extension Methods for use elsewhere in the Library.

FastNodeComparer

A Node Comparer which does faster comparisons since it only does lexical comparisons for literals rather than value comparisons.

FastVirtualNodeComparer

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.

FileGraphPersistenceWrapper

The File Graph Persistence Wrapper is a wrapper around another Graph that will be persisted to a file.

FullTripleComparer

Triple comparer which compares on subjects, then predicates and finally objects.

GraphDiff

Implementation of a Graph Difference algorithm for RDF Graphs.

GraphDiffReport

Represents the Differences between 2 Graphs.

GraphDiffReportExtensions

Provides useful Extension Methods for working with graph diff reports.

GraphEventArgs

Event Arguments for Events regarding Graphs.

GraphExtensions

Provides useful Extension Methods for working with Graphs.

GraphFactory

A Graph Factory provides access to consistent Graph References so that Nodes and Triples can be instantiated in the correct Graphs.

GraphLiteralNode

Class for representing Graph Literal Nodes which are supported in highly expressive RDF syntaxes like Notation 3.

GraphMatcher

Implements a Graph Isomorphism Algorithm.

GraphPersistenceAction

Represents a Graph that is queued for persistence (added/modified/removed).

GraphPersistenceWrapper

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.

GraphSizeComparer

A Comparer for Graphs which compares based on number of Triples.

GraphWrapperNode

A node wrapper that preserves a reference to a graph along with the node itself.

InMemoryExtensions

Extension methods for working with a IGraph instance as an in-memory queryable SPARQL dataset.

InferencingTripleStore

An implementation of the IInferencingTripleStore interface over an in-memory TripleStore.

LiteralExtensions

Provides extension methods for converting primitive types into appropriately typed Literal Nodes.

MimeTypeDefinition

Represents the definition of a MIME Type including mappings to relevant readers and writers.

MimeTypeSelector

Selector used in selecting which MIME type to use.

MimeTypesHelper

Helper Class containing definitions of MIME Types for the various RDF Concrete Syntaxes and Content Negotation Methods.

NamespaceMapper

Class for representing Mappings between Prefixes and Namespace URIs.

NestedNamespaceMapper

A Namespace Mapper which has an explicit notion of Nesting.

NodeFactory

A default implementation of a Node Factory which generates Nodes unrelated to Graphs (wherever possible we suggest using a Graph based implementation instead).

NodeFactoryOptions

Configuration options that can be passed to the NodeFactory constructor.

NonIndexedGraph

Class for representing RDF Graphs when you don't want Indexing.

NonIndexedThreadSafeGraph

A Thread Safe version of the Graph class.

ObjectComparer

Triple comparer which compares only on objects.

ObjectSubjectComparer

Triple comparer which compares on objects and then subjects.

Options

Configures Global Static Options for the Library.

PersistentTripleStore

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.

PredicateComparer

Triple comparer which compares only on predicates.

PredicateObjectComparer

Triple comparer which compares on predicates and then objects.

QNameMapping

Represents a mapping from a URI to a QName.

QNameOutputMapper

Class for representing Mappings from URIs to QNames.

QueryableGraph

Class for representing Graphs which can be directly queried using SPARQL.

RdfCanonicalizer

Implementation of the RDFC-1.0 algorithm. Transforms a RDF graph into its canonical form.

RdfCanonicalizer.CanonicalizedRdfDataset

A canonicalized RDF dataset, as per https://www.w3.org/TR/rdf-canon/#dfn-canonicalized-dataset. It does not contain the input blank node identifier map, as n-quads inputs are not currently supported.

SimpleTripleStore

A minimal implementation of the ITripleStore interface that provides only graph management functionality.

StoreGraphPersistenceWrapper

The Store Graph Persistence Wrapper is a wrapper around another Graph that will be persisted to an underlying store via a provided IStorageProvider implementation.

StringExtensions

A collection of cross-target extensions to the string class.

SubTreeIndexedTripleCollection

An indexed triple collection that uses our VDS.Common.Collections.MultiDictionary<TKey, TValue> and VDS.Common.Trees.BinaryTree<TKey, TValue> implementations under the hood for the index structures.

SubjectComparer

Triple comparer which compares only on subjects.

SubjectObjectComparer

Triple comparer which compares on subjects and then objects.

SubjectPredicateComparer

Triple comparer which compares on subjects and then predicates.

ThreadSafeGraph

A Thread Safe version of the Graph class.

ThreadSafeGraphCollection

Thread Safe decorator around a Graph collection.

ThreadSafeQNameOutputMapper

Thread Safe version of the QNameOutputMapper.

ThreadSafeTripleCollection

Thread Safe decorator for triple collections.

ThreadSafeTripleStore

A thread safe variant of TripleStore, simply a TripleStore instance with a ThreadSafeGraphCollection decorator around it's underlying BaseGraphCollection.

Tools

Tools class which contains a number of utility methods which are declared as static methods.

TreeIndexedTripleCollection

An indexed triple collection that uses our VDS.Common.Collections.MultiDictionary<TKey, TValue> and VDS.Common.Trees.BinaryTree<TKey, TValue> implementations under the hood for the index structures.

Triple

Class for representing RDF Triples in memory.

TripleCollection

Basic Triple Collection which is not indexed.

TripleEventArgs

Event Arguments for Events regarding the assertion and retraction of Triples.

TripleNode

Class for representing RDF-star triple nodes.

TriplePersistenceAction

Represents a Triple that is queued for persistence (either insertion/deletion).

TripleRefs

Struct used for reference counting the quotation of triples in an RDF-star graph.

TripleStore

Class for representing Triple Stores which are collections of RDF Graphs.

TripleStoreEventArgs

Event Arguments for Events regarding Graphs.

TripleStoreExtensions

Provides useful Extension Methods for working with Triple Stores.

TripleStorePersistenceAction

Represents an action on a Triple Store that is queued for persistence.

UnionGraph

A Graph which represents the Union of several Graphs.

UnionTripleCollection

Represents a union of multiple Triple Collections.

UnregisteredRdfWriterTypeException

Class for errors in mapping an IRdfWriter instance to its associated MIME type for HTTP interactions.

UriFactory

A static helper class for interning URIs to reduce memory usage.

VariableContext

Represents the Variable Context for Triples.

VariableNode

Class representing Variable Nodes (only used for N3).

WebDemandGraphCollection

A decorator for graph collections where graphs not in the underlying graph collection can be loaded on-demand from the Web as needed.

WebDemandTripleStore

Class for representing Triple Stores which are collections of RDF Graphs.

WrapperGraph

Abstract decorator for Graphs to make it easier to layer functionality on top of existing implementations.

WrapperGraphCollection

Abstract decorator for Graph Collections to make it easier to add new functionality to existing implementations.

WrapperNode

Abstract decorator for Nodes to make it easier to layer functionality on top of existing implementations.

WrapperTripleCollection

Abstract decorator for Triple Collections to make it easier to add additional functionality to existing collections.

WrapperTripleStore

Abstract decorator for Triple Stores to make it easier to add new functionality on top of existing implementations.

Interfaces

ICommentRdfHandler

Interface for Handlers which are able to accept comments.

IInMemoryQueryableStore

Interface for Triple Stores which can be queried in memory using method calls or the SPARQL implementation contained in this library.

IInferencingTripleStore

Interface for Triple Stores which can have a IInferenceEngine attached to them.

INamespaceMapper

Interface for Namespace Maps which provide mappings between Namespace Prefixes and Namespace URIs.

INativelyQueryableStore

Interface for Triple Stores which can be queried natively i.e. the Stores provide their own SPARQL implementations.

INestedNamespaceMapper

A Namespace Mapper which has an explicit notion of Nesting.

INodeFactory

Interface for classes which can create Nodes.

IObjectParser<T>

Interface for parsers that generate objects of some sort.

IRdfHandler

Interface for Handlers which handle the RDF produced by parsers.

IRdfReader

Interface to be implemented by RDF Readers which parse Concrete RDF Syntax.

IRdfWriter

Interface to be implemented by RDF Writers which generate RDF Concrete Syntax.

IRefNode

A marker interface shared by nodes that act as references to resources.

ISparqlResultsHandler

Interface for Handlers which handle the SPARQL Results produced by parsers.

ISparqlResultsReader

Interface for Reader Classes which parser Sparql Result Set syntaxes into Result Set objects.

ISparqlResultsWriter

Interface for Writer classes which serialize Sparql Result Sets into concrete results set syntaxes.

ISparqlUpdateTripleStore

Interface for Triple Stores which support SPARQL Update as per the SPARQL 1.1 specifications.

IStoreReader

Interface to be implemented by Triple Store Readers.

IStoreWriter

Interface to be implemented by Triple Store Writers.

ITransactionalGraph

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.

ITripleContext

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.

ITripleIndex

Interface for classes that support retrieval of triples by one or more of their nodes.

ITripleNode

Interface for triple nodes.

ITripleStore

Interface for Triple Stores.

IUpdateableTripleStore

Interface for Triple Stores which support SPARQL Update as per the SPARQL 1.1 specifications.

IUriFactory

Defines the interface for a factory class that creates URIs and optionally interns them to reduce memory usage from repeated creation of URIs with the same string value.