All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Please wait. This can take some minutes ...
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
edu.cornell.mannlib.vitro.webapp.utils.configuration.PropertyType Maven / Gradle / Ivy
/* $This file is distributed under the terms of the license in LICENSE$ */
package edu.cornell.mannlib.vitro.webapp.utils.configuration;
import static org.apache.jena.datatypes.xsd.XSDDatatype.XSDfloat;
import static org.apache.jena.datatypes.xsd.XSDDatatype.XSDstring;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.apache.jena.datatypes.RDFDatatype;
import org.apache.jena.datatypes.xsd.impl.RDFLangString;
import org.apache.jena.rdf.model.Literal;
import org.apache.jena.rdf.model.RDFNode;
import org.apache.jena.rdf.model.Statement;
/**
* An enumeration of the types of properties that the ConfigurationBeanLoader
* will support.
*
* Also, classes that represent the Java methods and RDF statements associated
* with those types.
*/
public enum PropertyType {
RESOURCE {
@Override
public PropertyStatement buildPropertyStatement(Statement s) {
return new ResourcePropertyStatement(s.getPredicate().getURI(), s
.getObject().asResource().getURI());
}
@Override
protected PropertyMethod buildPropertyMethod(Method method,
Property annotation) {
return new ResourcePropertyMethod(method, annotation);
}
},
STRING {
@Override
public PropertyStatement buildPropertyStatement(Statement s) {
return new StringPropertyStatement(s.getPredicate().getURI(), s
.getObject().asLiteral().getString());
}
@Override
protected PropertyMethod buildPropertyMethod(Method method,
Property annotation) {
return new StringPropertyMethod(method, annotation);
}
},
FLOAT {
@Override
public PropertyStatement buildPropertyStatement(Statement s) {
return new FloatPropertyStatement(s.getPredicate().getURI(), s
.getObject().asLiteral().getFloat());
}
@Override
protected PropertyMethod buildPropertyMethod(Method method,
Property annotation) {
return new FloatPropertyMethod(method, annotation);
}
};
public static PropertyType typeForObject(RDFNode object)
throws PropertyTypeException {
if (object.isURIResource()) {
return RESOURCE;
}
if (object.isLiteral()) {
Literal literal = object.asLiteral();
RDFDatatype datatype = literal.getDatatype();
if (datatype == null || datatype.equals(XSDstring) || datatype.equals(RDFLangString.rdfLangString)) {
return STRING;
}
if (datatype.equals(XSDfloat)) {
return FLOAT;
}
}
throw new PropertyTypeException("Unsupported datatype on object: "
+ object);
}
public static PropertyType typeForParameterType(Class parameterType)
throws PropertyTypeException {
if (Float.TYPE.equals(parameterType)) {
return FLOAT;
}
if (String.class.equals(parameterType)) {
return STRING;
}
if (!parameterType.isPrimitive()) {
return RESOURCE;
}
throw new PropertyTypeException(
"Unsupported parameter type on method: " + parameterType);
}
public static PropertyStatement createPropertyStatement(Statement s)
throws PropertyTypeException {
PropertyType type = PropertyType.typeForObject(s.getObject());
return type.buildPropertyStatement(s);
}
public static PropertyMethod createPropertyMethod(Method method,
Property annotation) throws PropertyTypeException {
Class parameterType = method.getParameterTypes()[0];
PropertyType type = PropertyType.typeForParameterType(parameterType);
return type.buildPropertyMethod(method, annotation);
}
protected abstract PropertyStatement buildPropertyStatement(Statement s);
protected abstract PropertyMethod buildPropertyMethod(Method method,
Property annotation);
public static abstract class PropertyStatement {
private final PropertyType type;
private final String predicateUri;
public PropertyStatement(PropertyType type, String predicateUri) {
this.type = type;
this.predicateUri = predicateUri;
}
public PropertyType getType() {
return type;
}
public String getPredicateUri() {
return predicateUri;
}
public abstract Object getValue();
}
public static class ResourcePropertyStatement extends PropertyStatement {
private final String objectUri;
public ResourcePropertyStatement(String predicateUri, String objectUri) {
super(RESOURCE, predicateUri);
this.objectUri = objectUri;
}
@Override
public String getValue() {
return objectUri;
}
}
public static class StringPropertyStatement extends PropertyStatement {
private final String string;
public StringPropertyStatement(String predicateUri, String string) {
super(STRING, predicateUri);
this.string = string;
}
@Override
public String getValue() {
return string;
}
}
public static class FloatPropertyStatement extends PropertyStatement {
private final float f;
public FloatPropertyStatement(String predicateUri, float f) {
super(FLOAT, predicateUri);
this.f = f;
}
@Override
public Float getValue() {
return f;
}
}
public static abstract class PropertyMethod {
protected final PropertyType type;
protected final Method method;
protected final String propertyUri;
protected final int minOccurs;
protected final int maxOccurs;
// Add cardinality values here! Final, with getters.
public PropertyMethod(PropertyType type, Method method,
Property annotation) {
this.type = type;
this.method = method;
this.propertyUri = annotation.uri();
this.minOccurs = annotation.minOccurs();
this.maxOccurs = annotation.maxOccurs();
checkCardinalityBounds();
}
private void checkCardinalityBounds() {
// This is where we check for negative values or out of order.
}
public Method getMethod() {
return method;
}
public Class getParameterType() {
return method.getParameterTypes()[0];
}
public String getPropertyUri() {
return propertyUri;
}
public int getMinOccurs() {
return minOccurs;
}
public int getMaxOccurs() {
return maxOccurs;
}
public void confirmCompatible(PropertyStatement ps)
throws PropertyTypeException {
if (type != ps.getType()) {
throw new PropertyTypeException(
"Can't apply statement of type " + ps.getType()
+ " to a method of type " + type);
}
}
public void invoke(Object instance, Object value)
throws PropertyTypeException {
try {
method.invoke(instance, value);
} catch (IllegalAccessException | IllegalArgumentException
| InvocationTargetException e) {
throw new PropertyTypeException("Property method failed.", e);
}
}
}
public static class ResourcePropertyMethod extends PropertyMethod {
public ResourcePropertyMethod(Method method, Property annotation) {
super(RESOURCE, method, annotation);
}
}
public static class StringPropertyMethod extends PropertyMethod {
public StringPropertyMethod(Method method, Property annotation) {
super(STRING, method, annotation);
}
}
public static class FloatPropertyMethod extends PropertyMethod {
public FloatPropertyMethod(Method method, Property annotation) {
super(FLOAT, method, annotation);
}
}
public static class PropertyTypeException extends Exception {
public PropertyTypeException(String message) {
super(message);
}
public PropertyTypeException(String message, Throwable cause) {
super(message, cause);
}
}
}