コード例 #1
0
  /** For internal use only. */
  public static void initMeta() {
    try {
      metaClass.setSuperMetaClass(DbSMSStructuralFeature.metaClass);
      metaClass.setIcon("dboodatamember.gif");

      fAssociationEnd.setJField(DbOODataMember.class.getDeclaredField("m_associationEnd"));
      fAssociationEnd.setVisibleInScreen(false);
      fVisibility.setJField(DbOODataMember.class.getDeclaredField("m_visibility"));
      fVisibility.setScreenOrder("<initialValue");
      fType.setJField(DbOODataMember.class.getDeclaredField("m_type"));
      fType.setFlags(MetaField.COPY_REFS | MetaField.INTEGRABLE_BY_NAME);
      fType.setRendererPluginName("DbFullNameInTip;DbOOAdt");
      fElementType.setJField(DbOODataMember.class.getDeclaredField("m_elementType"));
      fElementType.setFlags(MetaField.COPY_REFS | MetaField.INTEGRABLE_BY_NAME);
      fTypeUse.setJField(DbOODataMember.class.getDeclaredField("m_typeUse"));
      fTypeUseStyle.setJField(DbOODataMember.class.getDeclaredField("m_typeUseStyle"));
      fStatic.setJField(DbOODataMember.class.getDeclaredField("m_static"));
      fCommonItem.setJField(DbOODataMember.class.getDeclaredField("m_commonItem"));
      fDomain.setJField(DbOODataMember.class.getDeclaredField("m_domain"));

      fAssociationEnd.setOppositeRel(DbOOAssociationEnd.fAssociationMember);
      fType.setOppositeRel(DbOOAdt.fTypedDataMembers);
      fElementType.setOppositeRel(DbOOAdt.fTypedElementDataMembers);
      fCommonItem.setOppositeRel(DbORCommonItem.fFields);
      fDomain.setOppositeRel(DbORDomain.fFields);

    } catch (Exception e) {
      throw new RuntimeException("Meta init");
    }
  }
コード例 #2
0
  public DbObject createDbObject(
      MetaClass abstractMetaClass, DbObject composite, Object[] parameters) throws DbException {
    DbObject dbObject = null;

    if (composite != null) {
      if (abstractMetaClass.equals(DbORView.metaClass)) {
        dbObject = composite.createComponent(DbORAView.metaClass);
      } else if (abstractMetaClass.equals(DbORTable.metaClass)) {
        dbObject = composite.createComponent(DbORATable.metaClass);
      } else if (abstractMetaClass.equals(DbORTrigger.metaClass)) {
        dbObject = composite.createComponent(DbORATrigger.metaClass);
      } else if (abstractMetaClass.equals(DbORColumn.metaClass)) {
        dbObject = composite.createComponent(DbORAColumn.metaClass);
      } else if (abstractMetaClass.equals(DbORCheck.metaClass)) {
        dbObject = composite.createComponent(DbORACheck.metaClass);
      } else if (abstractMetaClass.equals(DbORPrimaryUnique.metaClass)) {
        dbObject = composite.createComponent(DbORAPrimaryUnique.metaClass);
      } else if (abstractMetaClass.equals(DbORIndex.metaClass)) {
        dbObject = composite.createComponent(DbORAIndex.metaClass);
      } else if (abstractMetaClass.equals(DbORDataModel.metaClass)) {
        DbORDataModel dataModel = (DbORDataModel) composite;
        return new DbORADataModel(
            composite, dataModel.getTargetSystem(), dataModel.getOperationalMode());
      } else {
        dbObject = super.createDbObject(abstractMetaClass, composite, parameters);
      } // end if
    }
    return dbObject;
  } // end createDbObject()
コード例 #3
0
  /** For internal use only. */
  public static void initMeta() {
    try {
      metaClass.setSuperMetaClass(DbSMSSemanticalObject.metaClass);
      metaClass.setIcon("dborapartition.gif");

      fTablespace.setJField(DbORAAbsPartition.class.getDeclaredField("m_tablespace"));
      fTablespace.setFlags(MetaField.INTEGRABLE_BY_NAME);
      fTablespace.setRendererPluginName("DbORATablespace");

      fTablespace.setOppositeRel(DbORATablespace.fAbsPartitions);

    } catch (Exception e) {
      throw new RuntimeException("Meta init");
    }
  }
コード例 #4
0
 /** @return metaclass */
 public MetaClass getStereotypeMetaClass() throws DbException {
   if (stereotypeMetaClass == null) {
     stereotypeMetaClass = MetaClass.find(getMetaClassName());
     if (stereotypeMetaClass == null) return DbSMSSemanticalObject.metaClass;
   }
   return stereotypeMetaClass;
 }
コード例 #5
0
  /** For internal use only. */
  public static void initMeta() {
    try {
      metaClass.setSuperMetaClass(DbORTrigger.metaClass);

    } catch (Exception e) {
      throw new RuntimeException("Meta init");
    }
  }
コード例 #6
0
  /** For internal use only. */
  public static void initMeta() {
    try {
      metaClass.setSuperMetaClass(DbSMSAssociationGo.metaClass);

    } catch (Exception e) {
      throw new RuntimeException("Meta init");
    }
  }
コード例 #7
0
 /**
  * @param name java.lang.String
  * @return metafield
  */
 public final MetaField getMetaField(String name) {
   if (fieldMap == null) {
     MetaField[] fields = metaClass.getAllMetaFields();
     fieldMap = new HashMap(fields.length + fields.length / 2);
     for (int i = 0; i < fields.length; i++) fieldMap.put(fields[i].getJName(), fields[i]);
   }
   return (MetaField) fieldMap.get(name);
 }
コード例 #8
0
 private ObjectScope getObjectScope(ObjectScope[] scope, String metaclassname) {
   MetaClass metaclass = MetaClass.find(metaclassname);
   if (metaclass == null) // obsolete metaClass
   return null;
   for (int i = 0; i < scope.length; i++) {
     if (scope[i].metaClass == metaclass) return scope[i];
   }
   return null;
 }
コード例 #9
0
  private boolean expandMetaChoice(
      Writer output,
      DbObject object,
      MetaChoice choice,
      boolean state[],
      MetaClass childrenMetaClass,
      RuleOptions options)
      throws DbException, IOException, RuleException {

    boolean expanded = false;
    Object child = object.get(choice);

    if (child instanceof DbObject) {
      DbObject dbChild = (DbObject) child;
      MetaClass metaClass = dbChild.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 metaClass2 = object.getMetaClass();
          String parentClassName = metaClass2.getGUIName();
          String connectionName = parentClassName + "." + choice.getGUIName();
          excluded = options.isExcluded(connectionName);
        } // end if
      } // end if

      if (!excluded) {
        if (childrenMetaClass.isAssignableFrom(metaClass)) {
          expanded |= expandChild(output, object, dbChild, 1, state, options);
        } // end if
      } // end if
    } // end if

    if ((!expanded) && (nullModifier != null)) {
      expanded |= nullModifier.expand(output, object, options);
    } // end if

    return expanded;
  } // end expandMetaChoice
コード例 #10
0
  private MetaClass getChildrenMetaClass() {
    MetaClass childrenMetaClass = m_childrenMetaClass;

    if (childrenMetaClass == null) {
      m_childrenMetaClass = MetaClass.find(sChildrenMetaClass);
      childrenMetaClass = m_childrenMetaClass;
    }

    return childrenMetaClass;
  }
コード例 #11
0
  /** For internal use only. */
  public static void initMeta() {
    try {
      metaClass.setSuperMetaClass(DbSemanticalObject.metaClass);
      metaClass.setIcon("dbsmsumlstereotype.gif");

      fStereotypedObjects.setJField(DbSMSStereotype.class.getDeclaredField("m_stereotypedObjects"));
      fSubStereotypes.setJField(DbSMSStereotype.class.getDeclaredField("m_subStereotypes"));
      fSuperStereotypes.setJField(DbSMSStereotype.class.getDeclaredField("m_superStereotypes"));
      fIcon.setJField(DbSMSStereotype.class.getDeclaredField("m_icon"));
      fIcon.setRendererPluginName("SrImage;StereotypeIcon");
      fBuiltIn.setJField(DbSMSStereotype.class.getDeclaredField("m_builtIn"));
      fBuiltIn.setEditable(false);
      fMetaClassName.setJField(DbSMSStereotype.class.getDeclaredField("m_metaClassName"));
      fMetaClassName.setRendererPluginName("SMSSemanticalMetaClass");

      fSubStereotypes.setOppositeRel(DbSMSStereotype.fSuperStereotypes);
      fSuperStereotypes.setOppositeRel(DbSMSStereotype.fSubStereotypes);

    } catch (Exception e) {
      throw new RuntimeException("Meta init");
    }
  }
コード例 #12
0
  protected boolean verifyExclusion(Serializable obj, RuleOptions options) {
    boolean excluded = false;

    if (options == null) {
      return false;
    }

    ArrayList excludeList = options.getExcludeList();

    if (obj != null) {
      if (obj instanceof DbObject) {
        DbObject dbObj = (DbObject) obj;
        MetaClass metaClass = dbObj.getMetaClass();
        String className = metaClass.getGUIName();
        if (excludeList != null) {
          if (excludeList.contains(className)) {
            excluded = true;
          }
        }
      }
    } // end if

    return excluded;
  }
コード例 #13
0
  public Connector(
      String ruleName,
      MetaRelationship aConnector,
      Rule aChildRule,
      MetaClass childrenMetaClass,
      Modifier[] someModifiers) {
    super(ruleName, someModifiers);
    m_connector = aConnector;
    m_childrenMetaClass = childrenMetaClass; // doesn't work
    childRule = aChildRule;

    // store m_connector because it is transient
    sConnector = m_connector.getJName();

    // store m_childrenMetaClass because it is transient
    if (m_childrenMetaClass != null) {
      sChildrenMetaClass = m_childrenMetaClass.getJClass().getName();
    }
  } // end Connector()
コード例 #14
0
  // 'official' constructor
  // new param: childrenMetaClass
  public Connector(
      String ruleName,
      MetaRelationship aConnector,
      String childRule,
      String[] optionalRules,
      MetaClass childrenMetaClass,
      Modifier[] someModifiers) {
    this(ruleName, aConnector, (Rule) null, childrenMetaClass, someModifiers);
    int nbRules = optionalRules.length;
    m_childStrRule = childRule;
    m_oneChildStrRule = optionalRules[0];
    m_whenCond = (nbRules > 1) ? optionalRules[1] : null;
    m_childrenMetaClass = childrenMetaClass;

    // store m_childrenMetaClass because it is transient
    if (m_childrenMetaClass != null) {
      sChildrenMetaClass = m_childrenMetaClass.getJClass().getName();
    }
  } // end Connector()
コード例 #15
0
  /** For internal use only. */
  public static void initMeta() {
    try {
      metaClass.setSuperMetaClass(DbSMSStyle.metaClass);

      fOr_nameDescriptor.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_or_nameDescriptor"));
      fLineColorDbORCommonItem.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_lineColorDbORCommonItem"));
      fDescriptorFontDbORCommonItem.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_descriptorFontDbORCommonItem"));
      fDashStyleDbORCommonItem.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_dashStyleDbORCommonItem"));
      fTextColorDbORCommonItem.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_textColorDbORCommonItem"));
      fHighlightDbORCommonItem.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_highlightDbORCommonItem"));
      fBackgroundColorDbORCommonItem.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_backgroundColorDbORCommonItem"));
      fOr_commonItemLengthDecimalsDisplay.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_or_commonItemLengthDecimalsDisplay"));
      fOr_commonItemLengthDecimalsFont.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_or_commonItemLengthDecimalsFont"));
      fReferringProjectCommonItem.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_referringProjectCommonItem"));
      fOr_commonItemNullValueFont.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_or_commonItemNullValueFont"));
      fOr_commonItemTypeFont.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_or_commonItemTypeFont"));
      fOr_commonItemTypeDisplay.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_or_commonItemTypeDisplay"));
      fOr_commonItemNullValueDisplay.setJField(
          DbORCommonItemStyle.class.getDeclaredField("m_or_commonItemNullValueDisplay"));

      fReferringProjectCommonItem.setOppositeRel(DbSMSProject.fOrDefaultCommonItemStyle);

    } catch (Exception e) {
      throw new RuntimeException("Meta init");
    }
  }
コード例 #16
0
  private boolean expandMetaRelation1(
      Writer output,
      DbObject object,
      MetaRelation1 metaRelation1,
      boolean state[],
      MetaClass childrenMetaClass,
      RuleOptions options)
      throws DbException, IOException, RuleException {

    boolean expanded = false;
    Object child;
    if (childrenMetaClass != null) {
      if (metaRelation1 == DbObject.fComposite) {
        child = object.getCompositeOfType(childrenMetaClass);
      } else {
        child = object.get(metaRelation1);
        if (child instanceof DbObject) {
          DbObject dbChild = (DbObject) child;
          MetaClass mc = dbChild.getMetaClass();
          if (mc != childrenMetaClass) {
            child = null;
          }
        }
      }
    } else {
      child = object.get(metaRelation1);
    } // end if

    if (child != null) {
      if (child instanceof DbObject) {
        DbObject dbChild = (DbObject) child;
        MetaClass metaClass = dbChild.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 + "." + metaRelation1.getGUIName();
            excluded = options.isExcluded(connectionName);
          } // end if
        } // end if

        if (!excluded) {
          expanded |= expandChild(output, object, dbChild, 1, state, options);
        } // end if
      } // end if
    } // end if

    // if a SUF modifier has to be expanded
    if ((expanded) && (suffixModifier != null)) {
      suffixModifier.expand(output, object, options);
    }

    // if a NULL modifier has to be expanded
    if ((!expanded) && (nullModifier != null)) {
      expanded |= nullModifier.expand(output, object, options);
    }

    return expanded;
  } // end expandMetaRelation1
コード例 #17
0
  // 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