class Pn2ScJobs {
 
  /* Transformation-related extension API */
  extension BatchTransformationRuleFactory ruleFactory = new BatchTransformationRuleFactory
  extension BatchTransformation transformation
  extension TransformationStatements statements
  extension IModelManipulations manipulation
 
  /* Makes available the Literals of the EPackage for the manipulation API */
  extension StatechartsPackage chartPackage = StatechartsPackage.eINSTANCE
 
  Statechart stateChart
  Resource resource
 
  new(Resource resource) {
    /Storing transformation-specific input elements
    this.resource = resource
    this.stateChart = resource.contents.head as Statechart
 
    /* Extensions are initialized as normal fields in Xtend */
    transformation = new BatchTransformation(resource.resourceSet)
    statements = new TransformationStatements(transformation)
    manipulation = new SimpleModelManipulations(transformation.iqEngine)
  }
 
...
 
}

/**
 * Map a PetriNet place to a base state in the StateChart with an "or" container.
 */
val createMapPlaceRuleSpecification = createRule(PlaceMatcher::querySpecification) [
  // create base b with b.name=p.name; and the state or, where or.contains={b}
  var or = stateChartResource.create(OR) as OR
  var basic = or.createChild(compound_Contains, basic) as Basic
  basic.set(state_Name, p.name)///name = p.name
  // create trace from place to or
  createTrace(p, or)
  ]
 
/**
 * Map a PetriNet transition to a hyperedge state in the StateChart without an "or" container.
 */
val createMapTransitionRuleSpecification = createRule(TransitionMatcher::querySpecification) [
  // create hyperEdge h with h.name=t.name (without an or container)
  var hyperEdge = stateChartResource.create(hyperEdge) as HyperEdge
  hyperEdge.name = t.name
  // create trace from transition to hyperEdge
  createTrace(t, hyperEdge)
]
 
/**
 * Create "next" edges in the StateChart between elements connected in the PetriNet.
 */
val createNextStateRuleSpecification = createRule(NextStateMatcher::querySpecification) [
  state1.addTo(state_Next, state2)
]
 
/**
 * Get rules for performing initial mapping
 */
def getInitialisationRules() {
  new TransformationRuleGroup(
    createMapPlaceRuleSpecification,
    createMapTransitionRuleSpecification,
    createNextStateRuleSpecification
  )
}

val moveChildrenRule = createRule(EquivContainsMatcher::querySpecification) [
  state.moveTo(newP, compound_Contains)
]
// add children elements to OR of the StateChart
moveChildrenRule.forall("namedElement" -> q)

def transformPn2Sc() {
  // place->OR mapping
  initialisationRules.until(alwaysFalse)
  // execute AND and OR rules
  andOrRules.until(alwaysFalse)
  // clean orphaned root ORs; and create StateChart root
  finalisationRules.until(alwaysFalse)
}