Menu
▾
▴
[Sblim-commit] ecute/Plugin/com/ibm/ecute/rsa/core/internal/properties QualifiersPropertySection.java,1.24,1.25 CheckAndRepair.java,1.1,1.2 FlavorsHelper.java,1.6,1.7
|
From: Benjamin B. <bg...@us...> - 2005-08-05 07:55:24
|
Update of /cvsroot/sblim/ecute/Plugin/com/ibm/ecute/rsa/core/internal/properties In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv1099/Plugin/com/ibm/ecute/rsa/core/internal/properties Modified Files: QualifiersPropertySection.java CheckAndRepair.java FlavorsHelper.java Log Message: flavors check Index: FlavorsHelper.java =================================================================== RCS file: /cvsroot/sblim/ecute/Plugin/com/ibm/ecute/rsa/core/internal/properties/FlavorsHelper.java,v retrieving revision 1.6 retrieving revision 1.7 diff -u -d -r1.6 -r1.7 --- FlavorsHelper.java 28 Jul 2005 17:59:51 -0000 1.6 +++ FlavorsHelper.java 5 Aug 2005 07:55:14 -0000 1.7 @@ -22,6 +22,7 @@ import org.eclipse.uml2.Constraint; import org.eclipse.uml2.Element; import org.eclipse.uml2.Model; +import org.eclipse.uml2.MultiplicityElement; import org.eclipse.uml2.NamedElement; import org.eclipse.uml2.OpaqueExpression; import org.eclipse.uml2.Operation; @@ -956,12 +957,23 @@ } if(attribute != null){ - if(attribute.isStatic()){ - return(new EffectiveInheritedValue("true", (Class)parents.get(j))); + if(override(attribute) || !override(attribute) && j == parents.size()-1){ + if(attribute.isStatic()){ + return(new EffectiveInheritedValue("true", (Class)parents.get(j))); + } else { + return(new EffectiveInheritedValue("false", (Class)parents.get(j))); + } } if(!override(attribute) && j != parents.size()-1){ return null; } + +// if(attribute.isStatic()){ +// return(new EffectiveInheritedValue("true", (Class)parents.get(j))); +// } +// if(!override(attribute) && j != parents.size()-1){ +// return null; +// } } } @@ -1154,6 +1166,290 @@ return null; } + public static String defaultValue(String qualifierName){ + + QualifiersList defaultQualifierNames=null; + try{ + defaultQualifierNames = EcuteEclipsePlugin.getDefault().getQualifiersList(); + }catch (Exception e){ + e.printStackTrace(); + } + Vector defaultQualifiers = defaultQualifierNames.GetElements(); + + //make a copy of the qualifiers list to remove the qualifiers already displayed + ArrayList allAvailableQualifers = new ArrayList(); + for(int i=0; i < defaultQualifiers.size(); i++){ + allAvailableQualifers.add(defaultQualifiers.get(i)); + } + + for(Iterator iterator1 = allAvailableQualifers.iterator(); iterator1.hasNext();) + { + Qualifier qualifier = (Qualifier)iterator1.next(); + if(qualifier.name.equalsIgnoreCase(qualifierName)){ + return qualifier.defaultValue; + } + } + + return null; + } + + public static String qualifierValue(NamedElement element, String qualifierName){ + + Stereotype cimStereotype = element.getAppliedStereotype("CIM::Qualifiers"); + List qualifierNames = (List) element.getValue(cimStereotype, "QualifierName"); + List qualifierValues = (List) element.getValue(cimStereotype, "QualifierValue"); + + for(int i = 0; i < qualifierNames.size(); i++){ + if(qualifierName.equalsIgnoreCase((String)qualifierNames.get(i))){ + return (String)qualifierValues.get(i); + } + } + + if(qualifierName.equalsIgnoreCase("Abstract")){ + if(element instanceof Class){ + if(((Class)element).isAbstract()){ + return "true"; + } else { + return "false"; + } + } else { + return null; + } + } + + else if(qualifierName.equalsIgnoreCase("Aggregate")){ + if(element instanceof Property){ + Property prop = (Property)element; + Property oppositeProp = null; + boolean isOwnedEnd = propertyIsOwnedEnd(prop); + // get the property of the other association end + if (isOwnedEnd){ + AssociationClass parentClass = (AssociationClass)prop.getOwner(); + List ends = parentClass.getOwnedEnds(); + if ((Property)ends.get(0) == prop){ + oppositeProp = (Property)ends.get(1); + } + if ((Property)ends.get(1) == prop){ + oppositeProp = (Property)ends.get(0); + } + + if(oppositeProp.getAggregation().getValue()== AggregationKind.SHARED + || oppositeProp.getAggregation().getValue()== AggregationKind.COMPOSITE){ + return "true"; + } else { + return "false"; + } + } else { + return null; + } + } else { + return null; + } + } + + else if(qualifierName.equalsIgnoreCase("Association")){ + if(element instanceof AssociationClass){ + return "true"; + } else if(element instanceof Class){ + return "false"; + } else { + return null; + } + } + + else if(qualifierName.equalsIgnoreCase("Aggregation")){ + if(element instanceof AssociationClass){ + AssociationClass assocClass = (AssociationClass)element; + EList ends = assocClass.getOwnedEnds(); + Iterator iter = ends.iterator(); + while(iter.hasNext()){ + Property prop = (Property)iter.next(); + if(prop.getAggregation().getValue()== AggregationKind.SHARED || + prop.getAggregation().getValue()== AggregationKind.COMPOSITE){ + return "true"; + } + } + return "false"; + } else { + return null; + } + } + + else if(qualifierName.equalsIgnoreCase("Composition")){ + if(element instanceof AssociationClass){ + AssociationClass assocClass = (AssociationClass)element; + EList ends = assocClass.getOwnedEnds(); + Iterator iter = ends.iterator(); + while(iter.hasNext()){ + Property prop = (Property)iter.next(); + if(prop.getAggregation().getValue() == AggregationKind.COMPOSITE){ + return "true"; + } + } + return "false"; + } else { + return null; + } + } + + else if(qualifierName.equalsIgnoreCase("Deprecated")){ + Stereotype stereo = element.getAppliedStereotype("CIM::Deprecated"); + if(stereo != null){ + return (String)element.getValue(stereo, "Value"); + } else { + return "null"; + } + } + + else if(qualifierName.equalsIgnoreCase("Description")){ + EList list = element.getOwnedComments(); + Iterator it = list.iterator(); + while (it.hasNext()){ + Comment comment = (Comment)it.next(); + Stereotype stereo = comment.getApplicableStereotype("Default::Documentation"); + if(stereo != null){ + return comment.getBody(); + } + } + return "null"; + } + + else if(qualifierName.equalsIgnoreCase("In")){ + if(element instanceof Parameter){ + ParameterDirectionKind kind = ((Parameter)element).getDirection(); + if(kind.getValue() == ParameterDirectionKind.IN || kind.getValue() == ParameterDirectionKind.INOUT){ + return "true"; + } else { + return "false"; + } + } else { + return null; + } + } + + else if(qualifierName.equalsIgnoreCase("Out")){ + if(element instanceof Parameter){ + ParameterDirectionKind kind = ((Parameter)element).getDirection(); + if(kind.getValue() == ParameterDirectionKind.OUT || kind.getValue() == ParameterDirectionKind.INOUT){ + return "true"; + } else { + return "false"; + } + } else { + return null; + } + } + + else if(qualifierName.equalsIgnoreCase("Key")){ + if(element instanceof Property){ + Stereotype stereo = element.getAppliedStereotype("CIM::Key"); + if(stereo != null){ + return "true"; + } else { + return "false"; + } + } else { + return null; + } + } + + else if(qualifierName.equalsIgnoreCase("Min") || qualifierName.equalsIgnoreCase("Max")){ + + if(element instanceof Property){ + Property prop = (Property)element; + Property oppositeProp = null; + boolean isOwnedEnd = propertyIsOwnedEnd(prop); + if(isOwnedEnd){ + if(((AssociationClass)prop.getOwner()).getOwnedEnds().contains(prop)){ + if(qualifierName.equalsIgnoreCase("Max")){ + String value = new Integer(prop.getUpper()).toString(); + if(value.equalsIgnoreCase("-1")){ + value = "null"; + } + return value; + } + else if(qualifierName.equalsIgnoreCase("Min")){ + String value = new Integer(prop.getLower()).toString(); + if(value.equalsIgnoreCase("-1")){ + value = "0"; + } + return value; + } + } else { + return null; + } + } else { + return null; + } + } else { + return null; + } + } + + else if(qualifierName.equalsIgnoreCase("Octetstring")){ + if(element instanceof Parameter || element instanceof Property + || element instanceof Operation){ + String octetstring = "octetstring"; + String octetstring_array = "octetstring[]"; + Type type = null; + if(element instanceof Parameter){ + type = ((Parameter)element).getType(); + } else if(element instanceof Property){ + type = ((Property)element).getType(); + } else { + Operation op = (Operation)element; + if(op.getReturnResult("ReturnType") != null){ + type = op.getReturnResult("ReturnType").getType(); + } + } + if(type != null){ + if(type.getName().equalsIgnoreCase(octetstring) || type.getName().equalsIgnoreCase(octetstring_array)){ + return "true"; + } else { + return "false"; + } + } else { + return "false"; + } + } else { + return null; + } + } + + else if(qualifierName.equalsIgnoreCase("Static")){ + if(element instanceof Property){ + if(((Property)element).isStatic()){ + return "true"; + } else { + return "false"; + } + } else if(element instanceof Operation){ + if(((Operation)element).isStatic()){ + return "true"; + } else { + return "false"; + } + } else { + return null; + } + } + + else if(qualifierName.equalsIgnoreCase("Write")){ + if(element instanceof Property){ + if(!(((Property)element).isReadOnly())){ + return "true"; + } else { + return "false"; + } + } else { + return null; + } + } + + return null; + + } + private static boolean propertyIsOwnedEnd(Property prop){ boolean isOwnedEnd = false; @@ -1234,7 +1530,7 @@ return false; } - private static boolean equalMethods(Operation method1, Operation method2){ + public static boolean equalMethods(Operation method1, Operation method2){ if(method1 == null || method2 == null){ return false; @@ -1271,14 +1567,21 @@ EditingDomain editingDomain = UMLModeler.getEditingDomain(); ArrayList applicableQualifiers = getApplicableQualifiers(element); // remove qualifiers with Restricted flavor + boolean removed = false; for(int i = 0; i < applicableQualifiers.size(); i++){ + if(removed){ + i--; + removed = false; + } Qualifier qualifier = (Qualifier)applicableQualifiers.get(i); if(qualifier.RestrictedFlavor){ applicableQualifiers.remove(i); + removed = true; } // remove qualifiers with Enable ToSubclass flavor if(skipEnableOverride && !qualifier.DissableOverrideFlavor && !qualifier.RestrictedFlavor){ applicableQualifiers.remove(i); + removed = true; } } @@ -1293,6 +1596,10 @@ String qualifierValue = null; if(effectiveInheritedValue(element, qualifierName) != null){ qualifierValue = effectiveInheritedValue(element, qualifierName).getValue(); + } else { + if(!(element instanceof Class && ((Class)element).getGenerals().size() == 0)){ + qualifierValue = defaultValue(qualifierName); + } } if(qualifierName.equalsIgnoreCase("Min") && qualifierValue != null){ @@ -1406,7 +1713,7 @@ } } - private ArrayList getApplicableQualifiers(NamedElement element){ + public ArrayList getApplicableQualifiers(NamedElement element){ String elementType = getNamedElementType(element); @@ -1430,6 +1737,18 @@ return applicableQualifers; } + public ArrayList getApplicableDisableOverrideQualifiers(NamedElement element){ + ArrayList list = getApplicableQualifiers(element); + ArrayList returnList = new ArrayList(); + for(int i = 0; i < list.size(); i++){ + Qualifier qualifier = (Qualifier)list.get(i); + if(qualifier.DissableOverrideFlavor && !qualifier.name.equalsIgnoreCase("Key")){ + returnList.add(qualifier); + } + } + return returnList; + } + public void mapQualifierToModel(Element element, String qualifierName, String newValue){ // AGGREGATION, COMPOSITION @@ -1456,7 +1775,7 @@ prop2.setAggregation(AggregationKind.NONE_LITERAL); // just to be sure } } - + // IN, OUT } else if(element instanceof Parameter && (qualifierName.equalsIgnoreCase("In")||qualifierName.equalsIgnoreCase("Out"))){ Index: CheckAndRepair.java =================================================================== RCS file: /cvsroot/sblim/ecute/Plugin/com/ibm/ecute/rsa/core/internal/properties/CheckAndRepair.java,v retrieving revision 1.1 retrieving revision 1.2 diff -u -d -r1.1 -r1.2 --- CheckAndRepair.java 28 Jul 2005 17:59:51 -0000 1.1 +++ CheckAndRepair.java 5 Aug 2005 07:55:14 -0000 1.2 @@ -10,9 +10,13 @@ import org.eclipse.uml2.Class; import org.eclipse.uml2.Model; import org.eclipse.uml2.NamedElement; +import org.eclipse.uml2.Operation; import org.eclipse.uml2.Package; +import org.eclipse.uml2.Parameter; import org.eclipse.uml2.Property; +import com.ibm.ecute.Qualifiers.Qualifier; +import com.ibm.ecute.rsa.core.internal.dialogs.ProgressLogDialog; import com.ibm.ecute.utils.License; /** @@ -41,16 +45,85 @@ this.model = model; this.flavorsHelper = new FlavorsHelper(model); } + + public void checkAll(ProgressLogDialog frame){ + //applyAllNativeInheritedValues(frame); + checkDisableOverrideQualifiers(frame); + } - public void applyAllNativeInheritedValues(NamedElement element){ - ArrayList orderedModelClasses = getOrderedModelClasses(element); + public void checkAndRepairAll(ProgressLogDialog frame){ + applyAllNativeInheritedValues(frame); + //checkDisableOverrideQualifiers(frame); + } + + public void applyAllNativeInheritedValues(ProgressLogDialog frame){ + + frame.addLine2Log("*******************************************************"); + frame.addLine2Log("Propagating all native inherited values"); + frame.addLine2Log("--------------------------------------------------"); + frame.addLine2Log(""); + + ArrayList orderedModelClasses = getOrderedModelClasses(); for(int i = 0; i < orderedModelClasses.size(); i++){ flavorsHelper.applyNativeInheritedValues((NamedElement)orderedModelClasses.get(i), true); } + + frame.addLine2Log("--> complete"); + frame.addLine2Log(""); + } - private ArrayList getOrderedModelClasses(NamedElement element){ - ArrayList classes = getAllModelClasses(element); + public void checkDisableOverrideQualifiers(ProgressLogDialog frame){ + + frame.addLine2Log("***************************************************************************"); + frame.addLine2Log("Checking ToSubclass DisableOverride qualifiers"); + frame.addLine2Log("---------------------------------------------------------"); + + // get all model base classes + ArrayList orderedModelClasses = getOrderedModelClasses(); + ArrayList modelBaseClasses = new ArrayList(); + for(int i = 0; i < orderedModelClasses.size(); i++){ + Class tempClass = (Class)orderedModelClasses.get(i); + if(tempClass.getGenerals().size() == 0){ + modelBaseClasses.add(tempClass); + } + } + ArrayList modelBaseAssociationClasses = new ArrayList(); + for(int i = 0; i < orderedModelClasses.size(); i++){ + if(orderedModelClasses.get(i) instanceof AssociationClass){ + AssociationClass tempClass = (AssociationClass)orderedModelClasses.get(i); + if(tempClass.getGenerals().size() == 0){ + modelBaseAssociationClasses.add(tempClass); + } + } + } + + // check classes + checkDisableOverrideClasses(frame, modelBaseClasses, orderedModelClasses); + + // check associationClasses + checkDisableOverrideAssociationClasses(frame, modelBaseAssociationClasses, orderedModelClasses); + + // check references + checkDisableOverrideReferences(frame, orderedModelClasses); + + // check properties + checkDisableOverrideProperties(frame, orderedModelClasses); + + // check methods + checkDisableOverrideMethods(frame, orderedModelClasses); + + // check parameters + checkDisableOverrideParameters(frame, orderedModelClasses); + + frame.addLine2Log(""); + frame.addLine2Log("--> DisableOverride test complete"); + frame.addLine2Log(""); + frame.addLine2Log("***************************************************************************"); + } + + private ArrayList getOrderedModelClasses(){ + ArrayList classes = getAllModelClasses(); ArrayList orderedClasses = new ArrayList(classes.size()); // get all classes without parents for(int i = 0; i < classes.size(); i++){ @@ -61,11 +134,12 @@ ArrayList tempList = orderedClasses; + // get child classes of the parent classes while(orderedClasses.size() < classes.size()){ ArrayList newOrderedClasses = new ArrayList(); for(int i = 0; i < tempList.size(); i++){ Class class_ = (Class)tempList.get(i); - ArrayList childClasses = getAllChildClasses(class_); + ArrayList childClasses = getAllChildClasses(class_, classes, true); newOrderedClasses.addAll(childClasses); } orderedClasses.addAll(newOrderedClasses); @@ -75,7 +149,7 @@ return orderedClasses; } - private ArrayList getAllModelClasses(NamedElement element){ + private ArrayList getAllModelClasses(){ ArrayList classes = new ArrayList(); // this call is usually used to modify the ownedMembers in the model @@ -109,7 +183,7 @@ ArrayList childClasses = new ArrayList(); // get model classes - ArrayList modelClasses = getAllModelClasses((NamedElement)class_); + ArrayList modelClasses = getAllModelClasses(); if(modelClasses.size() <= 0){ return null; } @@ -140,6 +214,38 @@ return childClasses; } + public ArrayList getAllChildClasses(Class class_, ArrayList modelClasses, boolean remove){ + + ArrayList childClasses = new ArrayList(); + + ArrayList currentChildren = new ArrayList(); + currentChildren.add(class_); + + while(currentChildren.size() > 0){ + String childClassName = ((Class)currentChildren.get(0)).getName(); + int n = modelClasses.size(); + for(int j = 0; j < n; j++){ + if(((Class)modelClasses.get(j)).getGenerals().size() > 0 && + (Class)((Class)modelClasses.get(j)).getGenerals().get(0) != null){ + String className = ((Class)((Class)modelClasses.get(j)).getGenerals().get(0)).getName(); + if(className.equalsIgnoreCase(childClassName)){ + currentChildren.add(modelClasses.get(j)); + childClasses.add(modelClasses.get(j)); + //m++; + if(remove){ + modelClasses.remove(j); + j--; n--; + } + } + } + } + currentChildren.remove(0); + } + + childClasses.trimToSize(); + return childClasses; + } + public ArrayList getOverrideSubProperties(Property property){ ArrayList subproperties = new ArrayList(); // check if property is a class property or an association end @@ -163,12 +269,472 @@ // the override qualifiers set if(FlavorsHelper.override(subProperty)){ subproperties.add(subProperty); + } else { + return subproperties; } } } return subproperties; } + + public ArrayList getOverrideSubMethods(Operation operation){ + ArrayList submethods = new ArrayList(); + + // get subclasses of the class which contains the property + ArrayList subclasses = getAllChildClasses((Class)operation.getOwner()); + + // check if subclasses define the searched method + for(int i = 0; i < subclasses.size(); i++){ + Class subClass = (Class)subclasses.get(i); + Operation method; + method = subClass.getOwnedOperation(operation.getName()); + + if(method != null){ + // if the subclass defines the method then check if the subMethod has + // the override qualifier set + if(FlavorsHelper.override(method)){ + submethods.add(method); + } else { + return submethods; + } + } + } + return submethods; + } + + public ArrayList getOverrideSubParameters(Parameter parameter){ + ArrayList subparameters = new ArrayList(); + + // get the owning method + Operation operation = (Operation)parameter.getOwner(); + + // get subclasses of the class which contains the property + ArrayList subclasses = getAllChildClasses((Class)operation.getOwner()); + + + // check if subclasses define the searched parameter + for(int i = 0; i < subclasses.size(); i++){ + Class subClass = (Class)subclasses.get(i); + Operation method; + method = subClass.getOwnedOperation(operation.getName()); + + if(method != null){ + // if the subclass defines the method then check if the subMethod has + // the override qualifier set + if(FlavorsHelper.override(method) && FlavorsHelper.equalMethods(operation, method)){ + subparameters.add(method.getOwnedParameter(parameter.getName())); + } else { + return subparameters; + } + } + } + return subparameters; + } + + private void checkDisableOverrideClasses(ProgressLogDialog frame, ArrayList modelBaseClasses, ArrayList orderedModelClasses){ + ArrayList disableOverrideClassQualifiers = new ArrayList(); + boolean firstClass = true; + boolean classErrors = false; + for(int i = 0; i < modelBaseClasses.size(); i++){ + Class thisClass = (Class)modelBaseClasses.get(i); + if(disableOverrideClassQualifiers.size() == 0){ + disableOverrideClassQualifiers = flavorsHelper.getApplicableDisableOverrideQualifiers(thisClass); + if(disableOverrideClassQualifiers.size() == 0){ + i = modelBaseClasses.size(); + } + } + if(disableOverrideClassQualifiers.size() > 0){ + ArrayList childClasses = getAllChildClasses(thisClass, orderedModelClasses, false); + for(int j = 0; j < disableOverrideClassQualifiers.size(); j++){ + Qualifier qualifier = (Qualifier)disableOverrideClassQualifiers.get(j); + String valueA = FlavorsHelper.qualifierValue(thisClass, qualifier.name); + boolean firstChild = true; + for(int k = 0; k < childClasses.size(); k++){ + Class class_ = (Class)childClasses.get(k); + String valueB = FlavorsHelper.qualifierValue(class_, qualifier.name); + if(valueA != null && valueB != null && !valueA.equalsIgnoreCase(valueB)|| + valueA == null && valueB != null){ + + if(firstClass){ + frame.addLine2Log(""); + frame.addLine2Log("Classes:"); + firstClass = false; + classErrors = true; + } + + if(firstChild){ + frame.addLine2Log(""); + frame.addLine2Log("The disable override qualifer " + qualifier.name + " defined in"); + frame.addLine2Log(((NamedElement)thisClass.getOwner()).getName() + "::" + thisClass.getName()+ " is overwritten in class "); + firstChild = false; + } + frame.addLine2Log(" - "+ ((NamedElement)class_.getOwner()).getName() + "::" + class_.getName()); + } + } + } + } + } + + if(!classErrors){ + frame.addLine2Log(""); + frame.addLine2Log("Classes: OK"); + } else { + frame.updateImage(frame.getWarningImage()); + } + } + + private void checkDisableOverrideAssociationClasses(ProgressLogDialog frame, ArrayList modelBaseAssociationClasses, ArrayList orderedModelClasses){ + ArrayList disableOverrideAssociationClassQualifiers = new ArrayList(); + boolean firstClass = true; + boolean classErrors = false; + for(int i = 0; i < modelBaseAssociationClasses.size(); i++){ + AssociationClass thisClass = (AssociationClass)modelBaseAssociationClasses.get(i); + if(disableOverrideAssociationClassQualifiers.size() == 0){ + disableOverrideAssociationClassQualifiers = flavorsHelper.getApplicableDisableOverrideQualifiers(thisClass); + if(disableOverrideAssociationClassQualifiers.size() == 0){ + i = modelBaseAssociationClasses.size(); + } + } + if(disableOverrideAssociationClassQualifiers.size() > 0){ + ArrayList childClasses = getAllChildClasses(thisClass, orderedModelClasses, false); + for(int j = 0; j < disableOverrideAssociationClassQualifiers.size(); j++){ + Qualifier qualifier = (Qualifier)disableOverrideAssociationClassQualifiers.get(j); + String valueA = FlavorsHelper.qualifierValue(thisClass, qualifier.name); + boolean firstChild = true; + for(int k = 0; k < childClasses.size(); k++){ + AssociationClass class_ = (AssociationClass)childClasses.get(k); + String valueB = FlavorsHelper.qualifierValue(class_, qualifier.name); + if(valueA != null && valueB != null && !valueA.equalsIgnoreCase(valueB) || + valueA == null && valueB != null){ + + if(firstClass){ + frame.addLine2Log(""); + frame.addLine2Log("AssociationClasses:"); + firstClass = false; + classErrors = true; + } + + if(firstChild){ + frame.addLine2Log(""); + frame.addLine2Log("The disable override qualifer " + qualifier.name + " defined in"); + frame.addLine2Log(((NamedElement)thisClass.getOwner()).getName() + "::" + thisClass.getName()+ " is overwritten in associationClass "); + firstChild = false; + } + frame.addLine2Log(" - "+ ((NamedElement)class_.getOwner()).getName() + "::" + class_.getName()); + } + } + } + } + } + + if(!classErrors){ + frame.addLine2Log(""); + frame.addLine2Log("AssociationClasses: OK"); + } else { + frame.updateImage(frame.getWarningImage()); + } + } + + private void checkDisableOverrideReferences(ProgressLogDialog frame, ArrayList orderedModelClasses){ + + ArrayList disableOverrideReferenceQualifiers = new ArrayList(); + ArrayList checkedSubclassReferences = new ArrayList(); + boolean firstReference = true; + boolean referenceErrors = false; + for(int i = 0; i < orderedModelClasses.size(); i++){ + if(orderedModelClasses.get(i) instanceof AssociationClass){ + AssociationClass thisClass = (AssociationClass)orderedModelClasses.get(i); + List classReferences = thisClass.getOwnedEnds(); + for(int m = 0; m < classReferences.size(); m++){ + Property property = (Property)classReferences.get(m); + if(disableOverrideReferenceQualifiers.size() == 0){ + disableOverrideReferenceQualifiers = flavorsHelper.getApplicableDisableOverrideQualifiers(property); + if(disableOverrideReferenceQualifiers.size() == 0){ + i = orderedModelClasses.size(); + } + } + if(disableOverrideReferenceQualifiers.size() > 0 && !alreadyChecked(property, checkedSubclassReferences)){ + ArrayList childProperties = getOverrideSubProperties(property); + boolean firstQualifier = true; + for(int j = 0; j < disableOverrideReferenceQualifiers.size(); j++){ + Qualifier qualifier = (Qualifier)disableOverrideReferenceQualifiers.get(j); + String valueA = FlavorsHelper.qualifierValue(property, qualifier.name); + boolean firstChild = true; + for(int k = 0; k < childProperties.size(); k++){ + Property childProperty = (Property)childProperties.get(k); + if(firstQualifier){ + checkedSubclassReferences.add(childProperty); + } + String valueB = FlavorsHelper.qualifierValue(childProperty, qualifier.name); + if(valueA != null && valueB != null && !valueA.equalsIgnoreCase(valueB)|| + valueA == null && valueB != null){ + + if(firstReference){ + frame.addLine2Log(""); + frame.addLine2Log("AssociationEnds:"); + firstReference = false; + referenceErrors = true; + } + + if(firstChild){ + frame.addLine2Log(""); + frame.addLine2Log("The disable override qualifer " + qualifier.name + " defined in"); + frame.addLine2Log(((NamedElement)property.getOwner().getOwner()).getName() + "::" + + ((NamedElement)property.getOwner()).getName() + "::" + property.getName() + " is overwritten in associationEnd "); + firstChild = false; + } + frame.addLine2Log(" - " + ((NamedElement)childProperty.getOwner().getOwner()).getName() + "::" + + ((NamedElement)childProperty.getOwner()).getName() + "::" + childProperty.getName()); + } + } + firstQualifier = false; + } + } + } + } + } + + if(!referenceErrors){ + frame.addLine2Log(""); + frame.addLine2Log("AssociationEnds: OK"); + } else { + frame.updateImage(frame.getWarningImage()); + } + + } + + private void checkDisableOverrideProperties(ProgressLogDialog frame, ArrayList orderedModelClasses){ + + ArrayList disableOverridePropertyQualifiers = new ArrayList(); + ArrayList checkedSubclassProperties = new ArrayList(); + boolean firstProperty = true; + boolean propertyErrors = false; + for(int i = 0; i < orderedModelClasses.size(); i++){ + Class thisClass = (Class)orderedModelClasses.get(i); + List classProperties = thisClass.getOwnedAttributes(); + for(int m = 0; m < classProperties.size(); m++){ + Property property = (Property)classProperties.get(m); + if(disableOverridePropertyQualifiers.size() == 0){ + disableOverridePropertyQualifiers = flavorsHelper.getApplicableDisableOverrideQualifiers(property); + if(disableOverridePropertyQualifiers.size() == 0){ + i = orderedModelClasses.size(); + } + } + if(disableOverridePropertyQualifiers.size() > 0 && !alreadyChecked(property, checkedSubclassProperties)){ + ArrayList childProperties = getOverrideSubProperties(property); + boolean firstQualifier = true; + for(int j = 0; j < disableOverridePropertyQualifiers.size(); j++){ + Qualifier qualifier = (Qualifier)disableOverridePropertyQualifiers.get(j); + String valueA = FlavorsHelper.qualifierValue(property, qualifier.name); + boolean firstChild = true; + for(int k = 0; k < childProperties.size(); k++){ + Property childProperty = (Property)childProperties.get(k); + if(firstQualifier){ + checkedSubclassProperties.add(childProperty); + } + String valueB = FlavorsHelper.qualifierValue(childProperty, qualifier.name); + if(valueA != null && valueB != null && !valueA.equalsIgnoreCase(valueB)|| + valueA == null && valueB != null){ + + if(firstProperty){ + frame.addLine2Log(""); + frame.addLine2Log("Properties:"); + firstProperty = false; + propertyErrors = true; + } + + if(firstChild){ + frame.addLine2Log(""); + frame.addLine2Log("The disable override qualifer " + qualifier.name + " defined in"); + frame.addLine2Log(((NamedElement)property.getOwner().getOwner()).getName() + "::" + + ((NamedElement)property.getOwner()).getName() + "::" + property.getName() + " is overwritten in property "); + firstChild = false; + } + frame.addLine2Log(" - " + ((NamedElement)childProperty.getOwner().getOwner()).getName() + "::" + + ((NamedElement)childProperty.getOwner()).getName() + "::" + childProperty.getName()); + } + } + firstQualifier = false; + } + } + } + } + + if(!propertyErrors){ + frame.addLine2Log(""); + frame.addLine2Log("Properties: OK"); + } else { + frame.updateImage(frame.getWarningImage()); + } + + } + + private void checkDisableOverrideMethods(ProgressLogDialog frame, ArrayList orderedModelClasses){ + + ArrayList disableOverrideMethodQualifiers = new ArrayList(); + ArrayList checkedSubclassMethods = new ArrayList(); + boolean firstMethod = true; + boolean methodErrors = false; + for(int i = 0; i < orderedModelClasses.size(); i++){ + Class thisClass = (Class)orderedModelClasses.get(i); + List classMethods = thisClass.getOwnedOperations(); + for(int m = 0; m < classMethods.size(); m++){ + Operation operation = (Operation)classMethods.get(m); + if(disableOverrideMethodQualifiers.size() == 0){ + disableOverrideMethodQualifiers = flavorsHelper.getApplicableDisableOverrideQualifiers(operation); + if(disableOverrideMethodQualifiers.size() == 0){ + i = orderedModelClasses.size(); + } + } + if(disableOverrideMethodQualifiers.size() > 0 && !alreadyChecked(operation, checkedSubclassMethods)){ + ArrayList childMethods = getOverrideSubMethods(operation); + boolean firstQualifier = true; + for(int j = 0; j < disableOverrideMethodQualifiers.size(); j++){ + Qualifier qualifier = (Qualifier)disableOverrideMethodQualifiers.get(j); + String valueA = FlavorsHelper.qualifierValue(operation, qualifier.name); + boolean firstChild = true; + for(int k = 0; k < childMethods.size(); k++){ + Operation childMethod = (Operation)childMethods.get(k); + if(firstQualifier){ + checkedSubclassMethods.add(childMethod); + } + String valueB = FlavorsHelper.qualifierValue(childMethod, qualifier.name); + if(valueA != null && valueB != null && !valueA.equalsIgnoreCase(valueB)|| + valueA == null && valueB != null){ + + if(firstMethod){ + frame.addLine2Log(""); + frame.addLine2Log("Methods:"); + firstMethod = false; + methodErrors = true; + } + + if(firstChild){ + frame.addLine2Log(""); + frame.addLine2Log("The disable override qualifer " + qualifier.name + " defined in"); + frame.addLine2Log(((NamedElement)operation.getOwner().getOwner()).getName() + "::" + + ((NamedElement)operation.getOwner()).getName() + "::" + operation.getName() + " is overwritten in method "); + firstChild = false; + } + frame.addLine2Log(" - " + ((NamedElement)childMethod.getOwner().getOwner()).getName() + "::" + + ((NamedElement)childMethod.getOwner()).getName() + "::" + childMethod.getName()); + } + } + firstQualifier = false; + } + } + } + } + + if(!methodErrors){ + frame.addLine2Log(""); + frame.addLine2Log("Methods: OK"); + } else { + frame.updateImage(frame.getWarningImage()); + } + } + + private void checkDisableOverrideParameters(ProgressLogDialog frame, ArrayList orderedModelClasses){ + + ArrayList disableOverrideParameterQualifiers = new ArrayList(); + ArrayList checkedSubclassParameters = new ArrayList(); + boolean firstParameter = true; + boolean parameterErrors = false; + for(int i = 0; i < orderedModelClasses.size(); i++){ + Class thisClass = (Class)orderedModelClasses.get(i); + List classMethods = thisClass.getOwnedOperations(); + for(int m = 0; m < classMethods.size(); m++){ + Operation operation = (Operation)classMethods.get(m); + List methodParameters = operation.getOwnedParameters(); + for(int n = 0; n < methodParameters.size(); n++){ + Parameter parameter = (Parameter)methodParameters.get(n); + if(disableOverrideParameterQualifiers.size() == 0){ + disableOverrideParameterQualifiers = flavorsHelper.getApplicableDisableOverrideQualifiers(parameter); + if(disableOverrideParameterQualifiers.size() == 0){ + i = orderedModelClasses.size(); + } + } + if(disableOverrideParameterQualifiers.size() > 0 && !alreadyChecked(parameter, checkedSubclassParameters)){ + ArrayList childParameters = getOverrideSubParameters(parameter); + boolean firstQualifier = true; + for(int j = 0; j < disableOverrideParameterQualifiers.size(); j++){ + Qualifier qualifier = (Qualifier)disableOverrideParameterQualifiers.get(j); + String valueA = FlavorsHelper.qualifierValue(parameter, qualifier.name); + boolean firstChild = true; + for(int k = 0; k < childParameters.size(); k++){ + Parameter childParameter = (Parameter)childParameters.get(k); + if(firstQualifier){ + checkedSubclassParameters.add(childParameter); + } + String valueB = FlavorsHelper.qualifierValue(childParameter, qualifier.name); + if(valueA != null && valueB != null && !valueA.equalsIgnoreCase(valueB)|| + valueA == null && valueB != null){ + + if(firstParameter){ + frame.addLine2Log(""); + frame.addLine2Log("Method parameters:"); + firstParameter = false; + parameterErrors = true; + } + + if(firstChild){ + frame.addLine2Log(""); + frame.addLine2Log("The disable override qualifer " + qualifier.name + " defined in"); + frame.addLine2Log(((NamedElement)parameter.getOwner().getOwner().getOwner()).getName() + "::" + + ((NamedElement)parameter.getOwner().getOwner()).getName() + "::" + + ((NamedElement)parameter.getOwner()).getName() + "::" + parameter.getName() + " is overwritten in parameter "); + firstChild = false; + } + frame.addLine2Log(" - " + ((NamedElement)childParameter.getOwner().getOwner().getOwner()).getName() + "::" + + ((NamedElement)childParameter.getOwner().getOwner()).getName() + "::" + + ((NamedElement)childParameter.getOwner()).getName() + "::" + childParameter.getName()); + } + } + firstQualifier = false; + } + } + } + } + } + + if(!parameterErrors){ + frame.addLine2Log(""); + frame.addLine2Log("Method parameters: OK"); + } else { + frame.updateImage(frame.getWarningImage()); + } + } + + private boolean alreadyChecked(NamedElement element, ArrayList checkedSubclassElements){ + + if(element instanceof Property){ + Property property = (Property)element; + for(int i = 0; i < checkedSubclassElements.size(); i++){ + if(property.equals((Property)checkedSubclassElements.get(i))){ + return true; + } + } + } else if(element instanceof Operation){ + Operation operation = (Operation)element; + for(int i = 0; i < checkedSubclassElements.size(); i++){ + if(operation.equals((Operation)checkedSubclassElements.get(i))){ + return true; + } + } + } else if(element instanceof Parameter){ + Parameter parameter = (Parameter)element; + for(int i = 0; i < checkedSubclassElements.size(); i++){ + if(parameter.equals((Parameter)checkedSubclassElements.get(i))){ + return true; + } + } + } + + + return false; + } + public boolean isReference(NamedElement element){ boolean isRef = false; Index: QualifiersPropertySection.java =================================================================== RCS file: /cvsroot/sblim/ecute/Plugin/com/ibm/ecute/rsa/core/internal/properties/QualifiersPropertySection.java,v retrieving revision 1.24 retrieving revision 1.25 diff -u -d -r1.24 -r1.25 --- QualifiersPropertySection.java 28 Jul 2005 17:59:51 -0000 1.24 +++ QualifiersPropertySection.java 5 Aug 2005 07:55:14 -0000 1.25 @@ -14,6 +14,8 @@ import java.util.Locale; import java.util.Vector; +import javax.swing.UIManager; + import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.emf.common.notify.Notification; @@ -58,6 +60,7 @@ import com.ibm.ecute.Qualifiers.Qualifier; import com.ibm.ecute.Qualifiers.QualifiersList; import com.ibm.ecute.rsa.core.internal.dialogs.EditQualifiersDialog; +import com.ibm.ecute.rsa.core.internal.dialogs.ProgressLogDialog; import com.ibm.ecute.utils.License; import com.ibm.xtools.common.ui.properties.TabbedPropertySheetPage; import com.ibm.xtools.emf.msl.EditingDomain; @@ -90,6 +93,7 @@ private Button editValueButton; public Button showAllButton; private Button inheritedValueButton; + private Button checkButton; private Button checkAndRepairButton; private TableColumn nameColumn; private TableColumn valueColumn; @@ -166,25 +170,61 @@ }); - //formdata inherited values buootn + //formdata inherited values button formdata = new FormData(); formdata.left = new FormAttachment(inheritedValueButton,10); formdata.top = new FormAttachment(0,0); - checkAndRepairButton = getWidgetFactory().createButton(composite1, "Check and Repair", 8); - checkAndRepairButton.setLayoutData(formdata); - checkAndRepairButton.addSelectionListener(new SelectionAdapter() { + checkButton = getWidgetFactory().createButton(composite1, "Check", 8); + checkButton.setLayoutData(formdata); + checkButton.addSelectionListener(new SelectionAdapter() { public void widgetSelected(SelectionEvent selectionevent) { final NamedElement element = (NamedElement)getEObject(); + + try { + UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); + } catch (Exception e) { + } + Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(); + ProgressLogDialog frame = new ProgressLogDialog(shell); + CheckAndRepair checkAndRepair = new CheckAndRepair(element.getModel()); - checkAndRepair.applyAllNativeInheritedValues(element); + checkAndRepair.checkAll(frame); refresh(); } }); + //formdata inherited values button + formdata = new FormData(); + formdata.left = new FormAttachment(checkButton,5); + formdata.top = new FormAttachment(0,0); + checkAndRepairButton = getWidgetFactory().createButton(composite1, "Check and Repair", 8); + checkAndRepairButton.setLayoutData(formdata); + checkAndRepairButton.addSelectionListener(new SelectionAdapter() { + + public void widgetSelected(SelectionEvent selectionevent) + { +// final NamedElement element = (NamedElement)getEObject(); +// +// try { +// UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); +// //"com.sun.java.swing.plaf.windows.WindowsLookAndFeel"); +// } catch (Exception e) { +// } +// Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(); +// ProgressLogDialog frame = new ProgressLogDialog(shell); +// +// CheckAndRepair checkAndRepair = new CheckAndRepair(element.getModel()); +// checkAndRepair.checkAll(frame); +// refresh(); + } + + }); + + //Table qualifiersTable = getWidgetFactory().createTable(composite1, SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.SINGLE| SWT.MouseDoubleClick); qualifiersTable.setHeaderVisible(true); |
