Consolidated logic in SharedOO and OperationAsClass. These provide the workhorse for the business logic.

Only outlier is ObjectAlgebras since its AIP is decidedly different from all other OO approaches.

Author: heineman

Diff for: TODO.txt

@@ -28,7 +28,6 @@ Trees that grow
 Notes: A1M3 for coco needs a full Exp and Factory. Why? Because otherwise merge accessing finalized instances from A1 are incompatible with
 the finalized instances from M3. Similar argument for M3W1 and even A1M3I2
 
-
    ifEqExpr <- ffiEquals.equalityCapabilities.areEqual(expType, expValue, zero)
      where expType is expType <- toTargetLanguageType(TypeRep.Double)
 
@@ -37,4 +36,8 @@ It wasn't working because I had mistakenly used a type for "ep.Exp[FT]"
 ALgebra had to go back to its own "dataTypeCasesWithNewOperations" for some reason.
 
 So Coco, Trivially and Algebra all have slightly different results and it REALLY makes me curious
-as to why
+as to why
+
+============================
+
+Runtime Dispatch FAILS whenever pass in a model. if we can fix this, then I can better integrate with OO code.

Diff for: core/src/main/scala/org/combinators/ep/approach/oo/CoCoClean.scala

@@ -3,12 +3,11 @@ package org.combinators.ep.approach.oo  /*DI:LI:AD*/
 import org.combinators.ep.domain.abstractions.{DataTypeCase, Operation, TestCase, TypeRep}
 import org.combinators.ep.domain.{GenericModel, abstractions}
 import org.combinators.ep.generator.Command.Generator
-import org.combinators.ep.generator.communication.{ReceivedRequest, Request}
 import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach
-import org.combinators.ep.generator.{AbstractSyntax, ApproachImplementationProvider, Command, EvolutionImplementationProvider, NameProvider, TestImplementationProvider, Understands, communication}
+import org.combinators.ep.generator.{AbstractSyntax, Command, EvolutionImplementationProvider, NameProvider, TestImplementationProvider, Understands, communication}
 import org.combinators.ep.generator.paradigm.{AddImport, AnyParadigm, Apply, FindClass, Generics, ObjectOriented, ParametricPolymorphism, ResolveImport, AddTypeLookup}
 
-trait CoCoClean extends ApproachImplementationProvider {
+trait CoCoClean extends SharedOO {
   val paradigm: AnyParadigm
   val ooParadigm: ObjectOriented.WithBase[paradigm.type]
   val polymorphics: ParametricPolymorphism.WithBase[paradigm.type]
@@ -22,10 +21,6 @@ trait CoCoClean extends ApproachImplementationProvider {
     val finalizedTypeParameter: paradigm.syntax.Name = names.mangle("FT")
     val finalizedPackage: paradigm.syntax.Name = names.mangle("finalized")
     val getSelfMethod: paradigm.syntax.Name = names.mangle("getSelf")
-
-    def getter(attribute: abstractions.Attribute): paradigm.syntax.Name = {
-      names.addPrefix("get", names.mangle(names.conceptNameOf(attribute)))
-    }
   }
 
   /**
@@ -464,41 +459,18 @@ trait CoCoClean extends ApproachImplementationProvider {
     import paradigm.methodBodyCapabilities._
     import ooParadigm.methodBodyCapabilities._
 
-    val properModel = latestModelDefiningNewFactoryType(domain)   // not Exp but the Factory!
-      .later(domain.findTypeCase(dataTypeCase).get)
-
     for {
       _ <- setOperationMethodSignature(domain, finalizedType, operation)
       _ <- if (domain.operationsPresentEarlier(dataTypeCase).contains(operation)) {
         setOverride()
       } else {
         Command.skip[paradigm.MethodBodyContext]
       }
-      arguments <- getArguments()
-      self <- selfReference()
-      attributes <- forEach(dataTypeCase.attributes) { attribute =>
-        for {
-          getterMethod <- getMember(self, ComponentNames.getter(attribute))
-          getterCall <- apply(getterMethod, Seq.empty)
-        } yield (attribute, getterCall)
-      }
-      receivedRequest =
-        ReceivedRequest(
-          onType = domain.baseDataType,
-          tpeCase = dataTypeCase,
-          selfReference = self,
-          attributes = attributes.toMap,
-          request = Request(
-            op = operation,
-            arguments = operation.parameters.zip(arguments.map(argument => argument._3)).toMap
-          ),
-          model = Some(properModel)
-        )
-      result <- domainSpecific.logic(this)(receivedRequest)
+
+      result <- completeImplementation(domain.baseDataType, dataTypeCase, operation, domain, domainSpecific, attributeAccess=attributeGetterAccess)
     } yield result
   }
 
-
   def addDataTypeCaseInterfaces(domain: GenericModel, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[paradigm.ProjectContext, Unit] = {
     val _newDataTypeCasesWithNewOperations = newDataTypeCasesWithNewOperations(domain)
 
@@ -554,7 +526,7 @@ trait CoCoClean extends ApproachImplementationProvider {
 
         // Add abstract getters if defined here
         _ <- forEach(if (domain.typeCases.contains(newDataTypeCase)) newDataTypeCase.attributes else List.empty) { attribute =>
-          addAbstractMethod(ComponentNames.getter(attribute), setAttributeGetterSignature(domain, finalizedType, attribute))
+          addAbstractMethod(getterName(attribute), setAttributeGetterSignature(domain, finalizedType, attribute))
         }
 
         // Add methods for new operations
@@ -852,7 +824,7 @@ trait CoCoClean extends ApproachImplementationProvider {
             } else Command.lift[ooParadigm.ClassContext, paradigm.syntax.Type](baseTypeInterface)
 
             _ <- addField(names.mangle(names.instanceNameOf(attribute)), attributeType)
-            _ <- addMethod(ComponentNames.getter(attribute), makeAttributeGetter(domain, finalizedType, attribute))
+            _ <- addMethod(getterName(attribute), makeAttributeGetter(domain, finalizedType, attribute))
           } yield ()
         }
 

Diff for: core/src/main/scala/org/combinators/ep/approach/oo/ExtensibleVisitor.scala

@@ -562,11 +562,8 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass {
     } yield ()
   }
 
-  def makeEachImplementation(domain:GenericModel, tpe: DataType,
-                tpeCase: DataTypeCase,
-                op: Operation,
-                domainSpecific: EvolutionImplementationProvider[this.type]
-               ): Generator[MethodBodyContext, Option[Expression]] = {
+  override def makeTypeCaseImplementation(tpe: DataType, tpeCase: DataTypeCase, op: Operation, domain:GenericModel,
+         domainSpecific: EvolutionImplementationProvider[this.type]): Generator[MethodBodyContext, Option[Expression]] = {
     import paradigm.methodBodyCapabilities._
     import ooParadigm.methodBodyCapabilities._
     val properModel = latestModelDefiningOperatorClass(domain, tpeCase, op, domainSpecific).get
@@ -744,7 +741,7 @@ trait ExtensibleVisitor extends SharedOO with OperationAsClass {
       // for all that are not in primary parent
       _ <- forEach (typeCasesToDeclare) { tpe =>
         for {
-          _ <- addMethod(visitor.visit, makeEachImplementation(domain, domain.baseDataType, tpe, operation, domainSpecific))
+          _ <- addMethod(visitor.visit, makeTypeCaseImplementation(domain.baseDataType, tpe, operation, domain, domainSpecific))
 
           // if dependent operations exist, those factories need to be generated as well later
         } yield ()

Diff for: core/src/main/scala/org/combinators/ep/approach/oo/Interpreter.scala

@@ -275,16 +275,31 @@ sealed trait Interpreter extends SharedOO {
     !latestModelDefiningNewTypeInterface(domain).beforeOrEqual(definingModel)
   }
 
-  def makeInterpreterImplementation(domain: GenericModel,
-                          tpe: DataType,
-                          tpeCase: DataTypeCase,
-                          op: Operation,
-                          domainSpecific: EvolutionImplementationProvider[this.type]
-                        ): Generator[MethodBodyContext, Option[Expression]] = {
+  /**
+   * Access attributes using default getter methods.
+   *
+   * @param attribute    Data Type Case attribute to be accessed
+   * @return
+   */
+  def attributeInterpreterAccess(att:Attribute, tpeCase: DataTypeCase, domain:GenericModel, baseType:Option[paradigm.syntax.Type]) : Generator[MethodBodyContext, Expression] = {
+    import ooParadigm.methodBodyCapabilities._
+
+    for {
+      thisRef <- selfReference()
+      att_member <- getMember(thisRef, names.mangle(names.instanceNameOf(att)))
+      casted <- if (att.tpe.isModelBase(domain) && mustCastToAccess(domain, tpeCase)) {    // only cast if Exp AND comes from older Exp
+        castObject(baseType.get, att_member)
+      } else {
+        Command.lift[MethodBodyContext, Expression](att_member)
+      }
+    } yield casted
+  }
+
+  def makeInterpreterImplementation(domain: GenericModel, tpe: DataType, tpeCase: DataTypeCase, op: Operation,
+                          domainSpecific: EvolutionImplementationProvider[this.type]): Generator[MethodBodyContext, Option[Expression]] = {
     import paradigm.methodBodyCapabilities._
     import ooParadigm.methodBodyCapabilities._
     import polymorphics.methodBodyCapabilities._
-    val properModel = latestModelDefiningOperatorClass(domain, tpeCase, op, domainSpecific).get
 
     for {
       _ <- makeInterpreterSignature(domain, op)
@@ -293,46 +308,9 @@ sealed trait Interpreter extends SharedOO {
         } else {
           Command.skip[MethodBodyContext]
         }
-      thisRef <- selfReference()
-      attAccessors: Seq[Expression] <- forEach (tpeCase.attributes) { att =>
-        for {
-          att_member <- getMember(thisRef, names.mangle(names.instanceNameOf(att)))
-          mostSpecificExp <- mostSpecificBaseInterfaceType(domain)
-          casted <- if (att.tpe.isModelBase(domain) && mustCastToAccess(domain, tpeCase)) {    // only cast if Exp AND comes from older Exp
-            castObject(mostSpecificExp, att_member)
-          } else {
-            Command.lift[MethodBodyContext, Expression](att_member)
-          }
-        } yield casted
-      }
-
-      atts = tpeCase.attributes.zip(attAccessors).toMap
 
-      allArgs <- getArguments()
-      castedArgs <- forEach(op.parameters.zip(allArgs)) { case (param,arg) =>
-        for {
-          mostSpecificExp <- mostSpecificBaseInterfaceType(domain)
-          casted <- if (param.tpe.isModelBase(domain)) {    // only cast if Exp
-            castObject(mostSpecificExp, arg._3)
-          } else {
-            Command.lift[MethodBodyContext, Expression](arg._3)
-          }
-        } yield (param,casted)
-      }
-
-      castedArgsMap = castedArgs.toMap
-
-      result <-
-        domainSpecific.logic(this)(
-          ReceivedRequest(
-            tpe,
-            tpeCase,
-            thisRef,
-            atts,
-            Request(op, castedArgsMap),
-            Some(properModel)   // scala implementation for j8 needed this
-          )
-        )
+      mostSpecificExp <- mostSpecificBaseInterfaceType(domain)
+      result <- completeImplementation(domain.baseDataType, tpeCase, op, domain, domainSpecific, attributeAccess=attributeInterpreterAccess, baseType=Some(mostSpecificExp))
     } yield result
   }
 

Diff for: core/src/main/scala/org/combinators/ep/approach/oo/ObjectAlgebras.scala

@@ -8,7 +8,9 @@ import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach
 import org.combinators.ep.generator.paradigm._
 import org.combinators.ep.generator._
 
-
+/**
+ * Sufficiently different EP approach that this trait does not extend SharedOO
+ */
 trait ObjectAlgebras extends ApproachImplementationProvider {
   val paradigm: AnyParadigm
   val ooParadigm: ObjectOriented.WithBase[paradigm.type]
@@ -1002,12 +1004,6 @@ trait ObjectAlgebras extends ApproachImplementationProvider {
             } yield (param, paramField)
           }
 
-          dtParams <- forEach (dt.attributes) { param =>
-            for {
-              paramField <- getMember(selfRef, names.mangle(param.name))
-            } yield (new Parameter(param.name, param.tpe), paramField)
-          }
-
           // An operation -- like equals(other) -- has an argument; the isXXX() operations have two arguments
           // or one argument -- based on whether the corresponding data type has 1 or 2 attributes. Somehow have
           // to collect together arguments to use within the ReceivedRequest(). Sometimes from the op... sometimes

Diff for: core/src/main/scala/org/combinators/ep/approach/oo/OperationAsClass.scala

@@ -1,7 +1,7 @@
 package org.combinators.ep.approach.oo    /*DI:LI:AD*/
 
 import org.combinators.ep.domain.GenericModel
-import org.combinators.ep.domain.abstractions.{DataType, DataTypeCase, Operation, Parameter}
+import org.combinators.ep.domain.abstractions.{Attribute, DataType, DataTypeCase, Operation, Parameter}
 import org.combinators.ep.generator.Command.Generator
 import org.combinators.ep.generator.paradigm.AnyParadigm.syntax.forEach
 import org.combinators.ep.generator.paradigm.ObjectOriented
@@ -17,14 +17,9 @@ trait OperationAsClass extends ApproachImplementationProvider {
   import paradigm._
   import syntax._
 
-  /** Requires the capability of constructing an implementation */
-  def makeImplementation(
-                          tpe: DataType,
-                          tpeCase: DataTypeCase,
-                          op: Operation,
-                          model: GenericModel,
-                          domainSpecific: EvolutionImplementationProvider[this.type]
-                        ): Generator[MethodBodyContext, Option[Expression]]
+  // Each AIP that includes this trait must provide implementation for how an entire method for a typecase is to be constructed.
+  def makeTypeCaseImplementation(tpe: DataType, tpeCase: DataTypeCase, op: Operation, model: GenericModel,
+                         domainSpecific: EvolutionImplementationProvider[this.type]): Generator[MethodBodyContext, Option[Expression]]
 
   /**
    * Constructor for an operation which MAY have parameters
@@ -88,16 +83,18 @@ trait OperationAsClass extends ApproachImplementationProvider {
    * @return
    * @see  makeImplementation
    */
-  def operationClass(methodName:Name, op:Operation, model:GenericModel, typeCases:Seq[DataTypeCase], base:DataType, domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ClassContext, Unit] = {
+  def operationClass(methodName:Name, op:Operation, model:GenericModel, typeCases:Seq[DataTypeCase], base:DataType,
+                     domainSpecific: EvolutionImplementationProvider[this.type]): Generator[ClassContext, Unit] = {
     import ooParadigm.classCapabilities._
 
     for {
       returnTpe <- toTargetLanguageType(op.returnType)
       _ <- resolveAndAddImport(returnTpe)
       _ <- addParamFields(op)
       _ <- addConstructor(makeOperationConstructor(op))
+
       _ <- forEach (typeCases) { tpe =>
-        addMethod(methodName, makeImplementation(base, tpe, op, model, domainSpecific))
+        addMethod(methodName, makeTypeCaseImplementation(base, tpe, op, model, domainSpecific))
       }
     } yield ()
   }