## Main Features of EGF

### General Features

- EGF can start from a simple project; EGF adds incrementally all the required project properties for running: project bundle, dependencies
- EGF is platform-aware: execution with resources in the workspace first else in the platform
- Set the EGF preferences: console, model settings, activity validation
- An activity (factory component, task) is stored in a fcore file; an fcore stores a set of activities

### General Commands

- Activity creation (Factory component, Task): [File][New][Other][EGF section][EGF Activity]
- An activity execution:
  - Dynamically: right-click on a factory component or task elements, and [Run EGF Activity...]
  - Fcore execution: [Right-click][Run EGF Activity...]

### Structural Features

- An activity is unit of execution.
  - An activity contains a set of contracts (i.e., the actity parameters)
  - A contract has a type, a mode (input, output, intput/output), a default value (depends on the type)
- A factory component (FC) is an activity.

- A FC contains a set of viewpoints. A viewpoint defines a type of generation data (e.g., domain, mapping, pattern).
- A FC contains an orchestration.
  - An orchestration contains a context, with the same characteristics than a contract
  - An orchestration contains an ordered set of activity invocations (to factory component or task)
  - An activity invocation provides values to the invoked activity: from 1) local values to the invocation, 2) the orchestration context, 3) the factory component contracts
  - A factory component hierarchy requires at least a task call to execute productively something

- A task is an activity. It is linked to a Java class that implements the expected behavior.
- A domain viewpoint is a viewpoint.
  - A domain viewpoint declares a domain with a URI (platform:/plugin/...)
  - The domain is used in activity invocations through a URI type that references the domain
- A pattern viewpoint is a viewpoint.
  - A pattern viewpoint contains pattern libraries which contains pattern libraries and patterns
  - A pattern has 1) a specification, where are declared the pattern parameters, 2) an implementation that contains methods
  - Pattern methods are in written in a language, for instance Jet for model-to-text transformation
  - Pattern can inherit from a super-pattern, can call patterns with a context injection or not

### Extensibility

EGF is extensible by nature

- Adding new type
- Adding new viewpoint
- Adding new orchestration type
- Adding new language and engine for pattern