[Sblim-commit] ecute/Plugin/com/ibm/ecute/UMLBuffer UMLBuffer.java,1.10,1.11

[Benjamin B. <bg...@us...>]

Update of /cvsroot/sblim/ecute/Plugin/com/ibm/ecute/UMLBuffer
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv9740/Plugin/com/ibm/ecute/UMLBuffer

Modified Files:
	UMLBuffer.java 
Log Message:


Index: UMLBuffer.java
===================================================================
RCS file: /cvsroot/sblim/ecute/Plugin/com/ibm/ecute/UMLBuffer/UMLBuffer.java,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -d -r1.10 -r1.11
--- UMLBuffer.java	15 Jul 2005 13:43:39 -0000	1.10
+++ UMLBuffer.java	19 Jul 2005 16:10:48 -0000	1.11
@@ -42,6 +42,7 @@
 	private static final String COPYRIGHT = License.COPYRIGHT;
 	private UMLFile mainFile;
 	private UMLClass lastClass = null;
+	private UMLClass lastCreatedClass = null;
 	private UMLClass lastAssociationClass = null;
 	private UMLFile lastFile = null;
 	private UMLMethod lastMethod = null;
@@ -51,12 +52,12 @@
 	boolean aggregateRole1 = true;
 	//boolean parentAggregates = false;
 	UMLClass parentAggregateClass = null;
-	boolean inheritedAggregate = false;
-	boolean isFirstAggregate = false;
-	boolean parentTwisted = false;
-	boolean parentRole1Aggregates = false;
-	boolean parentRole2Aggregates = false;
-	boolean thisClassAggregates = false;
+	//boolean inheritedAggregate = false;
+	//boolean isFirstAggregate = false;
+	//boolean parentTwisted = false;
+	//boolean parentRole1Aggregates = false;
+	//boolean parentRole2Aggregates = false;
+	//boolean thisClassAggregates = false;
 	boolean ready = false;
 	private ProgressFrame log;
 	public UMLBuffer(ProgressFrame log) {
@@ -414,7 +415,7 @@
 						}
 						break;
 				}
-				ArrayList qualifiers = theClass.getQualifiers(!completeClasses);
+				//ArrayList qualifiers = theClass.getQualifiers(!completeClasses);
 				CreateQualifiers(theClass);
 				createAttributes(theClass.getAttributes(!completeClasses));
 				CreateMethods(theClass.getMethods(!completeClasses));
@@ -522,89 +523,16 @@
 		}
 		return leftClasses;
 	}
+	
 	void CreateQualifiers(UMLQualified qualifiedElement) {
 
 		if (UMLProgram instanceof RSAModelCreator){
-			// set UMLClass attribute, if the references are twisted
-			// required for flavor inheritance
-			if (qualifiedElement.getType() == TCLASS &&
-					((UMLClass)qualifiedElement).getRole1() != null &&
-					((UMLClass)qualifiedElement).getRole2() != null){
-				if(((UMLClass)qualifiedElement).getBaseUMLClass() == null){ //TODO change this condition
-					
-					parentAggregateClass = (UMLClass)qualifiedElement;
-					
-//					if(((UMLClass)qualifiedElement).getRole2().getQualifier("Aggregate", true) != null){
-//						parentTwisted = true;
-//						//parentRole2Aggregates = true;
-//					} else if(((UMLClass)qualifiedElement).getRole1().getQualifier("Aggregate", true) != null){
-//						parentTwisted = false;
-//						//parentRole1Aggregates = true;
-//					} else {
-//						parentTwisted = false;
-//					}
-					
-					//isFirstAggregate = true;
-					
-				} //else {
-				//	isFirstAggregate = false;
-				//}
-				
-			}
 			
-			if (qualifiedElement.getType() == TCLASS 
-					&& ((UMLClass)qualifiedElement).getRole1() != null 
-					&& ((UMLClass)qualifiedElement).getRole2() != null 
-					&& ((UMLClass)qualifiedElement).getBaseUMLClass() != null
-					&& ((UMLClass)qualifiedElement).getQualifier("Aggregation", true) == null 
-					&& ((UMLClass)qualifiedElement).getQualifier("Composition", true) == null){
-
-				UMLClass thisClass		= (UMLClass)qualifiedElement;
-				UMLClass parentClass 	= ((UMLClass)qualifiedElement).getBaseUMLClass(); 
-				if(parentClass.getQualifier("Aggregation", true) != null && thisClass.getQualifier("Aggregation", true) == null){
-					thisClass.getQualifiers(true).add(parentClass.getQualifier("Aggregation", true));
-				}
-				if(parentClass.getQualifier("Composition", true) != null && thisClass.getQualifier("Composition", true) == null){
-					thisClass.getQualifiers(true).add(parentClass.getQualifier("Composition", true));
-				}
-
+			if(qualifiedElement.getType() == TCLASS){
+				lastCreatedClass = (UMLClass) qualifiedElement;
 			}
 			
-			if((qualifiedElement.getType() == TLINK1 || qualifiedElement.getType() == TLINK2) 
-					&& lastAssociationClass.getBaseUMLClass() != null 
-					&& lastAssociationClass.getBaseUMLClass().getRole1() != null 
-					&& lastAssociationClass.getBaseUMLClass().getRole2() != null){
-				
-				UMLRole role = (UMLRole)qualifiedElement;
-				UMLClass parentAssociationClass = lastAssociationClass.getBaseUMLClass();
-
-				if(qualifiedElement.getType() == TLINK1){
-					UMLRole parentRole1 = parentAssociationClass.getRole1();
-					
-					if(role.getQualifier("Min", true) == null && parentRole1.getQualifier("Min", true) != null){
-						role.getQualifiers(true).add(parentRole1.getQualifier("Min", true));
-					}
-					if(role.getQualifier("Max", true) == null && parentRole1.getQualifier("Max", true) != null){
-						role.getQualifiers(true).add(parentRole1.getQualifier("Max", true));
-					}
-					if(role.getQualifier("Key", true) == null && parentRole1.getQualifier("Key", true) != null){
-						role.getQualifiers(true).add(parentRole1.getQualifier("Key", true));
-					}
-					
-				} else if(qualifiedElement.getType() == TLINK2){
-					UMLRole parentRole2 = parentAssociationClass.getRole2();
-					
-					if(role.getQualifier("Min", true) == null && parentRole2.getQualifier("Min", true) != null){
-						role.getQualifiers(true).add(parentRole2.getQualifier("Min", true));
-					}
-					if(role.getQualifier("Max", true) == null && parentRole2.getQualifier("Max", true) != null){
-						role.getQualifiers(true).add(parentRole2.getQualifier("Max", true));
-					}
-					if(role.getQualifier("Key", true) == null && parentRole2.getQualifier("Key", true) != null){
-						role.getQualifiers(true).add(parentRole2.getQualifier("Key", true));
-					}
-				}
-			}				
+			getInheritedQualifiers(qualifiedElement);
 		}
 		
 		ArrayList qualifiers = qualifiedElement.getQualifiers(!completeClasses);
@@ -676,41 +604,7 @@
 			if (UMLProgram instanceof RSAModelCreator){
 				boolean aggregate = false;
 				
-
-				
-				// BB - set the aggregate diamond on the correct side of the association
-				// for normal and inherited associations
-				if(role1.getQualifier("Aggregate", true) == null &&	role2.getQualifier("Aggregate", true) == null){
-					
-					if(parentAggregateClass != null && parentAggregateClass.getRole1() != null 
-							&& parentAggregateClass.getRole2() != null
-							/*theClass.getBaseUMLClass() != null && theClass.getBaseUMLClass().getRole1() != null 
-							&& theClass.getBaseUMLClass().getRole2() != null*/ ){
-						
-						
-						//UMLClass parentAggregateClass = theClass.getBaseUMLClass();
-						UMLRole parentRole1 = parentAggregateClass.getRole1();
-						UMLRole parentRole2 = parentAggregateClass.getRole2();
-						
-						if(parentRole1.getQualifier("Aggregate", true) != null /*&& !parentTwisted*/){
-							role1.getQualifiers(true).add(parentRole1.getQualifier("Aggregate", true));
-							//parentTwisted = true;
-						/*} else if(parentRole1.getQualifier("Aggregate", true) != null && parentTwisted){
-							role2.getQualifiers(true).add(parentRole1.getQualifier("Aggregate", true));
-							//parentTwisted = false;
-						} else if(parentRole2.getQualifier("Aggregate", true) != null && !parentTwisted){
-							role2.getQualifiers(true).add(parentRole2.getQualifier("Aggregate", true));
-							//parentTwisted = true;*/
-						} else if(parentRole2.getQualifier("Aggregate", true) != null /*&& parentTwisted*/){
-							role2.getQualifiers(true).add(parentRole2.getQualifier("Aggregate", true));
-							//parentTwisted = false;
-						}
-						
-						//inheritedAggregate = true;
-					} /*else {
-						inheritedAggregate = false;
-					}*/
-				}
+				getInheritedAggregateQualifier(role1, role2);
 
 				//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 				// BB- this part influences the direction of the association in the property view +
@@ -816,4 +710,300 @@
 		theTime = theTime + calendar.get(Calendar.SECOND);
 		return theTime;
 	}
+	
+	//*********************************************************************
+	// FLAVORS METHODS FOR RSA
+	//*********************************************************************
+	
+	private void getInheritedQualifiers(UMLQualified qualifiedElement){
+		
+		// propagate class/associationClass qualifiers
+		if (qualifiedElement.getType() == TCLASS &&
+				((UMLClass)qualifiedElement).getRole1() != null &&
+				((UMLClass)qualifiedElement).getRole2() != null){
+			if(((UMLClass)qualifiedElement).getBaseUMLClass() == null){
+				parentAggregateClass = (UMLClass)qualifiedElement;
+			} 
+		}
+		
+		if (qualifiedElement.getType() == TCLASS 
+				&& ((UMLClass)qualifiedElement).getRole1() != null 
+				&& ((UMLClass)qualifiedElement).getRole2() != null 
+				&& ((UMLClass)qualifiedElement).getBaseUMLClass() != null){
+
+			UMLClass thisClass		= (UMLClass)qualifiedElement;
+			UMLClass parentClass 	= thisClass.getBaseUMLClass(); 
+			
+			if(thisClass.getQualifier("Association", true) == null && parentClass.getQualifier("Association", true) != null){
+				thisClass.getQualifiers(true).add(parentClass.getQualifier("Association", true));
+			}
+			
+			if(thisClass.getQualifier("Aggregation", true) == null && parentClass.getQualifier("Aggregation", true) != null){
+				thisClass.getQualifiers(true).add(parentClass.getQualifier("Aggregation", true));
+			}
+			
+			if(thisClass.getQualifier("Composition", true) == null && parentClass.getQualifier("Composition", true) != null){
+				thisClass.getQualifiers(true).add(parentClass.getQualifier("Composition", true));
+			}
+
+		}
+		
+		// propagate reference qualifiers
+		if((qualifiedElement.getType() == TLINK1 || qualifiedElement.getType() == TLINK2) 
+				&& lastAssociationClass.getBaseUMLClass() != null 
+				&& lastAssociationClass.getBaseUMLClass().getRole1() != null 
+				&& lastAssociationClass.getBaseUMLClass().getRole2() != null){
+			
+			UMLRole role = (UMLRole)qualifiedElement;
+			UMLClass parentAssociationClass = lastAssociationClass.getBaseUMLClass();
+
+			if(qualifiedElement.getType() == TLINK1 && role.getQualifier("Override", true) != null){
+				UMLRole parentRole1 = parentAssociationClass.getRole1();
+				
+				if(role.getQualifier("Min", true) == null && parentRole1.getQualifier("Min", true) != null){
+					role.getQualifiers(true).add(parentRole1.getQualifier("Min", true));
+				}
+				if(role.getQualifier("Max", true) == null && parentRole1.getQualifier("Max", true) != null){
+					role.getQualifiers(true).add(parentRole1.getQualifier("Max", true));
+				}
+//				if(role.getQualifier("Key", true) == null && parentRole1.getQualifier("Key", true) != null){
+//					role.getQualifiers(true).add(parentRole1.getQualifier("Key", true));
+//				}
+				
+			} else if(qualifiedElement.getType() == TLINK2  && role.getQualifier("Override", true) != null){
+				UMLRole parentRole2 = parentAssociationClass.getRole2();
+				
+				if(role.getQualifier("Min", true) == null && parentRole2.getQualifier("Min", true) != null){
+					role.getQualifiers(true).add(parentRole2.getQualifier("Min", true));
+				}
+				if(role.getQualifier("Max", true) == null && parentRole2.getQualifier("Max", true) != null){
+					role.getQualifiers(true).add(parentRole2.getQualifier("Max", true));
+				}
+//				if(role.getQualifier("Key", true) == null && parentRole2.getQualifier("Key", true) != null){
+//					role.getQualifiers(true).add(parentRole2.getQualifier("Key", true));
+//				}
+			}
+		}
+		
+		//	propagate property qualifiers
+		if(qualifiedElement.getType() == TATTRIBUTE){
+			
+			UMLAttribute attribute = (UMLAttribute) qualifiedElement;
+			if(attribute.getQualifier("Override", true) != null){
+				String overrideValue = ((UMLQualifier)attribute.getQualifier("Override", true)).value;
+				if(overrideValue == null){
+					overrideValue = attribute.getName();
+				}
+				
+				UMLAttribute 	overwrittenAttribute 	= null;
+				UMLClass	 	lastCheckedClass 		= lastCreatedClass;
+				boolean 		attributeFound 			= false;
+				
+				while(lastCheckedClass.getBaseUMLClass() != null){
+					ArrayList parentClassAttributes = lastCheckedClass.getBaseUMLClass().getAttributes(true);
+					
+					for(int i = 0; i < parentClassAttributes.size(); i++){
+						UMLAttribute parentAttribute = (UMLAttribute)parentClassAttributes.get(i);
+						if(parentAttribute.getName().equalsIgnoreCase(overrideValue)){
+							overwrittenAttribute = parentAttribute;
+							attributeFound = true;
+							break;
+						}
+					}
+					
+					if(!attributeFound){
+						lastCheckedClass = lastCheckedClass.getBaseUMLClass();
+					} else {
+						break;
+					}
+				}
+				
+				if(overwrittenAttribute != null){
+					if(attribute.getQualifier("Octetstring", true) == null 
+							&& overwrittenAttribute.getQualifier("Octetstring", true) != null){
+						attribute.getQualifiers(true).add(overwrittenAttribute.getQualifier("Octetstring", true));
+					}
+					
+					if(attribute.getQualifier("Static", true) == null 
+							&& overwrittenAttribute.getQualifier("Static", true) != null){
+						attribute.getQualifiers(true).add(overwrittenAttribute.getQualifier("Static", true));
+					}
+					
+					if(attribute.getQualifier("Write", true) == null 
+							&& overwrittenAttribute.getQualifier("Write", true) != null){
+						attribute.getQualifiers(true).add(overwrittenAttribute.getQualifier("Write", true));
+					}
+				}
+			}
+		}
+		
+		//	propagate method qualifiers
+		if(qualifiedElement.getType() == TMETHOD){
+			
+			UMLMethod method = (UMLMethod) qualifiedElement;
+			if(method.getQualifier("Override", true) != null){
+				String overrideValue = ((UMLQualifier)method.getQualifier("Override", true)).value;
+				if(overrideValue == null){
+					overrideValue = method.getName();
+				}
+				
+				UMLMethod	overwrittenMethod = null;
+				UMLClass 	lastCheckedClass  = lastCreatedClass;
+				boolean 	methodFound 	  = false;
+
+				while(lastCheckedClass.getBaseUMLClass() != null){
+//					ArrayList parentClassAttributes = lastCheckedClass.getBaseUMLClass().getAttributes(true);
+					
+//					for(int i = 0; i < parentClassAttributes.size(); i++){
+//						UMLAttribute parentAttribute = (UMLAttribute)parentClassAttributes.get(i);
+//						if(parentAttribute.getName().equalsIgnoreCase(overrideValue)){
+//							overwrittenAttribute = parentAttribute;
+//							attributeFound = true;
+//							break;
+//						}
+//					}
+					
+					ArrayList parentClassMethods = lastCheckedClass.getBaseUMLClass().getMethods(true);
+					for(int i = 0; i < parentClassMethods.size(); i++){
+						UMLMethod parentMethod = (UMLMethod)parentClassMethods.get(i);
+						if(parentMethod.getName().equalsIgnoreCase(overrideValue)){
+							
+							overwrittenMethod = parentMethod;
+							
+							ArrayList methodParameters 				= method.getParameters();
+							ArrayList overwrittenMethodParameters 	= overwrittenMethod.getParameters();
+							
+							// check number of parameters
+							if(methodParameters.size() != overwrittenMethodParameters.size()){
+								methodFound = false;
+								overwrittenMethod = null;
+								break;
+							}
+							
+							// check names and types of parameters
+							for(int j = 0; j < methodParameters.size(); j++){
+								UMLParameter parameter = (UMLParameter)methodParameters.get(j);
+								UMLParameter parentParameter = (UMLParameter)overwrittenMethodParameters.get(j);
+								
+								if(!parameter.getDataType().equalsIgnoreCase(parentParameter.getDataType()) 
+										|| !parameter.getName().equalsIgnoreCase(parentParameter.getName())){
+									methodFound = false;
+									overwrittenMethod = null;
+									break;
+								}
+							}
+							
+							methodFound = true;
+							break;
+						}
+					}
+					
+					if(!methodFound){
+						lastCheckedClass = lastCheckedClass.getBaseUMLClass();
+					} else {
+						break;
+					}
+				}	
+				
+				if(overwrittenMethod != null){
+					
+//					ArrayList methodParameters 				= method.getParameters();
+//					ArrayList overwrittenMethodParameters 	= overwrittenMethod.getParameters();
+//					
+//					// check number of parameters
+//					if(methodParameters.size() != overwrittenMethodParameters.size()){
+//						return;
+//					}
+//					
+//					// check names and types of parameters
+//					for(int i = 0; i < methodParameters.size(); i++){
+//						UMLParameter parameter = (UMLParameter)methodParameters.get(i);
+//						UMLParameter parentParameter = (UMLParameter)overwrittenMethodParameters.get(i);
+//						
+//						if(!parameter.getDataType().equalsIgnoreCase(parentParameter.getDataType()) 
+//								|| !parameter.getName().equalsIgnoreCase(parentParameter.getName())){
+//							return;
+//						}
+//					}
+					
+					if(method.getQualifier("Octetstring", true) == null 
+							&& overwrittenMethod.getQualifier("Octetstring", true) != null){
+						method.getQualifiers(true).add(overwrittenMethod.getQualifier("Octetstring", true));
+					}
+					
+					if(method.getQualifier("Static", true) == null 
+							&& overwrittenMethod.getQualifier("Static", true) != null){
+						method.getQualifiers(true).add(overwrittenMethod.getQualifier("Static", true));
+					}
+				
+					getInheritedParameterQualifiers(method, overwrittenMethod);
+				}
+			}
+		}
+	}
+	
+	private void getInheritedParameterQualifiers(UMLMethod method, UMLMethod parentMethod){
+		ArrayList methodParameters 			= method.getParameters();
+		ArrayList parentMethodParameters 	= parentMethod.getParameters();
+		
+//		// check number of parameters
+//		if(methodParameters.size() != parentMethodParameters.size()){
+//			return;
+//		}
+//		
+//		// check names and types of parameters
+//		for(int i = 0; i < methodParameters.size(); i++){
+//			UMLParameter parameter = (UMLParameter)methodParameters.get(i);
+//			UMLParameter parentParameter = (UMLParameter)parentMethodParameters.get(i);
+//			
+//			if(!parameter.getDataType().equalsIgnoreCase(parentParameter.getDataType()) 
+//					|| !parameter.getName().equalsIgnoreCase(parentParameter.getName())){
+//				return;
+//			}
+//		}
+		
+		// set qualifiers
+		for(int i = 0; i < methodParameters.size(); i++){
+			UMLParameter parameter = (UMLParameter)methodParameters.get(i);
+			UMLParameter parentParameter = (UMLParameter)parentMethodParameters.get(i);
+
+			if(parameter.getQualifier("In", true) == null 
+					&& parentParameter.getQualifier("In", true) != null){
+				parameter.getQualifiers(true).add(parentParameter.getQualifier("In", true));
+			}
+			
+			if(parameter.getQualifier("Out", true) == null 
+					&& parentParameter.getQualifier("Out", true) != null){
+				parameter.getQualifiers(true).add(parentParameter.getQualifier("Out", true));
+			}
+			
+			if(parameter.getQualifier("Octetstring", true) == null 
+					&& parentParameter.getQualifier("Octetstring", true) != null){
+				parameter.getQualifiers(true).add(parentParameter.getQualifier("Octetstring", true));
+			}
+		}
+
+	}
+	
+	private void getInheritedAggregateQualifier(UMLRole role1, UMLRole role2){
+		// BB - set the aggregate diamond on the correct side of the association
+		// for normal and inherited associations
+		if(role1.getQualifier("Aggregate", true) == null &&	role2.getQualifier("Aggregate", true) == null){
+			
+			if(parentAggregateClass != null && parentAggregateClass.getRole1() != null 
+					&& parentAggregateClass.getRole2() != null){
+				
+				UMLRole parentRole1 = parentAggregateClass.getRole1();
+				UMLRole parentRole2 = parentAggregateClass.getRole2();
+				
+				if(parentRole1.getQualifier("Aggregate", true) != null){
+					role1.getQualifiers(true).add(parentRole1.getQualifier("Aggregate", true));
+				} else if(parentRole2.getQualifier("Aggregate", true) != null){
+					role2.getQualifiers(true).add(parentRole2.getQualifier("Aggregate", true));
+				}
+			}
+		}
+	}
+	 
+	
 }
\ No newline at end of file