public Resource getNestedUnder(Resource identity) { if (_model.contains(identity, Vertere.nest_under)) { return _model.getProperty(identity, Vertere.nest_under).getResource(); } else { return null; } }
public String getContainer(Resource identity) { if (_model.contains(identity, Vertere.container)) { return _model.getProperty(identity, Vertere.container).getString(); } else { return ""; } }
public String getBaseUri(Resource resource) { if (_model.contains(resource, Vertere.base_uri)) { return _model.getProperty(resource, Vertere.base_uri).getString(); } else { return null; } }
public Set<Model> getSubModelsOld() { if (subModels == null) { subModels = new HashSet<Model>(); Iterator<? extends ModelObject> iterator = getObjects().iterator(); while (iterator.hasNext()) { ModelObject modelObject = iterator.next(); if (subModels.isEmpty()) { SubModel subModel = new SubModel(this); subModels.add(subModel); addAll(modelObject, subModel); } else { boolean found = false; for (Model m : subModels) { if (m.contains(modelObject)) { found = true; break; } } if (!found) { SubModel subModel = new SubModel(this); subModels.add(subModel); addAll(modelObject, subModel); } } } for (Model subModel : subModels) { subModel.indexGuids(); } } return subModels; }
public Resource getSourceResource(Resource identity) { if (_model.contains(identity, Vertere.source_resource)) { return _model.getProperty(identity, Vertere.source_resource).getResource(); } else { return null; } }
public Resource getAlternativeIdentity(Resource resource) { if (_model.contains(resource, Vertere.alternative_identity)) { return _model.getProperty(resource, Vertere.identity).getResource(); } else { return null; } }
public String getRegexOutput(Resource resource) { if (_model.contains(resource, Vertere.regex_output)) { return _model.getProperty(resource, Vertere.regex_output).getString(); } else { return null; } }
/** * Determine whether the given property is recognized and treated specially by this reasoner. This * is a convenience packaging of a special case of getCapabilities. * * @param property the property which we want to ask the reasoner about, given as a Node since * this is part of the SPI rather than API * @return true if the given property is handled specially by the reasoner. */ @Override public boolean supportsProperty(Property property) { if (factory == null) return false; Model caps = factory.getCapabilities(); Resource root = caps.getResource(factory.getURI()); return caps.contains(root, ReasonerVocabulary.supportsP, property); }
public String getExpectedHeader() { if (_model.contains(_specResource, Vertere.expected_header)) { return _model.getProperty(_specResource, Vertere.expected_header).getString(); } else { return null; } }
public String getSalt(Resource resource) { if (_model.contains(resource, Vertere.salt)) { return _model.getProperty(resource, Vertere.salt).getString(); } else { return ""; } }
public String getGlue(Resource resource) { if (_model.contains(resource, Vertere.source_column_glue)) { return _model.getProperty(resource, Vertere.source_column_glue).getString(); } else { return ""; } }
public String getLanguage(Resource attribute) { if (_model.contains(attribute, Vertere.language)) { return _model.getProperty(attribute, Vertere.language).getString(); } else { return null; } }
int getSubstrLength(Resource resource) { if (_model.contains(resource, Vertere.substring_length)) { return _model.getProperty(resource, Vertere.substring_length).getInt(); } else { return -1; } }
public Resource getRelationshipObjectFrom(Resource relationship) { if (_model.contains(relationship, Vertere.object_from)) { return _model.getProperty(relationship, Vertere.object_from).getResource(); } else { return null; } }
int getSubstrStart(Resource resource) { if (_model.contains(resource, Vertere.substring_start)) { return _model.getProperty(resource, Vertere.substring_start).getInt(); } else { return -1; } }
public Resource getIdentity(Resource resource) { if (!_model.contains(resource, Vertere.identity)) { throw new RuntimeException( "Resource " + resource.getURI() + " does not contain an identity so cannot be created."); } return _model.getProperty(resource, Vertere.identity).getResource(); }
public String getRegexMatch(Resource resource) { if (_model.contains(resource, Vertere.regex_match)) { return _model.getProperty(resource, Vertere.regex_match).getString(); } else { return null; } }
/** Answer the subset of <code>classes</code> which have no superclass in <code>m</code>. */ private static Set<Resource> selectRootClasses(Model m, Set<RDFNode> classes) { Set<Resource> roots = new HashSet<Resource>(); for (Iterator<RDFNode> it = classes.iterator(); it.hasNext(); ) { Resource type = (Resource) it.next(); if (!m.contains(type, RDFS.subClassOf, (RDFNode) null)) roots.add(type); } return roots; }
public Property getRelationshipProperty(Resource relationship) { if (_model.contains(relationship, Vertere.property)) { Resource resource = _model.getProperty(relationship, Vertere.property).getResource(); return ResourceFactory.createProperty(resource.getURI()); } else { return null; } }
public RDFList getProcessingSteps(Resource identity) { if (_model.contains(identity, Vertere.process)) { Resource processResource = _model.getProperty(identity, Vertere.process).getResource(); RDFList processSteps = processResource.as(RDFList.class); return processSteps; } else { return null; } }
public RDFDatatype getDatatype(Resource attribute) { if (_model.contains(attribute, Vertere.datatype)) { Resource resource = _model.getProperty(attribute, Vertere.datatype).getResource(); RDFDatatype datatype = new BaseDatatype(resource.getURI()); return datatype; } else { return null; } }
/** * Check that a predicate for which no shortnames are defined in name map still gets a term * binding in the metadata. */ @Test public void testTermBindingsCoverAllPredicates() throws URISyntaxException { Resource thisPage = ResourceFactory.createResource("elda:thisPage"); String pageNumber = "1"; Bindings cc = new Bindings(); URI reqURI = new URI(""); // EndpointDetails spec = new EndpointDetails() { @Override public boolean isListEndpoint() { return true; } @Override public boolean hasParameterBasedContentNegotiation() { return false; } }; EndpointMetadata em = new EndpointMetadata(spec, thisPage, pageNumber, cc, reqURI); // PrefixMapping pm = PrefixMapping.Factory.create().setNsPrefix("this", "http://example.com/root#"); Model toScan = ModelIOUtils.modelFromTurtle(":a <http://example.com/root#predicate> :b."); toScan.setNsPrefixes(pm); Resource predicate = toScan.createProperty("http://example.com/root#predicate"); Model meta = ModelFactory.createDefaultModel(); Resource exec = meta.createResource("fake:exec"); ShortnameService sns = new StandardShortnameService(); // APIEndpoint.Request r = new APIEndpoint.Request( new Controls(), reqURI, cc ); CompleteContext c = new CompleteContext(CompleteContext.Mode.PreferPrefixes, sns.asContext(), pm) .include(toScan); em.addTermBindings(toScan, meta, exec, c); @SuppressWarnings("unused") Map<String, String> termBindings = c.Do(); Resource tb = meta.listStatements(null, API.termBinding, Any).nextStatement().getResource(); assertTrue(meta.contains(tb, API.label, "this_predicate")); assertTrue(meta.contains(tb, API.property, predicate)); }
public int[] getSourceColumns(Resource resource) { if (_model.contains(resource, Vertere.source_column)) { Statement sourceColumn = _model.getProperty(resource, Vertere.source_column); return new int[] {sourceColumn.getInt()}; } else if (_model.contains(resource, Vertere.source_columns)) { Statement sourceColumns = _model.getProperty(resource, Vertere.source_columns); Resource listResource = sourceColumns.getResource(); RDFList list = listResource.as(RDFList.class); List<RDFNode> javalist = list.asJavaList(); int[] sourceColumnNumbers = new int[javalist.size()]; for (int i = 0; i < javalist.size(); i++) { RDFNode node = javalist.get(i); Literal value = node.asLiteral(); sourceColumnNumbers[i] = value.getInt(); } return sourceColumnNumbers; } else { return new int[0]; } }
@Test public void testTermbindsIncludesMetaproperties() throws URISyntaxException { Integer totalResults = null; Resource thisMetaPage = createMetadata(false, totalResults); for (Property p : expectedTermboundProperties) { Model model = thisMetaPage.getModel(); if (!model.contains(null, API.property, p)) { fail("term bindings should include " + model.shortForm(p.getURI())); } } }
private void addAll(ModelObject modelObject, Model model) { if (!model.contains(modelObject)) { model.add(modelObject); modelObject.setModel(model); for (ModelObject refFrom : modelObject.getReferencesFrom()) { addAll(refFrom, model); } for (ModelObject refTo : modelObject.getReferencesTo()) { addAll(refTo, model); } } }
int[] getColumns(Resource test) { if (_model.contains(test, Vertere.column)) { NodeIterator listObjectsOfProperty = _model.listObjectsOfProperty(test, Vertere.column); List<RDFNode> toList = listObjectsOfProperty.toList(); int[] columns = new int[toList.size()]; for (int i = 0; i < toList.size(); i++) { columns[i] = toList.get(i).asLiteral().getInt(); } return columns; } else { return new int[0]; } }
public RDFNode lookup(Resource identity, String sourceValue) { if (!_model.contains(identity, Vertere.lookup)) { return null; } Resource lookupResource = _model.getProperty(identity, Vertere.lookup).getResource(); NodeIterator listObjectsOfProperty = _model.listObjectsOfProperty(lookupResource, Vertere.lookup_entry); while (listObjectsOfProperty.hasNext()) { RDFNode entry = listObjectsOfProperty.next(); Resource asResource = entry.asResource(); String key = _model.getProperty(asResource, Vertere.lookup_key).getString(); if (sourceValue.equals(key)) { return _model.getProperty(asResource, Vertere.lookup_value).getObject(); } } return null; }
static CuisineCodeImpl getCuisineCode(Resource resource, Model model) throws JastorException { if (!model.contains(resource, RDF.type, CuisineCode.TYPE)) return null; return new CuisineCodeImpl(resource, model); }
static ExtendedUserBehaviourImpl getExtendedUserBehaviour(Resource resource, Model model) throws JastorException { if (!model.contains(resource, RDF.type, ExtendedUserBehaviour.TYPE)) return null; return new ExtendedUserBehaviourImpl(resource, model); }
static ClassificationImpl getClassification(Resource resource, Model model) throws JastorException { if (!model.contains(resource, RDF.type, Classification.TYPE)) return null; return new ClassificationImpl(resource, model); }