public void Run(IComponentsConfig config, string targetFile)
{
var rdfStore = new MemoryStore();
rdfStore.Add(new Statement(NS.CSO.classEntity, NS.Rdfs.subClassOf, NS.Rdfs.ClassEntity));
rdfStore.Add(new Statement(NS.CSO.interfaceEntity, NS.Rdfs.subClassOf, NS.Rdfs.ClassEntity));
var assemblyExtractor = new AssemblyMetadata();
assemblyExtractor.Extract(System.Web.HttpRuntime.BinDirectory, rdfStore);
var configExtractor = new WinterMetadata();
var baseUri = String.IsNullOrEmpty(BaseUri) ?
"file:///" + System.Web.HttpRuntime.AppDomainAppPath.Replace('\\', '/') + "#" :
BaseUri;
configExtractor.BaseNs = baseUri;
configExtractor.Extract(config, rdfStore);
using (RdfXmlWriter wr = new RdfXmlWriter(targetFile)) {
wr.BaseUri = NS.NrMeta;
wr.Namespaces.AddNamespace(NS.DotNet.Type, "type");
wr.Namespaces.AddNamespace(NS.DotNet.Property, "prop");
wr.Namespaces.AddNamespace(NS.NrMetaTerms, "nr");
wr.Write(rdfStore);
}
}
public static void Main()
{
// Create the instance data
MemoryStore dataModel = new MemoryStore();
BNode me = new BNode("me");
BNode you = new BNode("you");
Entity rdfType = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
Entity rdfsLabel = "http://www.w3.org/2000/01/rdf-schema#label";
Entity foafPerson = "http://xmlns.com/foaf/0.1/Person";
Entity foafAgent = "http://xmlns.com/foaf/0.1/Agent";
Entity foafName = "http://xmlns.com/foaf/0.1/name";
dataModel.Add(new Statement(me, rdfType, foafPerson));
dataModel.Add(new Statement(you, rdfType, foafPerson));
dataModel.Add(new Statement(me, foafName, (Literal)"John Doe"));
dataModel.Add(new Statement(you, foafName, (Literal)"Sam Smith"));
// Create the RDFS engine and apply it to the data model.
RDFS engine = new RDFS();
engine.LoadSchema(RdfReader.LoadFromUri(new Uri("http://xmlns.com/foaf/0.1/index.rdf")));
dataModel.AddReasoner(engine);
// Query the data model
// Ask for who are typed as Agents. Note that the people are
// typed as foaf:Person, and the schema asserts that foaf:Person
// is a subclass of foaf:Agent.
Console.WriteLine("Who are Agents?");
foreach (Entity r in dataModel.SelectSubjects(rdfType, foafAgent))
{
Console.WriteLine("\t" + r);
}
// Ask for the rdfs:labels of everyone. Note that the data model
// has foaf:names for the people, and the schema asserts that
// foaf:name is a subproperty of rdfs:label.
Console.WriteLine("People's labels:");
foreach (Statement s in dataModel.Select(new Statement(null, rdfsLabel, null)))
{
Console.WriteLine("\t" + s);
}
}
internal static Store resolve(Entity entity)
{
Store input = new MemoryStore();
input.Add(new Statement(entity, SemWebVocab.rdf_type, SemWebVocab.owl_thing));
return(new SADIService("http://sadiframework.org/resolver").invokeService(input));
}
public bool Add(SemWeb.Statement stmt)
{
if (stmt.Predicate == MetadataStore.Namespaces.Resolve("tiff:ImageWidth"))
{
if (width == null)
{
width = ((SemWeb.Literal)stmt.Object).Value;
}
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("tiff:ImageLength"))
{
if (height == null)
{
height = ((SemWeb.Literal)stmt.Object).Value;
}
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:PixelXDimension"))
{
width = ((SemWeb.Literal)stmt.Object).Value;
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:PixelYDimension"))
{
height = ((SemWeb.Literal)stmt.Object).Value;
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:ExposureTime"))
{
exposure = ((SemWeb.Literal)stmt.Object).Value;
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:ApertureValue"))
{
aperture = ((SemWeb.Literal)stmt.Object).Value;
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:FNumber"))
{
fnumber = ((SemWeb.Literal)stmt.Object).Value;
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:ISOSpeedRatings"))
{
iso_anon = stmt.Object;
}
else if (stmt.Subject == iso_anon && stmt.Predicate == MetadataStore.Namespaces.Resolve("rdf:li"))
{
iso_speed = ((SemWeb.Literal)stmt.Object).Value;
}
else if (add && stmt.Subject.Uri == null)
{
store.Add(stmt);
}
if (width == null || height == null || exposure == null || aperture == null || iso_speed == null)
{
return(true);
}
else
{
return(false);
}
}
public IActionResult SaveChanges(Post post)
{
if (post.Id == 0)
{
MemoryStore.Add(post);
return(CreatedAtAction(nameof(Get), new { Id = post.Id }));
}
MemoryStore.Update(post);
return(Ok());
}
public bool Add(Statement s)
{
// remove meta information
s = new Statement(s.Subject, s.Predicate, s.Object);
if (!m.Contains(s))
{
m.Add(s);
}
return(true);
}
private static void MergePredicates(MemoryStore store, string merged, string entity, params string[] others)
{
var groups = store
.Select(new Statement(null, entity, null))
.Select(statement => new
{
Main = statement,
Others = others
.Select(other => store.SelectSingle(new Statement(statement.Subject, other, null)))
.Where(other => other.HasValue)
.Select(other => other.Value)
.ToArray()
})
.Where(group => group.Others.Length > 0)
.ToArray();
//foreach (var group in groups)
//{
// store.Remove(group.Main);
// foreach (var other in group.Others)
// store.Remove(other);
//}
foreach (var group in groups)
{
var values = group.Others.Select(other => other.Object).Cast <Literal>().Select(GetLiteralValue).ToArray();
var uri = string.Join("/", new[] { group.Main.Object.Uri }.Concat(values));
store.Add(new Statement(group.Main.Subject, merged, new Entity(uri)));
var name = GetEntityName(store, new Uri(group.Main.Object.Uri));
if (values.Length > 0)
{
name = string.Format("{0} ({1})", name, string.Join(", ", values));
}
store.Add(new Statement(uri, foaf + "name", new Literal(name)));
}
Console.WriteLine("Merged to {0} statements.", store.StatementCount);
}
public static void Main()
{
MemoryStore store = new MemoryStore();
Entity computer = new Entity("http://example.org/computer");
Entity says = "http://example.org/says";
Entity wants = "http://example.org/wants";
Entity desire = new BNode();
Entity description = new Entity("http://example.org/description");
store.Add(new Statement(computer, says, (Literal)"Hello world!"));
store.Add(new Statement(computer, wants, desire));
store.Add(new Statement(desire, description, (Literal)"to be human"));
store.Add(new Statement(desire, RDF + "type", (Entity)"http://example.org/Desire"));
using (RdfWriter writer = new RdfXmlWriter(Console.Out)) {
writer.Namespaces.AddNamespace("http://example.org/", "ex");
writer.Write(store);
}
}
protected void LoadSchemaInfo(BaseDescriptor baseDescr, Entity subj, string defLabel, MemoryStore sink)
{
// avoid dup types
var typeSt = new Statement(subj, NS.Rdf.typeEntity, (Entity)baseDescr.RdfType);
if (!sink.Contains(typeSt))
{
sink.Add(typeSt);
}
string label = baseDescr.RdfsLabel != null ? baseDescr.RdfsLabel : defLabel;
// and multiple labels
if (!sink.Contains(new Statement(subj, NS.Rdfs.labelEntity, null)))
{
sink.Add(new Statement(subj, NS.Rdfs.labelEntity, new Literal(label)));
}
if (baseDescr.RdfsComment != null)
{
sink.Add(new Statement(subj, NS.Rdfs.commentEntity, new Literal(baseDescr.RdfsComment)));
}
}
public static void Main()
{
MemoryStore store = new MemoryStore();
Entity container = new Entity("http://www.example.org/#container");
store.Add(new Statement(container, RDF + "type", (Entity)(RDF + "Bag")));
store.Add(new Statement(container, RDF + "_3", (Literal)"Three"));
store.Add(new Statement(container, RDF + "_2", (Literal)"Two"));
store.Add(new Statement(container, RDF + "_1", (Literal)"One"));
// use the rdfs:member property to match for any rdf:_### predicates.
Entity rdfs_member = (Entity)(RDFS + "member");
using (RdfWriter writer = new N3Writer(Console.Out)) {
writer.Namespaces.AddNamespace(RDF, "rdf");
store.Select(new Statement(container, rdfs_member, null), writer);
}
foreach (Resource r in store.SelectObjects(container, rdfs_member))
{
Console.WriteLine(r);
}
}
private static void FilterDuplicates(MemoryStore store)
{
var statements = store
.Select(new Statement(null, null, null))
.GroupBy(statement => new { Subject = statement.Subject.Uri, Predicate = statement.Predicate.Uri })
.Select(group => group.First())
.ToArray();
store.Clear();
foreach (var statement in statements)
{
store.Add(statement);
}
Console.WriteLine("Filtered to {0} statements.", store.StatementCount);
}
private static void ParseFiles(MemoryStore store, Path cache)
{
Console.WriteLine("Searching cross-references...");
foreach (var statement in store.Select(new Statement(null, foaf + "page", null)).OrderBy(statement => statement.Subject.Uri))
{
var file = GetResourceCache(statement, cache);
if (file.Exists)
{
Console.WriteLine("\t{0}", GetEntityName(store, new Uri(statement.Subject.Uri)));
var document = new HtmlDocument();
document.Load(file.FullPath);
foreach (var node in document.DocumentNode.SelectNodes("//div[@id='bodyContent']/p//a[@href]"))
{
var uri = new Uri(new Uri(statement.Object.Uri), node.Attributes["href"].Value);
var tag = GetBeforeWords(node, 4).Concat(new[] { node.InnerText }).Concat(GetAfterWords(node, 4));
var predicate = StripNonAscii(string.Join("-", tag));
foreach (var stop in new[] { "&", "#", ";", ":", ",", ".", " ", "(", ")", "[", "]", "\"", "'", "$" })
{
predicate = predicate.Replace(stop, "");
}
predicate = myd + predicate;
var entity = store.SelectSingle(new Statement(null, foaf + "page", new Entity(uri.AbsoluteUri)));
if (entity.HasValue)
{
if (entity.Value.Subject != statement.Subject)
{
Console.WriteLine("\t\t[{0}] {1} = {2}", predicate, node.InnerText, uri.AbsoluteUri);
store.Add(new Statement(statement.Subject, new Entity(predicate), entity.Value.Subject));
}
}
else
{
//Console.WriteLine("\t\t[{0}] {1} = {2}", predicate, node.InnerText, uri.AbsoluteUri);
//store.Add(new Statement(statement.Subject, new Entity(predicate), new Entity(uri.AbsoluteUri)));
}
}
}
}
}
public void TestInitialize()
{
var memoryStore = new MemoryStore();
foreach (var testSetting in TestSettingFactory.CreateTestSettings1())
{
memoryStore.Add(testSetting.Name, testSetting.Value);
}
ConfigInfos = new[]
{
new ConfigInfo
{
DataStore = memoryStore,
Tags = new Dictionary <string, object>(),
ConfigType = typeof(TestConfig)
}
};
}
public void Init()
{
SourceNsHash = new Dictionary <string, IList <SourceDescriptor> >();
FieldSourceNsHash = new Dictionary <string, IList <SourceDescriptor> >();
FieldNsSourceHash = new Dictionary <SourceDescriptor, IDictionary <string, FieldDescriptor> >();
FieldNameSourceHash = new Dictionary <SourceDescriptor, IDictionary <string, FieldDescriptor> >();
EntityFieldHash = new Dictionary <FieldDescriptor, Entity>();
EntitySourceHash = new Dictionary <SourceDescriptor, Entity>();
SourceNameHash = new Dictionary <string, SourceDescriptor>();
SchemaStore = new MemoryStore();
for (int i = 0; i < Sources.Length; i++)
{
var descr = Sources[i];
AddToHashList(SourceNsHash, descr.Ns, descr);
var sourceEntity = new Entity(descr.Ns);
EntitySourceHash[descr] = sourceEntity;
SourceNameHash[descr.SourceName] = descr;
// fill schema
LoadSchemaInfo(descr, sourceEntity, descr.SourceName, SchemaStore);
var fieldNsHash = new Dictionary <string, FieldDescriptor>();
var fieldNameHash = new Dictionary <string, FieldDescriptor>();
for (int j = 0; j < descr.Fields.Length; j++)
{
var fldDescr = descr.Fields[j];
AddToHashList(FieldSourceNsHash, fldDescr.Ns, descr);
fieldNsHash[fldDescr.Ns] = descr.Fields[j];
fieldNsHash[fldDescr.FieldName] = fldDescr;
var fldEntity = new Entity(fldDescr.Ns);
EntityFieldHash[fldDescr] = fldEntity;
// fill schema
LoadSchemaInfo(fldDescr, fldEntity, fldDescr.FieldName, SchemaStore);
SchemaStore.Add(new Statement(fldEntity, NS.Rdfs.domainEntity, sourceEntity));
}
FieldNsSourceHash[descr] = fieldNsHash;
FieldNameSourceHash[descr] = fieldNameHash;
}
}
public void Add_Before_Registration_Uses_Default_Comparer_And_Succeeds_When_Keys_Match_But_Different_Objects()
{
// Arrange
var entity = new SomeEntityType {
GroupKey = "1", Id = Guid.NewGuid(), SomeString = "Hello", SomeInt = 1
};
var sameIdsEntity = new SomeEntityType {
GroupKey = entity.GroupKey, Id = entity.Id, SomeString = "World", SomeInt = 2
};
// Act
_sut.Add(entity);
_sut.Add(sameIdsEntity);
// Assert
_sut.Entities <SomeEntityType>().Count.Should().Be(2);
var entityFromStore = _sut.Entities <SomeEntityType>().First(x => x.Equals(entity));
var sameIdsEntityFromStore = _sut.Entities <SomeEntityType>().First(x => x.Equals(sameIdsEntity));
entityFromStore.Should().NotBeSameAs(sameIdsEntityFromStore);
}
public static void Main()
{
// Create the instance data
MemoryStore dataModel = new MemoryStore();
BNode paris = new BNode("paris");
BNode orleans = new BNode("orleans");
BNode chartres = new BNode("chartres");
BNode amiens = new BNode("amiens");
BNode blois = new BNode("blois");
BNode bourges = new BNode("bourges");
BNode tours = new BNode("tours");
BNode lemans = new BNode("lemans");
BNode angers = new BNode("angers");
BNode nantes = new BNode("nantes");
Entity oneway = new Entity("http://www.agfa.com/w3c/euler/graph.axiom#oneway");
Entity path = new Entity("http://www.agfa.com/w3c/euler/graph.axiom#path");
dataModel.Add(new Statement(paris, oneway, orleans));
dataModel.Add(new Statement(paris, oneway, chartres));
dataModel.Add(new Statement(paris, oneway, amiens));
dataModel.Add(new Statement(orleans, oneway, blois));
dataModel.Add(new Statement(orleans, oneway, bourges));
dataModel.Add(new Statement(blois, oneway, tours));
dataModel.Add(new Statement(chartres, oneway, lemans));
dataModel.Add(new Statement(lemans, oneway, angers));
dataModel.Add(new Statement(lemans, oneway, tours));
dataModel.Add(new Statement(angers, oneway, nantes));
// Create the inference rules by reading them from a N3 string.
string rules =
"@prefix : <http://www.agfa.com/w3c/euler/graph.axiom#>.\n" +
"\n" +
"{ ?a :oneway ?b } => { ?a :path ?b } .\n" +
"{ ?a :path ?b . ?b :path ?c . } => { ?a :path ?c } .\n";
// Create our question in the form of a statement to test.
Statement question = new Statement(paris, path, nantes);
// Create the Euler engine
Euler engine = new Euler(new N3Reader(new StringReader(rules)));
// First Method of Inference:
// Ask the engine whether there is a path from paris to nantes.
// The Prove method will return a list of proofs, or an empty
// array if it could not find a proof.
foreach (Proof p in engine.Prove(dataModel, new Statement[] { question }))
{
Console.WriteLine(p.ToString());
}
// Second Method of Inference:
// Apply the engine to the data model and then use the data
// model's Contains method to see if the statement is "in"
// the model + reasoning.
dataModel.AddReasoner(engine);
Console.WriteLine("Euler Says the Question is: " + dataModel.Contains(question));
}
