Generator Transformer

Basic Generator

The basic generator is a simple implementation of a transformer and is used as default on new generators.

class MyTransformer() extends Transformer {
  private val logger = LoggerFactory.getLogger(getClass)

  def transform(entity: GraphicalDslInstance) : Future[Transformer] = {
    logger.info(s"Model : $${entity.id}")
    entity.nodes.foreach { node =>
      logger.info(node.name)
    }
    entity.edges.foreach { edge =>
      logger.info(edge.name)
    }
    Future.successful(this)
  }

  def exit() : Future[Result] = {
    val result = Success("The generator finished")
    Future.successful(result)
  }
}

File Generator

Demo for creating files within a generator.

class MyTransformer() extends Transformer {
  private val logger: Logger = LoggerFactory.getLogger(getClass)

  private val injector = Guice.createInjector(new PersistenceModule)
  private val filePersistence = injector.getInstance(classOf[FileRepository])

  def transform(entity: GraphicalDslInstance): Future[Transformer] = {
    logger.info("Start example")
    val p = Promise[Transformer]

    val filename = "example.txt"
    val content =
      s"""
        |Number of nodes : ${entity.node.size}
        |Number of edges : ${entity.edge.size}
      """.stripMargin

   filePersistence.create(File(entity.id, filename, content)).map { _ =>
      logger.info(s"Successfully saved results to '$filename' for model '${entity.name}' (MetaModel '${entity.graphicalDslId}')")
      p.success(this)
    }.recover {
      case e: Exception => p.failure(e)
    }

    p.future
  }

  def exit(): Future[Result] = {
    val result = Success("The generator finished")
    Future.successful(result)
  }
}

Remote Generator

Demo for executing a child generator.

import scala.concurrent.Promise

import de.htwg.zeta.common.models.entity.File
import de.htwg.zeta.common.models.remote.Remote
import de.htwg.zeta.common.models.remote.RemoteGenerator
import rx.lang.scala.Notification.OnCompleted
import rx.lang.scala.Notification.OnError
import rx.lang.scala.Notification.OnNext

class MyGenerator(generatorId: UUID = UUID.randomUUID) extends Transformer {

  // TODO Remote /socket/generator is failing on authentication
  private val remote: Remote = RemoteGenerator(cmd.session.getOrElse(""), cmd.work.getOrElse(""), cmd.parent.toOption, cmd.key.toOption)
  private val logger = LoggerFactory.getLogger(getClass)

  private def transformBasicActorNode(node: Node) = {
    val actorName = "AttributeValue"
    val filename = s"${actorName}.scala"
    val content =
      s"""
        |class ${actorName}() extends Actor {
        |   def receive = {
        |
        |   }
        | }
      """.stripMargin

    File(UUID.randomUUID, filename, content)
  }

  private def transformPersistentActorNode(node: Node) = "transformPersistentActorNode"

  private def transformNode(node: Node) = {
    node.className match {
      case "BasicActor" => transformBasicActorNode(node)
      case "PersistentActor" => transformPersistentActorNode(node)
    }
  }

  def transform(entity: GraphicalDslInstance): Future[Transformer] = {
    val p = Promise[Transformer]

    val r1 = remote.call[RemoteOptions, File](generatorId, RemoteOptions("BasicActor", entity.id))
    val r2 = remote.call[RemoteOptions, File](generatorId, RemoteOptions("PersistentActor", entity.id))

    val merged = r1.merge(r2)

    merged.materialize.subscribe(n => n match {
      case OnNext(file) => logger.info(file.toString)
      case OnCompleted => p.success(this)
      case OnError(err) => p.failure(err)
    })

    p.future
  }

  def exit(): Future[Result] = {
    val result = Success("The generator finished")
    Future.successful(result)
  }
}