private boolean exists(ID subject, MappedClass mappedClass, UID context) { UID type = mappedClass.getUID(); if (type != null) { return connection.exists(subject, RDF.type, type, context, true); } return false; }
@Override public <T> List<T> findInstances(Class<T> clazz) { UID type = configuration.getMappedClass(clazz).getUID(); if (type != null) { Set<T> instances = new LinkedHashSet<T>(); findInstances(clazz, type, instances); return new ArrayList<T>(instances); } else { throw new IllegalArgumentException("No RDF type specified for " + clazz.getName()); } }
public ConfigurationOntology(Configuration configuration) { Set<UID> types = new HashSet<UID>(); Multimap<UID, UID> directSubtypes = MultimapFactory.<UID, UID> createWithSet(); Multimap<UID, UID> directSupertypes = MultimapFactory.<UID, UID> createWithSet(); for (MappedClass mappedClass : configuration.getMappedClasses()) { types.add(mappedClass.getUID()); for (MappedClass superClass : mappedClass.getMappedSuperClasses()) { directSupertypes.put(mappedClass.getUID(), superClass.getUID()); directSubtypes.put(superClass.getUID(), mappedClass.getUID()); } // ClassMapping classMapping = // mappedClass.getJavaClass().getAnnotation(ClassMapping.class); // if (!classMapping.parent().equals("")) { // UID parent = new UID(classMapping.parent()); // directSupertypes.put(mappedClass.getUID(), parent); // directSubtypes.put(parent, mappedClass.getUID()); // } } initializeTypeHierarchy(types, directSubtypes, directSupertypes); }
public SimpleConfiguration( ConverterRegistry converterRegistry, Set<MappedClass> mappedClasses) { this.converterRegistry = converterRegistry; this.mappedClasses = mappedClasses; for (MappedClass mappedClass : mappedClasses) { uidToMappedClass.put(mappedClass.getUID(), mappedClass); classToMappedClass.put(mappedClass.getJavaClass(), mappedClass); for (MappedClass superClass : mappedClass.getMappedSuperClasses()) { polymorphicClasses.add(superClass.getJavaClass()); } } }
private ID assignId(MappedClass mappedClass, BeanMap instance) { ID subject = createResource(mappedClass.getUID(), instance); setId(mappedClass, subject, instance); return subject; }
public MappedClassBuilder addProperties() { String ns = mappedClass.getUID().getNamespace(); for (Field field : mappedClass.getJavaClass().getDeclaredFields()) { if (!handled.contains(field.getName())) { Predicate predicate = new PredicateImpl("", ns, field.getName(), false); MappedPredicate mappedPredicate = new MappedPredicate(ns, predicate, null); addMappedPath(field, Collections.singletonList(mappedPredicate), predicate); } } return this; }
public MappedClassBuilder(MappedClass mappedClass) { this.mappedClass = Assert.notNull(mappedClass, "mappedClass"); this.defaultNamespace = mappedClass.getUID().getNamespace(); }
private Set<UID> getUIDs(Class<?>... classes) { Set<UID> uids = new HashSet<UID>(); for (Class<?> cl : classes) { uids.add(configuration.getMappedClass(cl).getUID()); } return uids; } }
public final void addClasses(Class<?>... classes) { for (Class<?> clazz : classes) { if (clazz.getAnnotation(ClassMapping.class) != null) { MappedClass mappedClass = mappedClassFactory.getMappedClass(clazz); if (mappedClass.getUID() != null) { ClassMapping classMapping = clazz.getAnnotation(ClassMapping.class); if (clazz.isEnum() && !classMapping.parent().equals(Object.class)) { MappedClass parentClass = mappedClassFactory.getMappedClass(classMapping .parent()); for (Object constant : clazz.getEnumConstants()) { UID instance = new UID(mappedClass.getClassNs(), ((Enum) constant).name()); addClass(instance, parentClass); } } addClass(mappedClass.getUID(), mappedClass); } for (MappedClass superClass : mappedClass.getMappedSuperClasses()) { polymorphicClasses.add(superClass.getJavaClass()); } mappedClasses.add(mappedClass); } else { throw new IllegalArgumentException("No @ClassMapping annotation for " + clazz.getName()); } } }
@Override @SuppressWarnings("unchecked") public ID getId(Object instance) { if (instance instanceof LID) { return identityService.getID((LID) instance); } else { MappedClass mappedClass = configuration.getMappedClass(getClass(assertMapped(instance))); if (instance.getClass().isEnum()) { return new UID(mappedClass.getUID().ns(), ((Enum) instance).name()); } else { BeanMap beanMap = toBeanMap(instance); return getId(mappedClass, beanMap); } } }
MappedClass mappedClass = configuration.getMappedClass(clazz); OWLClass owlClass = null; UID cuid = mappedClass.getUID(); if (cuid == null) { return null;
private Block handleRootPath(Path<?> path, Filters filters) { MappedClass mappedClass = configuration.getMappedClass(path.getType()); UID rdfType = mappedClass.getUID(); UID context = mappedClass.getContext(); QID pathNode = new QID(path.toString()); pathToMapped.put(path, pathNode); if (rdfType != null) { Collection<UID> types = ontology.getSubtypes(rdfType); if (types.size() > 1 && inferenceOptions.subClassOf()) { QID type = new QID(path + "_type"); filters.add(type.in(types)); return Blocks.pattern(pathNode, RDF.type, type); } else { if (context != null) { pathToContext.put(path, context); return Blocks.pattern(pathNode, RDF.type, rdfType, context); } else { return Blocks.pattern(pathNode, RDF.type, rdfType); } } } else { throw new IllegalArgumentException("No types mapped against " + path.getType().getName()); } }
@Test public void Default_Namespace_Available() { Configuration configuration = new DefaultConfiguration(TEST.NS, Entity.class); MappedClass mappedClass = configuration.getMappedClass(Entity.class); assertEquals(new UID(TEST.NS, Entity.class.getSimpleName()), mappedClass.getUID()); }
@Test public void GetMappedSubtypes() { MappedClass cl = configuration.getMappedClass(Entity1.class); assertEquals(getUIDs(Entity1.class, Entity2.class, Entity3.class), ontology.getSubtypes(cl.getUID())); cl = configuration.getMappedClass(Entity2.class); assertEquals(getUIDs(Entity2.class, Entity3.class), ontology.getSubtypes(cl.getUID())); cl = configuration.getMappedClass(Entity3.class); assertEquals(getUIDs(Entity3.class), ontology.getSubtypes(cl.getUID())); }
@Test public void GetMappedSupertypes() { MappedClass cl = configuration.getMappedClass(Entity3.class); assertEquals(getUIDs(Entity1.class, Entity2.class), ontology.getSupertypes(cl.getUID())); cl = configuration.getMappedClass(Entity2.class); assertEquals(getUIDs(Entity1.class), ontology.getSupertypes(cl.getUID())); cl = configuration.getMappedClass(Entity1.class); assertEquals(getUIDs(), ontology.getSupertypes(cl.getUID())); }
@SuppressWarnings("unchecked") private void toRDF(Object instance, ID subject, UID parentContext, MappedClass mappedClass, boolean update) { UID uri = mappedClass.getUID(); UID context = parentContext; if (!update && uri != null) {
@Test public void Without_namespace() { ConfigurationBuilder builder = new ConfigurationBuilder(); for (Class<?> cl : Arrays.<Class<?>> asList(Person.class, Department.class, Company.class, Labeled.class)) { builder.addClass(cl).addProperties(); } Configuration configuration = builder.build(); MappedClass person = configuration.getMappedClass(Person.class); String ns = "java:com.mysema.rdfbean.object.ConfigurationBuilderTest.Person#"; assertEquals(new UID(ns, "Person"), person.getUID()); assertEquals(new UID(ns, "labeled"), person.getMappedPath("labeled").getPredicatePath().get(0).getUID()); }
@Test public void UID_availability() { ConfigurationBuilder builder = new ConfigurationBuilder(); builder.addClass(Person.class); builder.addClass(Department.class); builder.addClass(Company.class); builder.addClass(Labeled.class); Configuration configuration = builder.build(); for (MappedClass mc : configuration.getMappedClasses()) { assertNotNull(mc.getUID()); } }