public void addAnnotation(Class<?> annotation, URI uri) { if (annotation.getDeclaredMethods().length != 1) throw new IllegalArgumentException( "Must specify annotation method if multiple methods exist: " + annotation); addAnnotation(annotation.getDeclaredMethods()[0], uri); }
/** * @return <code>true</code> If the given type can be used as a concept * parameter. */ public boolean isNamedConcept(Class<?> type) { return mapper.findType(type) != null; }
protected RoleMapper createRoleMapper(ValueFactory vf) throws ObjectStoreConfigException { return new RoleMapper(vf); }
private Collection<Class<?>> findAllRoles(URI type) { Set<Class<?>> set = new HashSet<Class<?>>(); for (Class<?> role : findRoles(type)) { if (set.add(role)) { addInterfaces(set, role.getSuperclass()); addInterfaces(set, role.getInterfaces()); } } return set; }
private Class<?> resolveIndividualEntity(URI resource, Collection<URI> types) { Collection<Class<?>> roles = new ArrayList<Class<?>>(); roles = mapper.findIndividualRoles(resource, roles); roles = mapper.findRoles(types, roles); return resolveRoles(roles); }
private boolean recordAnonymous(Class<?> role, Class<?> elm, boolean isConcept) throws ObjectStoreConfigException { boolean recorded = false; for (Annotation ann : elm.getAnnotations()) { for (Method m : ann.annotationType().getDeclaredMethods()) { try { URI name = findAnnotation(m); if (name == null && m.isAnnotationPresent(Iri.class)) { addAnnotation(m); name = findAnnotation(m); } if (name == null) continue; Object value = m.invoke(ann); recorded |= recordAnonymous(role, isConcept, name, value); } catch (Exception e) { logger.error(e.getMessage(), e); continue; } } } return recorded; }
private void recordRole(Class<?> clazz, String uri, boolean concept) throws ObjectStoreConfigException { if (uri == null || uri.length() == 0) { if (clazz.isAnnotation()) { roleMapper.addAnnotation(clazz); } else if (isAnnotationPresent(clazz) || concept) { roleMapper.addConcept(clazz); } else { roleMapper.addBehaviour(clazz); } } else { if (clazz.isAnnotation()) { roleMapper.addAnnotation(clazz, new URIImpl(uri)); } else if (isAnnotationPresent(clazz) || concept) { roleMapper.addConcept(clazz, new URIImpl(uri)); } else { roleMapper.addBehaviour(clazz, new URIImpl(uri)); } } }
public Class<?> findInterfaceConcept(URI uri) { Class<?> concept = null; Class<?> mapped = null; Collection<Class<?>> rs = findAllRoles(uri); for (Class<?> r : rs) { URI type = findType(r); if (r.isInterface() && type != null) { concept = r; if (uri.equals(type)) { mapped = r; if (r.getSimpleName().equals(uri.getLocalName())) { return r; } } } } if (mapped != null) return mapped; if (concept != null) return concept; return null; }
if (bean.isDatatype()) continue; if (mapper.isRecordedConcept(bean.getURI(), cl)) continue; addBaseClass(bean); if (bean.getURI() == null) continue; if (mapper.isRecordedAnnotation(bean.getURI())) continue; String namespace = bean.getURI().getNamespace(); if (bean.isDatatype()) continue; if (mapper.isRecordedConcept(bean.getURI(), cl)) { if ("java:".equals(bean.getURI().getNamespace())) continue; if (isComplete(bean, mapper.findRoles(bean.getURI()), resolver)) continue;
public boolean isRecordedAnnotation(URI uri) { return findAnnotationMethod(uri) != null; }
private Class findJavaClass(URI uri) { if (uri.equals(RDF.XMLLITERAL)) return literals.findClass(uri); Class klass = roles.findConcept(uri, cl); if (klass != null) return klass; klass = findLoadedMethod(uri); if (klass != null) return klass; Method m = roles.findAnnotationMethod(uri); if (m != null) return m.getDeclaringClass(); return literals.findClass(uri); }
continue; if (!"java:".equals(uri.getNamespace()) && mapper.isRecordedConcept(uri, cl) && !isComplete(bean, mapper.findRoles(uri), resolver)) { resolver.ignoreExistingClass(uri); String ns = uri.getNamespace();
StringBuilder where = new StringBuilder(); select.append("SELECT REDUCED ?subj"); boolean namedTypePresent = mapper.isNamedTypePresent(); if (namedTypePresent) { select.append(" ?subj_class"); if (typed) { Collection<URI> types = new HashSet<URI>(); mapper.findSubTypes(concept, types); Iterator<URI> iter = types.iterator(); assert iter.hasNext();
public ClassResolver(RoleMapper mapper, ClassLoader cl) throws ObjectStoreConfigException { this(mapper, new PropertyMapper(cl, mapper.isNamedTypePresent()), cl); }
public Collection<Class<?>> findAdditionalRoles(Collection<Class<?>> classes) { if (intersections.isEmpty() && complementIDs.isEmpty() && complementClasses.isEmpty()) return classes; List<Class<?>> result; result = new ArrayList<Class<?>>(classes.size() * 2 + 2); result.addAll(classes); int before = result.size(); addIntersectionsAndComplements(result); int after = result.size(); if (before != after) { ArrayList<Class<?>> anonymous; anonymous = new ArrayList<Class<?>>(result.subList(before, after)); addImpliedRoles(anonymous, result); } return result; }
private void scanConceptsWithReflections() throws ObjectStoreConfigException { logger.debug("Search for concepts with reflections"); Set<URL> classpath = new HashSet<>(); classpath.addAll(ClasspathHelper.forClassLoader()); classpath.addAll(ClasspathHelper.forJavaClassPath()); classpath.addAll(ClasspathHelper.forManifest()); classpath.addAll(ClasspathHelper.forPackage("")); Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(classpath) .useParallelExecutor() .filterInputsBy(FilterBuilder.parsePackages("-java, -javax, -sun, -com.sun")) .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner())); Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(Iri.class, true); logger.debug("Search for concepts with reflections resulted in " + annotated.size() + " classes"); for (Class clazz : annotated) { logger.debug("Found concept class: " + clazz.getCanonicalName()); roleMapper.addConcept(clazz); } }
public RoleMapper clone() { try { RoleMapper cloned = (RoleMapper) super.clone(); cloned.roleMapper = roleMapper.clone(); cloned.instances = clone(instances); cloned.matches = matches.clone(); cloned.annotations = new HashMap<Method, URI>(annotations); cloned.annotationURIs = new HashMap<URI, Method>(annotationURIs); cloned.complementIDs = new ConcurrentHashMap<Class<?>, String>(complementIDs); cloned.complementClasses = new ConcurrentHashMap<Class<?>, Class<?>>(complementClasses); cloned.intersections = clone(intersections); cloned.conceptClasses = new HashSet<Class<?>>(conceptClasses); return cloned; } catch (CloneNotSupportedException e) { throw new AssertionError(); } }
public Class<?> resolveBlankEntity(Set<URI> types) { Class<?> proxy = multiples.get(types); if (proxy != null) return proxy; Collection<Class<?>> roles = new ArrayList<Class<?>>(); proxy = resolveRoles(mapper.findRoles(types, roles)); multiples.putIfAbsent(types, proxy); return proxy; }
public Collection<Class<?>> findIndividualRoles(URI instance, Collection<Class<?>> classes) { List<Class<?>> list = instances.get(instance); if (list != null) { classes.addAll(list); addImpliedRoles(list, classes); } list = new ArrayList<Class<?>>(); matches.findRoles(instance.stringValue(), list); classes.addAll(list); addImpliedRoles(list, classes); return classes; }
private void recordRole(Class<?> clazz, String uri, boolean concept) throws ObjectStoreConfigException { if (uri == null || uri.length() == 0) { if (clazz.isAnnotation()) { roleMapper.addAnnotation(clazz); } else if (isAnnotationPresent(clazz) || concept) { roleMapper.addConcept(clazz); } else { roleMapper.addBehaviour(clazz); } } else { if (clazz.isAnnotation()) { roleMapper.addAnnotation(clazz, new URIImpl(uri)); } else if (isAnnotationPresent(clazz) || concept) { roleMapper.addConcept(clazz, new URIImpl(uri)); } else { roleMapper.addBehaviour(clazz, new URIImpl(uri)); } } }