Refine search
private void createNewNamespaceObjects(List<String> newNamespaces) { for (String newNamespace : newNamespaces) { metadataModel.enterCriticalSection(Lock.WRITE); try { // make a new namespace object int id = 1; while (metadataModel.getIndividual(namespaceForNamespaceObjects+"ns"+id) != null) { id++; } Individual nsInd = metadataModel.createIndividual(namespaceForNamespaceObjects+"ns"+id,metadataModel.getResource(VitroVocabulary.NAMESPACE)); nsInd.addProperty(metadataModel.getProperty(VitroVocabulary.NAMESPACE_NAMESPACEURI), newNamespace); knownNamespaces.add(newNamespace); } finally { metadataModel.leaveCriticalSection(); } } }
public static void main(String[] args) { String sourceURL = "http://www.eswc2006.org/technologies/ontology"; String namespace = sourceURL + "#"; OntModel base = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM ); base.read( sourceURL, "RDF/XML" ); OntModel inf = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM_MICRO_RULE_INF, base ); OntClass paperClass = base.getOntClass( namespace + "Paper" ); Individual paper = base.createIndividual( namespace + "paper1", paperClass ); System.out.println("---- Assertions in the data ----"); for (Iterator<Resource> i = paper.listRDFTypes(false); i.hasNext(); ) { System.out.println( paper.getURI() + " is a " + i.next() ); } System.out.println("\n---- Inferred assertions ----"); paper = inf.getIndividual( namespace + "paper1" ); for (Iterator<Resource> i = paper.listRDFTypes(false); i.hasNext(); ) { System.out.println( paper.getURI() + " is a " + i.next() ); } }
public static void main( String[] args ) { final OntModel ontModel = ModelFactory.createOntologyModel( OntModelSpec.RDFS_MEM ); ontModel.setNsPrefix( "so", NS ); final OntClass classA = ontModel.createClass( NS+"A" ); final OntClass classB = ontModel.createClass( NS+"B" ); final OntClass classC = ontModel.createClass( NS+"C" ); final Individual x = ontModel.createIndividual( NS+"x", classA ); x.addRDFType( classB ); classC.createIndividual( NS+"x" ); ontModel.write( System.out, "RDF/XML" ); }
private Individual getAction(Individual stepInd) { log.debug("Workflow step: "+stepInd.getURI()); RDFNode actionNode = stepInd.getPropertyValue(WorkflowOntology.action); if (actionNode != null && actionNode.canAs(Individual.class)) { return (Individual) actionNode.as(Individual.class); } return null; }
@SuppressWarnings("unchecked") public static void printPropertyValues(final Individual ind, final Property prop) { System.out.print(ind.getLocalName() + " has " + prop.getLocalName() + "(s): "); final ExtendedIterator<RDFNode> rsc = ind.listPropertyValues(prop); @SuppressWarnings("rawtypes") final ExtendedIterator<? extends Resource> rsc2 = (ExtendedIterator) rsc; // Resource extends RDFNode printIterator(rsc2); }
model.setStrictMode(false); final DatatypeProperty dp = model.createDatatypeProperty(ns + "dp"); final ObjectProperty op = model.createObjectProperty(ns + "op"); final OntClass C = model.createClass(ns + "C"); final Literal one = model.createTypedLiteral("1", TypeMapper.getInstance().getTypeByName(XSD.positiveInteger.getURI())); a.addProperty(dp, one); model.prepare(); assertIteratorValues(a.listPropertyValues(dp), new Literal[] { one }); a.addProperty(op, anon1); model.prepare(); assertIteratorValues(a.listPropertyValues(op), new Resource[] { anon1 }); final Individual anon2 = model.createIndividual(C); anon2.addProperty(op, a); model.prepare(); assertIteratorValues(anon2.listPropertyValues(op), new Resource[] { a });
model.read(_base + "dl-safe.owl"); assertTrue(Abel.hasProperty(sibling, Cain)); assertIteratorValues(Abel.listPropertyValues(sibling), new Resource[] { Cain }); assertTrue(Cain.hasProperty(sibling, Abel)); assertIteratorValues(Cain.listPropertyValues(sibling), new Resource[] { Abel }); assertTrue(Cain.hasProperty(hates, Abel)); assertTrue(Cain.hasRDFType(Grandchild)); assertTrue(Cain.hasRDFType(BadChild)); assertFalse(Romulus.hasProperty(sibling, Remus)); assertTrue(Romulus.hasProperty(hates, Remus)); assertTrue(Romulus.hasRDFType(Grandchild)); assertFalse(Romulus.hasRDFType(BadChild)); assertTrue(Oedipus.hasRDFType(Child)); assertIteratorValues(Cain.listRDFTypes(true), new Object[] { BadChild, Child, Person });
String wt = workflowTemplateNS + wingsTemplate.getLocalName()+"_v"+versionNumber; Individual abstractTemplateInstance; Individual wtInstance = opmwModel.createClass(Constants.OPMW_WORKFLOW_TEMPLATE).createIndividual(wt); wtInstance.addLabel(wingsTemplate.getLocalName(), null); wtInstance.addLiteral(opmwModel.createProperty(Constants.OWL_VERSION_INFO), versionNumber); wtInstance.addLiteral(opmwModel.createProperty(Constants.OPMW_DATA_PROP_HAS_MD5), HashUtils.createMD5ForTemplate(wingsTemplate,this.wingsTemplateModel, this.componentCatalog.getWINGSDomainTaxonomy())); String domain = wingsTemplate.getNameSpace().split("/workflows/")[0]; domain = domain.substring(domain.lastIndexOf("/")+1); wtInstance.addLiteral(opmwModel.createProperty(Constants.OPMW_DATA_PROP_HAS_DOMAIN),domain); opmwModel.add(wtInstance,opmwModel.createProperty(Constants.OPMW_DATA_PROP_HAS_NATIVE_SYSTEM_TEMPLATE),wingsTemplate.getURI(),XSDDatatype.XSDanyURI); try{ Literal docContent = qs.getLiteral("?doc"); wtInstance.addLiteral(opmwModel.createProperty(Constants.OPMW_DATA_PROP_HAS_DOCUMENTATION), docContent); }catch(Exception e){} try{ Individual contributor = agentClass.createIndividual(Constants.PREFIX_EXPORT_RESOURCE+ Constants.CONCEPT_AGENT+"/"+URLEncoder.encode(""+contrib, "UTF-8")); contributor.addLabel(contrib); wtInstance.addProperty(opmwModel.createProperty(Constants.PROP_HAS_CONTRIBUTOR), contributor); }catch(Exception e){} try{ Literal timeLastModified = qs.getLiteral("?time");
@Test public void testUserDefinedFloatDatatypes() { final String ns = "http://www.lancs.ac.uk/ug/dobsong/owl/float_test.owl#"; final OntModel model = ModelFactory.createOntologyModel(PelletReasonerFactory.THE_SPEC); model.read(_base + "float_test.owl"); model.prepare(); assertTrue(model.validate().isValid()); final OntClass ThingWithFloatValue = model.getOntClass(ns + "ThingWithFloatValue"); final OntClass ThingWithFloatProbability = model.getOntClass(ns + "ThingWithProbabilityValue"); final Individual exampleThingWithFloatValue = model.getIndividual(ns + "exampleThingWithFloatValue"); final Individual exampleThingWithFloatProbability = model.getIndividual(ns + "exampleThingWithProbabilityValue"); assertTrue(ThingWithFloatValue.hasSubClass(ThingWithFloatProbability)); assertTrue(!ThingWithFloatProbability.hasSubClass(ThingWithFloatValue)); assertTrue(exampleThingWithFloatValue.hasRDFType(ThingWithFloatValue)); assertTrue(!exampleThingWithFloatValue.hasRDFType(ThingWithFloatProbability)); assertTrue(exampleThingWithFloatProbability.hasRDFType(ThingWithFloatValue)); assertTrue(exampleThingWithFloatProbability.hasRDFType(ThingWithFloatProbability)); }
@Test public void testIFDP3() { final String ns = "http://www.example.org/test#"; final OntModel model = ModelFactory.createOntologyModel(PelletReasonerFactory.THE_SPEC); final DatatypeProperty dp = model.createDatatypeProperty(ns + "dp"); dp.addRange(XSD.nonNegativeInteger); dp.convertToInverseFunctionalProperty(); final OntClass C = model.createClass(ns + "C"); C.addSuperClass(model.createMinCardinalityRestriction(null, dp, 1)); final Individual a = model.createIndividual(ns + "a", C); final Individual b = model.createIndividual(ns + "b", C); final Individual c = model.createIndividual(ns + "c", C); final Literal zero = model.createTypedLiteral(Integer.valueOf(0)); a.addProperty(dp, zero); b.addRDFType(model.createAllValuesFromRestriction(null, dp, XSD.nonPositiveInteger)); final Literal one = model.createTypedLiteral(Integer.valueOf(1)); c.addProperty(dp, one); model.prepare(); assertTrue(a.isSameAs(b)); assertTrue(b.isSameAs(a)); assertIteratorValues(a.listSameAs(), new Resource[] { a, b }); assertIteratorValues(b.listSameAs(), new Resource[] { a, b }); assertTrue(!c.isSameAs(a)); assertTrue(!c.isSameAs(b)); }
assertTrue(grandfather.hasRDFType(Person)); assertTrue(grandfather.hasRDFType(Male)); assertTrue(grandfather.hasRDFType(Senior)); assertTrue(grandfather.hasRDFType(PersonWithAtLeastTwoChildren)); assertTrue(grandfather.hasRDFType(PersonWithAtLeastTwoMaleChildren)); assertTrue(grandfather.hasProperty(isMarriedTo, grandmother)); assertTrue(grandfather.hasProperty(hasChild, father)); assertTrue(grandfather.hasProperty(hasSon, father)); assertTrue(grandfather.isDifferentFrom(grandmother)); assertTrue(grandfather.isDifferentFrom(father)); assertTrue(grandfather.isDifferentFrom(mother)); assertTrue(grandfather.isDifferentFrom(son)); assertTrue(grandfather.isDifferentFrom(daughter)); assertTrue(grandmother.hasRDFType(Person)); assertTrue(grandmother.hasRDFType(Female)); assertTrue(grandmother.hasRDFType(Senior)); assertTrue(grandmother.hasProperty(isMarriedTo, grandfather)); assertTrue(grandmother.hasProperty(hasChild, father)); assertFalse(grandmother.hasProperty(hasSon, father)); assertTrue(father.hasRDFType(Person)); assertTrue(father.hasRDFType(Male)); assertTrue(father.hasRDFType(Adult)); assertTrue(father.hasProperty(hasParent, grandfather)); assertTrue(father.hasProperty(hasParent, grandmother)); assertTrue(father.hasProperty(hasFather, grandfather)); assertTrue(father.hasProperty(hasMother, grandmother)); assertTrue(father.hasProperty(hasChild, son));
@Test public void testBuiltinDatatypesWithHasValueRestriction() { final String ns = "urn:test:"; final Object[] datatypes = { XSD.anyURI, "http://www.w3.com", XSD.xboolean, "true", "1", XSD.xbyte, "8", XSD.date, "2004-03-15", XSD.dateTime, "2003-12-25T08:30:00", "2003-12-25T08:30:00.001", "2003-12-25T08:30:00-05:00", "2003-12-25T08:30:00Z", XSD.decimal, "3.1415292", XSD.xdouble, "3.1415292", "INF", "NaN", XSD.duration, "P8M3DT7H33M2S", "P1Y", "P1M", "P1Y2MT2H", XSD.xfloat, "3.1415292", "-1E4", "12.78e-2", "INF", "NaN", XSD.gDay, "---11", XSD.gMonth, "--02", XSD.gMonthDay, "--02-14", XSD.gYear, "0001", "1999", XSD.gYearMonth, "1972-08", XSD.xint, "77", XSD.integer, "77", XSD.xlong, "214", XSD.negativeInteger, "-123", XSD.nonNegativeInteger, "2", XSD.nonPositiveInteger, "0", XSD.positiveInteger, "500", XSD.xshort, "476", XSD.xstring, "Test", XSD.time, "13:02:00", }; for (int i = 0; i < datatypes.length;) { final Resource datatype = (Resource) datatypes[i++]; final OntModel model = ModelFactory.createOntologyModel(PelletReasonerFactory.THE_SPEC); final OntProperty p = model.createDatatypeProperty(ns + "prop"); p.addRange(datatype); final int start = i; while (i < datatypes.length && datatypes[i] instanceof String) { final Individual ind = model.createIndividual(ns + "testInd" + i, OWL.Thing); final Literal value = model.createTypedLiteral((String) datatypes[i], datatype.getURI()); ind.addProperty(p, value); final OntClass c = model.createClass(ns + "testCls" + i); c.addEquivalentClass(model.createHasValueRestriction(null, p, value)); i++; } model.prepare(); for (int j = start; j < i; j++) assertTrue(datatype.getLocalName() + " " + datatypes[j], model.getIndividual(ns + "testInd" + j).hasRDFType(model.getIndividual(ns + "testCls" + j))); } }
Set<String> classes = new HashSet<>(); Set<String> individuals = new HashSet<>(); Set<Triple> triples = model.getGraph().find(Triple.ANY).toSet(); ExtendedIterator<OntClass> itClass = model.listNamedClasses(); while (itClass.hasNext()) { classes.add(itClass.next().getURI()); ExtendedIterator<Individual> itIndividuals = model.listIndividuals(); while (itIndividuals.hasNext()) { individuals.add(itIndividuals.next().getURI());
@Test public void testDataPropCard2() { final String ns = "urn:test:"; final OntModel model = ModelFactory.createOntologyModel(PelletReasonerFactory.THE_SPEC); final DatatypeProperty prop = model.createDatatypeProperty(ns + "prop"); final OntClass C = model.createClass(ns + "C"); C.addSuperClass(model.createCardinalityRestriction(null, prop, 2)); final Individual x = model.createIndividual(ns + "x", C); x.addProperty(prop, "literal1"); x.addProperty(prop, "literal2"); x.addProperty(prop, "literal3"); assertTrue(!model.validate().isValid()); }
model.read(ont); model.prepare(); final OntClass Person = model.getOntClass("http://xmlns.com/foaf/0.1/Person"); final Property workHomepage = model.getProperty("http://xmlns.com/foaf/0.1/workInfoHomepage"); final Property foafName = model.getProperty("http://xmlns.com/foaf/0.1/name"); final String name = ((Literal) ind.getPropertyValue(foafName)).getString(); final Resource type = ind.getRDFType(); final Resource homepage = (Resource) ind.getPropertyValue(workHomepage);
@Test public void testIFDP1() { final String ns = "http://www.example.org/test#"; final OntModel model = ModelFactory.createOntologyModel(PelletReasonerFactory.THE_SPEC); final Individual a = model.createIndividual(ns + "a", OWL.Thing); final Individual b = model.createIndividual(ns + "b", OWL.Thing); final Individual c = model.createIndividual(ns + "c", OWL.Thing); final ObjectProperty op = model.createObjectProperty(ns + "op"); final DatatypeProperty dp = model.createDatatypeProperty(ns + "dp"); dp.convertToInverseFunctionalProperty(); a.addProperty(op, c); final Literal one = model.createTypedLiteral(Integer.valueOf(1)); a.addProperty(dp, one); b.addProperty(dp, one); model.prepare(); assertTrue(a.isSameAs(b)); assertIteratorValues(a.listSameAs(), new Resource[] { a, b }); assertTrue(b.hasProperty(op, c)); assertIteratorValues(b.listPropertyValues(op), new Resource[] { c }); }
if(cInstances.hasNext()){ Individual aux = (Individual) cInstances.next(); wingsCanonicalInstanceURI = aux.getURI(); wingsCanonicalInstanceName = aux.getLocalName(); catalogCanonicalInstance.addLabel(componentName, null); catalogCanonicalInstance.addProperty(localCatalog.createOntProperty(Constants.OWL_VERSION_INFO), ""+version); catalogCanonicalInstance.addProperty(localCatalog.createOntProperty(Constants.OPMW_DATA_PROP_HAS_MD5), HashUtils.MD5(componentName)); }else{ catalogCanonicalInstance.addLabel(wingsCanonicalInstanceName, null); catalogCanonicalInstance.addProperty(localCatalog.createOntProperty(Constants.OWL_VERSION_INFO), ""+version); switch (property.getURI()) { case Constants.WINGS_PROP_HAS_SOFTWARE_DEPENDENCY: catalogObj = copyObjectToCatalogAs(object, this.instanceCatalogURI+"SWDEP-"+catalogCanonicalInstance.getLocalName()); break; case Constants.WINGS_PROP_HAS_HARDWARE_DEPENDENCY: catalogObj = copyObjectToCatalogAs(object, this.instanceCatalogURI+"HWDEP-"+catalogCanonicalInstance.getLocalName()); break; default://no special name for the node. Possible problem if there are repeated bnodes catalogObj = copyObjectToCatalogAs(object, this.instanceCatalogURI+"A-"+new Date().getTime()+catalogCanonicalInstance.getLocalName()); break; catalogCanonicalInstance.addProperty(localCatalog.createOntProperty(property.getURI()), catalogObj); }catch(Exception e){ try{ catalogCanonicalInstance.addProperty(localCatalog.createOntProperty(property.getURI()), object);
@Ignore("Inverse functional datatype properties are only supported with asserted literals") @Test public void testIFDP2() { final String ns = "http://www.example.org/test#"; final OntModel model = ModelFactory.createOntologyModel(PelletReasonerFactory.THE_SPEC); model.setStrictMode(false); final DatatypeProperty p = model.createDatatypeProperty(ns + "p"); p.addRDFType(OWL.InverseFunctionalProperty); p.addRange(XSD.xboolean); final OntClass C = model.createClass(ns + "C"); C.addSuperClass(model.createCardinalityRestriction(null, p, 1)); final OntClass D = model.createClass(ns + "D"); final OntClass E = model.createClass(ns + "E"); D.addDisjointWith(E); final Individual i1 = model.createIndividual(ns + "i1", C); i1.addRDFType(D); final Individual i2 = model.createIndividual(ns + "i2", C); i2.addRDFType(D); final Individual i3 = model.createIndividual(ns + "i3", C); i3.addRDFType(E); model.prepare(); assertTrue(i1.isSameAs(i2)); assertIteratorValues(i1.listSameAs(), new Resource[] { i1, i2 }); assertTrue(!i1.isSameAs(i3)); assertFalse(i1.listProperties(p).hasNext()); assertFalse(i2.listProperties(p).hasNext()); assertFalse(i3.listProperties(p).hasNext()); }
Property namespaceURIProp = ontModel.getProperty(VitroVocabulary.NAMESPACE_NAMESPACEURI); ontModel.enterCriticalSection(Lock.WRITE); try { StmtIterator stmtIt = ontModel.listStatements((Resource)null,(Property)namespaceURIProp,ontModel.createLiteral(namespaceStr)); if (stmtIt.hasNext()) { Statement stmt = stmtIt.nextStatement(); namespaceInd = ontModel.createIndividual(ontModel.getResource(VitroVocabulary.NAMESPACE)); namespaceInd.addProperty(namespaceURIProp,namespaceStr); StmtIterator mappingStatementIt = namespaceInd.listProperties(ontModel.getProperty(VitroVocabulary.NAMESPACE_HASPREFIXMAPPING)); while (mappingStatementIt.hasNext()) { Statement stmt = mappingStatementIt.nextStatement(); oldMapping.remove(); Individual newMappingInd = ontModel.createIndividual(ontModel.getResource(VitroVocabulary.NAMESPACE_PREFIX_MAPPING)); newMappingInd.addProperty(ontModel.getProperty(VitroVocabulary.NAMESPACE_PREFIX),prefixStr); namespaceInd.addProperty(ontModel.getProperty(VitroVocabulary.NAMESPACE_HASPREFIXMAPPING),newMappingInd);
@Test public void testDifferentFrom1() { final String ns = "urn:test:"; final OntModel model = ModelFactory.createOntologyModel(PelletReasonerFactory.THE_SPEC); final OntClass C = model.createClass(ns + "C"); final OntClass D = model.createClass(ns + "D"); final Individual a = model.createIndividual(ns + "a", C); final Individual b = model.createIndividual(ns + "b", C); final Individual c = model.createIndividual(ns + "c", D); final Individual d = model.createIndividual(ns + "d", OWL.Thing); final ObjectProperty p = model.createObjectProperty(ns + "p"); C.addDisjointWith(D); a.addProperty(p, b); d.addRDFType(model.createAllValuesFromRestriction(null, p, OWL.Nothing)); model.prepare(); assertIteratorValues(a.listDifferentFrom(), new Resource[] { c, d }); assertIteratorValues(model.listSubjectsWithProperty(OWL.differentFrom, a), new Resource[] { c, d }); assertIteratorValues(b.listDifferentFrom(), new Resource[] { c }); assertIteratorValues(model.listSubjectsWithProperty(OWL.differentFrom, b), new Resource[] { c }); }