Generators

Stores information from what pieces Out is made

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

Translation strategy for a particular input subtype

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

Check is A <:< B in a platform-independent code

Should generate code pipeDerivation.lift { (in, ctx) => ... }

Should generate code pipeDerivation.mergeResults(ctx, ra, rb, (a, b) => ...)

Should generate code pipeDerivation.pureResult(a)

Should use platform-specific way of reporting information from macro on INFO level

Should use platform-specific way of reporting errors from macro

Should generate code pipeDerivation.unlift(pipe)(in, ctx)

Should generate code pipeDerivation.updateContext(ctx, path)

Derives using Settings parsed from PipeDerivationConfig[Pipe, In, Out] expression

Derives using default Settings

Generate message to be displayed by macro on INFO level (if requested by config)

Generates error message to be returned from macro on ERROR level

Check is A =:= B in a platform-independent code

Platform-specific way of parsing In data

Should:

• obtain a lift of subtypes OR enumeration values
• form it into EnumData[In]

Platform-specific way of parsing Out data

Should:

• obtain a lift of subtypes OR enumeration values
• form it into EnumData[In]

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 subtype input should generate code like:

pipeDerivation.lift { (in: In, ctx: pipeDerivation.Context) =>
 in match {
   case inSubtype: In.Foo => pipeDerivation.unlift(fooPipe, inSubtype, updateContext(ctx, path))
   case inSubtype: In.Bar => pipeDerivation.unlift(barPipe, inSubtype, updateContext(ctx, path))
 }
}

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 sealed

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"

Whether both In and Out are ADTs/Java Enums

Takes Settings and passes them to generators, the first which decides it's their case, attempt generation