ProductCaseGeneration

Value generation strategy for a particular output parameter/setter

Final platform-independent result of matching inputs with outputs using resolved strategies

Stores information how each attribute/getter could be extracted from In value

Stores information how Out value could be constructed from values of constructor parameters/passed to setters

Should create Out expression from the constructor arguments grouped in parameter lists

Platform-specific way of parsing In data

Should:

• obtain all methods which are Scala's getters (vals, nullary defs)
• obtain all methods which are Java Bean getters (starting with is- or get-)
• for each create an InField factory which takes In argument and returns InField expression
• form obtained collection into ProductInData

Platform-specific way of parsing Out data

Should:

• verify whether output is a case class, a case object or a Java Bean
• obtain respectively:
  • a constructor taking all arguments
  • expression containing case object value
  • a default constructor and collection of setters respectively
• form obtained data into ProductOutData

Platform-specific way of generating code from resolved information

For case class output should generate code like:

pipeDerivation.lift { (in: In, ctx: pipeDerivation.Context) =>
 pipeDerivation.mergeResult(
    ctx,
   pipeDerivation.mergeResult(
      ctx,
     pipeDerivation.pure(Array[Any](2)),
     pipeDerivation.unlift(fooPipe, in.foo, pipeDerivation.updateContext(ctx, Path.root.field("foo"))),
     { (left, right) =>
       left(0) = right
       left
      }
   ),
   pipeDerivation.unlift(barPipe, in.bar, pipeDerivation.updateContext(ctx, Path.root.field("bar"))),
   { (left, right) =>
     left(1) = right
     new Out(
       foo = left(0).asInstanceOf[Foo2],
       bar = left(1).asInstanceOf[Bar2],
     )
   }
 )
}

For case object output should generate code like:

pipeDerivation.lift { (in: In, ctx: pipeDerivation.Context) =>
 pipeDerivation.pure(CaseObject)
}

For Java Bean should generate code like:

pipeDerivation.lift { (in: In, ctx: pipeDerivation.Context) =>
 pipeDerivation.mergeResult(
   ctx,
   pipeDerivation.mergeResult(
     ctx,
     pipeDerivation.pure {
       val result = new Out()
       result
     },
     pipeDerivation.unlift(fooPipe, in.foo, pipeDerivation.updateContext(ctx, Path.root.field("foo"))),
     { (left, right) =>
       left.setFoo(right)
       left
     }
   ),
   pipeDerivation.unlift(barPipe, in.bar, pipeDerivation.updateContext(ctx, Path.root.field("bar"))),
   { (left, right) =>
     left.setBar(right)
     left
   }
 )
}

True iff A is defined as case class, is NOT abstract and has a public constructor

True iff A is defined as case object, and is public

True iff A has a (public) default constructor and at least one (public) method starting with set

True iff A is a tuple

Whether Out type could be constructed as "product case"