@Test
public void testGetResourceValueOPT3() throws SchemagenOptionsConfigurationException {
SchemagenOptions so0 = new SchemagenOptions();
SchemagenOptions so1 = new SchemagenOptions();
so0.setParent(so1);
Resource r0 = ResourceFactory.createResource("http://example.org/foo");
Resource r1 = ResourceFactory.createResource("http://example.org/bar");
so0.setOption(OPT.ROOT, r0);
so1.setOption(OPT.ROOT, r1);
assertEquals(r0, so0.getResource(OPT.ROOT));
}
@Test
public void testGetResourceValueOPT1() throws SchemagenOptionsConfigurationException {
SchemagenOptions so0 = new SchemagenOptions();
Resource r = ResourceFactory.createResource("http://example.org/foo");
so0.setOption(OPT.ROOT, r);
assertEquals(r, so0.getResource(OPT.ROOT));
}
protected BaseTestCaseResultImpl(String testCaseUri, RLOGLevel severity, String message) {
this(
ResourceFactory.createResource(),
testCaseUri,
severity,
message,
new XSDDateTime(Calendar.getInstance()));
}
@Test
public void testHasResourceValueOPT2() throws SchemagenOptionsConfigurationException {
SchemagenOptions so0 = new SchemagenOptions();
SchemagenOptions so1 = new SchemagenOptions();
so0.setParent(so1);
Resource r = ResourceFactory.createResource("http://example.org/foo");
so1.setOption(OPT.ROOT, r);
assertTrue(so0.hasResourceValue(OPT.ROOT));
}
@Cacheable("services")
public Optional<G4Service> getByIdentifier(String identifier) {
return datasource
.getOntModel()
.listIndividuals(DarkData.Visualization)
.toList()
.stream()
.filter(
i -> i.hasProperty(DCTerms.identifier, ResourceFactory.createTypedLiteral(identifier)))
.map(G4Service::new)
.findAny();
}
@Override
public String getString(final int index)
throws ReadDeniedException, AuthenticationRequiredException {
checkRead();
final String retval = holder.getBaseItem().getString(index);
checkRead(
new Triple(
holder.getBaseItem().asNode(),
RDF.li(index).asNode(),
ResourceFactory.createTypedLiteral(retval).asNode()));
return retval;
}
/** Test RDF model of a Context. */
@Test
public final void testRdfModel() {
final Context context =
new Context("My favorite actress is: Natalie Portman. She is very " + "stunning.", 0, 62);
final Sentence sentence = NullSentence.getInstance();
final Model model = ModelFactory.createDefaultModel();
context.addSentence(sentence);
final String nif = "http://persistence.uni-leipzig.org/nlp2rdf/ontologies/nif-core#";
final Map<String, String> prefixes = new HashMap<>();
prefixes.put("nif", nif);
final String base = "http://127.0.0.1/stanfordnlp#";
prefixes.put("local", base);
prefixes.put("xsd", "http://www.w3.org/2001/XMLSchema#");
model.setNsPrefixes(prefixes);
model.add(
ResourceFactory.createResource(base + "char=0,62"),
RDF.type,
ResourceFactory.createResource(nif + "String"));
model.add(
ResourceFactory.createResource(base + "char=0,62"),
RDF.type,
ResourceFactory.createResource(nif + "RFC5147String"));
model.add(
ResourceFactory.createResource(base + "char=0,62"),
RDF.type,
ResourceFactory.createResource(nif + "Context"));
model.add(
ResourceFactory.createResource(base + "char=0,62"),
ResourceFactory.createProperty(nif + "beginIndex"),
ResourceFactory.createTypedLiteral("0", XSDDatatype.XSDnonNegativeInteger));
model.add(
ResourceFactory.createResource(base + "char=0,62"),
ResourceFactory.createProperty(nif + "endIndex"),
ResourceFactory.createTypedLiteral("62", XSDDatatype.XSDnonNegativeInteger));
model.add(
ResourceFactory.createResource(base + "char=0,62"),
ResourceFactory.createProperty(nif + "isString"),
ResourceFactory.createTypedLiteral(
"My favorite actress is: Natalie Portman. She is very " + "stunning."));
Assert.assertTrue(
"Issue to create the model for a Context",
model.isIsomorphicWith(context.rdfModel("stanfordnlp", NlpProcess.POS)));
}
public class VocabPath {
public static final Resource start =
ResourceFactory.createProperty("http://ns.aksw.org/jassa/resource/start");
public static final Property joinsWith =
ResourceFactory.createProperty("http://ns.aksw.org/jassa/ontology/joinsWith");
}
private static Property property(String local) {
return ResourceFactory.createProperty(namespace, local);
}
private static Resource resource(String local) {
return ResourceFactory.createResource(namespace + local);
}
public class RdfTypeMap
// extends RdfPopulatorPropertyBase
extends RdfTypeComplexBase {
public static final Property entry =
ResourceFactory.createProperty("http://jsa.aksw.org/ontology/entry");
public static final Property key =
ResourceFactory.createProperty("http://jsa.aksw.org/ontology/key");
public static final Property value =
ResourceFactory.createProperty("http://jsa.aksw.org/ontology/value");
public static final Property keyClass =
ResourceFactory.createProperty("http://jsa.aksw.org/ontology/keyClass");
public static final Property valueClass =
ResourceFactory.createProperty("http://jsa.aksw.org/ontology/valueClass");
// protected MapOps mapOps;
protected Function<Object, Map> createMapView;
// , PropertyOps propertyOps, Node predicate, RdfType targetRdfType
public RdfTypeMap(Function<Object, Map> createMapView) {
/// super(typeFactory);
this.createMapView = createMapView;
}
@Override
public void exposeShape(ResourceShapeBuilder shapeBuilder) {
ResourceShapeBuilder tmp = shapeBuilder.out(entry.asNode());
tmp.out(key.asNode());
tmp.out(value.asNode());
}
@Override
public void emitTriples(
RdfEmitterContext emitterContext,
Object entity,
Node subject,
Graph shapeGraph,
Consumer<Triple> sink) {
@SuppressWarnings("unchecked")
Map<? super Object, ? super Object> map = createMapView.apply(entity);
int i = 1;
for (Entry<?, ?> e : map.entrySet()) {
Object k = e.getKey();
Object v = e.getValue();
Node eNode = NodeFactory.createURI(subject.getURI() + "-" + i);
// persistenceContext.
// persistenceContext.entityFor(new TypedNode(rdfType, node));
// Node kNode = null; // emitterContext.getValueNode(entity,
// propertyName)//RdfPersistenceContextImpl.getOrCreateRootNode(persistenceContext,
// typeFactory, k);
// Node vNode = null;
// //RdfPersistenceContextImpl.getOrCreateRootNode(persistenceContext, typeFactory, v);
// emitterContext.add(k, entity, "key" + i);
// emitterContext.add(v, entity, "value" + i);
// Node keyNode = emitterContext.
// Node kNode = emitterContext.getValueNode(entity, "key" + i, v);
// Node vNode = emitterContext.getValueNode(entity, "value" + i, v);
Node kNode = emitterContext.requestResolution(k);
Node vNode = emitterContext.requestResolution(v);
sink.accept(new Triple(subject, entry.asNode(), eNode));
sink.accept(new Triple(eNode, key.asNode(), kNode));
sink.accept(new Triple(eNode, value.asNode(), vNode));
++i;
}
}
@Override
public void populateEntity(
RdfPersistenceContext persistenceContext,
Object entity,
Node subject,
Graph graph,
Consumer<Triple> outSink) {
Model model = ModelFactory.createModelForGraph(graph);
RDFNode root = ModelUtils.convertGraphNodeToRDFNode(subject, model);
// <Object, Object>
Map map = createMapView.apply(entity);
for (Statement stmt : root.asResource().listProperties(entry).toList()) {
Resource e = stmt.getObject().asResource();
Node kNode = e.getProperty(key).getObject().asNode();
Node vNode = e.getProperty(value).getObject().asNode();
// TODO: We need to dynamically figure out which entity the node could be
RdfType rdfType = null;
Object k =
persistenceContext.entityFor(
Object.class, kNode, null); // new TypedNode(rdfType, kNode));
Object v =
persistenceContext.entityFor(
Object.class, vNode, null); // new TypedNode(rdfType, vNode));
map.put(k, v);
}
}
@Override
public Class<?> getEntityClass() {
// TODO Auto-generated method stub
return null;
}
@Override
public Node getRootNode(Object obj) {
// TODO Auto-generated method stub
return null;
}
@Override
public Object createJavaObject(Node node, Graph graph) {
@SuppressWarnings("rawtypes")
Map result = new HashMap();
return result;
}
@Override
public boolean hasIdentity() {
// TODO Auto-generated method stub
return false;
}
// @Override
// public Object createJavaObject(Node node) {
// //entityOps.
// // TODO Auto-generated method stub
// return null;
// }
}
