Added model builders (preliminary)
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/.classpath b/plugins/org.eclipse.app4mc.amalthea.model/.classpath
index 15a4e05..d2ff62f 100644
--- a/plugins/org.eclipse.app4mc.amalthea.model/.classpath
+++ b/plugins/org.eclipse.app4mc.amalthea.model/.classpath
@@ -8,5 +8,6 @@
</attributes>
</classpathentry>
<classpathentry kind="src" path="src"/>
+ <classpathentry kind="src" path="xtend-gen"/>
<classpathentry kind="output" path="bin"/>
</classpath>
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/META-INF/MANIFEST.MF b/plugins/org.eclipse.app4mc.amalthea.model/META-INF/MANIFEST.MF
index e0c963e..322f1ad 100644
--- a/plugins/org.eclipse.app4mc.amalthea.model/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.app4mc.amalthea.model/META-INF/MANIFEST.MF
@@ -6,6 +6,7 @@
Bundle-ClassPath: .
Bundle-RequiredExecutionEnvironment: JavaSE-1.8
Export-Package: org.eclipse.app4mc.amalthea.model,
+ org.eclipse.app4mc.amalthea.model.builder,
org.eclipse.app4mc.amalthea.model.check,
org.eclipse.app4mc.amalthea.model.impl,
org.eclipse.app4mc.amalthea.model.io,
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.xtend
new file mode 100644
index 0000000..0bb3b88
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.xtend
@@ -0,0 +1,85 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.Amalthea
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.CommonElements
+import org.eclipse.app4mc.amalthea.model.ComponentsModel
+import org.eclipse.app4mc.amalthea.model.ConstraintsModel
+import org.eclipse.app4mc.amalthea.model.EventModel
+import org.eclipse.app4mc.amalthea.model.HWModel
+import org.eclipse.app4mc.amalthea.model.IReferable
+import org.eclipse.app4mc.amalthea.model.MappingModel
+import org.eclipse.app4mc.amalthea.model.OSModel
+import org.eclipse.app4mc.amalthea.model.PropertyConstraintsModel
+import org.eclipse.app4mc.amalthea.model.SWModel
+import org.eclipse.app4mc.amalthea.model.StimuliModel
+
+class AmaltheaBuilder {
+
+ val objectRegistry = <String, IReferable> newHashMap
+
+ def amaltheaRoot((Amalthea)=>void initializer) {
+ AmaltheaFactory.eINSTANCE.createAmalthea.init(initializer)
+ }
+
+ // ********** Top level elements **********
+
+ def commonElements(Amalthea container, (CommonElements)=>void initializer) {
+ container.commonElements = AmaltheaFactory.eINSTANCE.createCommonElements.init(initializer)
+ }
+
+ def eventModel(Amalthea container, (EventModel)=>void initializer) {
+ container.eventModel = AmaltheaFactory.eINSTANCE.createEventModel.init(initializer)
+ }
+
+ def stimuliModel(Amalthea container, (StimuliModel)=>void initializer) {
+ container.stimuliModel = AmaltheaFactory.eINSTANCE.createStimuliModel.init(initializer)
+ }
+
+ def softwareModel(Amalthea container, (SWModel)=>void initializer) {
+ container.swModel = AmaltheaFactory.eINSTANCE.createSWModel.init(initializer)
+ }
+
+ def osModel(Amalthea container, (OSModel)=>void initializer) {
+ container.osModel = AmaltheaFactory.eINSTANCE.createOSModel.init(initializer)
+ }
+
+ def hardwareModel(Amalthea container, (HWModel)=>void initializer) {
+ container.hwModel = AmaltheaFactory.eINSTANCE.createHWModel.init(initializer)
+ }
+
+ def constraintsModel(Amalthea container, (ConstraintsModel)=>void initializer) {
+ container.constraintsModel = AmaltheaFactory.eINSTANCE.createConstraintsModel.init(initializer)
+ }
+
+ def propertyConstraintsModel(Amalthea container, (PropertyConstraintsModel)=>void initializer) {
+ container.propertyConstraintsModel = AmaltheaFactory.eINSTANCE.createPropertyConstraintsModel.init(initializer)
+ }
+
+ def componentsModel(Amalthea container, (ComponentsModel)=>void initializer) {
+ container.componentsModel = AmaltheaFactory.eINSTANCE.createComponentsModel.init(initializer)
+ }
+
+ def mappingModel(Amalthea container, (MappingModel)=>void initializer) {
+ container.mappingModel = AmaltheaFactory.eINSTANCE.createMappingModel.init(initializer)
+ }
+
+ // ********** Cross reference registry **********
+
+ def <T extends IReferable> void register(T obj, String name) {
+ objectRegistry.put(name, obj)
+ }
+
+ def <T extends IReferable> T ref(Class<T> cl, String name) {
+ val obj = objectRegistry.get(name)
+ cl.cast(obj)
+ }
+
+ // ********** private **********
+
+ def private <T> T init(T obj, (T)=>void init) {
+ init.apply(obj)
+ return obj
+ }
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.xtend
new file mode 100644
index 0000000..8da9a30
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.xtend
@@ -0,0 +1,34 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.CommonElements
+import org.eclipse.app4mc.amalthea.model.CoreClassifier
+import org.eclipse.app4mc.amalthea.model.MemoryClassifier
+import org.eclipse.app4mc.amalthea.model.Tag
+
+class CommonElementsBuilder {
+
+ def commonElementsRoot((CommonElements)=>void initializer) {
+ AmaltheaFactory.eINSTANCE.createCommonElements.init(initializer)
+ }
+
+ // ********** Top level elements **********
+
+ def memoryClassifier(CommonElements container, (MemoryClassifier)=>void initializer) {
+ container.memoryClassifiers += AmaltheaFactory.eINSTANCE.createMemoryClassifier.init(initializer)
+ }
+ def coreClassifier(CommonElements container, (CoreClassifier)=>void initializer) {
+ container.coreClassifiers += AmaltheaFactory.eINSTANCE.createCoreClassifier.init(initializer)
+ }
+ def tag(CommonElements container, (Tag)=>void initializer) {
+ container.tags += AmaltheaFactory.eINSTANCE.createTag.init(initializer)
+ }
+
+ // ********** private **********
+
+ def private <T> T init(T obj, (T)=>void init) {
+ init.apply(obj)
+ return obj
+ }
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.xtend
new file mode 100644
index 0000000..6df1998
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.xtend
@@ -0,0 +1,5 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+class ConstraintsBuilder {
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.xtend
new file mode 100644
index 0000000..20d304e
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.xtend
@@ -0,0 +1,113 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.Array
+import org.eclipse.app4mc.amalthea.model.BaseTypeDefinition
+import org.eclipse.app4mc.amalthea.model.Channel
+import org.eclipse.app4mc.amalthea.model.DataTypeDefinition
+import org.eclipse.app4mc.amalthea.model.Label
+import org.eclipse.app4mc.amalthea.model.Pointer
+import org.eclipse.app4mc.amalthea.model.SWModel
+import org.eclipse.app4mc.amalthea.model.Struct
+import org.eclipse.app4mc.amalthea.model.StructEntry
+
+class DatatypeBuilder {
+
+ def typeDefinition_BaseType(SWModel container, (BaseTypeDefinition)=>void initializer) {
+ container.typeDefinitions += AmaltheaFactory.eINSTANCE.createBaseTypeDefinition.init(initializer)
+ }
+
+ def typeDefinition_DataType(SWModel container, (DataTypeDefinition)=>void initializer) {
+ container.typeDefinitions += AmaltheaFactory.eINSTANCE.createDataTypeDefinition.init(initializer)
+ }
+
+ // ********** Data Types - Struct **********
+
+ def struct(Channel container, (Struct)=>void initializer) {
+ container.elementType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+ }
+
+ def struct(Label container, (Struct)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+ }
+
+ def struct(DataTypeDefinition container, (Struct)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+ }
+
+ def struct(Array container, (Struct)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+ }
+
+ def struct(StructEntry container, (Struct)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+ }
+
+ def struct(Pointer container, (Struct)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+ }
+
+ def entry(Struct container, (StructEntry)=>void initializer) {
+ container.entries += AmaltheaFactory.eINSTANCE.createStructEntry.init(initializer)
+ }
+
+ // ********** Data Types - Array **********
+
+ def array(Channel container, (Array)=>void initializer) {
+ container.elementType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+ }
+
+ def array(Label container, (Array)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+ }
+
+ def array(DataTypeDefinition container, (Array)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+ }
+
+ def array(Array container, (Array)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+ }
+
+ def array(StructEntry container, (Array)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+ }
+
+ def array(Pointer container, (Array)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+ }
+
+ // ********** Data Types - Pointer **********
+
+ def pointer(Channel container, (Pointer)=>void initializer) {
+ container.elementType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+ }
+
+ def pointer(Label container, (Pointer)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+ }
+
+ def pointer(DataTypeDefinition container, (Pointer)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+ }
+
+ def pointer(Array container, (Pointer)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+ }
+
+ def pointer(StructEntry container, (Pointer)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+ }
+
+ def pointer(Pointer container, (Pointer)=>void initializer) {
+ container.dataType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+ }
+
+ // ********** private **********
+
+ def private <T> T init(T obj, (T)=>void init) {
+ init.apply(obj)
+ return obj
+ }
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.xtend
new file mode 100644
index 0000000..0c0ddd2
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.xtend
@@ -0,0 +1,61 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.HWModel
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.CacheDefinition
+import org.eclipse.app4mc.amalthea.model.MemoryDefinition
+import org.eclipse.app4mc.amalthea.model.ProcessingUnitDefinition
+import org.eclipse.app4mc.amalthea.model.ConnectionHandlerDefinition
+import org.eclipse.app4mc.amalthea.model.FrequencyDomain
+import org.eclipse.app4mc.amalthea.model.PowerDomain
+import org.eclipse.app4mc.amalthea.model.HwFeatureCategory
+import org.eclipse.app4mc.amalthea.model.HwStructure
+
+class HardwareBuilder {
+
+ def hardwareModelRoot((HWModel)=>void initializer) {
+ AmaltheaFactory.eINSTANCE.createHWModel.init(initializer)
+ }
+
+ // ********** Top level elements **********
+
+ def definition_Cache(HWModel container, (CacheDefinition)=>void initializer) {
+ container.definitions += AmaltheaFactory.eINSTANCE.createCacheDefinition.init(initializer)
+ }
+
+ def definition_Memory(HWModel container, (MemoryDefinition)=>void initializer) {
+ container.definitions += AmaltheaFactory.eINSTANCE.createMemoryDefinition.init(initializer)
+ }
+
+ def definition_ProcessingUnit(HWModel container, (ProcessingUnitDefinition)=>void initializer) {
+ container.definitions += AmaltheaFactory.eINSTANCE.createProcessingUnitDefinition.init(initializer)
+ }
+
+ def definition_ConnectionHandler(HWModel container, (ConnectionHandlerDefinition)=>void initializer) {
+ container.definitions += AmaltheaFactory.eINSTANCE.createConnectionHandlerDefinition.init(initializer)
+ }
+
+ def domain_Frequency(HWModel container, (FrequencyDomain)=>void initializer) {
+ container.domains += AmaltheaFactory.eINSTANCE.createFrequencyDomain.init(initializer)
+ }
+
+ def domain_Power(HWModel container, (PowerDomain)=>void initializer) {
+ container.domains += AmaltheaFactory.eINSTANCE.createPowerDomain.init(initializer)
+ }
+
+ def featureCategory(HWModel container, (HwFeatureCategory)=>void initializer) {
+ container.featureCategories += AmaltheaFactory.eINSTANCE.createHwFeatureCategory.init(initializer)
+ }
+
+ def structure(HWModel container, (HwStructure)=>void initializer) {
+ container.structures += AmaltheaFactory.eINSTANCE.createHwStructure.init(initializer)
+ }
+
+ // ********** private **********
+
+ def private <T> T init(T obj, (T)=>void init) {
+ init.apply(obj)
+ return obj
+ }
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.xtend
new file mode 100644
index 0000000..59793bd
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.xtend
@@ -0,0 +1,77 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.Deviation
+import org.eclipse.app4mc.amalthea.model.Group
+import org.eclipse.app4mc.amalthea.model.HWModel
+import org.eclipse.app4mc.amalthea.model.LongObject
+import org.eclipse.app4mc.amalthea.model.ModeSwitchDefault
+import org.eclipse.app4mc.amalthea.model.ModeSwitchEntry
+import org.eclipse.app4mc.amalthea.model.ProbabilitySwitchEntry
+import org.eclipse.app4mc.amalthea.model.Runnable
+import org.eclipse.app4mc.amalthea.model.RunnableItem
+import org.eclipse.app4mc.amalthea.model.Scheduler
+import org.eclipse.app4mc.amalthea.model.util.InstructionsUtil
+
+class InstructionsBuilder {
+
+ // ********** Runnable Items - Execution Need **********
+
+ def execNeed_default_Instructions(Runnable container, long instructions) {
+ container.runnableItems += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+
+ def execNeed_default_Instructions(Runnable container, Deviation<LongObject> instructions) {
+ container.runnableItems += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+
+ def execNeed_default_Instructions(Group container, long instructions) {
+ container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+ def execNeed_default_Instructions(Group container, Deviation<LongObject> instructions) {
+ container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+
+ def execNeed_default_Instructions(ModeSwitchDefault<RunnableItem> container, long instructions) {
+ container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+
+ def execNeed_default_Instructions(ModeSwitchDefault<RunnableItem> container, Deviation<LongObject> instructions) {
+ container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+
+ def execNeed_default_Instructions(ModeSwitchEntry<RunnableItem> container, long instructions) {
+ container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+
+ def execNeed_default_Instructions(ModeSwitchEntry<RunnableItem> container, Deviation<LongObject> instructions) {
+ container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+
+ def execNeed_default_Instructions(ProbabilitySwitchEntry<RunnableItem> container, long instructions) {
+ container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+
+ def execNeed_default_Instructions(ProbabilitySwitchEntry<RunnableItem> container, Deviation<LongObject> instructions) {
+ container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+
+ // ********** Computation Items - Execution Need **********
+
+ def execNeed_default_Instructions(Scheduler container, long instructions) {
+ container.computationItems += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+
+ def execNeed_default_Instructions(Scheduler container, Deviation<LongObject> instructions) {
+ container.computationItems += InstructionsUtil.createDefaultExecutionNeed(instructions)
+ }
+
+ // ********** Hardware Feature Category **********
+
+ def featureCategory_Instructions(HWModel container) {
+ val category = AmaltheaFactory.eINSTANCE.createHwFeatureCategory()
+ category.name = InstructionsUtil.INSTRUCTIONS_CATEGORY_NAME
+ container.featureCategories += category
+ }
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.xtend
new file mode 100644
index 0000000..a6ab012
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.xtend
@@ -0,0 +1,95 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.InterruptController
+import org.eclipse.app4mc.amalthea.model.LabelAccess
+import org.eclipse.app4mc.amalthea.model.OSModel
+import org.eclipse.app4mc.amalthea.model.OperatingSystem
+import org.eclipse.app4mc.amalthea.model.OsAPIInstructions
+import org.eclipse.app4mc.amalthea.model.OsDataConsistency
+import org.eclipse.app4mc.amalthea.model.OsISRInstructions
+import org.eclipse.app4mc.amalthea.model.OsInstructions
+import org.eclipse.app4mc.amalthea.model.Scheduler
+import org.eclipse.app4mc.amalthea.model.SchedulerAssociation
+import org.eclipse.app4mc.amalthea.model.SchedulingParameters
+import org.eclipse.app4mc.amalthea.model.Semaphore
+import org.eclipse.app4mc.amalthea.model.TaskScheduler
+import org.eclipse.app4mc.amalthea.model.VendorOperatingSystem
+
+class OperatingSystemBuilder {
+
+ def osModelRoot((OSModel)=>void initializer) {
+ AmaltheaFactory.eINSTANCE.createOSModel.init(initializer)
+ }
+
+ // ********** Top level elements **********
+
+ def operatingSystem(OSModel container, (OperatingSystem)=>void initializer) {
+ container.operatingSystems += AmaltheaFactory.eINSTANCE.createOperatingSystem.init(initializer)
+ }
+
+ def operatingSystem_Vendor(OSModel container, (VendorOperatingSystem)=>void initializer) {
+ container.operatingSystems += AmaltheaFactory.eINSTANCE.createVendorOperatingSystem.init(initializer)
+ }
+
+ def semaphore(OSModel container, (Semaphore)=>void initializer) {
+ container.semaphores += AmaltheaFactory.eINSTANCE.createSemaphore.init(initializer)
+ }
+
+ def osOverhead(OSModel container, (OsInstructions)=>void initializer) {
+ container.osOverheads += AmaltheaFactory.eINSTANCE.createOsInstructions.init(initializer)
+ }
+
+ // ********** Operating system **********
+
+ def taskScheduler(OperatingSystem container, (TaskScheduler)=>void initializer) {
+ container.taskSchedulers += AmaltheaFactory.eINSTANCE.createTaskScheduler.init(initializer)
+ }
+
+ def interruptController(OperatingSystem container, (InterruptController)=>void initializer) {
+ container.interruptControllers += AmaltheaFactory.eINSTANCE.createInterruptController.init(initializer)
+ }
+
+ def dataConsistency(OperatingSystem container, (OsDataConsistency)=>void initializer) {
+ container.osDataConsistency = AmaltheaFactory.eINSTANCE.createOsDataConsistency.init(initializer)
+ }
+
+ def labelAccess(Scheduler container, (LabelAccess)=>void initializer) {
+ container.computationItems += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+ }
+
+ def parentAssociation(TaskScheduler container, (SchedulerAssociation)=>void initializer) {
+ container.parentAssociation = AmaltheaFactory.eINSTANCE.createSchedulerAssociation.init(initializer)
+ }
+
+ def schedulingParameters(SchedulerAssociation container, (SchedulingParameters)=>void initializer) {
+ container.schedulingParameters = AmaltheaFactory.eINSTANCE.createSchedulingParameters.init(initializer)
+ }
+
+ def parameter_extension(SchedulerAssociation container, String key, String value) {
+ container.parameterExtensions.put(key, value)
+ }
+
+
+ // ********** OS instructions (overhead) **********
+
+ def apiOverhead(OsInstructions container, (OsAPIInstructions)=>void initializer) {
+ container.apiOverhead = AmaltheaFactory.eINSTANCE.createOsAPIInstructions.init(initializer)
+ }
+
+ def isrOverheadCat1(OsInstructions container, (OsISRInstructions)=>void initializer) {
+ container.isrCategory1Overhead = AmaltheaFactory.eINSTANCE.createOsISRInstructions.init(initializer)
+ }
+
+ def isrOverheadCat2(OsInstructions container, (OsISRInstructions)=>void initializer) {
+ container.isrCategory2Overhead = AmaltheaFactory.eINSTANCE.createOsISRInstructions.init(initializer)
+ }
+
+ // ********** private **********
+
+ def private <T> T init(T obj, (T)=>void init) {
+ init.apply(obj)
+ return obj
+ }
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.xtend
new file mode 100644
index 0000000..9a6e177
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.xtend
@@ -0,0 +1,245 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.Channel
+import org.eclipse.app4mc.amalthea.model.CustomActivation
+import org.eclipse.app4mc.amalthea.model.EventActivation
+import org.eclipse.app4mc.amalthea.model.Group
+import org.eclipse.app4mc.amalthea.model.ISR
+import org.eclipse.app4mc.amalthea.model.Label
+import org.eclipse.app4mc.amalthea.model.LabelAccess
+import org.eclipse.app4mc.amalthea.model.Mode
+import org.eclipse.app4mc.amalthea.model.ModeLabel
+import org.eclipse.app4mc.amalthea.model.ModeLiteral
+import org.eclipse.app4mc.amalthea.model.ModeSwitchDefault
+import org.eclipse.app4mc.amalthea.model.ModeSwitchEntry
+import org.eclipse.app4mc.amalthea.model.PeriodicActivation
+import org.eclipse.app4mc.amalthea.model.ProbabilitySwitchEntry
+import org.eclipse.app4mc.amalthea.model.ProcessPrototype
+import org.eclipse.app4mc.amalthea.model.Runnable
+import org.eclipse.app4mc.amalthea.model.RunnableCall
+import org.eclipse.app4mc.amalthea.model.RunnableItem
+import org.eclipse.app4mc.amalthea.model.RunnableModeSwitch
+import org.eclipse.app4mc.amalthea.model.RunnableParameter
+import org.eclipse.app4mc.amalthea.model.RunnableProbabilitySwitch
+import org.eclipse.app4mc.amalthea.model.SWModel
+import org.eclipse.app4mc.amalthea.model.Section
+import org.eclipse.app4mc.amalthea.model.SingleActivation
+import org.eclipse.app4mc.amalthea.model.SporadicActivation
+import org.eclipse.app4mc.amalthea.model.Task
+import org.eclipse.app4mc.amalthea.model.VariableRateActivation
+
+class SoftwareBuilder {
+
+ def softwareModelRoot( (SWModel)=>void initializer) {
+ AmaltheaFactory.eINSTANCE.createSWModel.init(initializer)
+ }
+
+ // ********** Top level elements **********
+
+ def isr(SWModel container, (ISR)=>void initializer) {
+ container.isrs += AmaltheaFactory.eINSTANCE.createISR.init(initializer)
+ }
+
+ def task(SWModel container, (Task)=>void initializer) {
+ container.tasks += AmaltheaFactory.eINSTANCE.createTask.init(initializer)
+ }
+
+ def runnable(SWModel container, (Runnable)=>void initializer) {
+ container.runnables += AmaltheaFactory.eINSTANCE.createRunnable.init(initializer)
+ }
+
+ def label(SWModel container, (Label)=>void initializer) {
+ container.labels += AmaltheaFactory.eINSTANCE.createLabel.init(initializer)
+ }
+
+ def channel(SWModel container, (Channel)=>void initializer) {
+ container.channels += AmaltheaFactory.eINSTANCE.createChannel.init(initializer)
+ }
+
+ def processPrototype(SWModel container, (ProcessPrototype)=>void initializer) {
+ container.processPrototypes += AmaltheaFactory.eINSTANCE.createProcessPrototype.init(initializer)
+ }
+
+ def section(SWModel container, (Section)=>void initializer) {
+ container.sections += AmaltheaFactory.eINSTANCE.createSection.init(initializer)
+ }
+
+ def activation_Single(SWModel container, (SingleActivation)=>void initializer) {
+ container.activations += AmaltheaFactory.eINSTANCE.createSingleActivation.init(initializer)
+ }
+
+ def activation_Sporadic(SWModel container, (SporadicActivation)=>void initializer) {
+ container.activations += AmaltheaFactory.eINSTANCE.createSporadicActivation.init(initializer)
+ }
+
+ def activation_Periodic(SWModel container, (PeriodicActivation)=>void initializer) {
+ container.activations += AmaltheaFactory.eINSTANCE.createPeriodicActivation.init(initializer)
+ }
+
+ def activation_Event(SWModel container, (EventActivation)=>void initializer) {
+ container.activations += AmaltheaFactory.eINSTANCE.createEventActivation.init(initializer)
+ }
+
+ def activation_VariableRate(SWModel container, (VariableRateActivation)=>void initializer) {
+ container.activations += AmaltheaFactory.eINSTANCE.createVariableRateActivation.init(initializer)
+ }
+
+ def activation_Custom(SWModel container, (CustomActivation)=>void initializer) {
+ container.activations += AmaltheaFactory.eINSTANCE.createCustomActivation.init(initializer)
+ }
+
+ def mode(SWModel container, (Mode)=>void initializer) {
+ container.modes += AmaltheaFactory.eINSTANCE.createMode.init(initializer)
+ }
+
+ def modeLabel(SWModel container, (ModeLabel)=>void initializer) {
+ container.modeLabels += AmaltheaFactory.eINSTANCE.createModeLabel.init(initializer)
+ }
+
+ // ********** Mode Literals **********
+
+ def literal(Mode container, (ModeLiteral)=>void initializer) {
+ container.literals += AmaltheaFactory.eINSTANCE.createModeLiteral.init(initializer)
+ }
+
+ // ********** Runnable Parameters **********
+
+ def parameter(Runnable container, (RunnableParameter)=>void initializer) {
+ container.parameters += AmaltheaFactory.eINSTANCE.createRunnableParameter.init(initializer)
+ }
+
+ // ********** Runnable Items - Container - Group **********
+
+ def group(Runnable container, (Group)=>void initializer) {
+ container.runnableItems += AmaltheaFactory.eINSTANCE.createGroup.init(initializer)
+ }
+
+ def group(Group container, (Group)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createGroup.init(initializer)
+ }
+
+ def group(ModeSwitchDefault<RunnableItem> container, (Group)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createGroup.init(initializer)
+ }
+
+ def group(ModeSwitchEntry<RunnableItem> container, (Group)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createGroup.init(initializer)
+ }
+
+ def group(ProbabilitySwitchEntry<RunnableItem> container, (Group)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createGroup.init(initializer)
+ }
+
+ // ********** Runnable Items - Container - RunnableModeSwitch **********
+
+ def modeSwitch(Runnable container, (RunnableModeSwitch)=>void initializer) {
+ container.runnableItems += AmaltheaFactory.eINSTANCE.createRunnableModeSwitch.init(initializer)
+ }
+
+ def modeSwitch(Group container, (RunnableModeSwitch)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableModeSwitch.init(initializer)
+ }
+
+ def modeSwitch(ModeSwitchDefault<RunnableItem> container, (RunnableModeSwitch)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableModeSwitch.init(initializer)
+ }
+
+ def modeSwitch(ModeSwitchEntry<RunnableItem> container, (RunnableModeSwitch)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableModeSwitch.init(initializer)
+ }
+
+ def modeSwitch(ProbabilitySwitchEntry<RunnableItem> container, (RunnableModeSwitch)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableModeSwitch.init(initializer)
+ }
+
+ def entry(RunnableModeSwitch container, (ModeSwitchEntry<RunnableItem>)=>void initializer) {
+ container.entries += AmaltheaFactory.eINSTANCE.createModeSwitchEntry.init(initializer)
+ }
+
+ def defaultEntry(RunnableModeSwitch container, (ModeSwitchDefault<RunnableItem>)=>void initializer) {
+ container.defaultEntry = AmaltheaFactory.eINSTANCE.createModeSwitchDefault.init(initializer)
+ }
+
+ // ********** Runnable Items - Container - RunnableProbabilitySwitch **********
+
+ def probabilitySwitch(Runnable container, (RunnableProbabilitySwitch)=>void initializer) {
+ container.runnableItems += AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch.init(initializer)
+ }
+
+ def probabilitySwitch(Group container, (RunnableProbabilitySwitch)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch.init(initializer)
+ }
+
+ def probabilitySwitch(ModeSwitchDefault<RunnableItem> container, (RunnableProbabilitySwitch)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch.init(initializer)
+ }
+
+ def probabilitySwitch(ModeSwitchEntry<RunnableItem> container, (RunnableProbabilitySwitch)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch.init(initializer)
+ }
+
+ def probabilitySwitch(ProbabilitySwitchEntry<RunnableItem> container, (RunnableProbabilitySwitch)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch.init(initializer)
+ }
+
+ def entry(RunnableProbabilitySwitch container, (ProbabilitySwitchEntry<RunnableItem>)=>void initializer) {
+ container.entries += AmaltheaFactory.eINSTANCE.createProbabilitySwitchEntry.init(initializer)
+ }
+
+ // ********** Runnable Items - Label access **********
+
+ def labelAccess(Runnable container, (LabelAccess)=>void initializer) {
+ container.runnableItems += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+ }
+
+ def labelAccess(Group container, (LabelAccess)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+ }
+
+ def labelAccess(ModeSwitchDefault<RunnableItem> container, (LabelAccess)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+ }
+
+ def labelAccess(ModeSwitchEntry<RunnableItem> container, (LabelAccess)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+ }
+
+ def labelAccess(ProbabilitySwitchEntry<RunnableItem> container, (LabelAccess)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+ }
+
+ // ********** Runnable Items - Runnable call **********
+
+ def runnableCall(Runnable container, (RunnableCall)=>void initializer) {
+ container.runnableItems += AmaltheaFactory.eINSTANCE.createRunnableCall.init(initializer)
+ }
+
+ def runnableCall(Group container, (RunnableCall)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableCall.init(initializer)
+ }
+
+ def runnableCall(ModeSwitchDefault<RunnableItem> container, (RunnableCall)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableCall.init(initializer)
+ }
+
+ def runnableCall(ModeSwitchEntry<RunnableItem> container, (RunnableCall)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableCall.init(initializer)
+ }
+
+ def runnableCall(ProbabilitySwitchEntry<RunnableItem> container, (RunnableCall)=>void initializer) {
+ container.items += AmaltheaFactory.eINSTANCE.createRunnableCall.init(initializer)
+ }
+
+ // ********** Runnable Items - TODO **********
+
+
+
+ // ********** private **********
+
+ def private <T> T init(T obj, (T)=>void init) {
+ init.apply(obj)
+ return obj
+ }
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/CustomPropertyUtil.java b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/CustomPropertyUtil.java
index bc8cff3..312faaa 100644
--- a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/CustomPropertyUtil.java
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/CustomPropertyUtil.java
@@ -17,8 +17,11 @@
import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
import org.eclipse.app4mc.amalthea.model.IAnnotatable;
+import org.eclipse.app4mc.amalthea.model.IReferable;
import org.eclipse.app4mc.amalthea.model.IntegerObject;
+import org.eclipse.app4mc.amalthea.model.ReferenceObject;
import org.eclipse.app4mc.amalthea.model.StringObject;
+import org.eclipse.app4mc.amalthea.model.Time;
import org.eclipse.app4mc.amalthea.model.Value;
public final class CustomPropertyUtil {
@@ -31,7 +34,7 @@
return oldValue;
}
-
+
public static Value customPut(IAnnotatable object, String key, String str) {
StringObject valueObject;
valueObject = AmaltheaFactory.eINSTANCE.createStringObject();
@@ -40,7 +43,26 @@
return oldValue;
}
-
+
+ public static Value customPut(IAnnotatable object, String key, Time time) {
+ Time valueObject;
+ valueObject = AmaltheaFactory.eINSTANCE.createTime();
+ valueObject.setValue(time.getValue());
+ valueObject.setUnit(time.getUnit());
+ Value oldValue = object.getCustomProperties().put(key, valueObject);
+
+ return oldValue;
+ }
+
+ public static Value customPut(IAnnotatable object, String key, IReferable reference) {
+ ReferenceObject valueObject;
+ valueObject = AmaltheaFactory.eINSTANCE.createReferenceObject();
+ valueObject.setValue(reference);
+ Value oldValue = object.getCustomProperties().put(key, valueObject);
+
+ return oldValue;
+ }
+
public static Integer customGetInteger(IAnnotatable object, String key) {
Value valueObject = object.getCustomProperties().get(key);
if (valueObject instanceof IntegerObject) {
@@ -59,4 +81,26 @@
}
}
+ public static Time customGetTime(IAnnotatable object, String key) {
+ Value valueObject = object.getCustomProperties().get(key);
+ if (valueObject instanceof Time) {
+ Time time = (Time) valueObject;
+ Time result = AmaltheaFactory.eINSTANCE.createTime();
+ result.setValue(time.getValue());
+ result.setUnit(time.getUnit());
+ return result;
+ } else {
+ return null;
+ }
+ }
+
+ public static IReferable customGetReference(IAnnotatable object, String key) {
+ Value valueObject = object.getCustomProperties().get(key);
+ if (valueObject instanceof ReferenceObject) {
+ return ((ReferenceObject) valueObject).getValue();
+ } else {
+ return null;
+ }
+ }
+
}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/FactoryUtil.java b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/FactoryUtil.java
index c3b8815..75a94ab 100644
--- a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/FactoryUtil.java
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/FactoryUtil.java
@@ -21,20 +21,115 @@
import java.util.regex.Pattern;
import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.DataSize;
+import org.eclipse.app4mc.amalthea.model.DataSizeUnit;
import org.eclipse.app4mc.amalthea.model.Deviation;
import org.eclipse.app4mc.amalthea.model.ExecutionNeed;
+import org.eclipse.app4mc.amalthea.model.Frequency;
+import org.eclipse.app4mc.amalthea.model.FrequencyUnit;
import org.eclipse.app4mc.amalthea.model.HwFeature;
+import org.eclipse.app4mc.amalthea.model.LatencyConstant;
+import org.eclipse.app4mc.amalthea.model.LatencyDeviation;
import org.eclipse.app4mc.amalthea.model.LongObject;
import org.eclipse.app4mc.amalthea.model.Need;
import org.eclipse.app4mc.amalthea.model.NeedConstant;
import org.eclipse.app4mc.amalthea.model.NeedDeviation;
import org.eclipse.app4mc.amalthea.model.Time;
import org.eclipse.app4mc.amalthea.model.TimeUnit;
+import org.eclipse.app4mc.amalthea.model.TypeDefinition;
+import org.eclipse.app4mc.amalthea.model.TypeRef;
+import org.eclipse.app4mc.amalthea.model.Voltage;
+import org.eclipse.app4mc.amalthea.model.VoltageUnit;
import org.eclipse.app4mc.amalthea.model.WeibullEstimators;
public class FactoryUtil {
/**
+ * Creates a data size out of a value and a unit
+ * @param value
+ * @param unit
+ * @return DataSize
+ */
+ public static DataSize createDataSize(long value, DataSizeUnit unit) {
+ DataSize size = AmaltheaFactory.eINSTANCE.createDataSize();
+ size.setValue(BigInteger.valueOf(value));
+ size.setUnit(unit);
+ return size;
+ }
+
+ /**
+ * Creates a frequency out of a value and a unit
+ * @param value
+ * @param unit
+ * @return Frequency
+ */
+ public static Frequency createFrequency(double value, FrequencyUnit unit) {
+ Frequency frequency = AmaltheaFactory.eINSTANCE.createFrequency();
+ frequency.setValue(value);
+ frequency.setUnit(unit);
+ return frequency;
+ }
+
+ /**
+ * Creates a voltage out of a value and a unit
+ * @param value
+ * @param unit
+ * @return Voltage
+ */
+ public static Voltage createVoltage(double value, VoltageUnit unit) {
+ Voltage voltage = AmaltheaFactory.eINSTANCE.createVoltage();
+ voltage.setValue(value);
+ voltage.setUnit(unit);
+ return voltage;
+ }
+
+ /**
+ * Creates a time out of a value and a unit
+ * @param value
+ * @param unit
+ * @return Time
+ */
+ public static Time createTime(long value, TimeUnit unit) {
+ Time time = AmaltheaFactory.eINSTANCE.createTime();
+ time.setValue(BigInteger.valueOf(value));
+ time.setUnit(unit);
+ return time;
+ }
+
+ /**
+ * Creates a TypeRef object that refers to a type definition
+ * @param typeDefinition
+ * @return TypeRef
+ */
+ public static TypeRef createTypeRef(TypeDefinition typeDefinition) {
+ TypeRef refObj = AmaltheaFactory.eINSTANCE.createTypeRef();
+ refObj.setTypeDef(typeDefinition);;
+ return refObj;
+ }
+
+ /**
+ * Creates a HwLatency with constant cycles
+ * @param cycles
+ * @return LatencyConstant
+ */
+ public static LatencyConstant createLatency(long cycles) {
+ LatencyConstant latency = AmaltheaFactory.eINSTANCE.createLatencyConstant();
+ latency.setCycles(cycles);
+ return latency;
+ }
+
+ /**
+ * Creates a HwLatency with a deviation of cycles
+ * @param cycles
+ * @return LatencyDeviation
+ */
+ public static LatencyDeviation createLatency(Deviation<LongObject> cycles) {
+ LatencyDeviation latency = AmaltheaFactory.eINSTANCE.createLatencyDeviation();
+ latency.setCycles(cycles);;
+ return latency;
+ }
+
+ /**
* Creates a time out of a value and a unit given as String (lower case).
* @param value
* @param unit
@@ -51,7 +146,7 @@
return TimeUtil.adjustTimeUnit(BigInteger.valueOf(value), tu);
}
-
+
public static Time createTime(BigInteger value, String unit) {
TimeUnit tu = null;
if(unit.toLowerCase().equals("ps")) tu = TimeUnit.PS;
@@ -63,7 +158,7 @@
return TimeUtil.adjustTimeUnit(new BigInteger(value.toByteArray()), tu);
}
-
+
/**
* Creates a Time object parsed from a text representation.
* @param timeString string representation of a time (number follwed by time unit s, ms, us, ns or ps)
@@ -87,7 +182,7 @@
time.setUnit(inputTime.getUnit());
return time;
}
-
+
/**
*
* @param executionNeedCount absolute number of executionNeedCount (simular to instructions)
@@ -109,7 +204,6 @@
return TimeUtil.adjustTimeUnit(runtime, units.get(timeUnitIndex));
}
-
/**
* Returns a created Weibull Deviation.
@@ -129,9 +223,7 @@
result.setLowerBound(lB);
return result;
}
-
-
-
+
/**
* Returns a created Weibull Estimator.
* @param avgR
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.java
new file mode 100644
index 0000000..aa48aee
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.java
@@ -0,0 +1,85 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import java.util.HashMap;
+import org.eclipse.app4mc.amalthea.model.Amalthea;
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.CommonElements;
+import org.eclipse.app4mc.amalthea.model.ComponentsModel;
+import org.eclipse.app4mc.amalthea.model.ConstraintsModel;
+import org.eclipse.app4mc.amalthea.model.EventModel;
+import org.eclipse.app4mc.amalthea.model.HWModel;
+import org.eclipse.app4mc.amalthea.model.IReferable;
+import org.eclipse.app4mc.amalthea.model.MappingModel;
+import org.eclipse.app4mc.amalthea.model.OSModel;
+import org.eclipse.app4mc.amalthea.model.PropertyConstraintsModel;
+import org.eclipse.app4mc.amalthea.model.SWModel;
+import org.eclipse.app4mc.amalthea.model.StimuliModel;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class AmaltheaBuilder {
+ private final HashMap<String, IReferable> objectRegistry = CollectionLiterals.<String, IReferable>newHashMap();
+
+ public Amalthea amaltheaRoot(final Procedure1<? super Amalthea> initializer) {
+ return this.<Amalthea>init(AmaltheaFactory.eINSTANCE.createAmalthea(), initializer);
+ }
+
+ public void commonElements(final Amalthea container, final Procedure1<? super CommonElements> initializer) {
+ container.setCommonElements(this.<CommonElements>init(AmaltheaFactory.eINSTANCE.createCommonElements(), initializer));
+ }
+
+ public void eventModel(final Amalthea container, final Procedure1<? super EventModel> initializer) {
+ container.setEventModel(this.<EventModel>init(AmaltheaFactory.eINSTANCE.createEventModel(), initializer));
+ }
+
+ public void stimuliModel(final Amalthea container, final Procedure1<? super StimuliModel> initializer) {
+ container.setStimuliModel(this.<StimuliModel>init(AmaltheaFactory.eINSTANCE.createStimuliModel(), initializer));
+ }
+
+ public void softwareModel(final Amalthea container, final Procedure1<? super SWModel> initializer) {
+ container.setSwModel(this.<SWModel>init(AmaltheaFactory.eINSTANCE.createSWModel(), initializer));
+ }
+
+ public void osModel(final Amalthea container, final Procedure1<? super OSModel> initializer) {
+ container.setOsModel(this.<OSModel>init(AmaltheaFactory.eINSTANCE.createOSModel(), initializer));
+ }
+
+ public void hardwareModel(final Amalthea container, final Procedure1<? super HWModel> initializer) {
+ container.setHwModel(this.<HWModel>init(AmaltheaFactory.eINSTANCE.createHWModel(), initializer));
+ }
+
+ public void constraintsModel(final Amalthea container, final Procedure1<? super ConstraintsModel> initializer) {
+ container.setConstraintsModel(this.<ConstraintsModel>init(AmaltheaFactory.eINSTANCE.createConstraintsModel(), initializer));
+ }
+
+ public void propertyConstraintsModel(final Amalthea container, final Procedure1<? super PropertyConstraintsModel> initializer) {
+ container.setPropertyConstraintsModel(this.<PropertyConstraintsModel>init(AmaltheaFactory.eINSTANCE.createPropertyConstraintsModel(), initializer));
+ }
+
+ public void componentsModel(final Amalthea container, final Procedure1<? super ComponentsModel> initializer) {
+ container.setComponentsModel(this.<ComponentsModel>init(AmaltheaFactory.eINSTANCE.createComponentsModel(), initializer));
+ }
+
+ public void mappingModel(final Amalthea container, final Procedure1<? super MappingModel> initializer) {
+ container.setMappingModel(this.<MappingModel>init(AmaltheaFactory.eINSTANCE.createMappingModel(), initializer));
+ }
+
+ public <T extends IReferable> void register(final T obj, final String name) {
+ this.objectRegistry.put(name, obj);
+ }
+
+ public <T extends IReferable> T ref(final Class<T> cl, final String name) {
+ T _xblockexpression = null;
+ {
+ final IReferable obj = this.objectRegistry.get(name);
+ _xblockexpression = cl.cast(obj);
+ }
+ return _xblockexpression;
+ }
+
+ private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+ init.apply(obj);
+ return obj;
+ }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.java
new file mode 100644
index 0000000..6b7bc2b
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.java
@@ -0,0 +1,39 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.CommonElements;
+import org.eclipse.app4mc.amalthea.model.CoreClassifier;
+import org.eclipse.app4mc.amalthea.model.MemoryClassifier;
+import org.eclipse.app4mc.amalthea.model.Tag;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class CommonElementsBuilder {
+ public CommonElements commonElementsRoot(final Procedure1<? super CommonElements> initializer) {
+ return this.<CommonElements>init(AmaltheaFactory.eINSTANCE.createCommonElements(), initializer);
+ }
+
+ public boolean memoryClassifier(final CommonElements container, final Procedure1<? super MemoryClassifier> initializer) {
+ EList<MemoryClassifier> _memoryClassifiers = container.getMemoryClassifiers();
+ MemoryClassifier _init = this.<MemoryClassifier>init(AmaltheaFactory.eINSTANCE.createMemoryClassifier(), initializer);
+ return _memoryClassifiers.add(_init);
+ }
+
+ public boolean coreClassifier(final CommonElements container, final Procedure1<? super CoreClassifier> initializer) {
+ EList<CoreClassifier> _coreClassifiers = container.getCoreClassifiers();
+ CoreClassifier _init = this.<CoreClassifier>init(AmaltheaFactory.eINSTANCE.createCoreClassifier(), initializer);
+ return _coreClassifiers.add(_init);
+ }
+
+ public boolean tag(final CommonElements container, final Procedure1<? super Tag> initializer) {
+ EList<Tag> _tags = container.getTags();
+ Tag _init = this.<Tag>init(AmaltheaFactory.eINSTANCE.createTag(), initializer);
+ return _tags.add(_init);
+ }
+
+ private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+ init.apply(obj);
+ return obj;
+ }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.java
new file mode 100644
index 0000000..9d4ecc2
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.java
@@ -0,0 +1,5 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+@SuppressWarnings("all")
+public class ConstraintsBuilder {
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.java
new file mode 100644
index 0000000..04263e3
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.java
@@ -0,0 +1,113 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.Array;
+import org.eclipse.app4mc.amalthea.model.BaseTypeDefinition;
+import org.eclipse.app4mc.amalthea.model.Channel;
+import org.eclipse.app4mc.amalthea.model.DataTypeDefinition;
+import org.eclipse.app4mc.amalthea.model.Label;
+import org.eclipse.app4mc.amalthea.model.Pointer;
+import org.eclipse.app4mc.amalthea.model.SWModel;
+import org.eclipse.app4mc.amalthea.model.Struct;
+import org.eclipse.app4mc.amalthea.model.StructEntry;
+import org.eclipse.app4mc.amalthea.model.TypeDefinition;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class DatatypeBuilder {
+ public boolean typeDefinition_BaseType(final SWModel container, final Procedure1<? super BaseTypeDefinition> initializer) {
+ EList<TypeDefinition> _typeDefinitions = container.getTypeDefinitions();
+ BaseTypeDefinition _init = this.<BaseTypeDefinition>init(AmaltheaFactory.eINSTANCE.createBaseTypeDefinition(), initializer);
+ return _typeDefinitions.add(_init);
+ }
+
+ public boolean typeDefinition_DataType(final SWModel container, final Procedure1<? super DataTypeDefinition> initializer) {
+ EList<TypeDefinition> _typeDefinitions = container.getTypeDefinitions();
+ DataTypeDefinition _init = this.<DataTypeDefinition>init(AmaltheaFactory.eINSTANCE.createDataTypeDefinition(), initializer);
+ return _typeDefinitions.add(_init);
+ }
+
+ public void struct(final Channel container, final Procedure1<? super Struct> initializer) {
+ container.setElementType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+ }
+
+ public void struct(final Label container, final Procedure1<? super Struct> initializer) {
+ container.setDataType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+ }
+
+ public void struct(final DataTypeDefinition container, final Procedure1<? super Struct> initializer) {
+ container.setDataType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+ }
+
+ public void struct(final Array container, final Procedure1<? super Struct> initializer) {
+ container.setDataType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+ }
+
+ public void struct(final StructEntry container, final Procedure1<? super Struct> initializer) {
+ container.setDataType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+ }
+
+ public void struct(final Pointer container, final Procedure1<? super Struct> initializer) {
+ container.setDataType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+ }
+
+ public boolean entry(final Struct container, final Procedure1<? super StructEntry> initializer) {
+ EList<StructEntry> _entries = container.getEntries();
+ StructEntry _init = this.<StructEntry>init(AmaltheaFactory.eINSTANCE.createStructEntry(), initializer);
+ return _entries.add(_init);
+ }
+
+ public void array(final Channel container, final Procedure1<? super Array> initializer) {
+ container.setElementType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+ }
+
+ public void array(final Label container, final Procedure1<? super Array> initializer) {
+ container.setDataType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+ }
+
+ public void array(final DataTypeDefinition container, final Procedure1<? super Array> initializer) {
+ container.setDataType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+ }
+
+ public void array(final Array container, final Procedure1<? super Array> initializer) {
+ container.setDataType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+ }
+
+ public void array(final StructEntry container, final Procedure1<? super Array> initializer) {
+ container.setDataType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+ }
+
+ public void array(final Pointer container, final Procedure1<? super Array> initializer) {
+ container.setDataType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+ }
+
+ public void pointer(final Channel container, final Procedure1<? super Pointer> initializer) {
+ container.setElementType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+ }
+
+ public void pointer(final Label container, final Procedure1<? super Pointer> initializer) {
+ container.setDataType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+ }
+
+ public void pointer(final DataTypeDefinition container, final Procedure1<? super Pointer> initializer) {
+ container.setDataType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+ }
+
+ public void pointer(final Array container, final Procedure1<? super Pointer> initializer) {
+ container.setDataType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+ }
+
+ public void pointer(final StructEntry container, final Procedure1<? super Pointer> initializer) {
+ container.setDataType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+ }
+
+ public void pointer(final Pointer container, final Procedure1<? super Pointer> initializer) {
+ container.setDataType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+ }
+
+ private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+ init.apply(obj);
+ return obj;
+ }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.java
new file mode 100644
index 0000000..8a30f34
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.java
@@ -0,0 +1,76 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.CacheDefinition;
+import org.eclipse.app4mc.amalthea.model.ConnectionHandlerDefinition;
+import org.eclipse.app4mc.amalthea.model.FrequencyDomain;
+import org.eclipse.app4mc.amalthea.model.HWModel;
+import org.eclipse.app4mc.amalthea.model.HwDefinition;
+import org.eclipse.app4mc.amalthea.model.HwDomain;
+import org.eclipse.app4mc.amalthea.model.HwFeatureCategory;
+import org.eclipse.app4mc.amalthea.model.HwStructure;
+import org.eclipse.app4mc.amalthea.model.MemoryDefinition;
+import org.eclipse.app4mc.amalthea.model.PowerDomain;
+import org.eclipse.app4mc.amalthea.model.ProcessingUnitDefinition;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class HardwareBuilder {
+ public HWModel hardwareModelRoot(final Procedure1<? super HWModel> initializer) {
+ return this.<HWModel>init(AmaltheaFactory.eINSTANCE.createHWModel(), initializer);
+ }
+
+ public boolean definition_Cache(final HWModel container, final Procedure1<? super CacheDefinition> initializer) {
+ EList<HwDefinition> _definitions = container.getDefinitions();
+ CacheDefinition _init = this.<CacheDefinition>init(AmaltheaFactory.eINSTANCE.createCacheDefinition(), initializer);
+ return _definitions.add(_init);
+ }
+
+ public boolean definition_Memory(final HWModel container, final Procedure1<? super MemoryDefinition> initializer) {
+ EList<HwDefinition> _definitions = container.getDefinitions();
+ MemoryDefinition _init = this.<MemoryDefinition>init(AmaltheaFactory.eINSTANCE.createMemoryDefinition(), initializer);
+ return _definitions.add(_init);
+ }
+
+ public boolean definition_ProcessingUnit(final HWModel container, final Procedure1<? super ProcessingUnitDefinition> initializer) {
+ EList<HwDefinition> _definitions = container.getDefinitions();
+ ProcessingUnitDefinition _init = this.<ProcessingUnitDefinition>init(AmaltheaFactory.eINSTANCE.createProcessingUnitDefinition(), initializer);
+ return _definitions.add(_init);
+ }
+
+ public boolean definition_ConnectionHandler(final HWModel container, final Procedure1<? super ConnectionHandlerDefinition> initializer) {
+ EList<HwDefinition> _definitions = container.getDefinitions();
+ ConnectionHandlerDefinition _init = this.<ConnectionHandlerDefinition>init(AmaltheaFactory.eINSTANCE.createConnectionHandlerDefinition(), initializer);
+ return _definitions.add(_init);
+ }
+
+ public boolean domain_Frequency(final HWModel container, final Procedure1<? super FrequencyDomain> initializer) {
+ EList<HwDomain> _domains = container.getDomains();
+ FrequencyDomain _init = this.<FrequencyDomain>init(AmaltheaFactory.eINSTANCE.createFrequencyDomain(), initializer);
+ return _domains.add(_init);
+ }
+
+ public boolean domain_Power(final HWModel container, final Procedure1<? super PowerDomain> initializer) {
+ EList<HwDomain> _domains = container.getDomains();
+ PowerDomain _init = this.<PowerDomain>init(AmaltheaFactory.eINSTANCE.createPowerDomain(), initializer);
+ return _domains.add(_init);
+ }
+
+ public boolean featureCategory(final HWModel container, final Procedure1<? super HwFeatureCategory> initializer) {
+ EList<HwFeatureCategory> _featureCategories = container.getFeatureCategories();
+ HwFeatureCategory _init = this.<HwFeatureCategory>init(AmaltheaFactory.eINSTANCE.createHwFeatureCategory(), initializer);
+ return _featureCategories.add(_init);
+ }
+
+ public boolean structure(final HWModel container, final Procedure1<? super HwStructure> initializer) {
+ EList<HwStructure> _structures = container.getStructures();
+ HwStructure _init = this.<HwStructure>init(AmaltheaFactory.eINSTANCE.createHwStructure(), initializer);
+ return _structures.add(_init);
+ }
+
+ private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+ init.apply(obj);
+ return obj;
+ }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.java
new file mode 100644
index 0000000..a0f90c4
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.java
@@ -0,0 +1,103 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.ComputationItem;
+import org.eclipse.app4mc.amalthea.model.Deviation;
+import org.eclipse.app4mc.amalthea.model.ExecutionNeed;
+import org.eclipse.app4mc.amalthea.model.Group;
+import org.eclipse.app4mc.amalthea.model.HWModel;
+import org.eclipse.app4mc.amalthea.model.HwFeatureCategory;
+import org.eclipse.app4mc.amalthea.model.LongObject;
+import org.eclipse.app4mc.amalthea.model.ModeSwitchDefault;
+import org.eclipse.app4mc.amalthea.model.ModeSwitchEntry;
+import org.eclipse.app4mc.amalthea.model.ProbabilitySwitchEntry;
+import org.eclipse.app4mc.amalthea.model.RunnableItem;
+import org.eclipse.app4mc.amalthea.model.Scheduler;
+import org.eclipse.app4mc.amalthea.model.util.InstructionsUtil;
+import org.eclipse.emf.common.util.EList;
+
+@SuppressWarnings("all")
+public class InstructionsBuilder {
+ public boolean execNeed_default_Instructions(final org.eclipse.app4mc.amalthea.model.Runnable container, final long instructions) {
+ EList<RunnableItem> _runnableItems = container.getRunnableItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _runnableItems.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean execNeed_default_Instructions(final org.eclipse.app4mc.amalthea.model.Runnable container, final Deviation<LongObject> instructions) {
+ EList<RunnableItem> _runnableItems = container.getRunnableItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _runnableItems.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean execNeed_default_Instructions(final Group container, final long instructions) {
+ EList<RunnableItem> _items = container.getItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _items.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean execNeed_default_Instructions(final Group container, final Deviation<LongObject> instructions) {
+ EList<RunnableItem> _items = container.getItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _items.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean execNeed_default_Instructions(final ModeSwitchDefault<RunnableItem> container, final long instructions) {
+ EList<RunnableItem> _items = container.getItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _items.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean execNeed_default_Instructions(final ModeSwitchDefault<RunnableItem> container, final Deviation<LongObject> instructions) {
+ EList<RunnableItem> _items = container.getItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _items.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean execNeed_default_Instructions(final ModeSwitchEntry<RunnableItem> container, final long instructions) {
+ EList<RunnableItem> _items = container.getItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _items.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean execNeed_default_Instructions(final ModeSwitchEntry<RunnableItem> container, final Deviation<LongObject> instructions) {
+ EList<RunnableItem> _items = container.getItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _items.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean execNeed_default_Instructions(final ProbabilitySwitchEntry<RunnableItem> container, final long instructions) {
+ EList<RunnableItem> _items = container.getItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _items.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean execNeed_default_Instructions(final ProbabilitySwitchEntry<RunnableItem> container, final Deviation<LongObject> instructions) {
+ EList<RunnableItem> _items = container.getItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _items.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean execNeed_default_Instructions(final Scheduler container, final long instructions) {
+ EList<ComputationItem> _computationItems = container.getComputationItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _computationItems.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean execNeed_default_Instructions(final Scheduler container, final Deviation<LongObject> instructions) {
+ EList<ComputationItem> _computationItems = container.getComputationItems();
+ ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+ return _computationItems.add(_createDefaultExecutionNeed);
+ }
+
+ public boolean featureCategory_Instructions(final HWModel container) {
+ boolean _xblockexpression = false;
+ {
+ final HwFeatureCategory category = AmaltheaFactory.eINSTANCE.createHwFeatureCategory();
+ category.setName(InstructionsUtil.INSTRUCTIONS_CATEGORY_NAME);
+ EList<HwFeatureCategory> _featureCategories = container.getFeatureCategories();
+ _xblockexpression = _featureCategories.add(category);
+ }
+ return _xblockexpression;
+ }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.java
new file mode 100644
index 0000000..91f90d8
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.java
@@ -0,0 +1,102 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.ComputationItem;
+import org.eclipse.app4mc.amalthea.model.InterruptController;
+import org.eclipse.app4mc.amalthea.model.LabelAccess;
+import org.eclipse.app4mc.amalthea.model.OSModel;
+import org.eclipse.app4mc.amalthea.model.OperatingSystem;
+import org.eclipse.app4mc.amalthea.model.OsAPIInstructions;
+import org.eclipse.app4mc.amalthea.model.OsDataConsistency;
+import org.eclipse.app4mc.amalthea.model.OsISRInstructions;
+import org.eclipse.app4mc.amalthea.model.OsInstructions;
+import org.eclipse.app4mc.amalthea.model.Scheduler;
+import org.eclipse.app4mc.amalthea.model.SchedulerAssociation;
+import org.eclipse.app4mc.amalthea.model.SchedulingParameters;
+import org.eclipse.app4mc.amalthea.model.Semaphore;
+import org.eclipse.app4mc.amalthea.model.TaskScheduler;
+import org.eclipse.app4mc.amalthea.model.VendorOperatingSystem;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class OperatingSystemBuilder {
+ public OSModel osModelRoot(final Procedure1<? super OSModel> initializer) {
+ return this.<OSModel>init(AmaltheaFactory.eINSTANCE.createOSModel(), initializer);
+ }
+
+ public boolean operatingSystem(final OSModel container, final Procedure1<? super OperatingSystem> initializer) {
+ EList<OperatingSystem> _operatingSystems = container.getOperatingSystems();
+ OperatingSystem _init = this.<OperatingSystem>init(AmaltheaFactory.eINSTANCE.createOperatingSystem(), initializer);
+ return _operatingSystems.add(_init);
+ }
+
+ public boolean operatingSystem_Vendor(final OSModel container, final Procedure1<? super VendorOperatingSystem> initializer) {
+ EList<OperatingSystem> _operatingSystems = container.getOperatingSystems();
+ VendorOperatingSystem _init = this.<VendorOperatingSystem>init(AmaltheaFactory.eINSTANCE.createVendorOperatingSystem(), initializer);
+ return _operatingSystems.add(_init);
+ }
+
+ public boolean semaphore(final OSModel container, final Procedure1<? super Semaphore> initializer) {
+ EList<Semaphore> _semaphores = container.getSemaphores();
+ Semaphore _init = this.<Semaphore>init(AmaltheaFactory.eINSTANCE.createSemaphore(), initializer);
+ return _semaphores.add(_init);
+ }
+
+ public boolean osOverhead(final OSModel container, final Procedure1<? super OsInstructions> initializer) {
+ EList<OsInstructions> _osOverheads = container.getOsOverheads();
+ OsInstructions _init = this.<OsInstructions>init(AmaltheaFactory.eINSTANCE.createOsInstructions(), initializer);
+ return _osOverheads.add(_init);
+ }
+
+ public boolean taskScheduler(final OperatingSystem container, final Procedure1<? super TaskScheduler> initializer) {
+ EList<TaskScheduler> _taskSchedulers = container.getTaskSchedulers();
+ TaskScheduler _init = this.<TaskScheduler>init(AmaltheaFactory.eINSTANCE.createTaskScheduler(), initializer);
+ return _taskSchedulers.add(_init);
+ }
+
+ public boolean interruptController(final OperatingSystem container, final Procedure1<? super InterruptController> initializer) {
+ EList<InterruptController> _interruptControllers = container.getInterruptControllers();
+ InterruptController _init = this.<InterruptController>init(AmaltheaFactory.eINSTANCE.createInterruptController(), initializer);
+ return _interruptControllers.add(_init);
+ }
+
+ public void dataConsistency(final OperatingSystem container, final Procedure1<? super OsDataConsistency> initializer) {
+ container.setOsDataConsistency(this.<OsDataConsistency>init(AmaltheaFactory.eINSTANCE.createOsDataConsistency(), initializer));
+ }
+
+ public boolean labelAccess(final Scheduler container, final Procedure1<? super LabelAccess> initializer) {
+ EList<ComputationItem> _computationItems = container.getComputationItems();
+ LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+ return _computationItems.add(_init);
+ }
+
+ public void parentAssociation(final TaskScheduler container, final Procedure1<? super SchedulerAssociation> initializer) {
+ container.setParentAssociation(this.<SchedulerAssociation>init(AmaltheaFactory.eINSTANCE.createSchedulerAssociation(), initializer));
+ }
+
+ public void schedulingParameters(final SchedulerAssociation container, final Procedure1<? super SchedulingParameters> initializer) {
+ container.setSchedulingParameters(this.<SchedulingParameters>init(AmaltheaFactory.eINSTANCE.createSchedulingParameters(), initializer));
+ }
+
+ public String parameter_extension(final SchedulerAssociation container, final String key, final String value) {
+ return container.getParameterExtensions().put(key, value);
+ }
+
+ public void apiOverhead(final OsInstructions container, final Procedure1<? super OsAPIInstructions> initializer) {
+ container.setApiOverhead(this.<OsAPIInstructions>init(AmaltheaFactory.eINSTANCE.createOsAPIInstructions(), initializer));
+ }
+
+ public void isrOverheadCat1(final OsInstructions container, final Procedure1<? super OsISRInstructions> initializer) {
+ container.setIsrCategory1Overhead(this.<OsISRInstructions>init(AmaltheaFactory.eINSTANCE.createOsISRInstructions(), initializer));
+ }
+
+ public void isrOverheadCat2(final OsInstructions container, final Procedure1<? super OsISRInstructions> initializer) {
+ container.setIsrCategory2Overhead(this.<OsISRInstructions>init(AmaltheaFactory.eINSTANCE.createOsISRInstructions(), initializer));
+ }
+
+ private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+ init.apply(obj);
+ return obj;
+ }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.java
new file mode 100644
index 0000000..ea0ab20
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.java
@@ -0,0 +1,312 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.Activation;
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.Channel;
+import org.eclipse.app4mc.amalthea.model.CustomActivation;
+import org.eclipse.app4mc.amalthea.model.EventActivation;
+import org.eclipse.app4mc.amalthea.model.Group;
+import org.eclipse.app4mc.amalthea.model.ISR;
+import org.eclipse.app4mc.amalthea.model.Label;
+import org.eclipse.app4mc.amalthea.model.LabelAccess;
+import org.eclipse.app4mc.amalthea.model.Mode;
+import org.eclipse.app4mc.amalthea.model.ModeLabel;
+import org.eclipse.app4mc.amalthea.model.ModeLiteral;
+import org.eclipse.app4mc.amalthea.model.ModeSwitchDefault;
+import org.eclipse.app4mc.amalthea.model.ModeSwitchEntry;
+import org.eclipse.app4mc.amalthea.model.PeriodicActivation;
+import org.eclipse.app4mc.amalthea.model.ProbabilitySwitchEntry;
+import org.eclipse.app4mc.amalthea.model.ProcessPrototype;
+import org.eclipse.app4mc.amalthea.model.RunnableCall;
+import org.eclipse.app4mc.amalthea.model.RunnableItem;
+import org.eclipse.app4mc.amalthea.model.RunnableModeSwitch;
+import org.eclipse.app4mc.amalthea.model.RunnableParameter;
+import org.eclipse.app4mc.amalthea.model.RunnableProbabilitySwitch;
+import org.eclipse.app4mc.amalthea.model.SWModel;
+import org.eclipse.app4mc.amalthea.model.Section;
+import org.eclipse.app4mc.amalthea.model.SingleActivation;
+import org.eclipse.app4mc.amalthea.model.SporadicActivation;
+import org.eclipse.app4mc.amalthea.model.Task;
+import org.eclipse.app4mc.amalthea.model.VariableRateActivation;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class SoftwareBuilder {
+ public SWModel softwareModelRoot(final Procedure1<? super SWModel> initializer) {
+ return this.<SWModel>init(AmaltheaFactory.eINSTANCE.createSWModel(), initializer);
+ }
+
+ public boolean isr(final SWModel container, final Procedure1<? super ISR> initializer) {
+ EList<ISR> _isrs = container.getIsrs();
+ ISR _init = this.<ISR>init(AmaltheaFactory.eINSTANCE.createISR(), initializer);
+ return _isrs.add(_init);
+ }
+
+ public boolean task(final SWModel container, final Procedure1<? super Task> initializer) {
+ EList<Task> _tasks = container.getTasks();
+ Task _init = this.<Task>init(AmaltheaFactory.eINSTANCE.createTask(), initializer);
+ return _tasks.add(_init);
+ }
+
+ public boolean runnable(final SWModel container, final Procedure1<? super org.eclipse.app4mc.amalthea.model.Runnable> initializer) {
+ EList<org.eclipse.app4mc.amalthea.model.Runnable> _runnables = container.getRunnables();
+ org.eclipse.app4mc.amalthea.model.Runnable _init = this.<org.eclipse.app4mc.amalthea.model.Runnable>init(AmaltheaFactory.eINSTANCE.createRunnable(), initializer);
+ return _runnables.add(_init);
+ }
+
+ public boolean label(final SWModel container, final Procedure1<? super Label> initializer) {
+ EList<Label> _labels = container.getLabels();
+ Label _init = this.<Label>init(AmaltheaFactory.eINSTANCE.createLabel(), initializer);
+ return _labels.add(_init);
+ }
+
+ public boolean channel(final SWModel container, final Procedure1<? super Channel> initializer) {
+ EList<Channel> _channels = container.getChannels();
+ Channel _init = this.<Channel>init(AmaltheaFactory.eINSTANCE.createChannel(), initializer);
+ return _channels.add(_init);
+ }
+
+ public boolean processPrototype(final SWModel container, final Procedure1<? super ProcessPrototype> initializer) {
+ EList<ProcessPrototype> _processPrototypes = container.getProcessPrototypes();
+ ProcessPrototype _init = this.<ProcessPrototype>init(AmaltheaFactory.eINSTANCE.createProcessPrototype(), initializer);
+ return _processPrototypes.add(_init);
+ }
+
+ public boolean section(final SWModel container, final Procedure1<? super Section> initializer) {
+ EList<Section> _sections = container.getSections();
+ Section _init = this.<Section>init(AmaltheaFactory.eINSTANCE.createSection(), initializer);
+ return _sections.add(_init);
+ }
+
+ public boolean activation_Single(final SWModel container, final Procedure1<? super SingleActivation> initializer) {
+ EList<Activation> _activations = container.getActivations();
+ SingleActivation _init = this.<SingleActivation>init(AmaltheaFactory.eINSTANCE.createSingleActivation(), initializer);
+ return _activations.add(_init);
+ }
+
+ public boolean activation_Sporadic(final SWModel container, final Procedure1<? super SporadicActivation> initializer) {
+ EList<Activation> _activations = container.getActivations();
+ SporadicActivation _init = this.<SporadicActivation>init(AmaltheaFactory.eINSTANCE.createSporadicActivation(), initializer);
+ return _activations.add(_init);
+ }
+
+ public boolean activation_Periodic(final SWModel container, final Procedure1<? super PeriodicActivation> initializer) {
+ EList<Activation> _activations = container.getActivations();
+ PeriodicActivation _init = this.<PeriodicActivation>init(AmaltheaFactory.eINSTANCE.createPeriodicActivation(), initializer);
+ return _activations.add(_init);
+ }
+
+ public boolean activation_Event(final SWModel container, final Procedure1<? super EventActivation> initializer) {
+ EList<Activation> _activations = container.getActivations();
+ EventActivation _init = this.<EventActivation>init(AmaltheaFactory.eINSTANCE.createEventActivation(), initializer);
+ return _activations.add(_init);
+ }
+
+ public boolean activation_VariableRate(final SWModel container, final Procedure1<? super VariableRateActivation> initializer) {
+ EList<Activation> _activations = container.getActivations();
+ VariableRateActivation _init = this.<VariableRateActivation>init(AmaltheaFactory.eINSTANCE.createVariableRateActivation(), initializer);
+ return _activations.add(_init);
+ }
+
+ public boolean activation_Custom(final SWModel container, final Procedure1<? super CustomActivation> initializer) {
+ EList<Activation> _activations = container.getActivations();
+ CustomActivation _init = this.<CustomActivation>init(AmaltheaFactory.eINSTANCE.createCustomActivation(), initializer);
+ return _activations.add(_init);
+ }
+
+ public boolean mode(final SWModel container, final Procedure1<? super Mode> initializer) {
+ EList<Mode> _modes = container.getModes();
+ Mode _init = this.<Mode>init(AmaltheaFactory.eINSTANCE.createMode(), initializer);
+ return _modes.add(_init);
+ }
+
+ public boolean modeLabel(final SWModel container, final Procedure1<? super ModeLabel> initializer) {
+ EList<ModeLabel> _modeLabels = container.getModeLabels();
+ ModeLabel _init = this.<ModeLabel>init(AmaltheaFactory.eINSTANCE.createModeLabel(), initializer);
+ return _modeLabels.add(_init);
+ }
+
+ public boolean literal(final Mode container, final Procedure1<? super ModeLiteral> initializer) {
+ EList<ModeLiteral> _literals = container.getLiterals();
+ ModeLiteral _init = this.<ModeLiteral>init(AmaltheaFactory.eINSTANCE.createModeLiteral(), initializer);
+ return _literals.add(_init);
+ }
+
+ public boolean parameter(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super RunnableParameter> initializer) {
+ EList<RunnableParameter> _parameters = container.getParameters();
+ RunnableParameter _init = this.<RunnableParameter>init(AmaltheaFactory.eINSTANCE.createRunnableParameter(), initializer);
+ return _parameters.add(_init);
+ }
+
+ public boolean group(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super Group> initializer) {
+ EList<RunnableItem> _runnableItems = container.getRunnableItems();
+ Group _init = this.<Group>init(AmaltheaFactory.eINSTANCE.createGroup(), initializer);
+ return _runnableItems.add(_init);
+ }
+
+ public boolean group(final Group container, final Procedure1<? super Group> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ Group _init = this.<Group>init(AmaltheaFactory.eINSTANCE.createGroup(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean group(final ModeSwitchDefault<RunnableItem> container, final Procedure1<? super Group> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ Group _init = this.<Group>init(AmaltheaFactory.eINSTANCE.createGroup(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean group(final ModeSwitchEntry<RunnableItem> container, final Procedure1<? super Group> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ Group _init = this.<Group>init(AmaltheaFactory.eINSTANCE.createGroup(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean group(final ProbabilitySwitchEntry<RunnableItem> container, final Procedure1<? super Group> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ Group _init = this.<Group>init(AmaltheaFactory.eINSTANCE.createGroup(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean modeSwitch(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super RunnableModeSwitch> initializer) {
+ EList<RunnableItem> _runnableItems = container.getRunnableItems();
+ RunnableModeSwitch _init = this.<RunnableModeSwitch>init(AmaltheaFactory.eINSTANCE.createRunnableModeSwitch(), initializer);
+ return _runnableItems.add(_init);
+ }
+
+ public boolean modeSwitch(final Group container, final Procedure1<? super RunnableModeSwitch> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableModeSwitch _init = this.<RunnableModeSwitch>init(AmaltheaFactory.eINSTANCE.createRunnableModeSwitch(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean modeSwitch(final ModeSwitchDefault<RunnableItem> container, final Procedure1<? super RunnableModeSwitch> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableModeSwitch _init = this.<RunnableModeSwitch>init(AmaltheaFactory.eINSTANCE.createRunnableModeSwitch(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean modeSwitch(final ModeSwitchEntry<RunnableItem> container, final Procedure1<? super RunnableModeSwitch> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableModeSwitch _init = this.<RunnableModeSwitch>init(AmaltheaFactory.eINSTANCE.createRunnableModeSwitch(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean modeSwitch(final ProbabilitySwitchEntry<RunnableItem> container, final Procedure1<? super RunnableModeSwitch> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableModeSwitch _init = this.<RunnableModeSwitch>init(AmaltheaFactory.eINSTANCE.createRunnableModeSwitch(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean entry(final RunnableModeSwitch container, final Procedure1<? super ModeSwitchEntry<RunnableItem>> initializer) {
+ EList<ModeSwitchEntry<RunnableItem>> _entries = container.getEntries();
+ ModeSwitchEntry<RunnableItem> _init = this.<ModeSwitchEntry<RunnableItem>>init(AmaltheaFactory.eINSTANCE.<RunnableItem>createModeSwitchEntry(), initializer);
+ return _entries.add(_init);
+ }
+
+ public void defaultEntry(final RunnableModeSwitch container, final Procedure1<? super ModeSwitchDefault<RunnableItem>> initializer) {
+ container.setDefaultEntry(this.<ModeSwitchDefault<RunnableItem>>init(AmaltheaFactory.eINSTANCE.<RunnableItem>createModeSwitchDefault(), initializer));
+ }
+
+ public boolean probabilitySwitch(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super RunnableProbabilitySwitch> initializer) {
+ EList<RunnableItem> _runnableItems = container.getRunnableItems();
+ RunnableProbabilitySwitch _init = this.<RunnableProbabilitySwitch>init(AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch(), initializer);
+ return _runnableItems.add(_init);
+ }
+
+ public boolean probabilitySwitch(final Group container, final Procedure1<? super RunnableProbabilitySwitch> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableProbabilitySwitch _init = this.<RunnableProbabilitySwitch>init(AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean probabilitySwitch(final ModeSwitchDefault<RunnableItem> container, final Procedure1<? super RunnableProbabilitySwitch> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableProbabilitySwitch _init = this.<RunnableProbabilitySwitch>init(AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean probabilitySwitch(final ModeSwitchEntry<RunnableItem> container, final Procedure1<? super RunnableProbabilitySwitch> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableProbabilitySwitch _init = this.<RunnableProbabilitySwitch>init(AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean probabilitySwitch(final ProbabilitySwitchEntry<RunnableItem> container, final Procedure1<? super RunnableProbabilitySwitch> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableProbabilitySwitch _init = this.<RunnableProbabilitySwitch>init(AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean entry(final RunnableProbabilitySwitch container, final Procedure1<? super ProbabilitySwitchEntry<RunnableItem>> initializer) {
+ EList<ProbabilitySwitchEntry<RunnableItem>> _entries = container.getEntries();
+ ProbabilitySwitchEntry<RunnableItem> _init = this.<ProbabilitySwitchEntry<RunnableItem>>init(AmaltheaFactory.eINSTANCE.<RunnableItem>createProbabilitySwitchEntry(), initializer);
+ return _entries.add(_init);
+ }
+
+ public boolean labelAccess(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super LabelAccess> initializer) {
+ EList<RunnableItem> _runnableItems = container.getRunnableItems();
+ LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+ return _runnableItems.add(_init);
+ }
+
+ public boolean labelAccess(final Group container, final Procedure1<? super LabelAccess> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean labelAccess(final ModeSwitchDefault<RunnableItem> container, final Procedure1<? super LabelAccess> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean labelAccess(final ModeSwitchEntry<RunnableItem> container, final Procedure1<? super LabelAccess> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean labelAccess(final ProbabilitySwitchEntry<RunnableItem> container, final Procedure1<? super LabelAccess> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean runnableCall(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super RunnableCall> initializer) {
+ EList<RunnableItem> _runnableItems = container.getRunnableItems();
+ RunnableCall _init = this.<RunnableCall>init(AmaltheaFactory.eINSTANCE.createRunnableCall(), initializer);
+ return _runnableItems.add(_init);
+ }
+
+ public boolean runnableCall(final Group container, final Procedure1<? super RunnableCall> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableCall _init = this.<RunnableCall>init(AmaltheaFactory.eINSTANCE.createRunnableCall(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean runnableCall(final ModeSwitchDefault<RunnableItem> container, final Procedure1<? super RunnableCall> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableCall _init = this.<RunnableCall>init(AmaltheaFactory.eINSTANCE.createRunnableCall(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean runnableCall(final ModeSwitchEntry<RunnableItem> container, final Procedure1<? super RunnableCall> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableCall _init = this.<RunnableCall>init(AmaltheaFactory.eINSTANCE.createRunnableCall(), initializer);
+ return _items.add(_init);
+ }
+
+ public boolean runnableCall(final ProbabilitySwitchEntry<RunnableItem> container, final Procedure1<? super RunnableCall> initializer) {
+ EList<RunnableItem> _items = container.getItems();
+ RunnableCall _init = this.<RunnableCall>init(AmaltheaFactory.eINSTANCE.createRunnableCall(), initializer);
+ return _items.add(_init);
+ }
+
+ private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+ init.apply(obj);
+ return obj;
+ }
+}