/// <summary>
/// Serializes the Schemas Configuration
/// </summary>
/// <param name="context">Serialization Context</param>
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
context.EnsureObjectFactory(typeof(FullTextObjectFactory));
INode schemaObj = context.NextSubject;
context.Graph.Assert(schemaObj, context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)), context.Graph.CreateUriNode(new Uri(FullTextHelper.ClassSchema)));
context.Graph.Assert(schemaObj, ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType), context.Graph.CreateLiteralNode(this.GetType().FullName + ", dotNetRDF.Query.FullText"));
}
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
if (this._manager is IConfigurationSerializable)
{
((IConfigurationSerializable)this._manager).SerializeConfiguration(context);
}
else
{
throw new dotSesameRepo.config.RepositoryConfigException("This Repository does not support serializing it's Configuration");
}
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public override void SerializeConfiguration(VDS.RDF.Configuration.ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
context.NextSubject = manager;
base.SerializeConfiguration(context);
if (this._dbport != VirtuosoManager.DefaultPort)
{
INode port = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPort);
context.Graph.Assert(new Triple(manager, port, context.Graph.CreateLiteralNode(this._dbport.ToString())));
}
}
public org.openrdf.model.Resource export(org.openrdf.model.Graph g)
{
SesameGraph temp = new SesameGraph(g);
if (this._repo is IConfigurationSerializable)
{
IUriNode subj = temp.CreateUriNode(new Uri("dotnetrdf:interop:sesame:repository:" + this._name));
ConfigurationSerializationContext context = new ConfigurationSerializationContext(temp);
context.NextSubject = subj;
((IConfigurationSerializable)this._repo).SerializeConfiguration(context);
return g.getValueFactory().createURI(subj.ToString());
}
else
{
throw new NotSupportedException("The underlying Repository does not support having it's Configuration serialized");
}
}
public void ConfigurationSerializationOperators()
{
List <ISparqlOperator> ops = new List <ISparqlOperator>()
{
new AdditionOperator(),
new DateTimeAddition(),
new TimeSpanAddition(),
new DivisionOperator(),
new MultiplicationOperator(),
new DivisionOperator(),
new SubtractionOperator(),
new DateTimeSubtraction(),
new TimeSpanSubtraction()
};
Graph g = new Graph();
ConfigurationSerializationContext context = new ConfigurationSerializationContext(g);
List <INode> nodes = new List <INode>();
foreach (ISparqlOperator op in ops)
{
INode opNode = g.CreateBlankNode();
context.NextSubject = opNode;
nodes.Add(opNode);
((IConfigurationSerializable)op).SerializeConfiguration(context);
}
for (int i = 0; i < ops.Count; i++)
{
INode opNode = nodes[i];
ISparqlOperator resultOp = ConfigurationLoader.LoadObject(g, opNode) as ISparqlOperator;
Assert.IsNotNull(resultOp, "Failed to load serialized operator " + ops[i].GetType().Name);
Assert.AreEqual(ops[i].GetType(), resultOp.GetType());
}
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
INode queryPath = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyQueryPath);
INode updatePath = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUpdatePath);
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._baseUri)));
context.Graph.Assert(new Triple(manager, queryPath, context.Graph.CreateLiteralNode(this._queryService)));
if (this._updateService != null)
{
context.Graph.Assert(new Triple(manager, updatePath, context.Graph.CreateLiteralNode(this._updateService)));
}
}
/// <summary>
/// Serializes the Endpoint's Configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public override void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode endpoint = context.NextSubject;
INode endpointClass = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassSparqlEndpoint);
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode endpointUri = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyEndpointUri);
INode defGraphUri = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyDefaultGraphUri);
INode namedGraphUri = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyNamedGraphUri);
context.Graph.Assert(new Triple(endpoint, rdfType, endpointClass));
context.Graph.Assert(new Triple(endpoint, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(endpoint, endpointUri, context.Graph.CreateUriNode(this.Uri)));
foreach (String u in this._defaultGraphUris)
{
context.Graph.Assert(new Triple(endpoint, defGraphUri, context.Graph.CreateUriNode(UriFactory.Create(u))));
}
foreach (String u in this._namedGraphUris)
{
context.Graph.Assert(new Triple(endpoint, namedGraphUri, context.Graph.CreateUriNode(UriFactory.Create(u))));
}
context.NextSubject = endpoint;
base.SerializeConfiguration(context);
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
//TODO: Serialize Load Mode here
if (this._endpoint is IConfigurationSerializable)
{
//Use the indirect serialization method
//Serialize the Endpoints Configuration
INode endpoint = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyEndpoint);
INode endpointObj = context.Graph.CreateBlankNode();
context.NextSubject = endpointObj;
((IConfigurationSerializable)this._endpoint).SerializeConfiguration(context);
//Link that serialization to our serialization
context.Graph.Assert(new Triple(manager, endpoint, endpointObj));
}
else
{
//Use the direct serialization method
INode endpointUri = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyEndpointUri);
INode defGraphUri = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyDefaultGraphUri);
INode namedGraphUri = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyNamedGraphUri);
context.Graph.Assert(new Triple(manager, endpointUri, context.Graph.CreateLiteralNode(this._endpoint.Uri.ToString())));
foreach (String u in this._endpoint.DefaultGraphs)
{
context.Graph.Assert(new Triple(manager, defGraphUri, context.Graph.CreateUriNode(new Uri(u))));
}
foreach (String u in this._endpoint.NamedGraphs)
{
context.Graph.Assert(new Triple(manager, namedGraphUri, context.Graph.CreateUriNode(new Uri(u))));
}
}
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
if (this._customConnString)
{
throw new DotNetRdfConfigurationException("Cannot serialize the configuration of a VirtuosoManager which was created with a custom connection string");
}
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._dbserver)));
if (this._dbport != DefaultPort)
{
INode port = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPort);
context.Graph.Assert(new Triple(manager, port, this._dbport.ToLiteral(context.Graph)));
}
if (!this._dbname.Equals(DefaultDB))
{
INode db = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyDatabase);
context.Graph.Assert(new Triple(manager, db, context.Graph.CreateLiteralNode(this._dbname)));
}
if (this._dbuser != null && this._dbpwd != null)
{
INode username = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUser);
INode pwd = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPassword);
context.Graph.Assert(new Triple(manager, username, context.Graph.CreateLiteralNode(this._dbuser)));
context.Graph.Assert(new Triple(manager, pwd, context.Graph.CreateLiteralNode(this._dbpwd)));
}
}
/// <summary>
/// Serializes the Configuration of the Manager
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
context.Graph.Assert(manager, rdfType, ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager));
context.Graph.Assert(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().ToString()));
context.Graph.Assert(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString()));
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public virtual void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode sqlManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassSqlManager);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
INode database = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyDatabase);
context.Graph.Assert(new Triple(manager, rdfType, sqlManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._dbserver)));
context.Graph.Assert(new Triple(manager, database, context.Graph.CreateLiteralNode(this._dbname)));
if (this._dbuser != null && this._dbpwd != null)
{
INode username = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUser);
INode pwd = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPassword);
context.Graph.Assert(new Triple(manager, username, context.Graph.CreateLiteralNode(this._dbuser)));
context.Graph.Assert(new Triple(manager, pwd, context.Graph.CreateLiteralNode(this._dbpwd)));
}
}
/// <summary>
/// Serializes the Optimisers Configuration
/// </summary>
/// <param name="context">Serialization Context</param>
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
context.EnsureObjectFactory(typeof(FullTextObjectFactory));
INode optObj = context.NextSubject;
context.Graph.Assert(optObj, context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)), ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassAlgebraOptimiser));
context.Graph.Assert(optObj, ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType), context.Graph.CreateLiteralNode(this.GetType().FullName + ", dotNetRDF.Query.FullText"));
if (this._provider is IConfigurationSerializable)
{
INode searcherObj = context.Graph.CreateBlankNode();
context.NextSubject = searcherObj;
((IConfigurationSerializable)this._provider).SerializeConfiguration(context);
context.Graph.Assert(optObj, context.Graph.CreateUriNode(new Uri(FullTextHelper.PropertySearcher)), searcherObj);
}
else
{
throw new DotNetRdfConfigurationException("Unable to serialize configuration for this Full Text Optimiser as the Search Provider used does not implement the required IConfigurationSerializable interface");
}
}
/// <summary>
/// Helper method which adds proxy configuration to serialization
/// </summary>
/// <param name="objNode">Object Node representing the <see cref="IGenericIOManager">IGenericIOManager</see> whose configuration is being serialized</param>
/// <param name="context">Serialization Context</param>
protected void SerializeProxyConfig(INode objNode, ConfigurationSerializationContext context)
{
#if !NO_PROXY
if (this._proxy != null)
{
INode proxy = context.NextSubject;
INode usesProxy = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyProxy);
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode proxyType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassProxy);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
INode user = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUser);
INode pwd = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPassword);
context.Graph.Assert(new Triple(objNode, usesProxy, proxy));
context.Graph.Assert(new Triple(proxy, rdfType, proxyType));
context.Graph.Assert(new Triple(proxy, server, context.Graph.CreateLiteralNode(this._proxy.Address.ToString())));
if (this._proxy.Credentials is NetworkCredential)
{
NetworkCredential cred = (NetworkCredential)this._proxy.Credentials;
context.Graph.Assert(new Triple(proxy, user, context.Graph.CreateLiteralNode(cred.UserName)));
context.Graph.Assert(new Triple(proxy, pwd, context.Graph.CreateLiteralNode(cred.Password)));
}
}
#endif
}
private void mnuSaveConnection_Click(object sender, EventArgs e)
{
if (this.ActiveMdiChild != null)
{
if (this.ActiveMdiChild is fclsGenericStoreManager || this.ActiveMdiChild is fclsSQLStoreManager)
{
Object manager;
if (this.ActiveMdiChild is fclsGenericStoreManager)
{
manager = ((fclsGenericStoreManager)this.ActiveMdiChild).Manager;
}
else if (this.ActiveMdiChild is fclsSQLStoreManager)
{
manager = ((fclsSQLStoreManager)this.ActiveMdiChild).Manager;
if (manager == null) return;
}
else
{
return;
}
if (manager is IConfigurationSerializable)
{
this.sfdConnection.Filter = Constants.RdfFilter;
if (this.sfdConnection.ShowDialog() == DialogResult.OK)
{
//Append to existing configuration file or overwrite?
ConfigurationSerializationContext context;
if (File.Exists(this.sfdConnection.FileName))
{
DialogResult result = MessageBox.Show("The selected connection file already exists - would you like to append this connection to that file? Click Yes to append to this file, No to overwrite and Cancel to abort", "Append Connection?", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
switch (result)
{
case DialogResult.Yes:
Graph g = new Graph();
FileLoader.Load(g, this.sfdConnection.FileName);
context = new ConfigurationSerializationContext(g);
break;
case DialogResult.No:
context = new ConfigurationSerializationContext();
break;
default:
return;
}
}
else
{
//Create new configuration file
context = new ConfigurationSerializationContext();
}
//Save the Connection
((IConfigurationSerializable)manager).SerializeConfiguration(context);
try
{
IRdfWriter writer = MimeTypesHelper.GetWriter(MimeTypesHelper.GetMimeType(Path.GetExtension(this.sfdConnection.FileName)));
writer.Save(context.Graph, this.sfdConnection.FileName);
}
catch (RdfWriterSelectionException)
{
CompressingTurtleWriter ttlwriter = new CompressingTurtleWriter(WriterCompressionLevel.High);
ttlwriter.Save(context.Graph, this.sfdConnection.FileName);
}
}
}
else
{
MessageBox.Show("Unable to save the current connection as it does not support this feature", "Save Unavailable", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
else
{
this.mnuSaveConnection.Enabled = false;
}
}
else
{
this.mnuSaveConnection.Enabled = false;
}
}
private INode AddConnection(IGraph config, IGenericIOManager manager, String persistentFile)
{
if (config == null) return null;
ConfigurationSerializationContext context = new ConfigurationSerializationContext(config);
if (manager is IConfigurationSerializable)
{
INode objNode = context.Graph.CreateUriNode(new Uri("dotnetrdf:storemanager:" + DateTime.Now.ToString("yyyyMMddhhmmss")));
context.NextSubject = objNode;
((IConfigurationSerializable)manager).SerializeConfiguration(context);
if (persistentFile != null)
{
try
{
//Persist the graph to disk
CompressingTurtleWriter ttlwriter = new CompressingTurtleWriter();
ttlwriter.Save(config, persistentFile);
}
catch (Exception ex)
{
MessageBox.Show("Unable to persist a Connections File to disk", "Internal Error", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
return objNode;
}
return null;
}
/// <summary>
/// Serializes the endpoints Credential and Proxy information
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public virtual void SerializeConfiguration(ConfigurationSerializationContext context)
{
#if !NO_PROXY
if (this._credentials != null || this._proxy != null)
#else
if (this._credentials != null)
#endif
{
INode endpoint = context.NextSubject;
INode user = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUser);
INode pwd = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPassword);
if (this._credentials != null)
{
context.Graph.Assert(new Triple(endpoint, user, context.Graph.CreateLiteralNode(this._credentials.UserName)));
context.Graph.Assert(new Triple(endpoint, pwd, context.Graph.CreateLiteralNode(this._credentials.Password)));
#if !NO_PROXY
if (this._useCredentialsForProxy)
{
INode useCreds = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUseCredentialsForProxy);
context.Graph.Assert(new Triple(endpoint, useCreds, this._useCredentialsForProxy.ToLiteral(context.Graph)));
}
#endif
}
#if !NO_PROXY
if (this._proxy != null)
{
INode proxy = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode proxyType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassProxy);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
context.Graph.Assert(new Triple(proxy, rdfType, proxyType));
context.Graph.Assert(new Triple(proxy, server, context.Graph.CreateLiteralNode(this._proxy.Address.ToString())));
if (!this._useCredentialsForProxy && this._proxy.Credentials != null)
{
if (this._proxy.Credentials is NetworkCredential)
{
NetworkCredential cred = (NetworkCredential)this._proxy.Credentials;
context.Graph.Assert(new Triple(proxy, user, context.Graph.CreateLiteralNode(cred.UserName)));
context.Graph.Assert(new Triple(proxy, pwd, context.Graph.CreateLiteralNode(cred.Password)));
}
}
}
#endif
}
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public virtual void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "label"));
INode dnrType = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyType));
INode genericManager = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.ClassStorageProvider));
INode server = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyServer));
INode store = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyStore));
INode loadMode = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyLoadMode));
//Add Core config
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._baseUri)));
context.Graph.Assert(new Triple(manager, store, context.Graph.CreateLiteralNode(this._ns)));
base.SerializeStandardConfig(manager, context);
}
/// <summary>
/// Serializes the Endpoint's Configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public override void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode endpointObj = context.NextSubject;
INode endpointClass = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassSparqlEndpoint);
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode endpoint = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyEndpoint);
context.Graph.Assert(new Triple(endpointObj, rdfType, endpointClass));
context.Graph.Assert(new Triple(endpointObj, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
foreach (SparqlRemoteEndpoint ep in this._endpoints)
{
//Serialize the child endpoint configuration
INode epObj = context.Graph.CreateBlankNode();
context.NextSubject = epObj;
ep.SerializeConfiguration(context);
//Link that serialization to this serialization
context.Graph.Assert(new Triple(endpointObj, endpoint, epObj));
}
}
internal static void SerializeConfiguration(this Analyzer analyzer, ConfigurationSerializationContext context)
{
context.EnsureObjectFactory(typeof(FullTextObjectFactory));
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode analyzerClass = context.Graph.CreateUriNode(new Uri(FullTextHelper.ClassAnalyzer));
INode analyzerObj = context.NextSubject;
Type t = analyzer.GetType();
if (t.GetConstructor(Type.EmptyTypes) != null || t.GetConstructor(new Type[] { typeof(Lucene.Net.Util.Version) }) != null)
{
context.Graph.Assert(analyzerObj, rdfType, analyzerClass);
context.Graph.Assert(analyzerObj, dnrType, context.Graph.CreateLiteralNode(t.FullName + ", Lucene.Net"));
}
else
{
throw new DotNetRdfConfigurationException("dotNetRDF.Query.FullText only supports automatically serializing configuration for Lucene analyzers that have an unparameterised constructor or a constructor that takes a Version parameter");
}
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context"></param>
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
INode enableUpdates = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyEnableUpdates);
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._baseUri)));
context.Graph.Assert(new Triple(manager, enableUpdates, this._updatesEnabled.ToLiteral(context.Graph)));
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public virtual void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
INode store = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyStore);
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._baseUri)));
context.Graph.Assert(new Triple(manager, store, context.Graph.CreateLiteralNode(this._store)));
if (this._username != null && this._pwd != null)
{
INode username = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUser);
INode pwd = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPassword);
context.Graph.Assert(new Triple(manager, username, context.Graph.CreateLiteralNode(this._username)));
context.Graph.Assert(new Triple(manager, pwd, context.Graph.CreateLiteralNode(this._pwd)));
}
base.SerializeProxyConfig(manager, context);
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
INode file = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyFromFile);
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(manager, file, context.Graph.CreateLiteralNode(this._filename)));
}
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode subj = context.NextSubject;
context.Graph.Assert(subj, context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)), ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassTripleStore));
context.Graph.Assert(subj, ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType), context.Graph.CreateLiteralNode(this._store.GetType().FullName));
}
/// <summary>
/// Serializes the Configuration of the Manager
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public virtual void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyGenericManager);
context.Graph.Assert(manager, rdfType, ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager));
context.Graph.Assert(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().ToString()));
context.Graph.Assert(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString()));
if (this._manager is IConfigurationSerializable)
{
INode managerObj = context.Graph.CreateBlankNode();
context.NextSubject = managerObj;
((IConfigurationSerializable)this._manager).SerializeConfiguration(context);
context.Graph.Assert(manager, genericManager, managerObj);
}
else
{
throw new DotNetRdfConfigurationException("Unable to serialize configuration as the underlying IGenericIOManager is not serializable");
}
}
public void WritingCollectionCompressionComplex1()
{
SparqlConnector connector = new SparqlConnector(new VDS.RDF.Query.SparqlRemoteEndpoint(new Uri("http://dbpedia.org/sparql")));
Graph g = new Graph();
g.NamespaceMap.AddNamespace("ex", new Uri("http://example.org/"));
g.NamespaceMap.AddNamespace("dnr", new Uri(ConfigurationLoader.ConfigurationNamespace));
INode n = g.CreateBlankNode();
g.Assert(g.CreateUriNode("ex:subj"), g.CreateUriNode("dnr:genericManager"), n);
ConfigurationSerializationContext sContext = new ConfigurationSerializationContext(g);
sContext.NextSubject = n;
connector.SerializeConfiguration(sContext);
CompressingTurtleWriterContext context = new CompressingTurtleWriterContext(g, Console.Out);
WriterHelper.FindCollections(context);
Assert.AreEqual(2, context.Collections.Count, "Expected 2 collections");
this.CheckCompressionRoundTrip(g);
}
internal static void SerializeConfiguration(this Directory directory, ConfigurationSerializationContext context)
{
context.EnsureObjectFactory(typeof(FullTextObjectFactory));
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode indexClass = context.Graph.CreateUriNode(new Uri(FullTextHelper.ClassIndex));
INode dirObj = context.NextSubject;
context.Graph.Assert(dirObj, rdfType, indexClass);
context.Graph.Assert(dirObj, context.Graph.CreateUriNode(new Uri(FullTextHelper.PropertyEnsureIndex)), (true).ToLiteral(context.Graph));
if (directory is RAMDirectory)
{
context.Graph.Assert(dirObj, dnrType, context.Graph.CreateLiteralNode(directory.GetType().FullName + ", Lucene.Net"));
}
else if (directory is FSDirectory)
{
context.Graph.Assert(dirObj, dnrType, context.Graph.CreateLiteralNode(typeof(FSDirectory).FullName + ", Lucene.Net"));
context.Graph.Assert(dirObj, ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyFromFile), context.Graph.CreateLiteralNode(((FSDirectory)directory).GetDirectory().FullName));
}
else
{
throw new DotNetRdfConfigurationException("dotNetRDF.Query.FullText only supports automatically serializing configuration for Lucene indexes that use RAMDirectory or FSDirectory currently");
}
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public override void SerializeConfiguration(ConfigurationSerializationContext context)
{
//Firstly need to ensure our object factory has been referenced
context.EnsureObjectFactory(typeof(AdoObjectFactory));
//Then serialize the actual configuration
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode manager = context.NextSubject;
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
INode db = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyDatabase);
INode encrypt = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyEncryptConnection);
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName + ", dotNetRDF.Data.Sql")));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._azureServer)));
context.Graph.Assert(new Triple(manager, db, context.Graph.CreateLiteralNode(this._db)));
context.Graph.Assert(new Triple(manager, encrypt, this._encrypt.ToLiteral(context.Graph)));
INode username = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUser);
INode pwd = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPassword);
context.Graph.Assert(new Triple(manager, username, context.Graph.CreateLiteralNode(this._azureUser)));
context.Graph.Assert(new Triple(manager, pwd, context.Graph.CreateLiteralNode(this._password)));
}
/// <summary>
/// Serializes the Configuration of the Dataset
/// </summary>
/// <param name="context">Serialization Context</param>
public virtual void SerializeConfiguration(ConfigurationSerializationContext context)
{
if (this._dataset is IConfigurationSerializable)
{
INode dataset = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode datasetClass = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassSparqlDataset);
INode usingDataset = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUsingDataset);
INode innerDataset = context.Graph.CreateBlankNode();
#if !SILVERLIGHT
String assm = Assembly.GetAssembly(this.GetType()).FullName;
#else
String assm = this.GetType().Assembly.FullName;
#endif
if (assm.Contains(",")) assm = assm.Substring(0, assm.IndexOf(','));
String effectiveType = this.GetType().FullName + (assm.Equals("dotNetRDF") ? String.Empty : ", " + assm);
context.Graph.Assert(dataset, rdfType, datasetClass);
context.Graph.Assert(dataset, dnrType, context.Graph.CreateLiteralNode(effectiveType));
context.Graph.Assert(dataset, usingDataset, innerDataset);
context.NextSubject = innerDataset;
((IConfigurationSerializable)this._dataset).SerializeConfiguration(context);
}
else
{
throw new DotNetRdfConfigurationException("Unable to serialize configuration as the inner dataset is now serializable");
}
}
public override void SerializeConfiguration(VDS.RDF.Configuration.ConfigurationSerializationContext context)
{
throw new NotImplementedException();
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
INode store = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyStore);
INode loadMode = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyLoadMode);
//Add Core config
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._baseUri)));
context.Graph.Assert(new Triple(manager, store, context.Graph.CreateLiteralNode(this._kb)));
//Add reasoning mode
if (this._reasoning != StardogReasoningMode.None) context.Graph.Assert(new Triple(manager, loadMode, context.Graph.CreateLiteralNode(this._reasoning.ToString())));
//Add User Credentials
if (this._username != null && this._pwd != null)
{
INode username = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUser);
INode pwd = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPassword);
context.Graph.Assert(new Triple(manager, username, context.Graph.CreateLiteralNode(this._username)));
context.Graph.Assert(new Triple(manager, pwd, context.Graph.CreateLiteralNode(this._pwd)));
}
}
/// <summary>
/// Serializes Configuration of this Provider
/// </summary>
/// <param name="context">Serialization Context</param>
public virtual void SerializeConfiguration(ConfigurationSerializationContext context)
{
context.EnsureObjectFactory(typeof(FullTextObjectFactory));
INode searcherObj = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode searcherClass = context.Graph.CreateUriNode(new Uri(FullTextHelper.ClassSearcher));
INode index = context.Graph.CreateUriNode(new Uri(FullTextHelper.PropertyIndex));
INode schema = context.Graph.CreateUriNode(new Uri(FullTextHelper.PropertySchema));
INode analyzer = context.Graph.CreateUriNode(new Uri(FullTextHelper.PropertyAnalyzer));
//Basic Properties
context.Graph.Assert(searcherObj, rdfType, searcherClass);
context.Graph.Assert(searcherObj, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName + ", dotNetRDF.Query.FullText"));
//Serialize and link the Index
INode indexObj = context.Graph.CreateBlankNode();
context.NextSubject = indexObj;
this._indexDir.SerializeConfiguration(context);
context.Graph.Assert(searcherObj, index, indexObj);
//Serialize and link the Schema
INode schemaObj = context.Graph.CreateBlankNode();
context.NextSubject = schemaObj;
if (this._schema is IConfigurationSerializable)
{
((IConfigurationSerializable)this._schema).SerializeConfiguration(context);
}
else
{
throw new DotNetRdfConfigurationException("Unable to serialize configuration for this Lucene Search Provider as the IFullTextSchema used does not implement the IConfigurationSerializable interface");
}
context.Graph.Assert(searcherObj, schema, schemaObj);
//Serialize and link the Analyzer
INode analyzerObj = context.Graph.CreateBlankNode();
context.NextSubject = analyzerObj;
this._analyzer.SerializeConfiguration(context);
context.Graph.Assert(searcherObj, index, analyzerObj);
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public override void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
INode catalog = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyCatalog);
INode store = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyStore);
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
if (this._catalog != null)
{
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._baseUri.Substring(0, this._baseUri.IndexOf("catalogs/")))));
context.Graph.Assert(new Triple(manager, catalog, context.Graph.CreateLiteralNode(this._catalog)));
}
else
{
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._baseUri)));
}
context.Graph.Assert(new Triple(manager, store, context.Graph.CreateLiteralNode(this._store)));
if (this._username != null && this._pwd != null)
{
INode username = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUser);
INode pwd = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPassword);
context.Graph.Assert(new Triple(manager, username, context.Graph.CreateLiteralNode(this._username)));
context.Graph.Assert(new Triple(manager, pwd, context.Graph.CreateLiteralNode(this._pwd)));
}
}
