private Map<Byte, DbJVPrimitiveType> getJavaTypes() throws DbException { // if first call, build the map if (m_javaTypes == null) { m_javaTypes = new HashMap<Byte, DbJVPrimitiveType>(); DbRelationN relN = m_project.getComponents(); DbEnumeration enu = relN.elements(DbSMSBuiltInTypeNode.metaClass); while (enu.hasMoreElements()) { DbSMSBuiltInTypeNode typeNode = (DbSMSBuiltInTypeNode) enu.nextElement(); DbRelationN relN2 = typeNode.getComponents(); DbEnumeration enu2 = relN2.elements(DbSMSBuiltInTypePackage.metaClass); while (enu2.hasMoreElements()) { DbSMSBuiltInTypePackage pack = (DbSMSBuiltInTypePackage) enu2.nextElement(); DbSMSTargetSystem ts = pack.getTargetSystem(); if ("Java".equals(ts.getName())) { DbRelationN relN3 = pack.getComponents(); DbEnumeration enu3 = relN3.elements(DbJVPrimitiveType.metaClass); while (enu3.hasMoreElements()) { DbJVPrimitiveType type = (DbJVPrimitiveType) enu3.nextElement(); String name = type.getName(); if ("boolean".equals(name)) { m_javaTypes.put(Constants.T_BOOLEAN, type); } else if ("byte".equals(name)) { m_javaTypes.put(Constants.T_BYTE, type); } else if ("short".equals(name)) { m_javaTypes.put(Constants.T_SHORT, type); } else if ("char".equals(name)) { m_javaTypes.put(Constants.T_CHAR, type); } else if ("int".equals(name)) { m_javaTypes.put(Constants.T_INT, type); } else if ("long".equals(name)) { m_javaTypes.put(Constants.T_LONG, type); } else if ("double".equals(name)) { m_javaTypes.put(Constants.T_DOUBLE, type); } else if ("float".equals(name)) { m_javaTypes.put(Constants.T_FLOAT, type); } // end if } // end while enu3.close(); } // end if pack.getAlias(); } // end while enu2.close(); } // end while enu.close(); } // end if return m_javaTypes; }
private void insertProjects(SrVector children, Db db) throws DbException { db.beginTrans(Db.READ_TRANS); DbObject parent = db.getRoot(); DbEnumeration dbEnum = parent.getComponents().elements(DbProject.metaClass); while (dbEnum.hasMoreElements()) children.addElement(createPrimaryNode(parent, dbEnum.nextElement())); dbEnum.close(); db.commitTrans(); }
private void propagateCommonItemValues(DbORCommonItemModel model, int options) throws DbException { DbRelationN relN = model.getComponents(); DbEnumeration dbEnum = relN.elements(DbORCommonItem.metaClass); while (dbEnum.hasMoreElements()) { DbORCommonItem item = (DbORCommonItem) dbEnum.nextElement(); propagateCommonItemValues(item, options); } // end while dbEnum.close(); } // end propagateCommonItemValues()
// Overridden protected void insertComponents(SrVector children, DbObject dbParent) throws DbException { SemanticalModel model = ApplicationContext.getSemanticalModel(); DbEnumeration dbEnum = dbParent.getComponents().elements(); while (dbEnum.hasMoreElements()) { DbObject dbo = dbEnum.nextElement(); boolean isVisible = model.isVisibleOnScreen(dbParent, dbo, Explorer.class); if (isVisible) { children.addElement(createPrimaryNode(dbParent, dbo)); } // end if } // end while dbEnum.close(); } // end insertComponents()
// this update is always safe public final void updateSelectionAction() throws DbException { ApplicationDiagram diag = ApplicationContext.getFocusManager().getActiveDiagram(); Object[] objects = ApplicationContext.getFocusManager().getSelectedSemanticalObjects(); if ((diag == null) || (objects.length != 1) || !(objects[0] instanceof DbORAssociationEnd)) { setSelectedIndex(-1); setEnabled(false); return; } // update values dbos.clear(); DbORAssociationEnd end = (DbORAssociationEnd) objects[0]; DbORPrimaryUnique selKey = end.getReferencedConstraint(); DbORAbsTable tableSo = (DbORAbsTable) end.getOppositeEnd().getClassifier(); DbEnumeration dbEnum = tableSo.getComponents().elements(DbORPrimaryUnique.metaClass); while (dbEnum.hasMoreElements()) { DbORPrimaryUnique key = (DbORPrimaryUnique) dbEnum.nextElement(); dbos.add(key); } dbEnum.close(); int sizeadjustment = (dbos.size() == 0) ? 1 : 2; // adding a separator // and an item for // removing the // referenced // constraint // if no keys, do not add a separator Object[] items = new Object[dbos.size() + sizeadjustment]; items[0] = kNoReferencedConstraint; if (sizeadjustment == 2) { items[1] = null; } String tableName = tableSo.getName(); for (int i = 0; i < dbos.size(); i++) { String name = ((DbORPrimaryUnique) dbos.get(i)).getName(); items[i + sizeadjustment] = MessageFormat.format(kKeyNamePatern, new Object[] {tableName, name}); } setDomainValues(items); if (selKey == null) setSelectedIndex(0); else setSelectedIndex(dbos.indexOf(selKey) + sizeadjustment); setEnabled(true); }
// find, if any, the column of 'table' whose name is 'columnName' private DbORColumn findColumn(DbORTable table, String columnName) throws DbException { DbORColumn namedColumn = null; DbRelationN relN = table.getComponents(); DbEnumeration enu = relN.elements(DbORColumn.metaClass); while (enu.hasMoreElements()) { DbORColumn c = (DbORColumn) enu.nextElement(); if (columnName.equals(c.getName())) { namedColumn = c; break; } } // end while enu.close(); return namedColumn; }
private DbJVPackage findPackageByName(DbOOAbsPackage parent, String packageName) throws DbException { DbJVPackage foundPackage = null; DbRelationN relN = parent.getComponents(); DbEnumeration enu = relN.elements(DbJVPackage.metaClass); while (enu.hasMoreElements()) { DbJVPackage pack = (DbJVPackage) enu.nextElement(); String name = pack.getName(); if (packageName.equals(name)) { foundPackage = pack; break; } } // end while enu.close(); return foundPackage; }
private DbORTable findParentTable(DbORTable t1) throws DbException { DbORTable parent = null; DbRelationN relN = t1.getAssociationEnds(); DbEnumeration enu = relN.elements(DbORAssociationEnd.metaClass); while (enu.hasMoreElements()) { DbORAssociationEnd end = (DbORAssociationEnd) enu.nextElement(); int mult = end.getMultiplicity().getValue(); if (mult == SMSMultiplicity.EXACTLY_ONE) { DbORAssociationEnd oppEnd = end.getOppositeEnd(); DbORAbsTable t = oppEnd.getClassifier(); if (t instanceof DbORTable) { parent = (DbORTable) t; break; } } // end if } // end while enu.close(); return parent; }
private DbOOAdt findClassByName(DbJVPackage pack, String classname) throws DbException { DbJVClass foundClass = null; DbRelationN relN = (pack == null) ? m_classModel.getComponents() : pack.getComponents(); DbEnumeration enu = relN.elements(DbJVClass.metaClass); while (enu.hasMoreElements()) { DbJVClass claz = (DbJVClass) enu.nextElement(); String name = claz.getName(); if (classname.equals(name)) { foundClass = claz; break; } } // end while enu.close(); if (foundClass == null) { JVClassCategory catg = JVClassCategory.getInstance(JVClassCategory.CLASS); foundClass = (pack == null) ? new DbJVClass(m_classModel, catg) : new DbJVClass(pack, catg); foundClass.setName(classname); types.put(classname, foundClass); } return foundClass; } // end findClassByName()
protected final void refresh(DynamicNode parentNode) throws DbException { if (ApplicationContext.getFocusManager().isGuiLocked()) return; if (parentNode == null) return; if (!parentNode.hasLoaded() || parentNode.isLeaf()) { if (parentNode.getUserObject() instanceof DbObject) updateNode((DbObject) parentNode.getUserObject()); return; } Object userObject = parentNode.getUserObject(); if (userObject == ROOT) { int count = getChildCount(parentNode); for (int i = 0; i < count; i++) { DynamicNode node = (DynamicNode) getChild(parentNode, i); userObject = node.getUserObject(); if (userObject == DB_RAM) refresh(node); else { if (((Db) userObject).isValid()) { ((Db) userObject).beginTrans(Db.READ_TRANS); refresh(node); ((Db) userObject).commitTrans(); } else { removeNode(node); } } } return; } if (userObject == DB_RAM) { int count = getChildCount(parentNode); for (int i = count - 1; i >= 0; i--) { DynamicNode node = (DynamicNode) getChild(parentNode, i); Db db = ((DbObject) node.getUserObject()).getDb(); if (!db.isValid()) { removeNode(node); continue; } db.beginTrans(Db.READ_TRANS); refresh(node); // refresh the display text for the projects - we do not want to // apply a full update // using update(dbo) because we want to preserve the expanded // state for projects. node.setDisplayText(getDisplayText(null, (DbObject) node.getUserObject())); db.commitTrans(); } // check for missing Db Db[] dbs = Db.getDbs(); for (int i = 0; i < dbs.length; i++) { if (!dbs[i].isValid() || !(dbs[i] instanceof DbRAM)) continue; DynamicNode dbNode = getDynamicNode(parentNode, dbs[i], 0); if (dbNode != null) continue; dbs[i].beginTrans(Db.READ_TRANS); DbEnumeration dbEnum = dbs[i].getRoot().getComponents().elements(DbProject.metaClass); if (dbEnum.hasMoreElements()) { getDynamicNode(dbEnum.nextElement(), false); } dbEnum.close(); dbs[i].commitTrans(); } return; } SrVector children = new SrVector(10); if (userObject instanceof Db) { insertProjects(children, (Db) userObject); children.sort(); } else if (((DbObject) userObject).isAlive()) { insertComponents(children, (DbObject) userObject); if (childrenAreSorted((DbObject) userObject)) children.sort(getComparator((DbObject) userObject)); } DynamicNode groupNode = null; int index = 0; int iGroup = 0; for (int i = 0; i < children.size(); i++) { DynamicNode srcNode = (DynamicNode) children.elementAt(i); GroupParams group = srcNode.getGroupParams(); if (group.name == null) { refreshNode(srcNode, parentNode, index); index++; } else { if (groupNode == null || !groupNode.toString().equals(group.name)) { if (groupNode != null) deleteNodes(groupNode, iGroup); groupNode = getGroupNode(parentNode, group, index); if (groupNode == null) { groupNode = createGroupNode(group); insertNodeInto(groupNode, parentNode, index); } else if (groupNode != getChild(parentNode, index)) { removeNodeFromParent(groupNode); insertNodeInto(groupNode, parentNode, index); } index++; iGroup = 0; } refreshNode(srcNode, groupNode, iGroup); iGroup++; } } if (groupNode != null) deleteNodes(groupNode, iGroup); deleteNodes(parentNode, index); // Refresh subnodes in a separate pass to avoid interference from // automatic // adding of a primary node when adding a secondary node. refreshChildren(parentNode); }
private void propagateCommonItemValues(DbORCommonItem item, int options) throws DbException { // get mandatory properties DbORTypeClassifier type = item.getType(); Integer len = item.getLength(); Integer dec = item.getNbDecimal(); boolean isNull = item.getNull(); // get optional properties String name = item.getName(); String physicalName = item.getPhysicalName(); String alias = item.getAlias(); String desc = item.getDescription(); DbSMSStereotype stereotype = item.getUmlStereotype(); // for each column DbRelationN relN = item.getColumns(); DbEnumeration dbEnum = relN.elements(DbORColumn.metaClass); while (dbEnum.hasMoreElements()) { m_changesmade = true; // set mandatory properties DbORColumn column = (DbORColumn) dbEnum.nextElement(); column.setType(type); column.setLength(len); column.setNbDecimal(dec); column.setNull(Boolean.valueOf(isNull)); // set optional properties if ((options & NAME) != 0) { column.setName(name); } if ((options & PHYSICAL_NAME) != 0) { column.setPhysicalName(physicalName); } if ((options & ALIAS) != 0) { column.setAlias(alias); } if ((options & DESCRIPTION) != 0) { column.setDescription(desc); } if ((options & STEREOTYPE) != 0) { column.setUmlStereotype(stereotype); } } // end while dbEnum.close(); // get object properties DbOOAdt ooType = item.getOoType(); String typeUse = item.getTypeUse(); OOTypeUseStyle style = item.getTypeUseStyle(); JVVisibility visib = (JVVisibility) item.getVisibility(); boolean isStatic = item.isStatic(); boolean isFinal = item.isFinal(); boolean isTransient = item.isTransient(); boolean isVolatile = item.isVolatile(); // for each field relN = item.getFields(); dbEnum = relN.elements(DbJVDataMember.metaClass); while (dbEnum.hasMoreElements()) { m_changesmade = true; // set mandatory oo properties DbJVDataMember field = (DbJVDataMember) dbEnum.nextElement(); field.setType(ooType); field.setTypeUse(typeUse); field.setTypeUseStyle(style); field.setVisibility(visib); field.setStatic(Boolean.valueOf(isStatic)); field.setFinal(new Boolean(isFinal)); field.setTransient(new Boolean(isTransient)); field.setVolatile(new Boolean(isVolatile)); // set optional properties if ((options & NAME) != 0) { field.setName(name); } if ((options & ALIAS) != 0) { field.setAlias(alias); } if ((options & DESCRIPTION) != 0) { field.setDescription(desc); } if ((options & STEREOTYPE) != 0) { field.setUmlStereotype(stereotype); } } // end while dbEnum.close(); } // end propagateCommonItemValues()
// // PRIVATE METHODS // private void propagateCommonItems() { g_options = getOptions(); m_changesmade = false; try { m_semObjs[0].getDb().beginWriteTrans(m_title); int nb = m_semObjs.length; for (int i = 0; i < nb; i++) { DbObject semObj = m_semObjs[i]; if (semObj instanceof DbORCommonItemModel) { DbORCommonItemModel model = (DbORCommonItemModel) semObj; propagateCommonItemValues(model, g_options); } else if (semObj instanceof DbORCommonItem) { DbORCommonItem item = (DbORCommonItem) semObj; propagateCommonItemValues(item, g_options); } // end if else if (semObj instanceof DbORDataModel) { DbObject tableOrView = null; DbEnumeration orTableEnum = semObj.getComponents().elements(DbORAbsTable.metaClass); while (orTableEnum.hasMoreElements()) { tableOrView = orTableEnum.nextElement(); DbEnumeration orColumnEnum = tableOrView.getComponents().elements(DbORColumn.metaClass); DbORCommonItem item = null; while (orColumnEnum.hasMoreElements()) { DbORColumn parm = (DbORColumn) orColumnEnum.nextElement(); item = (DbORCommonItem) parm.get(DbORColumn.fCommonItem); if (item != null) propagateCommonItemValues(item, parm, false, g_options); } orColumnEnum.close(); } orTableEnum.close(); } else if (semObj instanceof DbORColumn) { DbORCommonItem item = (DbORCommonItem) semObj.get(DbORColumn.fCommonItem); if (item != null) propagateCommonItemValues(item, semObj, false, g_options); } else if (semObj instanceof DbORAbsTable) { DbEnumeration orColumnEnum = semObj.getComponents().elements(DbORColumn.metaClass); DbORCommonItem item = null; while (orColumnEnum.hasMoreElements()) { DbORColumn parm = (DbORColumn) orColumnEnum.nextElement(); item = (DbORCommonItem) parm.get(DbORColumn.fCommonItem); if (item != null) propagateCommonItemValues(item, parm, false, g_options); } orColumnEnum.close(); } else if (semObj instanceof DbOOClassModel) { DbObject tableOrView = null; DbEnumeration orTableEnum = semObj.getComponents().elements(DbOOClass.metaClass); while (orTableEnum.hasMoreElements()) { tableOrView = orTableEnum.nextElement(); DbEnumeration orColumnEnum = tableOrView.getComponents().elements(DbJVDataMember.metaClass); DbORCommonItem item = null; while (orColumnEnum.hasMoreElements()) { DbJVDataMember parm = (DbJVDataMember) orColumnEnum.nextElement(); item = (DbORCommonItem) parm.get(DbJVDataMember.fCommonItem); if (item != null) propagateCommonItemValues(item, parm, true, g_options); } orColumnEnum.close(); } orTableEnum.close(); } else if (semObj instanceof DbOOClass) { DbEnumeration orColumnEnum = semObj.getComponents().elements(DbJVDataMember.metaClass); DbORCommonItem item = null; while (orColumnEnum.hasMoreElements()) { DbJVDataMember parm = (DbJVDataMember) orColumnEnum.nextElement(); item = (DbORCommonItem) parm.get(DbJVDataMember.fCommonItem); if (item != null) propagateCommonItemValues(item, parm, true, g_options); } orColumnEnum.close(); } else if (semObj instanceof DbJVDataMember) { DbORCommonItem item = (DbORCommonItem) semObj.get(DbJVDataMember.fCommonItem); if (item != null) propagateCommonItemValues(item, semObj, true, g_options); } } // end for m_semObjs[0].getDb().commitTrans(); if (m_changesmade == false) JOptionPane.showMessageDialog( this, LocaleMgr.screen.getString("NoCommonItemToPropagate"), ApplicationContext.getApplicationName(), JOptionPane.INFORMATION_MESSAGE); } catch (Exception e) { org.modelsphere.jack.util.ExceptionHandler.processUncatchedException( ApplicationContext.getDefaultMainFrame(), e); } } // end propagateCommonItems()
// add childrenMetaClass to filter only children of that class // if null, scan each child protected boolean expandMetaRelationN( Writer output, DbObject object, MetaRelationship metaRelation, boolean state[], MetaClass childrenMetaClass, RuleOptions options) throws DbException, IOException, RuleException { boolean expanded = false; DbEnumeration dbEnumChildren = null; DbRelationN relationN = (DbRelationN) object.get(metaRelation); if (childrenMetaClass == null) { dbEnumChildren = relationN.elements(); } else { dbEnumChildren = relationN.elements(childrenMetaClass); } // a first pass to find out the number of children int nbChildren = 0; try { while (dbEnumChildren.hasMoreElements()) { dbEnumChildren.nextElement(); nbChildren++; // Cancel everything if the user has decided to stop the // operation if (options != null) { Controller controller = options.m_controller; if (controller != null) { boolean can_continue = controller.checkPoint(); if (!can_continue) { throw new RuleException(controller.getAbortedString()); } } } // end if } // end while } finally { dbEnumChildren.close(); } // cannot rollback to the first element, so recreate the enumeration if (childrenMetaClass == null) { dbEnumChildren = relationN.elements(); } else { dbEnumChildren = relationN.elements(childrenMetaClass); } try { while (dbEnumChildren.hasMoreElements()) { DbObject child = (DbObject) dbEnumChildren.nextElement(); MetaClass metaClass = child.getMetaClass(); String className = metaClass.getGUIName(); boolean excluded = false; // check if child's class is excluded if (options != null) { excluded = options.isExcluded(className); // if not, check if parent's connection is excluded if (!excluded) { metaClass = object.getMetaClass(); String parentClassName = metaClass.getGUIName(); String connectionName = parentClassName + "." + metaRelation.getGUIName(); excluded = options.isExcluded(connectionName); } // end if } // end if if (!excluded) { expanded |= expandChild(output, object, child, nbChildren, state, options); } // end if } // end while } finally { dbEnumChildren.close(); } boolean atLeastOneChildPrinted = state[1]; if ((atLeastOneChildPrinted) && (suffixModifier != null)) { expanded |= suffixModifier.expand(output, object, options); } else if ((!atLeastOneChildPrinted) && (nullModifier != null)) { expanded |= nullModifier.expand(output, object, options); } return expanded; } // end expandMetaRelationN