public final String getSetterDAPStatement(DomainClass domainClass, String slotName, String typeName) { //System.out.println("\tGenerating setter DAP statement for " + domainClass.getFullName() + "." + slotName + " of type " + typeName); if (DAP_ENABLED) { return "pt.ist.dap.implementation.simple.SimpleContextManager.updateWriteStatisticsWithoutContext(\"" + domainClass.getFullName() + "\", \"" + slotName + "\");"; } else { return ""; } }
public final String getGetterDAPStatement(DomainClass domainClass, String slotName, String typeName) { //System.out.println("\tGenerating getter DAP statement for " + domainClass.getFullName() + "." + slotName + " of type " + typeName); if (DAP_ENABLED) { return "pt.ist.dap.implementation.simple.SimpleContextManager.updateReadStatisticsWithoutContext(\"" + domainClass.getFullName() + "\", \"" + slotName + "\");"; } else { return ""; } }
private static boolean isClass(final DomainClass domainClass, final Class<?> superClass) { return domainClass != null && domainClass.getFullName().equals(superClass.getName()); }
public void addClass(DomainClass domClass) { checkNotFinalized(); checkNameUnique(domClass.getFullName()); classes.put(domClass.getFullName(), domClass); }
/** Scans for domain classes annotated with @Indexed **/ private static Set<Class<?>> getIndexedDomainClasses() { Set<Class<?>> classList = new HashSet<Class<?>>(); for (DomainClass dc : FenixFramework.getDomainModel().getDomainClasses()) { try { Class<?> domainClass = Class.forName(dc.getFullName()); if (domainClass.getAnnotation(org.hibernate.search.annotations.Indexed.class) != null) { logger.trace("Indexing " + dc.getFullName()); classList.add(domainClass); } } catch (ClassNotFoundException e) { throw new RuntimeException(e); } } return classList; } }
private static void load() { startActivities = new HashMap<String, Activity<? extends Process>>(); final Collection<DomainClass> domainClasses = FenixFramework.getDomainModel().getDomainClasses(); for (final DomainClass domainClass : domainClasses) { try { final Class<?> clazz = Class.forName(domainClass.getFullName()); if (Process.class.isAssignableFrom(clazz) && !Modifier.isAbstract(clazz.getModifiers())) { final Activity<? extends Process> activity = getStartActivity((Class<? extends Process>) clazz); if (activity != null) { startActivities.put(domainClass.getFullName(), activity); } } } catch (Exception e) { logger.error(e.getMessage(), e); } } }
public static DomainClass getDomainClassFor(final Class<? extends DomainObject> className) { final DomainModel domainModel = FenixFramework.getDomainModel(); for (DomainClass domainClass : domainModel.getDomainClasses()) { if (domainClass.getFullName().equals(className.getName())) { return domainClass; } } return null; }
/** * @return the {@link DomainMetaClass} of the superclass of the metaClass * passed as argument */ private DomainMetaClass getDomainMetaSuperclassFromDML(DomainMetaClass metaClass) { try { DomainClass dmlDomainSuperclass = (DomainClass) existingDMLDomainClasses.get(metaClass.getDomainClass()).getSuperclass(); Class<? extends DomainObject> domainSuperclass = (Class<? extends DomainObject>) Class.forName(dmlDomainSuperclass.getFullName()); return existingDomainMetaClasses.get(domainSuperclass); } catch (ClassNotFoundException e) { e.printStackTrace(); throw new Error(e); } }
/** * @return a <code>Map</code> of <code>Classes</code> to {@link DomainClass} with all the existing classes of the * domain model, except those annotated with {@link NoDomainMetaObjects}. */ private Map<Class<? extends DomainObject>, DomainClass> getExistingDomainClasses(DomainModel domainModel) { Map<Class<? extends DomainObject>, DomainClass> existingDomainClasses = new HashMap<Class<? extends DomainObject>, DomainClass>(); Iterator<DomainClass> domainClassesIterator = domainModel.getClasses(); try { while (domainClassesIterator.hasNext()) { DomainClass dmlDomainClass = domainClassesIterator.next(); Class<? extends DomainObject> domainClass = (Class<? extends DomainObject>) Class.forName(dmlDomainClass.getFullName()); if (!domainClass.getSuperclass().getName().equals(domainClass.getName() + "_Base")) { throw new Error("The domain class: " + domainClass + " must extend its corresponding _Base class."); } if (domainClass.isAnnotationPresent(NoDomainMetaObjects.class)) { continue; } existingDomainClasses.put(domainClass, dmlDomainClass); } return existingDomainClasses; } catch (ClassNotFoundException e) { e.printStackTrace(); throw new Error(e); } }
public void start() { for (Iterator iter = getModel().getClasses(); iter.hasNext();) { String className = ((DomainClass) iter.next()).getFullName(); try { loadClass(className); } catch (ClassNotFoundException cnfe) { System.err.println("Error: Couldn't load class " + className + ": " + cnfe); } } } }
@SuppressWarnings("unchecked") public static List<Class<? extends DomainObject>> getDomainClassHierarchy(final Class<?> superClass, boolean shouldContainSuperClass, boolean shouldContainAbstractClass) { final DomainModel domainModel = FenixFramework.getDomainModel(); List<Class<? extends DomainObject>> classNames = new ArrayList<Class<? extends DomainObject>>(); for (DomainClass domainClass : domainModel.getDomainClasses()) { if (isClassInstance(domainClass, superClass, shouldContainSuperClass)) { try { final Class<? extends DomainObject> clazz = (Class<? extends DomainObject>) Class.forName(domainClass.getFullName()); if (shouldContainAbstractClass || !Modifier.isAbstract(clazz.getModifiers())) { classNames.add(clazz); } } catch (ClassNotFoundException e) { // ignore error e.printStackTrace(); } } } return classNames; }
private static void addClassExtentOfAncesterClassDescriptors(final Map<String, ClassDescriptor> ojbMetadata, final DomainEntity domainEntity, final Class<?> clazz) { if (domainEntity != null && domainEntity instanceof DomainClass) { final DomainClass domainClass = (DomainClass) domainEntity; final String ancesterClassname = domainClass.getFullName(); final ClassDescriptor classDescriptor = ojbMetadata.get(ancesterClassname); classDescriptor.addExtentClass(clazz); addClassExtentOfAncesterClassDescriptors(ojbMetadata, domainClass.getSuperclass(), clazz); } }
static void initializeClassInfos(DomainModel model, int serverId) { serverOidBase = (long) serverId << 48; // the server id provides de 16 most significant bits of the OID int maxId = 0; Map<Class, DomainClassInfo> map = new IdentityHashMap<Class, DomainClassInfo>(); ArrayList<DomainClassInfo> array = new ArrayList<DomainClassInfo>(); // special case: create record for DomainRoot (must get class id = 0) addNewInfo(map, array, new DomainClassInfo(DomainRoot.class, 0)); // create all other records, skipping DomainRoot of course for (DomainClass domClass : model.getDomainClasses()) { Class javaClass; try { javaClass = Class.forName(domClass.getFullName()); } catch (ClassNotFoundException e) { throw new ExceptionInInitializerError(e); } if (javaClass != DomainRoot.class && !map.containsKey(javaClass)) { DomainClassInfo classInfo = new DomainClassInfo(javaClass, ++maxId); addNewInfo(map, array, classInfo); } } // finish the initialization by assigning to the static variables classInfoMap = Collections.unmodifiableMap(map); classInfoById = new DomainClassInfo[maxId + 1]; array.toArray(classInfoById); }
private static int createAnyMissingRecords(Map<Class<? extends AbstractDomainObject>, DomainClassInfo> map, ArrayList<DomainClassInfo> array, int maxId, DomainModel domainModel) throws ClassNotFoundException { ArrayList<DomainClassInfo> newClasses = new ArrayList<DomainClassInfo>(); for (DomainClass domClass : domainModel.getDomainClasses()) { Class<? extends AbstractDomainObject> javaClass = findClass(domClass.getFullName()); if (!map.containsKey(javaClass)) { // special case: record for DomainRoot must get class id = 0 int id = javaClass == DomainRoot.class ? 0 : ++maxId; DomainClassInfo classInfo = new DomainClassInfo(javaClass, id); addNewInfo(map, array, classInfo); newClasses.add(classInfo); if (logger.isInfoEnabled()) { logger.info("Registering new domain class '{}' with id '{}'", javaClass.getName(), Long.toHexString(classInfo.classId)); } } } if (!newClasses.isEmpty()) { JVSTMBackEnd.getInstance().getRepository() .storeDomainClassInfos(newClasses.toArray(new DomainClassInfo[newClasses.size()])); } return maxId; }
static void initializeClassInfos(DomainModel model, int serverId) { serverOidBase = (long) serverId << 48; // the server id provides de 16 most significant bits of the OID int maxId = 0; Map<Class, DomainClassInfo> map = new IdentityHashMap<Class, DomainClassInfo>(); ArrayList<DomainClassInfo> array = new ArrayList<DomainClassInfo>(); // special case: create record for DomainRoot (must get class id = 0) addNewInfo(map, array, new DomainClassInfo(DomainRoot.class, 0)); // create all other records, skipping DomainRoot of course for (DomainClass domClass : model.getDomainClasses()) { Class javaClass; try { javaClass = Class.forName(domClass.getFullName()); } catch (ClassNotFoundException e) { throw new ExceptionInInitializerError(e); } if (javaClass != DomainRoot.class && !map.containsKey(javaClass)) { DomainClassInfo classInfo = new DomainClassInfo(javaClass, ++maxId); addNewInfo(map, array, classInfo); } } // finish the initialization by assigning to the static variables classInfoMap = Collections.unmodifiableMap(map); classInfoById = new DomainClassInfo[maxId + 1]; array.toArray(classInfoById); }
public static void updateOJBMappingFromDomainModel(DomainModel domainModel) throws Exception { final DescriptorRepository descriptorRepository = MetadataManager.getInstance().getGlobalRepository(); @SuppressWarnings("unchecked") Map<String, ClassDescriptor> ojbMetadata = descriptorRepository.getDescriptorTable(); for (DomainClass domClass : domainModel.getDomainClasses()) { final String classname = domClass.getFullName(); final Class<?> clazz = Class.forName(classname); final ClassDescriptor classDescriptor = new ClassDescriptor(descriptorRepository); classDescriptor.setClassOfObject(clazz); classDescriptor.setTableName(getExpectedTableName(domClass)); ojbMetadata.put(domClass.getFullName(), classDescriptor); } for (DomainClass domClass : domainModel.getDomainClasses()) { final String classname = domClass.getFullName(); final Class<?> clazz = Class.forName(classname); final ClassDescriptor classDescriptor = ojbMetadata.get(classname); addClassExtentOfAncesterClassDescriptors(ojbMetadata, domClass.getSuperclass(), clazz); if (classDescriptor != null) { setFactoryMethodAndClass(classDescriptor); updateFields(domainModel, classDescriptor, domClass, ojbMetadata, clazz); if (!Modifier.isAbstract(clazz.getModifiers())) { updateRelations(classDescriptor, domClass, ojbMetadata, clazz); } } } }
boolean isDomainRoot = domClass.getFullName().equals(DomainRoot.class.getName()); Class javaClass = Class.forName(domClass.getFullName()); if (!map.containsKey(javaClass)) { DomainClassInfo classInfo = new DomainClassInfo(javaClass, isDomainRoot ? 0 : ++maxId);
ClassDescriptor otherClassDescriptor = ojbMetadata.get(((DomainClass) role.getType()).getFullName()); logger.warn("Ignoring {}", ((DomainClass) role.getType()).getFullName()); continue;