private static String getClassName(Class<?> cls, Model model) { if (cls != null) { ClassDescriptor cld = model.getClassDescriptorByName(cls.getName()); if (cld != null && !cld.isInterface()) { return cld.getName(); } } return ""; }
/** * Set the model to be used. * @param modelName the model to be used */ public void setModel(String modelName) { try { model = Model.getInstanceByName(modelName); } catch (Exception e) { throw new BuildException(e); } }
/** @param m The model to add. **/ public void addModel(Model m) { String name = m.getName(); models.put(name, m); }
/** * Get the ClassDescriptors for the all subclasses of a class * @param cld the parent ClassDescriptor * @return the ClassDescriptors of all descedents */ public Set<ClassDescriptor> getAllSubs(ClassDescriptor cld) { Set<ClassDescriptor> returnSubs = new TreeSet<ClassDescriptor>(); Set<ClassDescriptor> directSubs = getDirectSubs(cld); returnSubs.addAll(directSubs); for (ClassDescriptor sub : directSubs) { returnSubs.addAll(getAllSubs(sub)); } return returnSubs; }
/** * Save a model, in serialized form, to the specified directory * @param model the model * @param destDir the destination directory * @throws IOException if an error occurs */ public static void saveModel(Model model, File destDir) throws IOException { write(model.toString(), new File(destDir, getFilename(MODEL, model.getName()))); }
public void setUp() throws Exception { parser = new InterMineModelParser(); testModel = Model.getInstanceByName("testmodel"); emptyModel = new Model("testModel", "org.intermine.model.testmodel", Collections.EMPTY_SET); }
public void testGetClassDescriptorByName() throws MetaDataException { ClassDescriptor cld1 = cdMaker.makeClass("Class1"); ClassDescriptor cld2 = cdMaker.makeClass("Class2"); Model model = new Model("model", cdMaker.getPackageName(), Arrays.asList(cld1, cld2)); assertEquals(cld1, model.getClassDescriptorByName("Class1")); assertEquals(cld2, model.getClassDescriptorByName("Class2")); }
private void processAdditionalConverters(Attributes attrs) { String fullyQualifiedName = attrs.getValue("class-name"); String constraintPath = attrs.getValue("constraint-path"); String targetType = attrs.getValue("target-type"); String title = attrs.getValue("title"); String urlField = attrs.getValue("urlField"); ClassDescriptor typeCld = model.getClassDescriptorByName(targetType); if (typeCld == null) { LOG.warn("Invalid target type for additional converter: " + targetType); return; } try { new Path(model, constraintPath); } catch (PathException e) { LOG.warn("Can't add converter to bag-queries.xml, constraint-path '" + constraintPath + "' isn't in " + model.getName() + " model."); return; } Set<String> clds = new HashSet<String>(); clds.add(typeCld.getName()); for (ClassDescriptor cld : model.getAllSubs(typeCld)) { clds.add(cld.getName()); } AdditionalConverter additionalConverter = new AdditionalConverter(constraintPath, targetType, fullyQualifiedName, title, urlField); for (String nextCld : clds) { Util.addToSetMap(additionalConverters, TypeUtil.unqualifiedName(nextCld), additionalConverter); } }
private Map<String, InterMineBag> filterBagsByType(Map<String, InterMineBag> bags, String type, boolean onlyCurrent, boolean includeSupers) { Set<String> acceptableTypes = new HashSet<String>(); acceptableTypes.add(type); ClassDescriptor bagTypeCld = model.getClassDescriptorByName(type); if (bagTypeCld == null) { throw new NullPointerException("Could not find ClassDescriptor for name " + type); } for (ClassDescriptor cld : model.getAllSubs(bagTypeCld)) { acceptableTypes.add(cld.getUnqualifiedName()); } if (includeSupers) { for (ClassDescriptor cld : bagTypeCld.getAllSuperDescriptors()) { acceptableTypes.add(cld.getUnqualifiedName()); } } Map<String, InterMineBag> bagsOfType = new HashMap<String, InterMineBag>(); for (Map.Entry<String, InterMineBag> entry : bags.entrySet()) { InterMineBag bag = entry.getValue(); if (acceptableTypes.contains(bag.getType())) { if ((onlyCurrent && bag.isCurrent()) || !onlyCurrent) { bagsOfType.put(entry.getKey(), bag); } } } return bagsOfType; }
public void testFieldsInNonInterMineObject() throws Exception { Model model = Model.getInstanceByName("basicmodel"); ClassDescriptor cld = model.getClassDescriptorByName("SimpleObject"); assertEquals(3, cld.getAllFieldDescriptors().size()); assertEquals( new HashSet<String>(Arrays.asList("employee", "name")), model.getFieldDescriptorsForClass(SimpleObject.class).keySet()); }
public void testGetTopDownTraversal() throws Exception { Model model = Model.getInstanceByName("basicmodel"); ClassDescriptor im = model.getClassDescriptorByName("org.intermine.model.InterMineObject"); List<ClassDescriptor> actual = smallModel.getTopDownLevelTraversal(); assertEquals(smallModel.getClassDescriptorByName("A"), actual.get(1)); expected.add(smallModel.getClassDescriptorByName("B")); expected.add(smallModel.getClassDescriptorByName("G")); assertEquals(expected, new HashSet<ClassDescriptor>(actual.subList(2, 4))); expected.add(smallModel.getClassDescriptorByName("C")); expected.add(smallModel.getClassDescriptorByName("E")); expected.add(smallModel.getClassDescriptorByName("F")); assertEquals(expected, new HashSet<ClassDescriptor>(actual.subList(4, 7))); assertEquals(smallModel.getClassDescriptorByName("D"), actual.get(7));
/** * Create a new BagQueryHandler object. * * @param model * the Model to use when checking types */ public BagQueryHandler(Model model) { super(); this.model = model; this.pkg = model.getPackageName(); }
public void testAddAttribute() throws Exception { String modelStr = "<model name=\"testmodel\" package=\"org.intermine.model.testmodel\"><class name=\"org.intermine.model.testmodel.Secretary\" is-interface=\"false\"><attribute name=\"name\" type=\"java.lang.String\"/></class></model>"; Model model = parser.process(new StringReader(modelStr)); String addition = "<class name=\"org.intermine.model.testmodel.Secretary\" is-interface=\"false\"><attribute name=\"age\" type=\"java.lang.Integer\"/></class>"; Set additionClds = parser.generateClassDescriptors(new StringReader(addition), model.getPackageName()); String expected = "<model name=\"testmodel\" package=\"org.intermine.model.testmodel\"><class name=\"org.intermine.model.testmodel.Secretary\" is-interface=\"false\"><attribute name=\"name\" type=\"java.lang.String\"/><attribute name=\"age\" type=\"java.lang.Integer\"/></class></model>"; //assertXMLEqual(expected, xml); assertEquals(parser.process(new StringReader(expected)).getClassDescriptors(), ModelMerger.mergeModel(model, additionClds).getClassDescriptors()); }
public void testGetAllSubs() throws Exception { Model model = Model.getInstanceByName("basicmodel"); Set<ClassDescriptor> hasAddressCds = model.getClassDescriptorsForClass(org.intermine.model.basicmodel.Thing.class); assertEquals(1, hasAddressCds.size()); ClassDescriptor addressCld = (ClassDescriptor) hasAddressCds.iterator().next(); if (addressCld.getName() == "org.intermine.model.InterMineObject") { // we want org.intermine.model.basicmodel.HasAddress addressCld = (ClassDescriptor) hasAddressCds.iterator().next(); } Set<ClassDescriptor> resultCds = model.getAllSubs(addressCld); Set<String> expectedCdNames = new HashSet<String>(); expectedCdNames.add("org.intermine.model.basicmodel.Employable"); expectedCdNames.add("org.intermine.model.basicmodel.Address"); expectedCdNames.add("org.intermine.model.basicmodel.Employee"); expectedCdNames.add("org.intermine.model.basicmodel.Manager"); expectedCdNames.add("org.intermine.model.basicmodel.Department"); expectedCdNames.add("org.intermine.model.basicmodel.Contractor"); Set<String> resultCdNames = new HashSet<String>(); for (ClassDescriptor cld : resultCds) { resultCdNames.add(cld.getName()); } assertEquals(expectedCdNames, resultCdNames); }
/** * Test whether the given type can be added to this bag, type can be a * qualified or un-qualified string. * @param testType type to check * @return true if type can be added to the bag */ public boolean isOfType(String testType) { Model model = os.getModel(); // this method works with qualified and unqualified class names ClassDescriptor testCld = model.getClassDescriptorByName(testType); if (testCld == null) { throw new IllegalArgumentException("Class not found in model: " + testType); } Set<ClassDescriptor> clds = model.getClassDescriptorsForClass(testCld .getType()); for (ClassDescriptor cld : clds) { String className = cld.getName(); if (TypeUtil.unqualifiedName(className).equals(getType())) { return true; } } return false; }
public void testGetTopDownTraversalSimpleObjects() throws Exception { Model simpleObjectModel = getSimpleObjectModel(); List<ClassDescriptor> expected = new ArrayList<ClassDescriptor>(); expected.add(simpleObjectModel.getClassDescriptorByName("Simple")); expected.add(simpleObjectModel.getClassDescriptorByName("org.intermine.model.InterMineObject")); expected.add(simpleObjectModel.getClassDescriptorByName("A")); expected.add(simpleObjectModel.getClassDescriptorByName("B")); assertEquals(expected, simpleObjectModel.getTopDownLevelTraversal()); }
public void testGetDirectSubs() throws Exception { Model model = Model.getInstanceByName("basicmodel"); Set<ClassDescriptor> hasAddressCds = model.getClassDescriptorsForClass(org.intermine.model.basicmodel.Thing.class); assertEquals(1, hasAddressCds.size()); ClassDescriptor addressCld = (ClassDescriptor) hasAddressCds.iterator().next(); if (addressCld.getName() == "org.intermine.model.InterMineObject") { // we want org.intermine.model.basicmodel.HasAddress addressCld = (ClassDescriptor) hasAddressCds.iterator().next(); } Set<ClassDescriptor> resultCds = model.getDirectSubs(addressCld); Set<String> expectedCdNames = new HashSet<String>(); expectedCdNames.add("org.intermine.model.basicmodel.Employable"); expectedCdNames.add("org.intermine.model.basicmodel.Address"); expectedCdNames.add("org.intermine.model.basicmodel.Department"); Set<String> resultCdNames = new HashSet<String>(); for (ClassDescriptor cld : resultCds) { resultCdNames.add(cld.getName()); } assertEquals(expectedCdNames, resultCdNames); }
public void testGetClassDescriptorsForClass() throws Exception { Model model = Model.getInstanceByName("basicmodel"); Set<ClassDescriptor> cds = model.getClassDescriptorsForClass(org.intermine.model.basicmodel.Employee.class); Set<String> expectedCdNames = new HashSet<String>(); expectedCdNames.add("org.intermine.model.basicmodel.Employee"); Set<String> cdNames = new HashSet<String>(); for (ClassDescriptor cd: cds) { cdNames.add(cd.getName()); } assertEquals(expectedCdNames, cdNames); }
/** * Takes a Class, and generates a Map of all FieldDescriptors that are the class fields * or any of its parents. The Class may be a dynamic class - ie not in the model, although * at least one of its parents are in the model. * * @param c a Class * @return a Map of FieldDescriptor objects */ public Map<String, FieldDescriptor> getFieldDescriptorsForClass(Class<?> c) { synchronized (classToFieldDescriptorMap) { Map<String, FieldDescriptor> retval = classToFieldDescriptorMap.get(c); if (retval == null) { retval = new LinkedHashMap<String, FieldDescriptor>(); for (ClassDescriptor cld : getClassDescriptorsForClass(c)) { for (FieldDescriptor fd : cld.getFieldDescriptors()) { retval.put(fd.getName(), fd); } } classToFieldDescriptorMap.put(c, retval); } return retval; } }
if (!CLASS_KEYS.containsKey(model)) { ClassKeys theseKeys = new ClassKeysImpl(); for (ClassDescriptor cld : model.getTopDownLevelTraversal()) { String clsName = cld.getUnqualifiedName(); if (props.containsKey(cld.getUnqualifiedName())) { if (fld != null) { ClassKeyHelper.addKey(theseKeys, clsName, fld); for (ClassDescriptor subCld : model.getAllSubs(cld)) { ClassKeyHelper.addKey(theseKeys, subCld.getUnqualifiedName(), fld);