How to Update child class when parent class changes in Enterprise Architect - oop

Question

I want to make a class diagram in Enterprise Architect ( Version 10.0 ) which implement an inheritance. I add an abstract class then create 3 class which implement abstract class.
Now if I make some change in abstract class, child classes doesn't change. (for example add another method to abstract class, but child class dose not have this method).
How can update(or refresh) a child class when parent class changed?

Answer 1

Select the class and press Ctrl + Shift + o to refresh. However this doesn't perform full refresh, so you will need to remove older versions of operations etc, but EA will display the override methods dialog.

Answer 2

You can use my addin EA-Matic to do so.
EA-Matic catches the add-in events in Enterprise Architect and forwards them the built-in scripting environment.
This allows to create scripts with full blown add-in abilities, synchronizing overrides is just one of the possible applications.
One of the example scripts I wrote to demonstrate the add-in does exactly this: Automatically synchronize overrides in Enterprise Architect with EA-Matic
This example script uses the events EA_OnContextItemChanged to store the overrides of the selected operation
'Event Called when a new element is selected in the context. We use this operation to keep the id of the selected operation and a list of its overrides
'Because now is the only moment we are able to find it's overrides. Once changed we cannot find the overrides anymore because then they already
'have a different signature
function EA_OnContextItemChanged(GUID, ot)
'we only want to do something when the selected element is an operation
if ot = otMethod then
'get the model
dim model
set model = getEAAddingFrameworkModel()
'get the operation
dim operation
set operation = model.getOperationByGUID(GUID)
'remember the operationID
operationID = operation.id
'remember the overrides
set overrides = getOverrides(operation, model)
Repository.WriteOutput "EA-Matic", overrides.Count & " overrides found for: " & operation.name,0
end if
end function
and EA_OnNotifyContextItemModified to modify the overrides in case something changed.
'Event called when an element is changed. Unfortunately EA doesn't call it for an operation, only for the owner so we have to work with that.
function EA_OnNotifyContextItemModified(GUID, ot)
'we only want to do something when the selected element is an operation
if ot = otElement then
'get the operation
'Here we use the EA API object directly as most set methods are not implemented in EA Addin Framework
dim wrappedOperation
set wrappedOperation = Repository.GetMethodByID(operationID)
dim modifiedElement
set modifiedElement = Repository.GetElementByGuid(GUID)
if not wrappedOperation is Nothing and not modifiedElement is Nothing then
'check to be sure we have the same operation
if modifiedElement.ElementID = wrappedOperation.ParentID AND overrides.Count > 0 then
dim synchronizeYes
synchronizeYes = MsgBox("Found " & overrides.Count & " override(s) for operation "& modifiedElement.Name & "." & wrappedOperation.Name & vbNewLine & "Synchronize?" _
,vbYesNo or vbQuestion or vbDefaultButton1, "Synchronize overrides?")
if synchronizeYes = vbYes then
synchronizeOverrides wrappedOperation
'log to output
Repository.WriteOutput "EA-Matic", "Operation: " & wrappedOperation.name &" synchronized" ,0
end if
'reset operationID to avoid doing it all again
operationID = 0
end if
end if
end if
end function
In OnContextItemChanged it gets the overrides by first selecting all operations with the same signature from the model with a query.
'gets the overrides of the given operation by first getting all operations with the same signature and then checking if they are owned by a descendant
function getOverrides(operation, model)
'first get all operations with the exact same signature
dim overrideQuery
overrideQuery = "select distinct op2.OperationID from (((t_operation op " & _
"inner join t_operation op2 on op2.[Name] = op.name) "& _
"left join t_operationparams opp on op.OperationID = opp.OperationID) "& _
"left join t_operationparams opp2 on opp2.OperationID = op2.OperationID) "& _
"where op.OperationID = "& operation.id &" "& _
"and op2.ea_guid <> op.ea_guid "& _
"and (op2.TYPE = op.Type OR (op2.TYPE is null AND op.Type is null)) "& _
"and (op2.Classifier = op.Classifier OR (op2.Classifier is null AND op.Classifier is null)) "& _
"and (opp.Name = opp2.Name OR (opp.Name is null AND opp2.Name is null)) "& _
"and (opp.TYPE = opp2.TYPE OR (opp.TYPE is null AND opp2.Type is null)) "& _
"and (opp.DEFAULT = opp2.DEFAULT OR (opp.DEFAULT is null AND opp2.DEFAULT is null)) "& _
"and (opp.Kind = opp2.Kind OR (opp.Kind is null AND opp2.Kind is null)) "& _
"and (opp.Classifier = opp2.Classifier OR (opp.Classifier is null AND opp2.Classifier is null)) "
dim candidateOverrides
set candidateOverrides = model.ToArrayList(model.getOperationsByQuery(overrideQuery))
'then get the descendants of the owner
dim descendants
dim descendant
'first find all elements that either inherit from the owner or realize it
dim owner
set owner = model.toObject(operation.owner)
set descendants = getDescendants(owner, model)
'then filter the candidates to only those of the descendants
'loop operations backwards
dim i
for i = candidateOverrides.Count -1 to 0 step -1
dim found
found = false
for each descendant in descendants
if descendant.id = model.toObject(candidateOverrides(i).owner).id then
'owner is a descendant, operation can stay
found = true
exit for
end if
next
'remove operation from non descendants
if not found then
candidateOverrides.RemoveAt(i)
end if
next
set getOverrides = candidateOverrides
end function
Then we its all the descendants of the owner of the operation (recursively) and filter the operations to only those owned by a descendant.
'gets all descendant of an element. That is all subclasses and classes that Realize the element.
'Works recursively to get them all.
function getDescendants(element, model)
dim descendants
dim getdescendantsQuery
getdescendantsQuery = "select c.Start_Object_ID as Object_ID from (t_object o " _
& "inner join t_connector c on c.End_Object_ID = o.Object_ID) " _
& "where "_
& "(c.[Connector_Type] like 'Generali_ation' "_
& "or c.[Connector_Type] like 'Reali_ation' )"_
& "and o.Object_ID = " & element.id
set descendants = model.toArrayList(model.getElementWrappersByQuery(getdescendantsQuery))
'get the descendants descendants as well
dim descendant
dim descendantsChildren
for each descendant in descendants
if IsEmpty(descendantsChildren) then
set descendantsChildren = getDescendants(descendant, model)
else
descendantsChildren.AddRange(getDescendants(descendant, model))
end if
next
'add the descendantsChildren to the descendants
if not IsEmpty(descendantsChildren) then
if descendantsChildren.Count > 0 then
descendants.AddRange(descendantsChildren)
end if
end if
set getDescendants = descendants
end function
Finally it synchronizes the operations using the following functions
'Synchronizes the operation with it's overrides
function synchronizeOverrides(wrappedOperation)
dim override
for each override in overrides
dim wrappedOverride
set wrappedOverride = override.WrappedOperation
'synchronize the operation with the override
synchronizeOperation wrappedOperation, wrappedOverride
'tell EA something might have changed
Repository.AdviseElementChange wrappedOverride.ParentID
next
end function
'Synchronizes the operation with the given override
function synchronizeOperation(wrappedOperation, wrappedOverride)
dim update
update = false
'check name
if wrappedOverride.Name <> wrappedOperation.Name then
wrappedOverride.Name = wrappedOperation.Name
update = true
end if
'check return type
if wrappedOverride.ReturnType <> wrappedOperation.ReturnType then
wrappedOverride.ReturnType = wrappedOperation.ReturnType
update = true
end if
'check return classifier
if wrappedOverride.ReturnType <> wrappedOperation.ReturnType then
wrappedOverride.ReturnType = wrappedOperation.ReturnType
update = true
end if
if update then
wrappedOverride.Update
end if
'check parameters
synchronizeParameters wrappedOperation, wrappedOverride
end function
'Synchronizes the parameters of the given operatin with that of the overrride
function synchronizeParameters(wrappedOperation, wrappedOverride)
'first make sure they both have the same number of parameters
if wrappedOverride.Parameters.Count < wrappedOperation.Parameters.Count then
'add parameters as required
dim i
for i = 0 to wrappedOperation.Parameters.Count - wrappedOverride.Parameters.Count -1
dim newParameter
set newParameter = wrappedOverride.Parameters.AddNew("parameter" & i,"")
newParameter.Update
next
wrappedOverride.Parameters.Refresh
elseif wrappedOverride.Parameters.Count > wrappedOperation.Parameters.Count then
'remove parameters as required
for i = wrappedOverride.Parameters.Count -1 to wrappedOperation.Parameters.Count step -1
wrappedOverride.Parameters.DeleteAt i,false
next
wrappedOverride.Parameters.Refresh
end if
'make parameters equal
dim wrappedParameter
dim overriddenParameter
dim j
for j = 0 to wrappedOperation.Parameters.Count -1
dim parameterUpdated
parameterUpdated = false
set wrappedParameter = wrappedOperation.Parameters.GetAt(j)
set overriddenParameter = wrappedOverride.Parameters.GetAt(j)
'name
if overriddenParameter.Name <> wrappedParameter.Name then
overriddenParameter.Name = wrappedParameter.Name
parameterUpdated = true
end if
'type
if overriddenParameter.Type <> wrappedParameter.Type then
overriddenParameter.Type = wrappedParameter.Type
parameterUpdated = true
end if
'default
if overriddenParameter.Default <> wrappedParameter.Default then
overriddenParameter.Default = wrappedParameter.Default
parameterUpdated = true
end if
'kind
if overriddenParameter.Kind <> wrappedParameter.Kind then
overriddenParameter.Kind = wrappedParameter.Kind
parameterUpdated = true
end if
'classifier
if overriddenParameter.ClassifierID <> wrappedParameter.ClassifierID then
overriddenParameter.ClassifierID = wrappedParameter.ClassifierID
parameterUpdated = true
end if
'update the parameter if it was changed
if parameterUpdated then
overriddenParameter.Update
end if
next
end function

Answer 3

When you tell EA to override or implement an operation in a base class or interface, it creates a copy of the operation in the child class. This copy has no reference to the original base class / interface, and subsequent changes are not reflected in the child.
If you draw a realization to an interface and select not to override any operations, EA will generate code for them as you'd expect, but it doesn't do that for abstract classes - even if the child is a leaf.
You can always modify the code generation templates (Tools - Source Code Generation Templates). They're a bit tricky to get your head around the first time, but you'll soon get the hang of it.