internal static void SerializeConfiguration(this Directory directory, ConfigurationSerializationContext context)
{
context.EnsureObjectFactory(typeof(FullTextObjectFactory));
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode dnrType = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyType));
INode indexClass = context.Graph.CreateUriNode(UriFactory.Create(FullTextHelper.ClassIndex));
INode dirObj = context.NextSubject;
context.Graph.Assert(dirObj, rdfType, indexClass);
context.Graph.Assert(dirObj, context.Graph.CreateUriNode(UriFactory.Create(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, context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyFromFile)), context.Graph.CreateLiteralNode(((FSDirectory)directory).Directory.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 Configuration of the Dataset
/// </summary>
/// <param name="context">Serialization Context</param>
public override void SerializeConfiguration(ConfigurationSerializationContext context)
{
if (this._dataset is IConfigurationSerializable)
{
context.EnsureObjectFactory(typeof(FullTextObjectFactory));
INode dataset = context.NextSubject;
context.NextSubject = dataset;
//First get the base class to serialize the main configuration
base.SerializeConfiguration(context);
//Then add additional configuration to the serialization
if (this._indexer is IConfigurationSerializable)
{
INode indexer = context.NextSubject;
context.NextSubject = indexer;
context.Graph.Assert(dataset, context.Graph.CreateUriNode(UriFactory.Create(FullTextHelper.PropertyIndexer)), indexer);
context.Graph.Assert(dataset, context.Graph.CreateUriNode(UriFactory.Create(FullTextHelper.PropertyIndexNow)), this._indexNow.ToLiteral(context.Graph));
((IConfigurationSerializable)this._indexer).SerializeConfiguration(context);
}
else
{
throw new DotNetRdfConfigurationException("Unable to serialize configuration as the full text indexer is not serializable");
}
}
else
{
throw new DotNetRdfConfigurationException("Unable to serialize configuration as the inner dataset is not serializable");
}
}
/// <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 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(UriFactory.Create(RdfSpecsHelper.RdfType)), context.Graph.CreateUriNode(UriFactory.Create(FullTextHelper.ClassSchema)));
context.Graph.Assert(schemaObj, context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyType)), context.Graph.CreateLiteralNode(this.GetType().FullName + ", dotNetRDF.Query.FullText"));
}
/// <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(UriFactory.Create(RdfSpecsHelper.RdfType));
INode dnrType = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyType));
INode searcherClass = context.Graph.CreateUriNode(UriFactory.Create(FullTextHelper.ClassSearcher));
INode index = context.Graph.CreateUriNode(UriFactory.Create(FullTextHelper.PropertyIndex));
INode schema = context.Graph.CreateUriNode(UriFactory.Create(FullTextHelper.PropertySchema));
INode analyzer = context.Graph.CreateUriNode(UriFactory.Create(FullTextHelper.PropertyAnalyzer));
INode indexSync = context.Graph.CreateUriNode(UriFactory.Create(FullTextHelper.PropertyIndexSync));
//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);
//Serialize auto-sync settings
context.Graph.Assert(searcherObj, indexSync, this._autoSync.ToLiteral(context.Graph));
}
internal static void SerializeConfiguration(this Analyzer analyzer, ConfigurationSerializationContext context)
{
context.EnsureObjectFactory(typeof(FullTextObjectFactory));
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode dnrType = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyType));
INode analyzerClass = context.Graph.CreateUriNode(UriFactory.Create(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 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(UriFactory.Create(RdfSpecsHelper.RdfType)), context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.ClassAlgebraOptimiser)));
context.Graph.Assert(optObj, context.Graph.CreateUriNode(UriFactory.Create(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(UriFactory.Create(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");
}
}
