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);
}