/** * Constructor * @param name the name to use for the primary key * @param fields a comma-delimited list of field names * @param cld the ClassDescriptor that this PrimaryKey refers to */ public PrimaryKey(String name, String fields, ClassDescriptor cld) { this.name = name; this.cld = cld; if (fields == null) { throw new NullPointerException("fields parameter cannot be null"); } String[] tokens = fields.split(","); for (int i = 0; i < tokens.length; i++) { String token = tokens[i].trim(); FieldDescriptor field = cld.getFieldDescriptorByName(token); if (field == null) { throw new IllegalArgumentException("No such field name " + token + " in class " + cld.getName() + " for primary key " + name); } if (field instanceof CollectionDescriptor) { throw new IllegalArgumentException("Field " + token + " in primary key " + cld.getName() + "." + name + " is a collection - must be an attribute " + "or a reference"); } fieldNames.add(token); } }
private void countAndStore(ObjectStore os, Model model, ClassDescriptor cld) throws ObjectStoreException { if (!classCountsMap.containsKey(cld.getName())) { int classCount = countClass(os, cld.getType()); LOG.info("Adding class count: " + cld.getUnqualifiedName() + " = " + classCount); classCountsMap.put(cld.getName(), new Integer(classCount)); // if this class is empty all subclasses MUST be empty as well if (classCount == 0) { for (ClassDescriptor subCld : model.getAllSubs(cld)) { if (!classCountsMap.containsKey(subCld.getName())) { classCountsMap.put(subCld.getName(), new Integer(classCount)); } } } } }
/** * Gets a ReferenceDescriptor for a field of the given name. Returns null if * not found. Does NOT look in any superclasses or interfaces. * * @param name the name of a ReferenceDescriptor to find * @return a ReferenceDescriptor */ public ReferenceDescriptor getReferenceDescriptorByName(String name) { return getReferenceDescriptorByName(name, false); }
/** * Throw a RuntimeException if the name parameter isn't an collection in the class set by * setClassName() in the Model set by setModel(). Returns immediately if the Model or the * className of this Item haven't been set. * * @param name the collection name */ protected void checkCollection(String name) { if (model == null || classDescriptor == null) { return; } if (classDescriptor.getCollectionDescriptorByName(name, true) == null) { throw new RuntimeException("class \"" + classDescriptor.getName() + "\" has no \"" + name + "\" collection"); } }
private Set<ClassDescriptor> findAllSuperDescriptors() { Set<ClassDescriptor> supers = new LinkedHashSet<ClassDescriptor>(); for (ClassDescriptor superCld : this.getSuperDescriptors()) { if (!superCld.getName().equals(INTERMINEOBJECT_NAME)) { supers.add(superCld); supers.addAll(superCld.getAllSuperDescriptors()); } } return supers; } }
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 ""; }
nonEmptyFieldsMap.put(cld.getName(), new HashSet<String>()); countAndStore(os, model, cld); int classCount = classCountsMap.get(cld.getName()).intValue(); if (classCount == 0) { continue; for (AttributeDescriptor att : cld.getAllAttributeDescriptors()) { String fieldName = att.getName(); if ("id".equals(fieldName)) { String clsFieldName = cld.getName() + "." + fieldName; if (doneFields.contains(clsFieldName) || ignoreFields.contains(clsFieldName)) { continue; Set<String> emptyAttributes = emptyAttributesMap.get(cld.getName()); if (emptyAttributes == null) { emptyAttributes = new HashSet<String>(); emptyAttributesMap.put(cld.getName(), emptyAttributes); fieldValuesMap.put(clsFieldName, fieldValues); LOG.info("Adding " + fieldValues.size() + " values for " + cld.getUnqualifiedName() + "." + fieldName); LOG.info("Too many values for " + cld.getUnqualifiedName() + "." + fieldName); for (ClassDescriptor superCld : cld.getAllSuperDescriptors()) { if (cld.equals(superCld) || superCld.getType().equals(InterMineObject.class)) {
if (cld.getModel().hasClassDescriptor(referencedType)) { referencedClassDesc = cld.getModel().getClassDescriptorByName(referencedType); + referencedType + "' in model while processing: '" + cld.getName() + "'." + name); reverseRefDesc = referencedClassDesc.getReferenceDescriptorByName(reverseRefName); if (reverseRefDesc == null) { reverseRefDesc = referencedClassDesc .getCollectionDescriptorByName(reverseRefName); + reverseRefName + "' in class " + referencedClassDesc.getName() + " while processing: " + getClassDescriptor().getName() + "." + getName()); throw new NonFatalMetaDataException("Reverse reference names do not match: " + reverseRefDesc.getReverseReferenceFieldName() + " and " + this.name + " (" + this.cld.getName() + ": " + this.toString() + ", " + referencedType + ": " + reverseRefDesc.toString() + ")"); if (!reverseRefDesc.referencedType.equals(this.cld.getName())) { modelSet = true; throw new NonFatalMetaDataException("Reverse reference types do not match: " + this.cld.getName() + ": " + this.toString() + ", " + referencedType + ": " + reverseRefDesc.toString());
/** * Creates a table name for a class descriptor * * @param cld ClassDescriptor * @return a valid table name */ public static String getTableName(ClassDescriptor cld) { return generateSqlCompatibleName(cld.getUnqualifiedName()); }
.append(terseClass(className)); if (superNames != null) { retval.append(" extends ").append(Util.join(terseClasses(superNames), ", ")); for (AttributeDescriptor desc : getAllAttributeDescriptors()) { ClassDescriptor cld = desc.getClassDescriptor(); table.addRow(new String[] {desc.getName(), terseClass(desc.getType()), (cld == this ? "" : "from " + terseClass(cld.getName()))}); for (ReferenceDescriptor desc : getAllReferenceDescriptors()) { ClassDescriptor cld = desc.getClassDescriptor(); table.addRow(new String[] {desc.getName(), terseClass(desc.getReferencedClassName()), (cld == this ? "" : "from " + terseClass(cld.getName()))}); for (CollectionDescriptor desc : getAllCollectionDescriptors()) { ClassDescriptor cld = desc.getClassDescriptor(); table.addRow(new String[] {desc.getName(), "collection of " + terseClass(desc.getReferencedClassName()), (cld == this ? "" : "from " + terseClass(cld.getName()))});
/** * Check that a class exists and has a field of the given name. If the either the class or * field aren't in the model this will write a warning to the log preceded by the give message * and throw a MetaDataException. If fieldName is null or an empty string just the class will * be tested. * @param model the data model * @param className the class to check in the model * @param fieldName check that className has a field with this name, can be null or empty string * @param message some text to precede the logged warning. * @throws MetaDataException if the the class or field name don't exist */ public static void checkFieldExists(Model model, String className, String fieldName, String message) throws MetaDataException { ClassDescriptor cld = model.getClassDescriptorByName(className); if (cld == null) { LOG.warn(message + " because " + className + " doesn't exist in model"); throw new MetaDataException(); } if (!StringUtils.isBlank(fieldName)) { if (cld.getFieldDescriptorByName(fieldName) == null) { LOG.warn(message + " because " + cld.getUnqualifiedName() + "." + fieldName + " doesn't exist in model"); throw new MetaDataException(); } } }
public void testGetAllAttributeDescriptors() throws Exception { // three superclass levels with one attribute each, getAllAttributeDescriptors on cld3 should return all 3 AttributeDescriptor atb1 = new AttributeDescriptor("att1", "java.lang.String"); ClassDescriptor cld1 = new ClassDescriptor("package.name.Class1", null, false, Collections.singleton(atb1), noRefs, noColls); AttributeDescriptor atb2 = new AttributeDescriptor("att2", "java.lang.String"); ClassDescriptor cld2 = new ClassDescriptor("package.name.Class2", "package.name.Class1", false, Collections.singleton(atb2), noRefs, noColls); AttributeDescriptor atb3 = new AttributeDescriptor("att3", "java.lang.String"); ClassDescriptor cld3 = new ClassDescriptor("package.name.Class3", "package.name.Class2", false, Collections.singleton(atb3), noRefs, noColls); new Model("test", "package.name", Arrays.asList(cld1, cld2, cld3)); FieldDescriptor id = cld3.getFieldDescriptorByName("id"); Set<FieldDescriptor> atts = new HashSet<FieldDescriptor>(Arrays.asList(atb3, atb2, atb1, id)); assertEquals(atts, cld3.getAllAttributeDescriptors()); }
/** * Find ClassDescriptor in set with given name. */ private static ClassDescriptor descriptorByName(Set<ClassDescriptor> clds, String name) { for (ClassDescriptor cld : clds) { if (cld.getName().equals(name)) { return cld; } } return null; } }
private static void verifyClassAndField(String className, String fieldName, Model model) { String checkFileMsg = "Please check modelUpdate.properties file"; if ("".equals(className)) { throw new BuildException("Class " + className + " can not be blank. " + checkFileMsg); } ClassDescriptor cd = model.getClassDescriptorByName(className); if (cd == null) { if (fieldName != null) { throw new BuildException("Class " + className + " containing " + fieldName + " not defined in the model " + model.getName() + ". " + checkFileMsg); } else { throw new BuildException("Class " + className + " not defined in the model " + model.getName() + ". " + checkFileMsg); } } if (fieldName != null) { if ("".equals(fieldName)) { throw new BuildException("Attribute " + fieldName + " in the class " + className + " can not be blank. " + checkFileMsg); } if (cd.getAttributeDescriptorByName(fieldName) == null && cd.getReferenceDescriptorByName(fieldName) == null && cd.getCollectionDescriptorByName(fieldName) == null) { throw new BuildException("The " + fieldName + " in the class " + className + " not defined in the model " + model.getName() + ". " + checkFileMsg); } } }
ClassDescriptor merge) throws ModelMergerException { Set<ReferenceDescriptor> newSet = new HashSet<ReferenceDescriptor>(); newSet.addAll(cloneReferenceDescriptors(original.getReferenceDescriptors())); for (ReferenceDescriptor merg : merge.getReferenceDescriptors()) { ReferenceDescriptor orig = original.getReferenceDescriptorByName(merg.getName()); if (orig != null) { String fldName = original.getName() + "." + orig.getName(); throw new ModelMergerException("type mismatch between reference types: " + fldName + ":" + merg.getReferencedClassName() + " != " String fldName = original.getName() + "." + orig.getName(); throw new ModelMergerException("mismatch between reverse reference field name: " + fldName + "<-" + merg.getReverseReferenceFieldName() + " != "
/** * {@inheritDoc} */ @Override public Set<Query> createPKQueriesForClass(InterMineObject obj, Source source, boolean queryNulls, ClassDescriptor cld) throws MetaDataException { if (hints.classNotExists(cld.getType())) { return Collections.emptySet(); } return super.createPKQueriesForClass(obj, source, queryNulls, cld); }
public void testFieldDescriptorByName() throws Exception { ClassDescriptor cld = new ClassDescriptor( "package.name.Class1", null, false, getAttributes(), getReferences(), getCollections()); cld.setAllFieldDescriptors(); assertNotNull(cld.getFieldDescriptorByName("atd1")); assertNotNull(cld.getFieldDescriptorByName("atd2")); assertNotNull(cld.getFieldDescriptorByName("rfd1")); assertNotNull(cld.getFieldDescriptorByName("rfd2")); assertNotNull(cld.getFieldDescriptorByName("cld1")); assertNotNull(cld.getFieldDescriptorByName("cld2")); }
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; }
Set<String> superClassNames = getSuperclassNames(); String name = className.substring(className.lastIndexOf(".") + 1); sb.append("{\"name\":\"") addFields(sb, getAllAttributeDescriptors()); sb.append("},\"references\":{"); addFields(sb, getAllReferenceDescriptors()); sb.append("},\"collections\":{"); addFields(sb, getAllCollectionDescriptors()); sb.append("}}"); return sb.toString();
private Vector<ClassAttributes> getClassAttributes(Model model, Class<?> baseClass) { Vector<ClassAttributes> attributes = decomposedClassesCache.get(baseClass); if (attributes == null) { LOG.info("decomposedClassesCache: No entry for " + baseClass + ", adding..."); attributes = new Vector<ClassAttributes>(); for (Class<?> cls : Util.decomposeClass(baseClass)) { ClassDescriptor cld = model.getClassDescriptorByName(cls.getName()); attributes.add(new ClassAttributes(cld.getUnqualifiedName(), cld .getAllAttributeDescriptors())); } decomposedClassesCache.put(baseClass, attributes); } return attributes; }