Added new functionality to handle "ExplicitBaseClassCall" stereotype during runtime

HammerMaximilian · HammerMaximilian · commit 650866f99baf · 2024-01-17T23:21:43.000+01:00
diff --git a/fUML-CPP/fuml/src/fuml/extensions/structuredclassifiers/SignatureBasedDispatchStrategy.cpp b/fUML-CPP/fuml/src/fuml/extensions/structuredclassifiers/SignatureBasedDispatchStrategy.cpp
@@ -14,6 +14,11 @@
 using namespace fuml::extensions::structuredclassifiers;
 
 BehaviorPtr SignatureBasedDispatchStrategy::getMethod(const Object_Ptr& object_, const OperationPtr& operation)
+{
+	return this->getMethod(object_, operation, false);
+}
+
+BehaviorPtr SignatureBasedDispatchStrategy::getMethod(const Object_Ptr& object_, const OperationPtr& operation, bool isExplicitBaseClassCall)
 {
     // Find the member operation of a type of the given object_ that
     // is the same as or overrides the given operation. Then
@@ -24,12 +29,31 @@ BehaviorPtr SignatureBasedDispatchStrategy::getMethod(const Object_Ptr& object_,
     // the first one is arbitrarily chosen.]
 
     BehaviorPtr method = nullptr;
+    const Class_Ptr& operationClass = operation->class_.lock();
+
     unsigned int i = 1;
     unsigned int sizeOfTypes = object_->types->size();
     while (method == nullptr && i <= sizeOfTypes)
     {
         const Class_Ptr& type = object_->types->at(i - 1);
-        method = this->getMethod(type, operation);
+
+        if(isExplicitBaseClassCall)
+        {
+            // The operation call shall explicitly invoke a base class operation,
+            // even if the operation is overridden by type (or a direct or indirect base class of type).
+            // This behaves as if object_'s actual type was the type that owns operation,
+            // if operationClass is a direct or indirect base class of type.
+
+            if(operationClass != nullptr && this->isSpecializationOf(type, operationClass))
+            {
+                method = this->getMethod(operationClass, operation);
+            }
+        }
+        else
+        {
+            method = this->getMethod(type, operation);
+        }
+
         i++;
     }
 
@@ -71,8 +95,7 @@ BehaviorPtr SignatureBasedDispatchStrategy::getMethod(const Class_Ptr& type, con
         unsigned int sizeOfGeneral = general->size();
         while(method == nullptr && i <= sizeOfGeneral)
         {
-        	const Class_Ptr baseClass = std::dynamic_pointer_cast<Class_>(general->at(i - 1));
-            if(baseClass)
+            if(Class_Ptr baseClass = std::dynamic_pointer_cast<Class_>(general->at(i - 1)))
             {
                 method = this->getMethod(baseClass, operation);
             }
@@ -115,7 +138,7 @@ bool SignatureBasedDispatchStrategy::operationsMatch(const OperationPtr& ownedOp
 
                     matches = ownedOperationReturnType &&
                             baseOperationReturnType &&
-                            this->isCovariant(ownedOperationReturnType, baseOperationReturnType);
+                            this->isSpecializationOf(ownedOperationReturnType, baseOperationReturnType);
                 }
                 else
                 {
@@ -135,24 +158,24 @@ bool SignatureBasedDispatchStrategy::operationsMatch(const OperationPtr& ownedOp
     return matches;
 } // operationsMatch
 
-bool SignatureBasedDispatchStrategy::isCovariant(const ClassifierPtr& ownedOperationReturnType, const ClassifierPtr& baseOperationReturnType)
+bool SignatureBasedDispatchStrategy::isSpecializationOf(const ClassifierPtr& specializedType, const ClassifierPtr& generalType)
 {
-    bool isCovariant = false;
+    bool isSpecialized = false;
 
     unsigned int i = 1;
-    unsigned int sizeOfGeneral = ownedOperationReturnType->general->size();
-    while (isCovariant == false && i <= sizeOfGeneral)
+    unsigned int sizeOfGeneral = specializedType->general->size();
+    while (isSpecialized == false && i <= sizeOfGeneral)
     {
-        const ClassifierPtr& baseType = ownedOperationReturnType->general->at(i - 1);
-        isCovariant = baseOperationReturnType == baseType;
+        const ClassifierPtr& directBase = specializedType->general->at(i - 1);
+        isSpecialized = generalType == directBase;
 
-        if(!isCovariant)
+        if(!isSpecialized)
         {
-            isCovariant = this->isCovariant(baseType, baseOperationReturnType);
+            isSpecialized = this->isSpecializationOf(directBase, generalType);
         }
 
         i++;
     }
 
-    return isCovariant;
+    return isSpecialized;
 } // isCovariant
diff --git a/fUML-CPP/fuml/src/fuml/extensions/structuredclassifiers/SignatureBasedDispatchStrategy.h b/fUML-CPP/fuml/src/fuml/extensions/structuredclassifiers/SignatureBasedDispatchStrategy.h
@@ -18,9 +18,10 @@ namespace fuml::extensions::structuredclassifiers
 			virtual ~SignatureBasedDispatchStrategy() = default;
 
 			virtual BehaviorPtr getMethod(const Object_Ptr&, const OperationPtr&) override;
+			virtual BehaviorPtr getMethod(const Object_Ptr&, const OperationPtr&, bool) override;
 			BehaviorPtr getMethod(const Class_Ptr&, const OperationPtr&);
 			virtual bool operationsMatch(const OperationPtr&, const OperationPtr&);
-			bool isCovariant(const ClassifierPtr&, const ClassifierPtr&);
+			bool isSpecializationOf(const ClassifierPtr&, const ClassifierPtr&);
 	};
 // SignatureBasedDispatchStrategy
 }
diff --git a/fUML-CPP/fuml/src/fuml/semantics/actions/CallOperationActionActivation.cpp b/fUML-CPP/fuml/src/fuml/semantics/actions/CallOperationActionActivation.cpp
@@ -36,6 +36,7 @@ ExecutionPtr CallOperationActionActivation::getCallExecution()
 	// operation to it and return the resulting execution object.
 
 	CallOperationActionPtr action = std::dynamic_pointer_cast<CallOperationAction>(this->node);
+	bool isExplicitBaseClassCall = this->isExplicitBaseClassCall(action);
 	ValuePtr target = this->takeTokens(action->target)->at(0);
 
 	ExecutionPtr execution;
@@ -44,7 +45,7 @@ ExecutionPtr CallOperationActionActivation::getCallExecution()
 
 	if (reference)
 	{
-		execution = reference->dispatch(action->operation);
+		execution = reference->dispatch(action->operation, isExplicitBaseClassCall);
 	}
 	else
 	{
diff --git a/fUML-CPP/fuml/src/fuml/semantics/actions/CallOperationActionActivation.h b/fUML-CPP/fuml/src/fuml/semantics/actions/CallOperationActionActivation.h
@@ -20,6 +20,7 @@ namespace fuml::semantics::actions
 			virtual bool isReady() override;
 			virtual ExecutionPtr getCallExecution() override;
 			virtual ParameterListPtr getParameters() override;
+			bool isExplicitBaseClassCall(const CallOperationActionPtr&); // implemented in CallOperationActionActivationExtension.cpp
 
 	};
 // CallOperationActionActivation
diff --git a/fUML-CPP/fuml/src/fuml/semantics/actions/CallOperationActionActivationExtension.cpp b/fUML-CPP/fuml/src/fuml/semantics/actions/CallOperationActionActivationExtension.cpp
@@ -0,0 +1,29 @@
+/*
+ * CallOperationActionActivationExtension.cpp
+ *
+ *  Created on: 17.01.2024
+ *      Author: maha6913
+ */
+
+#include <fuml/semantics/actions/CallOperationActionActivation.h>
+
+#include <uml/actions/CallOperationAction.h>
+#include <uml/packages/Stereotype.h>
+
+bool CallOperationActionActivation::isExplicitBaseClassCall(const CallOperationActionPtr& callOperationAction)
+{
+    const StereotypeListPtr& appliedStereotypes = callOperationAction->appliedStereotype;
+    unsigned int i = 0;
+    unsigned int appliedStereotypesSize = appliedStereotypes->size();
+    bool isExplicitBaseClassCall = false;
+
+    while (i < appliedStereotypesSize && !isExplicitBaseClassCall)
+    {
+        const StereotypePtr& s = appliedStereotypes->at(i);
+        if (s->name == "ExplicitBaseClassCall")
+        {
+            isExplicitBaseClassCall = true;
+        }
+    }
+    return isExplicitBaseClassCall;
+}
diff --git a/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/DispatchStrategy.h b/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/DispatchStrategy.h
@@ -20,7 +20,9 @@ namespace fuml::semantics::structuredclassifiers
 
 			virtual std::string getName() override;
 			ExecutionPtr dispatch(const Object_Ptr&, const OperationPtr&);
+			ExecutionPtr dispatch(const Object_Ptr&, const OperationPtr&, bool); //implemented in DispatchStrategyExtension.cpp
 			virtual BehaviorPtr getMethod(const Object_Ptr&, const OperationPtr&);
+			virtual BehaviorPtr getMethod(const Object_Ptr&, const OperationPtr&, bool); // implemented in DispatchStrategyExtension.cpp
 	};
 // DispatchStrategy
 }
diff --git a/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/DispatchStrategyExtension.cpp b/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/DispatchStrategyExtension.cpp
@@ -0,0 +1,25 @@
+/*
+ * DispatchStrategyExtension.cpp
+ *
+ *  Created on: 17.01.2024
+ *      Author: maha6913
+ */
+
+#include <fuml/semantics/structuredclassifiers/DispatchStrategy.h>
+
+#include <fuml/semantics/loci/ExecutionFactory.h>
+#include <fuml/semantics/loci/Locus.h>
+#include <fuml/semantics/structuredclassifiers/Object_.h>
+
+ExecutionPtr DispatchStrategy::dispatch(const Object_Ptr& object, const OperationPtr& operation, bool isExplicitBaseClassCall)
+{
+	// Extends DispatchStrategy::dispatch(const Object_Ptr&, const OperationPtr&) by flag "isExplicitBaseClassCall"
+	// Propagate "isExplicitBaseClassCall" to DispatchStrategy::getMethod
+
+	return object->locus->factory->createExecution(this->getMethod(object, operation, isExplicitBaseClassCall), object);
+} // dispatch
+
+BehaviorPtr DispatchStrategy::getMethod(const Object_Ptr& object, const OperationPtr& operation, bool)
+{
+	return this->getMethod(object, operation);
+} // getMethod
diff --git a/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/Object_.h b/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/Object_.h
@@ -27,6 +27,7 @@ namespace fuml::semantics::structuredclassifiers
 
 			void startBehavior(const Class_Ptr&, const ParameterValueListPtr&);
 			virtual ExecutionPtr dispatch(const OperationPtr&);
+			virtual ExecutionPtr dispatch(const OperationPtr&, bool); // implemented in Object_Extension.cpp
 			void send(const EventOccurrencePtr&);
 			virtual void destroy() override;
 			void register_(const EventAccepterPtr&);
diff --git a/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/Object_Extension.cpp b/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/Object_Extension.cpp
@@ -0,0 +1,29 @@
+/*
+ * Object_Extension.cpp
+ *
+ *  Created on: 17.01.2024
+ *      Author: maha6913
+ */
+
+#include <fuml/semantics/structuredclassifiers/Object_.h>
+
+#include <fuml/semantics/loci/ExecutionFactory.h>
+#include <fuml/semantics/loci/Locus.h>
+#include <fuml/semantics/structuredclassifiers/DispatchStrategy.h>
+
+ExecutionPtr Object_::dispatch(const OperationPtr& operation, bool isExplicitBaseClassCall)
+{
+	// Extends Object_::dispatch(const OperationPtr&) by flag "isExplicitBaseClassCall".
+	// If "isExplicitBaseClassCall" is false, delegate to Object_::dispatch(const OperationPtr&).
+	// Otherwise, delegate to DispatchStrategy::dispatch(const Object_Ptr&, const OperationPtr&, bool)
+
+	if(!isExplicitBaseClassCall)
+	{
+		return this->dispatch(operation);
+	}
+
+	DispatchStrategyPtr dispatchStrategy = std::dynamic_pointer_cast<DispatchStrategy>(
+		this->locus->factory->getStrategy("dispatch"));
+
+	return dispatchStrategy->dispatch(this->thisObject_Ptr.lock(), operation, isExplicitBaseClassCall);
+} // dispatch
diff --git a/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/Reference.h b/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/Reference.h
@@ -22,6 +22,7 @@ namespace fuml::semantics::structuredclassifiers
 
 			virtual void startBehavior(const Class_Ptr&, const ParameterValueListPtr&);
 			virtual ExecutionPtr dispatch(const OperationPtr&);
+			virtual ExecutionPtr dispatch(const OperationPtr&, bool); // implemented in ReferenceExtension.cpp
 			virtual void send(const EventOccurrencePtr&);
 			void destroy();
 			virtual bool equals(const ValuePtr&) override;
diff --git a/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/ReferenceExtension.cpp b/fUML-CPP/fuml/src/fuml/semantics/structuredclassifiers/ReferenceExtension.cpp
@@ -0,0 +1,18 @@
+/*
+ * ReferenceExtension.cpp
+ *
+ *  Created on: 17.01.2024
+ *      Author: maha6913
+ */
+
+#include <fuml/semantics/structuredclassifiers/Reference.h>
+
+#include <fuml/semantics/structuredclassifiers/Object_.h>
+
+ExecutionPtr Reference::dispatch(const OperationPtr& operation, bool isExplicitBaseClassCall)
+{
+	// Extends Reference::dispatch(const Operation)Ptr& by flag "isExplicitBaseClassCall".
+	// Delegate "isExplicitBaseClassCall" to Object_::dispatch(const OperationPtr&, bool).
+
+	return this->referent->dispatch(operation, isExplicitBaseClassCall);
+} // dispatch

Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ ExecutionPtr CallOperationActionActivation::getCallExecution()`
`36`	`36`	`// operation to it and return the resulting execution object.`
`37`	`37`
`38`	`38`	`CallOperationActionPtr action = std::dynamic_pointer_cast<CallOperationAction>(this->node);`
	`39`	`+ bool isExplicitBaseClassCall = this->isExplicitBaseClassCall(action);`
`39`	`40`	`ValuePtr target = this->takeTokens(action->target)->at(0);`
`40`	`41`
`41`	`42`	`ExecutionPtr execution;`
`@@ -44,7 +45,7 @@ ExecutionPtr CallOperationActionActivation::getCallExecution()`
`44`	`45`
`45`	`46`	`if (reference)`
`46`	`47`	`{`
`47`		`- execution = reference->dispatch(action->operation);`
	`48`	`+ execution = reference->dispatch(action->operation, isExplicitBaseClassCall);`
`48`	`49`	`}`
`49`	`50`	`else`
`50`	`51`	`{`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,9 @@ namespace fuml::semantics::structuredclassifiers`
`20`	`20`
`21`	`21`	`virtual std::string getName() override;`
`22`	`22`	`ExecutionPtr dispatch(const Object_Ptr&, const OperationPtr&);`
	`23`	`+ ExecutionPtr dispatch(const Object_Ptr&, const OperationPtr&, bool); //implemented in DispatchStrategyExtension.cpp`
`23`	`24`	`virtual BehaviorPtr getMethod(const Object_Ptr&, const OperationPtr&);`
	`25`	`+ virtual BehaviorPtr getMethod(const Object_Ptr&, const OperationPtr&, bool); // implemented in DispatchStrategyExtension.cpp`
`24`	`26`	`};`
`25`	`27`	`// DispatchStrategy`
`26`	`28`	`}`