/// <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))); } }