/// <summary>
/// Updates a store asynchronously.
/// </summary>
/// <param name="storage">Storage Provider.</param>
/// <param name="updates">SPARQL Update.</param>
/// <param name="callback">Callback.</param>
/// <param name="state">State to pass to the callback.</param>
internal static void AsyncUpdate(this IUpdateableStorage storage, string updates, AsyncStorageCallback callback, object state)
{
Task.Factory.StartNew(() => Update(storage, updates)).ContinueWith(antecedent =>
callback(storage,
antecedent.IsFaulted
? new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, updates,
antecedent.Exception)
: new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, updates), state));
}
/// <summary>
/// Updates a store asynchronously
/// </summary>
/// <param name="storage">Storage Provider</param>
/// <param name="updates">SPARQL Update</param>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
internal static void AsyncUpdate(this IUpdateableStorage storage, String updates, AsyncStorageCallback callback, Object state)
{
AsyncUpdateDelegate d = new AsyncUpdateDelegate(Update);
d.BeginInvoke(storage, updates, r =>
{
try
{
d.EndInvoke(r);
callback(storage, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, updates), state);
}
catch (Exception e)
{
callback(storage, new AsyncStorageCallbackArgs(AsyncStorageOperation.SparqlUpdate, updates, e), state);
}
}, state);
}
internal static IGraph CreateUpdateControlledDataset(this SpinWrappedDataset queryModel)
{
IGraph dataset = queryModel._configuration;
IUpdateableStorage storage = queryModel.UnderlyingStorage;
if (!dataset.ContainsTriple(new Triple(RDFUtil.CreateUriNode(dataset.BaseUri), RDF.PropertyType, SD.ClassDataset)) && !dataset.ContainsTriple(new Triple(RDFUtil.CreateUriNode(dataset.BaseUri), RDF.PropertyType, RDFRuntime.ClassUpdateControlledDataset)))
{
throw new Exception("Invalid dataset to operate on : " + dataset.BaseUri.ToString());
}
// TODO ?See whether we should nest "transactions" or not? Currently not
if (dataset.ContainsTriple(new Triple(RDFUtil.CreateUriNode(dataset.BaseUri), RDF.PropertyType, RDFRuntime.ClassUpdateControlledDataset)))
{
return(dataset);
}
// creates the work Dataset
SpinDatasetDescription workingset = new SpinDatasetDescription();
workingset.BaseUri = UriFactory.Create(RDFRuntime.DATASET_NS_URI + Guid.NewGuid().ToString());
workingset.Assert(dataset.Triples);
INode datasetNode = RDFUtil.CreateUriNode(dataset.BaseUri);
INode workingsetNode = RDFUtil.CreateUriNode(workingset.BaseUri);
// adds workingset metadata
workingset.Retract(dataset.GetTriplesWithSubject(datasetNode));
workingset.Assert(workingsetNode, RDFRuntime.PropertyUpdatesGraph, workingsetNode);
workingset.Assert(workingsetNode, RDF.PropertyType, RDFRuntime.ClassUpdateControlledDataset);
workingset.Assert(workingsetNode, RDFRuntime.PropertyUpdatesDataset, datasetNode);
workingset.Assert(workingsetNode, DCTerms.PropertyCreated, DateTime.Now.ToLiteral(RDFUtil.nodeFactory));
queryModel._configuration = workingset;
queryModel.Initialise();
return(workingset);
}
internal static SpinDatasetDescription Load(IUpdateableStorage storage, Uri datasetUri = null, IEnumerable <Uri> graphsUri = null)
{
SpinDatasetDescription dataset;
if (datasetUri == null)
{
SparqlResultSet datasetDiscovery = (SparqlResultSet)storage.Query("SELECT ?dataset WHERE {?dataset a <" + SD.ClassDataset.Uri.ToString() + ">}");
int datasetCount = datasetDiscovery.Results.Count;
if (datasetCount > 1)
{
throw new Exception("More than one dataset has been found in the current storage provider. Please specify which to use through the datasetUri parameter.");
}
else if (datasetCount == 1)
{
datasetUri = ((IUriNode)datasetDiscovery.Results.FirstOrDefault().Value("dataset")).Uri;
}
else
{
datasetUri = UriFactory.Create(RDFRuntime.DATASET_NS_URI + Guid.NewGuid().ToString());
}
}
dataset = new SpinDatasetDescription(datasetUri);
storage.LoadGraph(dataset, datasetUri);
dataset.BaseUri = datasetUri;
Triple isUpdateControlledDataset = dataset.GetTriplesWithPredicate(RDFRuntime.PropertyUpdatesDataset).FirstOrDefault();
if (isUpdateControlledDataset != null)
{
dataset._sourceUri = ((IUriNode)isUpdateControlledDataset.Object).Uri;
}
else
{
dataset.Assert(RDFUtil.CreateUriNode(datasetUri), RDF.PropertyType, SD.ClassDataset);
}
return(dataset);
}
private static void Update(IUpdateableStorage storage, string updates)
{
storage.Update(updates);
}
public ZWaveNodeController(IUpdateableStorage tripleStore, ZWaveSerialController zwaveController)
{
_tripleStore = tripleStore;
_zwaveController = zwaveController;
}
/// <summary>
/// Inititalize a SpinWrapperDataset upon a storage engine using a RDF SparqlDataset definition.
/// </summary>
/// <param name="datasetUri"></param>
/// <param name="storage"></param>
public SpinWrappedDataset(Uri datasetUri, IUpdateableStorage storage)
{
Storage = storage;
Configuration = SpinDatasetDescription.Load(Storage, datasetUri);
Initialise();
}
/// <summary>
/// Inititalize a SpinWrapperDataset upon a storage engine using all the graphs in the store.
/// </summary>
/// <param name="storage"></param>
internal SpinWrappedDataset(IUpdateableStorage storage)
{
Storage = storage;
Configuration = SpinDatasetDescription.Load(Storage);
Initialise();
}
/// <summary>
/// Inititalize a SPIN model upon a storage engine using a RDF SparqlDataset definition composed of the specified graphs.
/// </summary>
/// <param name="datasetUri"></param>
/// <param name="storage"></param>
/// <param name="graphUris"></param>
public SpinWrappedDataset(Uri datasetUri, IUpdateableStorage storage, IEnumerable <Uri> graphUris)
{
Storage = storage;
Configuration = SpinDatasetDescription.Load(Storage, datasetUri, graphUris);
Initialise();
}
public ZWaveTripleCollector(ZWaveSerialController zwaveController, IUpdateableStorage tripleStore)
{
_zwaveController = zwaveController;
_zwaveController.FrameReceived += _zwaveController_FrameReceived;
_tripleStore = tripleStore;
}
