All Classes (EASy-Producer Documentation API)

All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class	Description
AbstractArrayWrapper<T>	Implements an array wrapper for the VIL collection type.
AbstractArtifactRepresentation	An abstract implementation of artifact representations which cares for modifiability and for listeners.
AbstractCallExpression	Implements the type checking and automated type conversion mechanism in an abstracted form based on `IMetaType` and `IMetaOperation`.
AbstractCallExpression.ConvertibleOperation	Stores an operation as well as the required type conversion operations.
AbstractChainedReasoner	Implements an abstract chained reasoner.
AbstractChainedReasoner.DerivedReasonerDescriptor	Implements a derived reasoner descriptor taking over capabilities.
AbstractCollectionWrapper<T>	Abstract basic wrapper implementation.
AbstractComboBox<Value>	Super class for combox box working with information of a `PLPInfo` object.
AbstractComboBox.ComboBoxListener<Value>	A listener to react on state changes of `AbstractComboBox`.
AbstractConfigMenu	Abstract super class for menu modifying the `GUIConfiguration`.
AbstractConfigurationFilter	Abstract filter for the `ConfigurationTableEditor`.
AbstractConfigurationLabelProvider	Super class for configuration label provider.
AbstractConfigurationStatisticsVisitor	Visitor for a `Configuration` to generate statistics of the configuration.
AbstractConfigurationStatisticsVisitor.ConfigStatistics	Gathered statistical information of the visited configuration.
AbstractConfigurationVisitor	Provides a basic implementation of the visitor interface for visiting the decisions in the sequence of storage.
AbstractConstraintProcessor	Interface for a generic constraint processor functor (avoid collections, process directly).
AbstractConstraintProcessor.ExpressionType	Expression types.
AbstractConstraintTreeVisitor	Visitor which runs through all elements of a `ConstraintSyntaxTree`, but does nothing.
AbstractDecisionVariableEvaluationAccessor	An accessor based on a decision variable.
AbstractDeclarationFinder	Abstract super class for finding all toplevel `DecisionVariableDeclaration`'s of a `Project`.
AbstractDescriptorConverter	Abstract converter used by `ReflectionOperationDescriptorConverter` and `IvmlComparisonOperationDescriptorConverter`.
AbstractEASyEditorPage	Abstract super class for editor pages of the EASy-Producer tool suite.
AbstractEcoreModelQuery<P extends org.eclipse.emf.ecore.EObject,R>	Some common functionality for the common VIL expressions language.
AbstractEcoreModelQuery<P extends org.eclipse.emf.ecore.EObject,R>	An absract implementation of the Ecore model query interface with common helpful functionality.
AbstractException	A common exception with identifier for testing.
AbstractExpandableGUIVariable	Super class for variables, which contain nested elements and can be expanded.
AbstractFileInstantiator	An abstract file instantiator providing helpful functionality..
AbstractFiletypeWizard	This is the common super class for wizards creating new variability definition/realization files.
AbstractFiletypeWizardPage	The "New" wizard page allows setting the container for the new file as well as the file name.
AbstractFrozenChecker<M extends ContainableModelElement>	Super class for Filters which should remove elements based on already frozen variables.
AbstractFrozenElementsFinder	Abstract superclass for `FreezeBlockFinder` and `FrozenElementsFinder` for discovering frozen elements.
AbstractHeaderMenu	Abstract super class for header menus (buttons), which are parts different editor pages.
AbstractImportResolverPoolManager<M extends IModel>	An abstract pool manager for `ImportResolver` classes.
AbstractIvmlFieldDescriptor	Implements the common capabilities for an IVML read-only field descriptor.
AbstractIvmlTypeDescriptor	Implements a dynamic type descriptor for IVM decision variables.
AbstractIvmlTypeOperationDescriptor	An abstract basic operation descriptor for type operations.
AbstractIvmlVariable	Wraps a decision variable.
AbstractIvmlVariable.DecVar	Implements a dynamic mapping of nested (container) values to temporary decision variables.
AbstractJavaLogger	Super class for `ILogger`s using the `Logger`.
AbstractJavaStatement	Super class for nested elements of a `JavaMethod`.
AbstractListWrapper<T>	Implements an array wrapper for the VIL collection type.
AbstractModelChangeListener	Abstract listener for listening to changes of an underlying model and updating the respective `org.eclipse.xtext.ui.editor.XtextEditor` registered to this listener as well as all other `org.eclipse.xtext.ui.editor.XtextEditor` currently running.
AbstractModelInitializer<M extends IModel>	Implements an abstract model initializer for the language parsers.
AbstractModelTranslator<M extends Script,L extends de.uni_hildesheim.sse.vilBuildLanguage.LanguageUnit>	Implements the translation from the DSL to the build model in the instantiator core.
AbstractPathRuleMatchExpression	Path matching expressions.
AbstractPathRuleMatchExpression.MatchState	Defines matching states.
AbstractProjectCreationDescriptor	Wrapper to use Eclipse project "configurators" to configure EASy projects.
AbstractProjectCreator	Super class for creating new EASy projects.
AbstractProjectVisitor	Abstract super class for visiting projects.
AbstractReasonerListener	`IReasonerListener` which shall update the GUI.
AbstractResolvableModel<V extends IMetaParameterDeclaration,M extends IModel>	A basic implementation of `IResolvableModel`.
AbstractRule	Defines an abstract VIL rule.
AbstractRuleMatchExpression	Represents a rule pre/post match condition (not a rule call in a pre condition).
AbstractStateVariablesInConstraintFinder	Searches for used `IDecisionVariable`s and their states inside a `ConstraintSyntaxTree`.
AbstractTemplateElement	An abstract template element.
AbstractTest<R extends IModel>	An abstract test support class for reading, parsing and comparing models.
AbstractTest.EqualitySetup<R extends IModel>	Setup data needed to compare test results for equality.
AbstractTracerBase	An abstract base tracer implementation storing the actual locale.
AbstractVariable	Defines an abstract variable.
AbstractVariableInConstraintFinder	Superclass for searching for variables/declarations inside `ConstraintSyntaxTree`s.
AbstractVarModelWriter	Super class for translating the variability model to a `StringBuffer`, which can be used for saving.
AbstractVarModelWriter.DefaultSpace	Defines default space locations.
AbstractVilTracer	Implements a combined tracer for VIL and VTL with common indentation.
AbstractVisitor	An abstract visitor which performs a default traversal of the various sets of elements in the model.
AbstractWriter	An abstract class for writing an object model as a textual output.
AbstractXTextEditor<T extends org.eclipse.emf.ecore.EObject,R>	An abstract XText editor providing some capabilities for VIL/VTL.
Activator	Extends the generated activator.
Activator	The activator class controls the plug-in life cycle.
Activator	An explicit bundle activator providing access to the resources of this bundle.
Activator	The activator class controls the plug-in life cycle.
Activator	The activator class controls the plug-in life cycle.
Activator	The activator class controls the plug-in life cycle.
ActualValueReflectionTypeDescriptor<T>	Allows the use the `IActualValueProvider` mechanism for reflective types.
AdvancedJavaLogger	Another `JavaLogger` implementation.
Advice	Establishes a link to a variability model for resolving names in tools.
AdviceConverter	A converter for the `Advice`.
AggregatingModelLoadingListener	Implements an aggregating model loading listener, which enables the given controls only if all listeners are enabled.
AliasTypeDescriptor<T>	Defines a delegating alias type.
AllButFailureTraceFilter	A filter that only emits failure messages.
AllFilter	A filter for all elements, i.e., a filter which includes nothing.
AllFreezeSelector	A freeze selector which just freezes all variables.
AlternativeBranchTreeNode	Represents an alternative branch tree node.
AlternativeExpression	Represents a VIL alternative.
AlternativeExpressionTreeNode	Implements an element node for alternative expressions.
AlternativeFragment	Describes an alternative fragment.
AlternativeStatement	Representation of an alternative-statement in VIL templates which allows conditional processing of two template language statements or blocks (if-then-else).
AnnotationAssignmentConstraint	Reasoner specific constraint type indicating a `Constraint.Type.ANNOTATION_ASSIGNMENT` constraint.
AnnotationAssignmentFinder	Searches for all assignment blocks of annotations.
AnnotationsViewDialog	Displays the current annotation values for a given `IDecisionVariable`.
AnnotationViewContentProvider	Content provider for the default configuration editor.
AnnotationVisitor	Visits a certain set of annotation declarations and assignments (applying to a given scope) and allows processing all of them.
Ant	Builds Java applications with ANT.
AnyType	The AnyType is the "Object" of OCL, a type to which all types are compatible.
Application	This class controls all aspects of the application's execution.
ApplicationActionBarAdvisor	An action bar advisor is responsible for creating, adding, and disposing of the actions added to a workbench window.
ApplicationWorkbenchAdvisor	Class for configuring the workbench.
ApplicationWorkbenchWindowAdvisor	Public class for configuring the window of the Qualimaster-App.
Applicator	Applies the result of the matches determined by the `LhsRhsMatchLoop.matchLoop(Rule, Object[], Applicator, ITracer)` method.
Argument	Represents a user-specified call argument.
ArithmeticOperationType	Basic (number) operations.
ArrayIterable<T>	A simple internal iterator/iterable for arrays.
ArraySequence<T>	Implements an array wrapper for the VIL sequence type.
ArraySet<T>	Implements an array wrapper for the VIL set type.
ArtifactChangedListenerQueue	Handles `IArtifactChangedListener`.
ArtifactCreator	Allows to bind an artifact creator to an artifact implementation.
ArtifactCreatorNode	Stores an artifact creator and its subordinate (more specific) creators according to the inheritance hierarchy.
ArtifactFactory	A factory to create individual artifacts.
ArtifactMatchExpression	Implements an artifact match expression.
ArtifactModel	Implements the artifact model starting at a certain file root.
ArtifactOperations	The artifact operations which cannot be implemented in an interface.
ArtifactTypes	Provides access to the type descriptors of the types defined in this package.
AspectJ	Compiles java files using the AspectJ compiler.
AspectJ.CompletionRunner	A completion runner for AspectJ.
AssignmentDetector	Implements a visitor which searches for assignments.
AssignmentReducer	Part of the `ProjectRewriteVisitor` to remove sub values of a RHS of an assignment, if declarations of this assignments have been removed. Visiting should be started with `AssignmentReducer.reduce(OCLFeatureCall)` instead of using the usual `accept` methods.
AssignmentResolver	Resolves the initial assignment settings for a configuration.
AssignmentState	Defines the default and global assignment states.
AssignmentStateFilter	Filters variables which are in a specific state.
AttachedConstraint	Implements a constraint with attached object (fixed and `Constraint.Type.USUAL` type).
Attribute	Represents an attribute from a variability model imported into VIL.
Attribute	Defines an attribute.
AttributeAssignment	Represents an assignment of a value to attributes of at least one model element.
AttributeAssignment.Assignment	Characterizes an attribute-value assignment.
AttributeException	A specific exception which may occur when assigning values to attributes.
AttributeFilter	Filter for filtering elements having certain attribute assignments.
AttributeFilter.AttributeFilterItem	One attribute value which other variables should have.
AttributeRegExFilter	Implements a simple attribute filter.
AttributesCheckVisitor	A visitor for checking frozen values for all variables which correspond to a given (temporary) assignment of attribute values.
AttributesComboViewer	A combobox for displaying and selecting attributes.
AttributesComboViewer.IGroupValueProvider	A value provider for the group value (to be considered at runtime).
AttributeSynchronizer	Implements an XML attribute synchronizer.
AttributeValues	Stores attributes and their assigned values as an additional information to be considered while reasoning.
AttributeValuesPage	Editor for displaying and editing the temporary attribute settings to be passed configuration of the current project.
AttributeValuesPage.AttributeAssignmentState	Defines a specific assignment state for user-provided attribute values.
AttributeValuesPage.AttributeHeaderMenu	The header menu for attribute values.
AttributeVariable	A variable which represents an attribute.
AvailableModels<M extends IModel>	Stores information about available models, i.e., the relation between model names and all available model information objects.
BaseTypeVisitor	A visitor which determines the (recursive) base type of a given type.
BasicCopyVisitor	Implements a basic constraint copy visitor.
BasicDecisionVariableContainer	This class basically realizes a decision variable container (this class does not support realizing constraints).
BasicModelLoadingListener<M extends IModel>	Generically implements a model processing (loading) listener which disables UI controls.
BasicProgressObserver	A basic, eclipse-like progress observer.
BasicProgressObserver.IProgressMonitor	Simple progress monitor interface.
BasicProgressObserver.Task	Representation of a task, which will be observed by the `BasicProgressObserver.IProgressMonitor`.
BasisDatatype	Represents the basic data types of the IVML.
BasisDatatypeValue	Holding basis data types.
BasisGUIVariable	GUI representation of `IDecisionVariable`s which can be configured with a simple text editor.
BasisVariable	Class for variables which do not bear nested variables.
Binary	The binary representation of an artifact.
BlockExpression	Represents a block of expressions.
BooleanMatchExpression	Implements a Boolean match expression, i.e., a traditional pre- or postcondition.
BooleanOperations	Implements Boolean operations.
BooleanOperations.BinaryBooleanOperation	Defines the interface for a binary boolean operation.
BooleanOperations.BinaryOperationEvaluator	Generically implements binary Boolean operations.
BooleanType	Creates the BasisDatatype Boolean.
BooleanValue	This class holds the value for the boolean.
BuildCollectionApplicator	An applicator which collects the RHS values which need a build and pushes the related match variable values into the given runtime environment.
BuildEnablingApplicator	An applicator which may enable the execution of a loop body.
BuildExecutionApplicator	An applicator which actually executes a rule body if build is required for a LHS/RHS match.
BuildLangConfig	Stores some global configuration values.
BuildlangExecution	Executes a build language project.
BuildLangImportResolver	A specific resolver for VIL enabling calls to VTL.
BuildLangModelUtility	Provides language-wide functionality.
BuildlangWriter	For writing a buildlanguage model to a print stream.
BuildModel	Provides mechanisms for loading, linking, referring, searching and storing build models according to their name, their version and their location.
BuildModel.VilModelRepository	Refined model repository for IVML.
BuildModelListener	A `de.uni_hildesheim.sse.easy_producer.instantiator.model.buildlangModel.Script` listener, which receives notifications about changes of the build model and then forces an update of the `de.uni_hildesheim.sse.ui.XtextEditor` instance that is used to edit the corresponding document in which the script is defined.
BuildResolverVisitor	Implements a visitor which builds a resolver for modifying a VIL model.
BuiltIn	Initializes built-in VIL artifact types.
BuiltIn	Initializes built-in VIL types.
BuiltIn	Initializes built-in VIL instantiators.
BuiltIn	Initializes built-in VIL types.
BuiltIn	Initializes built-in VIL types.
Bundle	Stores data about the containing OSGi bundle (static bundle without activator).
Bundle	Stores data about the containing OSGi bundle (static bundle without activator).
Bundle	Bundle/activator class for this plugin.
Bundle	Bundle/activator class for this plugin.
Bundle	Stores data about the containing OSGi bundle (static bundle without activator).
Bundle	Stores data about the containing OSGi bundle (static bundle without activator).
BundleId	Defines the Bundle ID for this bundle.
ButtonUiControl	Implements a UI control class for `Button`.
CallArgument	Describes an optionally named call argument.
CallExpression	Represents a call to an operation of a `TypeDescriptor`.
CallExpression.CallType	Defines some basic call types.
CallExpressionTreeNode	Implements an element node for rule call expressions.
ChainedReasonerState	Helper class implementing a chained reasoner state.
ChangeHistory	Implements a checkpointing change history of variable changes.
ChangeHistory.CSet	Defines the type of a change set.
CheckInitializerVisitor	Visits constraints and checks for contained constraints for constraint variables.
ClassFileArtifact	Represents a Java class file.
ClassMeta	Marker annotation for classes to rename classes as they shall appear in VIL.
ClassNameAliasingMapper	Class Aliasing Mapper that shortens the class names.
ClassWrapper	Wraps the public static methods into VIL operation descriptors.
ClassWrapperConverter	Converter to serialize the `ClassWrapper`.
CocktailInstantiator	The SAP cocktail instantiator.
Collection<T>	Defines the basic VIL collection type to be used with maps and joins.
CollectionElementVariable	A temporary variable representing a value of a container.
CollectionMatchExpression	Implements a collection match expression.
CollectionOperations	Defines basic collection operations.
ColumnType	This enumeration should classify the different columns.
ComboboxGUICellEditor	Implements an updatable combobox cell editor.
ComboboxGUIVariable	GUI representation of `IDecisionVariable`s which can be configured with a combo box (bounded range).
ComboboxGUIVariable.ComboItem	Elements of this combo box.
ComboGUIEditor	Implements a combo GUI editor representation.
CommandAssignmentState	Pseudo states carrying command information to be translated to `AssignmentState`.
CommandLineProgramRegistry	A registry for command line programs.
Comment	Represents a comment in a parse tree.
Comment	Represents a comment in the source of an IVML file.
CommentResource	A simple comment resource emulating basic functionalities of `Properties`, which, however, interprets IVML qualified names according to its own convention.
CommentResourceVisitor	A visitor turning (partial) IVML elements into more or less explainable strings based on a given `CommentResource`.
CommentsFiletypeWizard	This is a new file wizard for ivml files.
CommentsFiletypeWizardPage	The "New" wizard page allows setting the container for the new file as well as the file name.
CommentsPageCreator	Creates the contents of the `CommentsFiletypeWizard`.
CommentsWizardPageDescriptor	Specification of the `CommentsFiletypeWizardPage`.
CommentUtils	Methods for accessing and converting comments.
CommonXtextEditor<T extends org.eclipse.emf.ecore.EObject,R>	A common extension of the general `org.eclipse.xtext.ui.editor.XtextEditor`.
ComponentArtifact	Represents a runtime component.
CompositeArtifact	The (abstract) top-level decomposable artifact of this package.
CompositeExpression	Represents a composite expression.
CompositeFragmentArtifact	The (abstract) composite fragment artifact.
Compound	Implements a compound type declaration for VIL.
Compound	Represents a compound mostly through its type.
Compound	Implements a compound type declaration for VIL.
Compound	A compound type groups multiple types into a single named unit.
CompoundAccess	Represents an expression which accesses a compound slot where the compound is specified as a `ConstraintSyntaxTree`.
CompoundAccessStatement	Represents a compound access statement, e.g., within a freeze block.
CompoundGUIVariable	GUI representation of compound values.
CompoundInitializer	Represents a typed initializer for compounds.
CompoundInstance	Represents a compound instance.
CompoundItemConfigProvider	`VariableConfigProvider` for nested Elements of a `ContainerVariable`.
CompoundMatchExpression	Denotes the special expression regarding a path match.
CompoundOperations	Implements compound operations.
CompoundSlotAccessor	Implements an accessor for decision variables.
CompoundTypeDescriptor	Implements a compound type descriptor.
CompoundTypeDescriptor.ConstructorOperationDescriptor	The constructor operation(s).
CompoundTypeDescriptor.SlotDescriptor	A slot field descriptor for compounds.
CompoundTypeDescriptor.TypeOperationDescriptor	Represents a type->name operation descriptor.
CompoundValue	CompoundValue class.
CompoundValueSetter	This class handles setting values for compounds.
CompoundVariable	Class for variables of Compounds.
Config	Stores some global configuration values.
ConfigEditorValueRetriever	This class is part of the `ConfigurationCellEditor.getValue(Object)` and converts a given `IDecisionVariable` to an Object so that the Eclipse editors are able to handle it.
ConfigNameFilter	Shows only variable where its name matches to a given regular expression.
ConfigQuery	Provides an interface to query `Configuration`s.
ConfigurableIVMLWriter	An IVML writer which may or not emit imports.
Configuration	Represents a variability model and its configuration in VIL.
Configuration	Implements the base (path) configuration of EASy.
Configuration	Represents a configuration, i.e.
Configuration.PathKind	Defines the supported paths.
ConfigurationCellEditor	The Cell Editor for the Decision Editor Table.
ConfigurationContentHandler	Processes the SAX XML reading.
ConfigurationContentProvider	Content provider for the default configuration editor.
ConfigurationContextResolver	Resolves the context around changed variables, including their parent variables, their references and the variables referencing them.
ConfigurationContextResolver.ResolutionList	Stores the variables already processed and to be resolved.
ConfigurationEditorFactory	Implements a factory for creating EASy configuration editors.
ConfigurationEditorFactory.IConfigurationEditorCreator	Defines the instance of an editor creator.
ConfigurationException	Implements a specific exception for errors in the configuration.
ConfigurationHeaderMenu	Header menu holding buttons for the product configuration editor page. This buttons allow the user to: Validate made Decisions Transform the product This class also handles the transformator notification pop up.
ConfigurationInitializerRegistry	Externalizes the initialization of a configuration, so that a specific reasoner can do this job.
ConfigurationInitializerRegistry.IConfigurationInitializer	Defines the interface for the configuration initializer.
ConfigurationLabelProvider	Concrete label provider for the default configuration editor.
ConfigurationPage	Editor for displaying and editing the configuration of the current project.
ConfigurationSaver	This method is part of the configuration and responsible for saving the values of the configuration inside the `Configuration.toProject(boolean)` method.
ConfigurationTableEditor	The table for editing the configuration, without surrounding buttons or other stuff.
ConfigurationTableEditor.IUpdateListener	A listener which is called when the editor performs (async) updates.
ConfigurationTableEditorFactory	An UI element factory (preliminary).
ConfigurationTableEditorFactory.ConfigTableEditor	Just for now as the constructor of the target class is protected.
ConfigurationTableEditorFactory.DelegatingGuiVariable	Implements a delegating GuiVariable for externally created editors, so that they can be handled like EASy variables.
ConfigurationTableEditorFactory.IEditorCreator	An extensible editor creator for tailoring the general EASy mechanism.
ConfigurationTableEditorFactory.UIChangeListener	A listener called when variables are changed.
ConfigurationTableEditorFactory.UIConfiguration	A UI configuration class wrapping the internally used configuration instance.
ConfigurationTableEditorFactory.UIParameter	Defines a simple UI parameter with name and default value.
ConsoleInstantiatorObserver	This class represents an observer that listens for new messages send from the instantiators.
ConsoleTracerFactory	Factory for the creation of VIL build language tracer and VIL template language tracer.
ConstantAccessor	Implements an accessor for constant values.
ConstantDecisionVariableDeclaration	Defines a constant decision variable declaration.
ConstantExpression	Represents a parenthesis expression.
Constants	Global configuration constants for the IVML translation.
Constants	General language constants.
Constants	Just some constants.
ConstantValue	Class for a constant value.
ConstantValueResolver	Implements a constant value resolution visitor.
Constraint	Implements the constraint (delegate).
Constraint	Class to create a rule-based constraint.
Constraint.IConstraintType	Base type for (extensible) constraint types.
Constraint.Type	The conceptual type of the constraint.
ConstraintBase	Implements the constraint base, a combination of linked list and map in order to quickly store, retrieve and delete constraints to be evaluated.
ConstraintClassifier	This class is able to classify a constraint in one of the following categories.
ConstraintClassifier.ExpectedType	With the aid of this enum is it possible to tell the Classifier which part of a constraint is expected to be next.
ConstraintFinder	This class locates all (visible) constraints in an IVML project.
ConstraintFunctions	Generic constraint functions based on the `AbstractConstraintProcessor`.
ConstraintFunctions.TransitiveConstraintFinder	A transitive constraint/variables finder.
ConstraintList	Implements a constraint list.
ConstraintList.IModificationListener	A listener to be informed if the underlying list changes.
ConstraintList.Node	The node type in a linked constraint base.
ConstraintOperations	Implements constraint operations.
ConstraintReplacer	Class to copy an expression.
ConstraintSeparator	Class for extracting the constraints out of a `Project`.
ConstraintSplitWriter	Splits the textual output at a given `constraint`.
ConstraintSplitWriter.IConstraintFilter	Identifies the constraint where to split at.
ConstraintSplitWriter.IdentityConstraintFilter	An identity constraint filter.
ConstraintSyntaxException	Exception thrown in case that a constraint is given as string and parsed by `ModelUtility.createConstraint(String, de.uni_hildesheim.sse.model.varModel.Project, boolean)`.
ConstraintSyntaxTree	Class to show the syntax of an Constraint.
ConstraintType	Defines the basis datatype for holding constraints.
ConstraintValue	This class holds the value for a constraint type.
ConstraintVariableConstraint	Reasoner specific constraint type indicating a `Constraint.Type.CONSTRAINT`.
ConstructorCallExpression	Represents a constructor call.
ContainableElementsMapAndComparator	A helper class which supports ordering of containable model elements.
ContainableElementsMapAndComparator.Data	Stores internal data to be assigned to a key.
ContainableModelElement	Represents the objects, a project can handle.
ContainableModelElementList	A list of containable model elements which acts as `IResolutionScope`.
Container	Realizes an abstract container.
ContainerElementAccessor	Implements an accessor for decision variables.
ContainerGUIVariable	GUI representation of container values.
ContainerInitializer	Represents an initializer for containers.
ContainerInitializerExpression	Represents a container initializer expression consisting of various entries all in the same dimension.
ContainerItemConfigProvider	`VariableConfigProvider` for nested variables of a `ContainerVariable`.
ContainerIterators	Implements the container iterators.
ContainerIterators.ClosureIteratorEvaluator	Implements a basic closure iterator which can stop on a cycle.
ContainerIterators.CollectingIteratorEvaluator	Implements an evaluator adaptor for collecting operations.
ContainerIterators.CollectIteratorEvaluator	Implements `Container.SELECT` and `Container.REJECT`.
ContainerIterators.DefaultValueComparator	The default value comparator for any value based on `StringProvider`.
ContainerIterators.NumberIteratorEvaluator	A number aggregating iterator.
ContainerOperationCall	Represents a set operation call with declarators, e.g.
ContainerOperations	Implements the default container operations.
ContainerOperations.CalcEvaluator	Implements a container calculation evaluator (just as needed for now).
ContainerOperations.Container2Operation	Defines a container/container operation.
ContainerOperations.Container2OperationEvaluator	Implements a container/container operation generically.
ContainerOperations.ContainerArgument	A combined container value / accessor.
ContainerOperations.ContainerValueOperation	Defines a container/value operation.
ContainerOperations.ContainerValueOperationEvaluator	Implements a container/value operation generically.
ContainerOperations.FindOperationEvaluator	Implements the "includes"/"excludes" function.
ContainerOperations.FlattenOperationEvaluator	Implements the "flattens" operation.
ContainerOperations.IncludesAllOperationEvaluator	Implements the "includesAll"/"excludesAll" function.
ContainerOperations.IsEmptyOperationEvaluator	Implements the "isEmpty"/"notEmpty" function.
ContainerOperations.TypeSelectEvaluator	Implements the typeSelection operation.
ContainerTextGUIEditor	Class that implements the GUIEditor.
ContainerValue	ContainerValue class.
ContainerVariable	`VariableConfigProvider` for nested variables of a `ContainerVariable`.
ContainsSelfVisitor	Searches a constraint for the occurrence of `self`.
ContentAlternativeExpression	Implements a content alternative expression.
ContentImportExpression	Represents an import of a template through a in-content expression.
ContentLoopExpression	Implements a content loop expression.
ContentStatement	Implements a statement which contains content.
ContentStatement.LineEndType	Defines the line end types.
ContentVarDeclExpression	Creates a content expression/statement that declares and initializes a variable.
Context	Stores knowledge about the current constraint visitation (the context of earlier elements).
ContextStack	Implements a context stack for nested translations.
ContextStack	Realizes a context stack for evaluating nested self expressions.
ContextStack.Context	A linked stack entry.
ContextStack.StackFrame	Implements a poolable stack frame.
ContextStack.TranslateMode	(Compound) Translation mode for active type caches.
Contributions	For contributions to the EASY core.
Contributions	For contributions to the EASY core.
Contributions	For contributions to the EASY UI.
Contributions.CoreFunction	Denotes individual core functions.
Contributions.ToolTipListener	A listener showing a tooltip on a disabled button.
Contributions.UIElement	Denotes individual UI elements.
Controller	Parent-class for all controller-classes.
Conversion	Marker annotation for the singleton instance of a type class.
CopyVisitor	Implements a visitor for copying expressions.
CopyVisitor	Copies a constraint syntax tree possibly mapping the variables.
CopyVisitor.IVariableReplacer	Defines a common variable replacer.
CSTCopyVisitor	Special `CopyVisitor` as needed by the `ProjectCopyVisitor`.
CSTSemanticException	Exception for invalid Constraints.
CSTUtils	Utility functions for handling `ConstraintSyntaxTree`s.
CustomAntLogger	ANT-Message Handler.
CustomDatatype	Abstract class, implements the setName method for the custom data types.
CustomDynamicOperation	Implements a non-static custom operation subject to dynamic dispatch while evaluation.
CustomOperation	Represents a custom operation as defined in the IVML model.
CustomXtextEditorCallback	Implements a custom CompoundXtextEditorCallback which can be registered to a XtextEditor in oder to react on key events.
DataStorage	Extensible delegator for persistent access.
DatatypeFinder	Visitor for finding `CustomDatatype` of a specific type.
DatatypeVisitor	Implements a default visitor where contained types are surrounded by their containing types.
Debug	Debugging support.
DebugConstraintTreeVisitor	A visitor for printing out constraint syntax trees.
DebugLevel	Extension for java.util.logging.Level since it does not have a DEBUG level.
DebugStatus	Subclass of Status for own DEBUG Status in eclipse logging.
DecisionVariable	Realizes the bridge to the decision variables.
DecisionVariable	Implements a decision variable (delegate).
DecisionVariable	Implements a decision variable representing a specific decision.
DecisionVariableDeclaration	Implements a decision variable.
DeclarationFinder	This class locates all top-level DecisionVariableDeclaration in a project.
DeclarationFinder.VisibilityType	Specifies which kind of found declarations shall by returned.
DeclarationInContainerFinder	Tests whether a `ContainableModelElement` is a `DecisionVariableDeclaration` or an `AttributeAssignment`.
DeclarationMapper	This filter class searches all top level `DecisionVariableDeclaration`s and stores them into a Map.
DeclarationNameFilter	Filters `DecisionVariableDeclaration`s based on their names.
DeclrationInConstraintFinder	Filter class for retrieving all `AbstractVariable`'s nested inside a given constraint.
Def	Implements a template language subtemplate ('def').
DefaultConfigurationStatisticsVisitor	A default implementation of the `AbstractConfigurationStatisticsVisitor` with empty implementation of special treatments.
DefaultConstraint	Reasoner specific constraint type indicating a `Constraint.Type.DEFAULT` constraint.
DefaultFileArtifactCreator	Defines the default file artifact creator.
DefaultFolderArtifactCreator	Defines the default folder creator.
DefaultImportResolver<M extends IModel>	A model imports resolver.
DefaultImportResolver	A project imports resolver.
DefaultJavaFileArtifactCreator	Defines the default file artifact creator.
DefaultLib	Collects URLs representing the IVML/VIL/VTL default library.
DefaultLocale	Provides access to the default locale.
DefaultReasonerAccess	Provides descriptive access to the default reasoner.
DefaultReasonerAccess.IDefaultReasonerProvider	Defines the interface for a reasoner provider.
DefaultValue	Indicates a data structure containing the default value(s) of a type or of parameters.
DefaultValueHelper	Assigns the defined default value(s).
DefaultValueTranslator	Turns partial compound default values into complete values as EASy allows only one default assignment per variable.
DefaultVtlJavaExtension	A default random extension for VTL.
DefaultXmlFileArtifactCreator	Defines the default file artifact creator.
DeferInitExpression	An expression to indicate that the contained expression shall not be evaluated rather than used as value.
DeferredResolvableOperationExpression	Defines a deferrable resolvable operation expression, i.e., a currently unresolved "function pointer".
DefInfo	Stores (temporary) information about the relation of an ECore and an Template model instance.
DelegatingEasyEditorPage	Implementation of an editorpage to use the configuration table editor within usual composites.
DelegatingEasyEditorPage.IDirtyListener	A dirty listener interface.
DelegatingReasonerInstance	Provides a default implementation for reasoner instances by delegating the respective calls to a given delegate reasoner.
DelegatingSysoutWriter	A writer which writes to the original (delegate) Writer and to system out.
DelegatingType	An internal delegating type to resolve cyclic class dependencies.
DelegatingTypeConverter	A type converter for delegating types.
DeletedElementsCollector	Part of the `ProjectRewriteVisitor`, to detect deleted elements if a complete Import was removed.
DerivedDatatype	DerivedDatatype allows the user to create new data types based on existing types.
DerivedProjectCreator	Creates a derived EASy project, which will have one predecessor.
DerivedTypeMetaCompoundAccessVisitor	A checking visitor for illegal compound accesses in declaration of derived data types.
Descriptor	A specific reasoner descriptor for AssignmentResolver reasoner.
Dialogs	Error and Info Box utility class.
DispatchInformation	Stores dispatch information for dynamically dispatching a custom operation.
DisplayNameProvider	A provider for display names (e.g., in case that not variable names shall be displayed).
DotAttribute	Special form of attribute specified by ".".
Dtd	Contains all information of a DTD.
DtdParser	This class is used to read embedded DTDs from XML files and write them back later.
DummyModel<V extends IMetaParameterDeclaration,M extends IModel>	Implements a dummy model used for properly initializing `RuntimeEnvironment`.
EASyConfigFileFilter	`FileFilter` for EASy config files (variability model, build scripts, and templates).
EASyConfigFileImporter	Copies all EASy config files (of a predecessor project) from one folder to another while keeping sub folder hierarchy. This is needed for imported variability models, build scripts, and templates.
EASyDebugInformationButton	Checkbox for (de-)selecting whether debug infomration shall be saved.
EasyExecutor	Defines a configurable executor class to run the main steps of EASy-Producer in a convenient manner.
EasyExecutor.Logger	Defines a simple logger frontend interface.
EASyInitializer	This singelton class controls the `IResourceInitializer` for the EASyPeristencer.
EASyJavaConfigurator	Configures a new created `IProject` to an Java project with a src folder.
EASyLoggerFactory	Factory for the current logger.
EASyNature	The nature for all EASy-Producer projects.
EASyPersistencer	Abstraction Layer for saving/reading persistent EASy-Producer information.
EASyPreferenceStore	Implements a frontend for EASy-specific Eclipse preference store values.
EASyProducerConstants	Naming constants for hole plug-in, especially GUI.
EasyProducerDialog	Error and Info Box for EASy-Producer.
EASyProjectCreatorFactory	Creates new EASy projects in Eclipse.
EASyUtils	Some utility methods.
EclipseConsole	Retrieve the MessageConsole of the currently running Elcipse-instance.
EclipseLogger	ILogger implementation for eclipse logger.
EclipsePersistencer	This class represents an interlayer between persistency-layer and model.
EclipseProgressObserver	Wrapping eclipse progress observer.
EclipseProgressObserver	Observes the progress of a longer lasting task for the eclipse ui.
EclipseProgressObserver.MyProgressMonitor	Wraps the eclipse progress monitor to the basic progress observer interface.
EclipseProgressObserver.MyProgressMonitor	Wraps the eclipse progress monitor to the basic progress observer interface.
EclipseProjectConfigurationDescriptor	Creates an EASy project based on a plain Eclipse project without any programming language specific stuff.
EclipseProjectCreationResult	This result will be returned after calling the `EclipsePersistencer#createEASyProject(String, String, String...)` method.
EclipseResourceInitializer	A resource initializer specific for Eclipse.
EcoreModelQuery
Editor	Multipage editor for editing and configuring one product line project.
EditorConstants	This interface contains global constants for the Editor.
EditorContextMenuListener	Listener for the context menu of the `ConfigurationTableEditor`.
EditorContextMenuListener.Action	Specifies the action which should be handled by the `EditorContextMenuListener` instance.
EditorEmbedderFactory	A factory for creating embedded editors.
EditorEmbedderFactory.IEditorCreator	Creates a specific embedded editor.
EditorType	Specification which Editor should be opened for a `ProductLineProject`.
EditorUtils	Provides editor utility methods.
EditorUtils	Provides editor utility methods.
EditProductLineAction	EASy contribution for the context menu of eclipse's package explorer.
ElementTreeNode<E>	Implements an element node.
EmbeddedXtextSourceEditor	Represents an embedded Xtext editor.
EmbeddedXtextSourceEditor.DocumentContextObserver	Implements a delegating document context observer.
EmbeddingHelper	Helps embedding the xText-editor of a certain grammar.
EmptyInitializer	An internal temporary node representing an untyped empty initializer.
Engine	Class for executing reasoner and returning the result.
Entity	This class represents the entities for the persistency data-model.
Enum	Enumerations allow the definition of sets of named values.
EnumLiteral	Objects represents the literal of an enum.
EnumOperations	Implements enum and ordered enum operations.
EnumOperations.BinaryEnumComparisonOperation	Defines the evaluation of a binary enum (literal) operation.
EnumOperations.EnumComparisonOperation	Implements the generic enum comparison operation based on `EnumOperations.BinaryEnumComparisonOperation`.
EnumOperations.MinMaxEvaluator	Implements `OrderedEnum.MIN`.
EnumValue	Represents an IVML enum value.
EnumValue	Holding enum literals.
EnumValueConverter	Converter for the enums.
Environment	Static utility functions regarding the environment of EASy.
ErrorCodes	Defines error codes for messages used in unit testing.
ErrorCodes	Defines error codes for messages used in unit testing.
ErrorSetter	Sets error messages for `GUIVariable`s.
EvalBlockFinder	This class locates all `PartialEvaluationBlock` in a project.
EvaluationAccessor	Defines a unified accessor to variables, constants, slots etc.
EvaluationBlock	An evaluation block consisting of constraints to be evaluated.
EvaluationContext	Some basic functionality required by the evaluators without exposing the `EvaluationVisitor`.
EvaluationResult	A specific reasoning result for evaluations of presence conditions.
EvaluationResult.ConstraintEvaluationResult	Denotes the possible results of a constraint evaluation.
EvaluationResult.EvaluationPair	Defines a pair of a constraint and its evaluation result.
EvaluationUtils	Some evaluation utility methods.
EvaluationUtils.VariableReplacer	Implements a variable replacer.
EvaluationVisitor	A basic visitor for evaluating expressions.
EvaluationVisitor	Evaluation visitor for IVML expressions.
EvaluationVisitor.Message	Extended Message class for saving variables that fail in assignments.
EvaluatorRegistry	Allows to register, query and unregister evaluators for IVML operations.
EvalVisitor	This class shall extend `EvaluationVisitor` for using it in the Reasoning plugin.
ExceptionLevel	Extension for java.util.logging.Level since it does not have a EXCEPTION level.
ExceptionStatus	Subclass of Status for own EXCEPTION Status in eclipse logging.
ExecutableOperand	Frontend access to the executable operands.
ExecutableRules	Stores information about executable rules.
ExecutionLocal	Provides access to execution global information that is available via registered tracers for instances that do not have references to the execution visitor.
ExecutionVisitor<M extends IResolvableModel<V,M>,O extends IResolvableOperation<V>,V extends VariableDeclaration,R extends Resolver<M,O,?,V>>	Extends the basic expression evaluation visitor for the execution of those classes being defined in this package.
ExecutionVisitor.ConditionTest	Specifies various types of artifact condition tests.
Executor	Executes VIL scripts.
Executor.IExecutable	Characterizes the final executable.
ExplicitTypeVariableDeclaration	Represents an explicitly typed declarator in a set operation.
Expression	An expression used in the instantiation languages.
ExpressionCopyVisitor	The copy visitor for VIL expressions.
ExpressionCopyVisitor	The copy visitor for VTL expressions.
ExpressionDslDescriptionLabelProvider	Provides labels for a IEObjectDescriptions and IResourceDescriptions.
ExpressionDslFormatter	This class contains custom formatting description.
ExpressionDslJavaValidator
ExpressionDslLabelProvider	Provides labels for a EObjects.
ExpressionDslOutlineTreeProvider	customization of the default outline structure
ExpressionDslProposalProvider	see http://www.eclipse.org/Xtext/documentation/latest/xtext.html#contentAssist on how to customize content assistant
ExpressionDslQuickfixProvider
ExpressionDslRuntimeModule	Use this class to register components to be used at runtime / without the Equinox extension registry.
ExpressionDslScopeProvider	This class contains custom scoping description.
ExpressionDslStandaloneSetup	Initialization support for running Xtext languages without equinox extension registry
ExpressionDslUiModule	Use this class to register components to be used within the IDE.
ExpressionEvaluator	A wrapper type to pass and evaluate expressions in VIL languages.
ExpressionParserRegistry	A global registry for expression parsers.
ExpressionParserRegistry.ILanguage<R extends Resolver<?>>	Identifies a language.
ExpressionProposalProvider	Implements a proposal provider for IVML expressions.
ExpressionStatement	Represents a statement which contains just of an expression.
ExpressionStatement	Represents a statement which contains just of an expression.
ExpressionStatement	Represents a statement which contains just of an expression.
ExpressionTranslator	A specific expression translator for the build language.
ExpressionTranslator	Implements a class which translates a given EMF expression in terms of the IVML grammar into the IVML object model.
ExpressionTranslator<I extends VariableDeclaration,R extends Resolver<I>,E extends ExpressionStatement>	Implements the translation from the expression DSL to the expression model in the instantiator core.
ExpressionTranslator	A specific expression translator for the template language.
ExpressionTranslator	A basic implementation of an expression translator, i.e., a basic class for translating individual expressions into model instances.
ExpressionTranslator.CallType	Defines basic VIL call types.
ExpressionVersionRestriction	A version restriction based on VIL expressions.
ExpressionVersionRestriction	A version restriction based on expressions.
ExpressionVersionRestriction	A version restriction based on VTL expressions.
ExpressionVersionRestriction	A version expression based on IVML constraints.
ExpressionVersionRestrictionValidator	Implements a VIL expression version restriction validator.
ExpressionVersionRestrictionValidator	Implements a basic expression version restriction validator.
ExpressionVersionRestrictionValidator	Implements a VTL expression version restriction validator.
ExpressionVersionRestrictionValidator	A simple validator for version restrictions, disallowing if-then-else, let-in and compound initializers.
ExpressionWriter	Implements a writer for expressions using the default VIL expression syntax.
ExtensionClassLoaders	Allows to register extension class loaders to be considered by `JavaExtension`.
Extensions	Extension to activate the serialization of runtime VIL files.
ExternalEditor	Enables to plug in external editors.
FailedElementDetails	Class for storing Failed elements details.
FailedElements	Part of the `FailedRules`.
FakeOperationDescriptor	Represents a fake operation descriptor, i.e., an operation which accepts every type of parameter and the result can be used everywhere.
FakeTypeDescriptor	Represents a fake type descriptor for IVML.
FieldAccessExpression	Represents a field access.
FieldDescriptor	Implements an abstract field descriptor.
FileArtifact	Implements a simple file artifact, i.e., an artifact which is represented as a file.
FileArtifactExecutableOperandType	An executable operand type for `FileArtifact`.
FileLogger	Simple logger for logging into a specified file.
FileSystemArtifactExecutableOperandType	An executable operand type for `IFileSystemArtifact`.
FileSystemArtifactOperations	The file system artifact operations which cannot be implemented in an interface.
FileUpgrader	An upgrader for file input locations.
FileUtils	Some file utility methods (may partially be taken from commons.io but this is currently no defined as dependency of this bundle - see standalone).
FileUtils	Some file helper methods.
FileUtils	Some basic file utilities.
FileUtils.ScanResult<T extends IArtifact>	Represents the result of a `FileUtils.scan(File, ArtifactModel, long, ScanResult, Class)` execution.
FilterMenu	Graphical Menu for filtering configuration items (variables) displayed inside the GUI.
FilterMenu.IAttributeSelectionChangedListener	Defines a listener which is notified about the changed value of an attribute.
FilterType	This enumeration if for the constructors of this package to denote whether imports should be considered during filtering the current project.
FixedListSequence<T>	Implements an array wrapper for the VIL sequence type which does not allow sequence reordering `FixedListSequence.allowSequenceAdjustment()`.
FixedListSet<T>	Implements an array wrapper for the VIL set type which does not allow sequence reordering `FixedListSet.allowSequenceAdjustment()`.
FloatValueConverter	Converts strings recognized by the grammar to float values.
FlushStatement	Represents an explicit content flush.
FolderArtifact	Represents a file system folder.
FormattingConfiguration	Stores VTL formatting configurations.
ForStatement	Implements a VIL for statement.
Fragment	Marker annotation for classes which act as fragments.
FragmentArtifact	The (abstract) top-level fragment artifact.
FreezeBlock	Handles frozen elements.
FreezeBlockFinder	Finds all freeze blocks in a given project.
FreezeEvaluator	Implements a freeze selector based on expression evaluation.
FreezeVariableType	An internal type for freezes to iterate / specify expressions on freezables.
FreezeVarOperations	Implements the operations of the internal freeze variable type.
FreezeVarOperations.NameOperationEvaluator	Implements the operation evaluator for variable names.
FrozenCompoundConstraintsOmitter	Removes constraint out of compounds, pointing to only frozen and constant elements.
FrozenConstraintsFilter	A `IModelElementFilter` to filter constraints, containing only frozen variables and constants.
FrozenConstraintVarFilter	Removes frozen `ConstraintType` variables if they are only pointing to frozen variable.
FrozenElementsFinder	This class searches through a project (and its imports) for finding frozen elements.
FrozenTypeDefResolver	Checks whether all instances of a given `DerivedDatatype` are frozen and will remove all constraints, if all instances are frozen or if none exist.
FrozenVariablesFilter	Enables only frozen variables, i.e., variables with assignment state `frozen`.
FullDecisionVariableContainer	An extended version of the a decision variable container which also supports realizing constraints.
GeneralMeasures	General reasoner measures.
GeneralReasonerCapabilities	Defines general reasoner capabilities.
GenericEditorOpener<T extends org.eclipse.emf.ecore.EObject,P extends org.eclipse.emf.ecore.EObject,M extends IModel,E,R>	This class provides a single method for opening an language-specific editor and selecting a specific element of the opened file in that editor based on a given `ILeafNode` that represents the element for which the declaration should be displayed.
GenericHyperlink<P extends org.eclipse.emf.ecore.EObject>	This class realizes a custom hyperlink that is created for any IVML-element in an IVML-file if the user selects such an element either via pressing the "F3"-key or by clicking on that element while pressing the "CTRL"-key.
GenericHyperlinkHelper<P extends org.eclipse.emf.ecore.EObject>	This class enables the creation of `GenericHyperlink`s for any IVML-element in an IVML-file if the user selects such an element either via pressing the "F3"-key or by clicking on that element while pressing the "CTRL"-key.
GenericNumberOperations	Generic Number (`IntegerType`, `RealType`) operations.
GenericNumberOperations.INumberComparator	Strategy for comparing two numbers.
GenericOperations	Generic operation implementation for the individual types.
GlobalPathPreferencePage	Implements the global EASy path preference page.
GUIConfiguration	Wrapper class for this configuration as needed by the Eclipse GUI.
GUIConfigurationFilter	Container for usable ViewerFilter.
GUIEditor	Defines a GUI editor representation.
GUIHistory	Stores values entered via the GUI until they are saved permanently.
GUIHistoryItem	Stores one value entered via the GUI until they are saved permanently.
GuiTracerFactory	Factory for the creation of VIL build language tracer and VIL template language tracer.
GUIUtils	Static functions used inside the GUI, e.g.
GUIValueFactory	Creates a `GUIVariable` for a given `IDecisionVariable`.
GUIValueFactory.VariableVisitor	Part of the `GUIValueFactory` for creating a `GUIVariable`.
GUIVariable	A `IDecisionVariable` with functionality needed by the Eclipse UI.
HintedExpression	Wraps an expression with a formatting hint.
IActualTypeAssignmentProvider	Allows defining type compatibilities of later defined types.
IActualTypeProvider	VIL types implementing this interface may provide a more actual type of an object, e.g., an argument during dynamic dispatch.
IActualValueProvider	VIL types implementing this interface may provide a more actual value of an object, e.g., during value assignment in the `RuntimeEnvironment`.
IAggregatableListener	An aggregatable listener.
IArgumentProvider	Marks a class which stores / provides arguments.
IArtifact	Represents a generic artifact.
IArtifactChangedListener	A listener which notifies interested parties about a changed artifact.
IArtifactChangedListenerQueue	Defines the interface for a set of listeners (observer part).
IArtifactCreator	Describes creator instances which know how to translate real world objects into artifact instances.
IArtifactNotifier	An instance which notifies the `artifact model` about changed artifacts.
IArtifactRepresentation	The common interface for all artifact representations.
IArtifactRoot	Represents a dedicated part of the artifact model linked to a certain project.
IArtifactVisitor	A visitor for all top-level (default) artifacts.
IAssignmentState	Defines the interface of an (extensible) assignment state value.
IAttributableElement	Interface to mark attributable elements.
IAttributeAccess	Provides access to attributes.
IBuildlangElement	The top-level interface for the build language specific model elements.
IBuildlangVisitor	Defines the type for the entire buildlang visitor.
ICallExpressionTester<M extends IResolvableModel<V,M>,O extends IResolvableOperation<V>,E extends ModelCallExpression<V,M,O>,V extends IMetaParameterDeclaration>	The interface of a dynamic call expression tester.
IChainingReasoner	A specialized interface for reasoners, which, in principle, can be chained, i.e., composed to a chain of reasoners, passing along results and configurations.
IChangeHistoryTracer	Allows tracing configuration history changes.
IChangeHistoryVisitor	Visits a change history, i.e., methods are called upon the respective information in no specific sequence.
IClassNameMapper	Allows to map class names to VIL names.
IClassNameMapperProvider	Provides a class name mapper.
ICollectionElementVariable	Represents a (temporary) element of a collection as collection (by design decision) do no have real contained variables.
ICommandLineProgram	Interface for separating a command line program with own libraries from instantiator code to enable optional loading of heavy-weight libraries.
ICompoundReceiver	The interface for a compound receiver.
IConfiguration	Provides access to configured variables.
IConfigurationChangeListener	Interface for listeners, which should be informed in case of changes inside the configuration.
IConfigurationElement	Defines the interface for elements in a configuration (including the configuration itself).
IConfigurationFilter	A filter for deriving configurations.
IConfigurationVisitable	Marks visitable elements of a configuration.
IConfigurationVisitor	Defines an interface to visit a configuration.
IConstraint	Represents a constraint.
IConstraintEvaluator	Interface to the constraint evaluator to avoid unnecessary access when passing along an evaluation visitor.
IConstraintHolder	Specific methods for holding constraints.
IConstraintTreeVisitor	Defines the interface for a visitor for the constraint tree.
IContainableElementsSorter	Defines an interface for classes which are able to sort their elements according to a given comparator.
IControl	Defines the interface of a control to be used with the simple model processing listener.
ICustomDatatypeVisitor	Defines an interface for visiting datatypes.
ICustomOperationAccessor	Provides access to custom operations.
IDatatype	Abstract class, implements some methods for all existing data types.
IDatatypeVisitable	Defines an element which can be visited by the `IDatatypeVisitor`.
IDatatypeVisitor	A specific visitor for building type identities.
IDecisionVariable	Represents a decision variable.
IDecisionVariable	Interface for configurable `DecisionVariable`.
IDecisionVariableContainer	Describes a container for decision variables.
IDecisionVariableInConstraintFinder	Searches for `IDecisionVariable`s in a `ConstraintSyntaxTree`.
IDeferredModelLoader<M extends IModel>	Allows deferred loading of models, which require that functionality.
IdentifierValueConverter	Converts version numbers by removing the leading "v".
IDerivedDatatypeListener	Interface for `DecisionVariableDeclaration`s of `DerivedDatatype` to get informed whenever the constraints of the related `DerivedDatatype` changes.
IDirectTypeRegistryAccess	Provides direct access to the type registration for `ITypeResolver`.
IEASyEditorPage	Represents the actual parent class for an EASy table editor.
IEASyEditorPageCreator	"Factory" for creating a specialized editor for a given `ProductLineProject`.
IEASyPageListener	Listener for `AbstractEASyEditorPage`s.
IEASyProjectConfigurator	Configurator for configuring newly created EASy projects.
IEclipseProjectCreationResult	An instance of this class will be returned after calling `EclipsePersistencer.createProject(String, File, String)`.
IEcoreModelQuery<P extends org.eclipse.emf.ecore.EObject,R>	Performs queries on underlying models.
IEmbeddedEditor	Represents an embedded editor.
IEmbeddedEditor.IDocumentStateListener	Informs interested parties about actual document changes.
IEmbeddedEditor.IValidationStateListener	Informs interested parties about the actual validation state of the editor.
IEnumeratingLoop	Defines the internal interface of an enumerating loop.
IEvaluationInterceptor	An evaluation interceptor may step into the expression evaluation at certain points in time to modify setting/getting values.
IExecutableOperandType	Operates on the first operand of a `StrategyCallExpression` in mode `StrategyCallExpression.Type.EXECUTE`.
IExpressionIterator	Defines a simple expression iterator.
IExpressionParser<R extends Resolver<?>>	Allows parsing a string to an expression.
IExpressionVisitor	A visitor interface for expressions.
IFileSystemArtifact	Represents a file system artifact, i.e., a real-world entity in a file system.
IFreezable	The IFreezable interface represents model elements that can be frozen in a freeze block.
IFreezeSelector	Determines whether a decision variable shall be frozen.
IfThen	Represents a conditional expression.
IGUIConfigChangeListener	Listener interface for informing listeners that the `GUIConfiguration` contains unsaved data.
IGUIConfigurableElement	Interface for all configurable elements of the `GUIConfiguration`.
IGUIConfigurationContainer	Interface for a viewer holding the GUIConfiguration.
IGUITextHandler	Interface for a GUITextHandler.
IHyperlinkFactory<P extends org.eclipse.emf.ecore.EObject>	Creates language-dependent hyperlinks.
IIdentifiable	An identifiable (to be implemented by exceptions).
IInitializableValue	An initializable value provided by a `ConstructorCallExpression` that requires the `EvaluationVisitor` to be initialized correctly.
IInstantiatorProject	Needed project information for the instantiation process.
IInstantiatorProjectManager	Interface for a management class providing information, needed by the instantiators.
IInstantiatorStateObserver	This interface enables instantiators to send messages to the console of the currently running Eclipse instance, e.g., for displaying information to the user.
IInstantiatorTracer	A tracer for instantiators.
IIteratorEvaluator	Provides an iterator aggregation function.
IJavaParent	The interface of an artifact / fragment which may act as the parent of a Java element.
ILanguageElement	A generic language element.
ILazyDescriptor	Marks a lazy descriptor and enables forced (early) initialization.
ILogger	Interface for concrete Loggers, which can be handled by the `EASyLoggerFactory`.
ImageProvider	An image provider shielding the platform UI image source in case of RCP applications.
ImageProvider	Provides `Image`s for the `InstantiatorConfigPage`.
ImageProvider.ImageType	Defines the supported image types.
Images
Images
Images
Images	Central class for images used in the reasoner core UI.
IMatchVisitor	Visitor methods for the match expressions.
IMeasurementKey	Base type for measurement keys.
IMessage	Defines a message.
IMessageHandler	Passes on messages.
IMessageListener	Defines a lister to be notified in case that reasoner messages are issued.
IMessageReceiver	The fundamental interface of a message receiver based on EObjects and EStructuralFeatures for xText grammars.
IMetaField	Represents a data field.
IMetaOperation	Describes an operation defined for a `IMetaType`.
IMetaOperation.CompatibilityResult	Returns the result of a type compatibility comparison.
IMetaParameterDeclaration	Defines the interface of a parameter declaration.
IMetaType	Defines the interface of a meta type.
IModel	Represents the type of models to be managed.
IModel	Represents a variability model.
IModelAccess	A basic class providing access to models.
IModelAccess	A basic class providing access to models.
IModelData	Specifies the interface to the most basic data of a model (and model info).
IModelElement	Classifies elements of an IVML model.
IModelElement	Defines the interface for a model element.
IModelElementFilter<M extends ContainableModelElement>	Optional Rule how to handle elements of a `Project`, while creating a copy using the `ProjectRewriteVisitor`.
IModelInfo	Returns information about an available persisted model.
IModelListener<M extends IModel>	Defines a model listener in order to inform interested parties about changes within a model instance.
IModelLoader<M extends IModel>	Defines the interface for a mechanism being able to load models.
IModelLoader.IModelInfoHolder<M extends IModel>	An instance providing limited access to model information.
IModelLoader.LoadResult<M extends IModel>	Represents the result of loading a model.
IModelManagementRepository<M extends IModel>	Defines the internal interface of a model management repository.
IModelProcessingListener<M extends IModel>	Defines the model processing listener interface, a listener that is informed when a certain model is being processed.
IModelProcessingListener.Type	Processing types.
IModelQuery<M extends IModel,E,R>	Performs queries on the respective semantic model.
IModelReloadListener<M extends IModel>	Defines a model listener in order to inform interested parties about model reloads.
IModelRepository<M extends IModel>	Defines the interface of a model repository.
IModelVisitor	IModelVisitor interface.
IModifier	Marker interface for variable declaration modifiers.
IModifierHolder	Defines the interface of a class holding modifiers.
ImplicitContainerInitializerExpression	A container initializer expression that can be internally used to iterate over / declare container operations over a single value rather than a container.
ImplicitVariableDeclaration	Defines an implicit variable declaration, i.e., one that shall not be emitted again.
ImplicitVariableDeclaration	Defines an implicit variable declaration, i.e., one that shall not be emitted again.
Importance	State, declaring whether a declaration is mandatory or not.
ImportNameFilter	Filters `ProjectImport`s based on their names.
ImportRegExNameFilter	Import filter based on a Java regular expression.
ImportResolver<M extends IModel>	Basic implementation of a model import resolver.
Imports<M extends Script>	Stores the model imports and VTL requirements for a Script.
Imports<M extends IModel>	Stores the model imports for a language unit.
ImportTranslator	A class which specifically does the import translations.
InContentExpression	Introduces a common type for in-content expressions/statements.
IndentationConfiguration	Stores optional indentation configuration.
IndentationPrintWriter	A print writer with indentation.
IndentationUtils	Indentation utilities.
IndexAccessor	Implements an accessor for index access.
IndexAccessPathElement	An index access path element, e.g., for collections or as fallback.
InitialStructureCollector	Part of the `ProjectRewriteVisitor`, will collect all relevant elements to facilitate a fast retrieval of needed elements.
InPlaceCommand<I extends VariableDeclaration>	Replaces an in-place command/expression within a string/content expression.
InPlaceForCommand<I extends VariableDeclaration>	Replaces an in-place for-command/expression within a string/content expression.
InPlaceIfCommand<I extends VariableDeclaration>	Replaces an in-place if-command/expression within a string/content expression.
InPlaceImportCommand<I extends VariableDeclaration>	Represents an in-place import command.
InPlaceVarDeclCommand<I extends VariableDeclaration>	Represents an in-place variable declaration command.
InsertInstantiatorDialog	Creates a dialog for inserting instantiators.
InsertInstantiatorDialog.ArgumentEditingSupport	Implements argument editing support.
InsertInstantiatorDialog.ParamTableContentProvider	Implements a parameter table content provider.
InsertInstantiatorDialog.ParamTableLabelProvider	Implements a parameter table lable provider.
InstanceNameValueMapper	Implements a simple instance-name based value mapper.
InstantiateExpression	Represents an instantiate expression.
InstantiateExpressionTreeNode	Implements an element node for instantiate expressions.
Instantiator	Indicates that a `IVilType` is an instantiator.
InstantiatorConfigPage	Creates the editor page for linking files with a file instantiator. This page allows the user to: Add and delete instantiator engines See configured instantiator engines Change the files bound to an instantiator if that instantiator had been created in this ProductLineProject See informations about the instantiator that is currently shown See the filetype an instantiator will handle, after clicking save, if there are multiple filetypes to be handled, the type will be shown as "various" To check for files that might be instantiated by multiple instantiator engines
InstantiatorTreeContentProvider	Defines the instantiator tree content provider.
InstantiatorTreeLabelProvider	Label provider for the instantiator tree.
IntegerOperations	Implements integer operations.
IntegerSequenceConstructors	A "instantiator" for VIL sequences.
IntegerTextHandler	Class to handle and format Set of Integers in the Editor.
IntegerType	Creates the BasisDatatype Integer.
InterfaceDropDown	Drop down menu for selecting project interfaces defined in this project, to use them as a filter.
InterfaceFilter	A filter based on `ProjectInterface`s defined in the same project as the currently shown project.
IntHolder	Represents a modifiable int.
IntValue	This class holds the value for the integer.
IntValueConverter	Converts a string recognized by the grammar to an integer.
InvalidProjectnameException	Exception which will be thrown, if a chosen name of a project is not valid.
Invisible	Marker annotation for methods which shall be invisible to the dynamic dispatch mechanism, i.e., which shall not be recognized as artifact types or artifact operations (internal operations of the artifact model).
InvocationRemovalVisitor	Visitor to find all method invocations.
IOButton	A graphical component to inform the user that a functional component, e.g.
IOperationEvaluator	Evaluates an IVML operation.
IOverridingEditor	Declares the interface of an overriding editor in `ConfigurationTableEditorFactory` that can be wrapped into a `GUIVariable`.
IParameterizable<V extends IMetaParameterDeclaration>	Defines the access to parameters.
IParser	Just a markup interface for OSGi DS.
IPartialEvaluable	An element which may act as an evaluable expression in an eval block.
IPersistencer	General interface for different Persistencer plug-ins.
IPoolManager<T>	Represents a pool manager (delegate) for a typed `pool`.
IProductLineProjectListener	Listener for changes inside the `PLPInfo`.
IProjectCreationResult	An instance of this class will be returned after calling `IPersistencer.createProject(String, File, String, boolean)`.
IProjectDescriptor	Describes a `Project` for creation of a project object.
IProjectDescriptor.ModelKind	Defines different model kinds.
IProjectImportFilter	Optional Rule how to handle `ProjectImport`s, while creating a copy using the `ProjectRewriteVisitor`.
IProjectListener	Defines a project listener in order to inform interested parties about changes within a project instance.
IProjectModifier	Optional Rule how to handle `Project`s, while creating a modifying using the `ProjectRewriteVisitor`.
IRangeRestriction	Optional filter to restrict values of a `GUIVariable`.
IReasoner	General interface for reasoner, which can be registered to the `ReasonerRegistry`.
IReasonerCapability	Defines the basic types for reasoner capability constants.
IReasonerInstance	A reuseable reasoner instance.
IReasonerInterceptor	An initial reasoner interceptor to be informed about the reasoning process in detail.
IReasonerListener	Listener for the `IReasoner`, to inform the caller of the reasoner, that the reasoning has been finished.
IReasonerMessage	Defines a message for internally sending signals among reasoners.
IReasonerMessage.IType	Defines the type of message types.
IReasonerMessage.Type	Defines basic message types.
IReasonerRegistry	Public interface for this reasoner registry capable of handling multiple reasoners.
IRefreshableEditor	Declares the interface of an editor, which may refresh its contents based on model changes.
IRegisteredStringValueProvider	Defines the interface of an externally registered string value provider.
IRegistration	Just a markup interface for DS registration.
IResolutionListener	Informs interested parties about the resolution of a variable to a decision variable.
IResolutionPathElement	Represents a resolution path of a nested element through a configuration.
IResolutionScope	Provides access to containable model elements.
IResolvable	A resolvable for `IResolver`.
IResolvableModel<V extends IMetaParameterDeclaration,M extends IModel>	Defines the interface for a resolvable model which may provide its parts as operations.
IResolvableOperation<V extends IMetaParameterDeclaration>	Defines the interface of a resolvable operation.
IResolver<V extends IResolvable>	Defines the interface of a simple variable resolver.
IResourceInitializer	Defines a plug-in resource initializer.
IRestrictionEvaluationContext	Defines the evaluation context for version restrictions.
IRuleBlock	Defines the interface for a rule block, i.e., a block containing `rule elements`.
IRuleElement	A rule element interface which must be implemented by all elements that can be part of a rule in the rule body.
IRuntimeArtifact	The root interface for all artifacts to be manipulated at runtime.
IRuntimeEnvironment	Defines the type of a runtime environment to evaluate expressions in.
ISerializerPlugin<M extends IModel>	Interface for the SerializerPlugin that adds the functionality of serializing runtime VIL.
ISettingsInitializer	Interface to initialize settings.
IStatus	Denotes a message status.
IStringParserFactory<I extends VariableDeclaration>	An optional factory turning in-place commands into language-specific expressions.
IStringValueProvider	Provides a string value for execution of itself.
IStringValueProvider.StringComparator	Defines the interface for comparing individual string values.
ITemplateElement	Marks a language element which may occur in a (sub-)template.
ITemplateLangElement	Marks a language element of the VIL template language.
ITemplateLangVisitor	Defines the type for the entire template language visitor.
IterLet	Implements a specific expression for defining local variables with variable initialization expressions in iterator expressions.
ITerminatable	Something that can be terminated.
ITerminator	Something that can terminate a `ITerminatable` indirectly on demand.
ITraceFilter	Allows to filter trace output.
ITraceFilter.LanguageElementKind	Abstracted kinds of language element (VIL, VTL, rt-VTL) to trace.
ITracer	A simple tracer interface providing test support to the execution part.
ITracer	A simple tracer interface providing test support to the execution part.
ITracer	Defines a tracer interface for receiving information about runtime execution, e.g., for testing.
ITracer	A simple tracer interface providing test support to the execution part.
ITypedefReceiver	The interface for a typedef receiver.
ITypedModel	Defines a typed model, i.e., a model which knows its `TypeRegistry`.
ITypeResolver	An external type resolver for `TypeRegistry`.
IUpdatableEditor	An updatable editor.
IUpdateListener	A listener to be informed about editor updates.
IUpdateProvider	Supports external updates to the created editors.
IUpgrader	Defines the interface to an installation upgrade mechanism.
IValueChangeListener	Is called when the `EvaluationVisitor` changes a value in the configuration.
IValueChangeListener.ChangeKind	Indicates the kind of the change.
IValueParent	A parent instance that holds the actual value, typically a configured variable.
IValueVisitor	Defines a visitor for values.
IVariable	Denotes a variable of a model language in the broadest sense, i.e., something for which a variable value can be set set somehow.
IVariableDeclarationReceiver<I extends IResolvable>	An instance which receives (global) variable declarations.
IVariableFilter	Defines a variable filter.
IVariableValueMapper	Performs a variable value mapping.
IVersionRestriction	Denotes a version restriction.
IVersionRestriction.IVariableMapper	Maps a variable to another while copying.
IVilExecutionListener	Part of the `VilExecutionThread` to inform other threads when the instantiation was finished or aborted.
IVilGenericType	An interface for implementations of generic VIL types.
IVilType	Represents the hierarchy of all types usable in VIL and its languages.
IVisitor	A visitor interface for the build language elements.
IVisitor	A visitor interface for the common types.
IVisitor	A visitor interface for the template language elements.
IvmlAccessorFieldDescriptor	Defines a pseudo field descriptor which enables comfortable access to an individual decision variables via its name.
IvmlAnnotationFieldDescriptor	Defines a pseudo field descriptor which enables comfortable access to an individual annotation via its name.
IvmlBaseTypeResolver	A basic IVML type resolver that just creates fake types.
IvmlBundleId	Stores data about the containing OSGi bundle (static bundle without activator).
IvmlComparisonOperationDescriptor	Implements equality and unequality for the dynamic types.
IvmlComparisonOperationDescriptorConverter	Converter for the `IvmlComparisonOperationDescriptor`.
IvmlConfigurationConversionOperationDescriptor	Defines an operation descriptor which enables access to the underlying configuration.
IvmlConfigurationFieldDescriptor	Defines a pseudo field descriptor which enables comfortable access to an individual decision variables via its name.
IvmlConfigurationOperationDescriptor	Defines an operation descriptor which enables comfortable access to a top-level decision variable by its name.
IvmlConstructorOperationDescriptor	Implements an IMVL type constructor.
IvmlConversionOperationDescriptor	Defines an operation descriptor which enables comfortable access to an individual decision variables via its name.
IvmlDatatypeVisitor	Implements a default datatype visitor for IVML.
IvmlDeclaration	Represents an IVML declaration.
IvmlDescriptionLabelProvider	Provides labels for a IEObjectDescriptions and IResourceDescriptions.
IvmlElement	Denotes an element resolved in IVML.
IvmlException	A top level exception class for all IVML exceptions.
IVMLFiletypeWizard	This is a new file wizard for ivml files.
IVMLFiletypeWizardPage	The "New" wizard page allows setting the container for the new file as well as the file name.
IVMLFileWriter	Extended `IVMLWriter`, which writes `Project`s and their imported `Project`s to a given location.
IvmlFormatter	This class contains custom formatting description.
IvmlHyperlinkFactory	A IVML hyperlink factory.
IvmlHyperlinkHelper	This class enables the creation of hyperlinks for any IVML-element in an IVML-file if the user selects such an element either via pressing the "F3"-key or by clicking on that element while pressing the "CTRL"-key.
IvmlIdentifierCheck	Provides methods to identify correct IVML identifiers.
IvmlIndentationPreferencePage	Implements preferencePage for customization of ivml-properties such as indentation.
IvmlJavaValidator	The on-the-fly validator calling the model transformation mechanism.
IVMLKeyWord	Annotation to mark `OclKeyWords` as also reserved inside the IVML language.
IvmlKeyWords	This class contains keywords and constants related to ivml files.
IvmlLabelProvider	Provides labels for a EObjects.
IvmlMessageAdapter	Adapts messages, in particular warnings that may be resolved later.
IvmlModelAccessor	Implements a model accessor for the top level IVML project.
IVMLModelLoader	Loader to load IVML files.
IvmlModelQuery
IvmlModelQuery	Provides IVML specific model query operations.
IvmlOperationDescriptor	Implements a delegating operation descriptor, i.e., virtual operations representing access to IVML configuration data.
IvmlOrderedEnumComparisonOperationDescriptor	Represents the comparison operation for ordered IVML enums.
IvmlOrderedEnumComparisonOperationDescriptor.OperationKind	The operation kinds.
IvmlOrderedEnumMinMaxOperationDescriptor	Represents the minimum or maximum operation for ordered IVML enums.
IvmlOrderedEnumMinMaxOperationDescriptor.OperationKind	The operation kinds.
IvmlOutlineTreeProvider	Customization of the default outline structure.
IVMLPageCreator	Creates the contents of the `IVMLFiletypeWizard`.
IvmlParser	Registers IMVL automatically.
IvmlProjectTypeDescriptor	Implements a dynamic type descriptor for a project containing IVML decision variables.
IvmlProposalProvider	Customized IVML content assist, just for statements.
IvmlQuickfixProvider
IvmlReasonerCapabilities	Defines some differentiating reasoner capabilities to react in EASy on provided capabilities in an abstract way.
IvmlRuntimeModule	Use this class to register components to be used at runtime / without the Equinox extension registry.
IvmlScopeProvider	This class contains custom scoping description.
IvmlSemanticSequencer	A semantic sequencer...
IvmlSequenceConversionOperationDescriptor	Operation descriptor for decision variable to sequence conversion using `AbstractIvmlVariable.variables()`.
IvmlSetConversionOperationDescriptor	Operation descriptor for decision variable to sequence conversion using `AbstractIvmlVariable.variables()`.
IvmlStandaloneSetup	Initialization support for running Xtext languages without equinox extension registry.
IvmlSyntacticSequencer	A syntactic sequencer...
IvmlToStringConversionOperationDescriptor	Performs a conversion of an object (usually an `IvmlTypeDescriptor` to a String.
IvmlTypeDescriptor	Implements a dynamic type descriptor for IVML decision variables.
IVMLTypeDescriptorConverter	Converter for the `IVMLTypeDescriptor`.
IvmlTypeResolver	A type resolver for IVML models.
IvmlTypes	Provides access to the type descriptors of the types defined in this package.
IvmlUiModule	Use this class to register components to be used within the IDE.
IvmlUiModule.MyConcurrentEditingCallback
IvmlValidationVisitor	Checks a model for IVML compliance.
IvmlValueConverters	Factory for the value converters.
IVMLWizardPageDescriptor	Specification of the `IVMLFiletypeWizardPage`.
IVMLWriter	Writer for writing the variability model to an IVML output file.
IWizardPageDescriptor	Specification of relevant information of a `AbstractFiletypeWizardPage` instance.
IWizardPageFactory	Factory interface for individual wizard pages.
IXmlContainer	Defines the operations of an XML container, i.e., an element which contains XML elements.
Jar	Creates JAR files.
JarHandler	A ZIP handler for JAR files.
JarUtils	Some helpful Jar methods.
JavaAnnotation	Represents a Java annotation.
JavaAssignment	Represents an assignment expression within a method.
JavaAttribute	Represents a Java attribute.
Javac	Compiles java files using Javac.
JavaCall	Represents a Java annotation.
JavaClass	Represents a Java class.
JavaExtension	Defines a java extension of the template language.
JavaFileArtifact	Represents a Java source code file artifact.
JavaFragmentArtifact	A Java source fragment which has a `parent`.
JavaImport	Represents a Java import.
JavaLogger	This class is the ILogger implementation for java.util.logging.Logger.
JavaMethod	Represents a Java annotation.
JavaPackage	Represents a Java package.
JavaParentFragmentArtifact	A Java fragment artifact, which is also a Java parent element.
JavaPath	Represents a Java path.
JavaProjectConfigurationDescriptor	`AbstractProjectCreationDescriptor` to configur EASy projects as Java projects.
JavaProjectHandler	Implements a Java project handler for the initialization of path environments.
JavaQualifiedName	Represents a java qualified name.
JavaSettings	Java Settings.
JavaSettingsInitializer	Initializes the settings for java.
JavaUtilities	Common utility functions for Java operations which may be used by several instantiators.
JavaUtils	Some java helper methods.
JoinExpression	Realizes a VIL join, typically over the variability model configuration and / or a project's artifact model.
JoinExpressionTreeNode	Implements an element node for join expressions.
JoinVariableDeclaration	Defines a variable declaration for VIL joins.
LabelGUIEditor	Implements a (non-modifable) label editor implementation.
Leaf	Class for leaves in the ConstraintSyntaxTree.
Let	Represents a let expression, i.e.
LhsRhsMatchLoop	A generic loop over LHS/RHS matches determining which combinations need a build.
ListSequence<T>	Implements an array wrapper for the VIL sequence type.
ListSet<T>	Implements an list wrapper for the VIL set type.
ListVariableDeclarationReceiver<I extends IResolvable>	Implements a simple list variable declaration receiver.
ListWrapperValue	Special wrapper value for lists.
LoadProperties	Represents a file of properties to be loaded.
LocalConfiguration	Creates a local configuration instance.
LocalDecisionVariable	A local decision variable representing a parameter or a local variable.
LogFormatter	This Formatter is used by the EASyLogger to format the logging output.
LoggingLevel	ENUM for ILogger Logging Level.
LogMessageReceiver	A simple fallback receiver that does not store messages.
LoopExpressionTreeNode	Implements an element node for loop expressions.
LoopStatement	Representation of a loop-statement in VIL which allows multiple processing of a `WorkflowElementBlock` instance.
Main	Executes the language generator.
MainPreferencePage	Just an empty preference page as the main hook-in point for EASy-Producer preference pages.
MainPropertyPage	Just an empty property page as the main hook-in point for EASy-Producer preference pages.
Make	A Make-Instantiator, wich runs make-scripts with the help of ANT (operating system independent).
MandatoryClassifierSettings	Settings for the `MandatoryDeclarationClassifier`.
MandatoryDeclarationClassifier	Heuristic classifier, which determines whether the variables of a `Configuration` should be changed by the user or not.
Map<K,V>	Defines the VIL type "Map".
MapExpression	Describes a map statement.
MatchFactory	A factory to create the match expressions implemented in this package.
MatchResolver	This class resolves match expressions if necessary.
Maven	Builds Java applications with Maven.
Maven.CliMessageManipulator	Gets rid of the class name / logging level in Maven CLI mode.
Maven.PlexusMessageManipulator	Gets rid of the logging level.
Measures	The measures provided/supported by the SSE reasoner.
MemberController	Creates a new MemberController for a PLP.
MemberIterator	An `Iterator` over all predecessors or successors of one `PLPInfo`.
Message	Defines a message to be emitted during runtime.
Message	Implements a message issues by the model translator (in order to provide feedback on multiple issues at once).
Message	Part of the `ReasoningResult` class, expressing on error/warning of a complete `ReasoningResult`.
Message.IssueLocation	Represents an issue location.
Message.SuggestionType	Defines supported suggestion types.
MessageDialogWithCopy	SWT MEssagebox with a text field allowing copy pasting the message.
MessageHandler	Implements a message handler for xText delegating to `MessageReceiver`.
MessageReceiver	A class which is able to receive and handle messages.
MetaType	Implements a data type which represents types (as result of type operations).
MetaTypeOperations	Implements the meta type operations.
MetaTypeValue	Holds the value for a `MetaType`.
Model	Represents the type of models to be managed.
Model	Basic implementation for the readable model.
Model	Objects of this class stores information related to exactly one model.
ModelCallExpression<V extends IMetaParameterDeclaration,M extends IResolvableModel<V,M>,O extends IResolvableOperation<V>>	Represents the explicit execution of a model operation.
ModelCombobox	Combobox for selecting the model to use.
ModelCommentsPersistencer	Implements (internationalized) comment persistence mechanisms on model level.
ModelConnector	This class is used to get information out of the variability model that cannot be accessed via the ECore model directly.
ModelContainer<M extends IModel>	Extended capabilities for `IModel`s.
ModelContainerFactory	Factory for `ModelContainer`s.
ModelDeserializer	This class offers the methods for the deserialization of the model.
ModelEditorConfigurer	Defines an interface and registration methods to describe how top-level models shall be displayed in the EASy product line editor.
ModelEditorConfigurer.IHeader	Defines the interface for a header component created by a configurer.
ModelEditorConfigurer.IModelEditorConfigurer	The actual configurer interface.
ModelEditorPage	A model editor page for the product line editor which shows an embedded editor.
ModelElement	All elements a VarModel could contain.
ModelElementFilter	A `IModelElementFilter` to specify that a certain sub class of `ContainableModelElement` should be generally omitted.
ModelElementTypeFinder	This class provides a visitor for providing a `ModelElementTypeFinder.ModelElementDescription` of a model element in a specific `Project`.
ModelElementTypeFinder.ClassType	Type descriptions.
ModelEvents<M extends IModel>	Notifications on model contents changes.
ModelException	Thrown in case of illegal input to the IRET-IVML integration interface.
ModelImport<M extends IModel>	Defines model imports and related restrictions.
ModelInfo<M extends IModel>	Stores high-level information about an available (possibly unresolved) model.
ModelInfoHolder<M extends IModel>	An implementation of the model info holder for internal use.
ModelInformation	Implements the model information object.
ModelInitializer	Supports the transparent registration of models, locations, model loaders etc.
ModelInitializer.IModelInitializer	Defines the interface of an initializer.
ModelLoader<Model extends IModel>	Part of the `Persistencer`, responsible for loading IVML/VIL models.
ModelLoaders<M extends IModel>	Manages the model loaders.
ModelLocale	Provides internationalization support, i.e., which locale is valid for loading models.
ModelLocations<M extends IModel>	Manages the model locations.
ModelLocations.Location	Represents a location with dependent locations (to be considered while loading a model).
ModelManagement<M extends IModel>	A reusable class performing model imports, model linking etc.
ModelManagementException	An exception thrown by the model management itself typically on global consistency issues.
ModelQuery	Provides an interface to query models.
ModelQuery.FirstDeclTypeSelector	Selects the first declaration with the given type.
ModelQuery.IDeclarationSelector	Defines the interface of a declaration selector.
ModelQuery.IncrementalNamespace	Represents an incrementally resolved namespace.
ModelQuery.MqDatatypeVisitor	A private quick datatype visitor.
ModelQueryException	Defines an exception type thrown by the `ModelQuery` class.
ModelRepository<M extends IModel>	Implements the model repository interface by delegating to `ModelManagement`.
ModelSerializer	This class offers the methods for the serialization of the model.
ModelStatistics	This class provides some methods to access statistical information about a given project.
ModelTranslator	Implements the translation from the DSL to the build model in the instantiator core.
ModelTranslator	Implements a ECore-to-IVML translator.
ModelTranslator<M extends IModel,I extends VariableDeclaration,R extends Resolver<I>,S extends ExpressionStatement,E extends ExpressionTranslator<I,R,S>>	A reusable model translator.
ModelTranslator	Translates a parsed template language in ECore instances into instances of the template language model and performs semantic analysis.
ModelTranslator<E extends ExpressionTranslator>	A basic implementation of a model translator, i.e., a basic class for translating individual model elements into model instances.
ModelTranslator.Result	Implements a translation result enabling deferred model loading.
ModelType	List of possible models which can be stored via the `Model` class.
ModelUpdateUtils	A set of algorithms to enable recursive model updates along the imports.
ModelUtility	(Entry points for) Utilities for working with the EMF model.
ModelUtility<E extends org.eclipse.emf.ecore.EObject,R extends IModel>	A basic set of model utilities.
ModelUtils	Some utilities on model side.
ModelUtils.IModelFinder<M extends IModel,E>	A model finder for a certain model.
ModelVisitorAdapter	An empty implementation of `IModelVisitor`.
MultiAndExpression	Represents a multi-and expression.
MultiAndExpression	Represents a multi-and expression.
MultipleSelectionEditor	Implements a GUI representation for references.
MultipleSelectionFragment	Represents a multiple selection fragment.
NameAccessPathElement	Represents a name-based access path element, e.g., for compounds.
NamedArgument	Implements a named argument as a transparent constraint syntax tree.
NameRegExFilter	A name filter based on regular expressions (Perl-Style).
NameRegExFilter.DataType	Defines the data type to filter on.
NamespaceFilter	A filter for showing only variables of a given namespace (project name).
NamespaceFinder	Extracts all namespaces (project names) of a given project, including all imported projects.
NatureHelper	The NatureHelper supports querying and modifying Eclipse nature-like elements without having an Eclipse running.
NatureHelper.ProjectHandler	Implements core functionality accessing the project file.
NatureUtils	Some utility methods for natures.
NestedRuleBlock	A nested rule block.
NestedVarConfigProvider	`VariableConfigProvider` for nested variables of a `StructuredVariable`.
NewEASyProjectWizard	Wizard for the creation of a new productline project.
NewEASyProjectWizardPage	WizardPage for the creation of a new product line project.
NewProjectCreator	Creates a new EASy project.
NoFilter	A no filter, i.e., a filter which includes everything.
NoFreezeSelector	A freeze selector which does not freeze any variable.
NoInstantiatorStateObserver	This class implements an empty observer for instantiator states.
NonFrozenFilter	Implements a simple attribute filter.
NoTraceFilter	A filter that does not filter anything.
NoTracer	Implements a no-action execution tracer.
NoTracer	Implements a no-action execution tracer.
NoTracer	Implements a tracer which does noting.
NoTracer	Implements a no-action execution tracer.
NoVariableFilter	A filter that enables all variables.
NullValue	Defines the null value.
NullValue.NullValueType	Defines the type of the singleton null value.
NullValueConverter	A type converter for delegating types.
NullValueTypeConverter	A type converter for null value types.
ObservableTask	Combines observable and task/subtask for convenient use.
ObservableWorkspaceJob
ObservableWorkspaceJob	A job that makes an atomic modification to the workspace.
OCLFeatureCall	Class for OCLFeatureCall.
OclKeyWords	Defines constants for the OCL keywords for operations.
Operation	Describes an operation.
Operation.FormattingHint	Defines some formatting hints for emitting operations in a canonical form.
Operation.NestingMode	Defines the nesting mode of the results.
Operation.ReturnTypeMode	Defines how to handle the return type of an operation.
OperationConverter	A type converter for built-in operations.
OperationDefinition	A containable element which represents user defined operations.
OperationDescriptor	Represents an individual operation available to the VIL languages.
OperationDescriptor.AliasType	Declares different types of alias.
OperationMeta	Marker annotation for providing details for a VIL operation implementation.
OperationType	Defines the operation / operator types.
OptionalityFragment	Describes an optional fragment.
OrderedEnum	Enumerations allow the definition of sets of named values.
OtherProjects	Realizes the implicit variable OTHERPROJECTS in `Script`.
ParameterMeta	Annotation for providing details to a VIL operation parameter.
Parenthesis	Represents a parenthesis.
ParenthesisExpression	Represents a parenthesis expression.
PartialEvaluationBlock	Maintains partial evaluable elements.
Path	Represents a path within a file system (not a folder!).
PathEnvironment	An environment for transparently making paths relative and absolute.
PathEnvironmentFactory	Creates path environments in a generic way considering information from projects such as relevant classpaths.
PathEnvironmentFactory.IProjectHandler	Handles a certain type of project.
PathExecutableOperandType	An executable operand type for `Path`.
PathMatchExpression	Denotes the special expression regarding a path match.
PathPropertyPage	Implements the global preference page.
PathUtils	Some path utilities.
PathUtils	Normalizes a path into an XML document.
PerformanceStatistics	Class contains statistic methods for measuring and displaying reasoning performance.
PersistenceConstants	Constants related to the persistence layer.
PersistenceException	Exception for errors occuring during save/load operations.
Persistencer	This class represents an interlayer between persistency-layer and model.
PersistencerFactory	This class returns a correct `IPersistencer` instance as it is needed by the `EASyPersistencer`.
PersistenceUtils	Static utility functions related to the persistence layer.
PersistenceUtils	Provides Eclipse-specific persistent utility methods.
PersistencyConstants	Constants for saving/loading instantiation model files.
PersistencyConstants	Constants for saving/loading variability model files.
PersistentProject	Top-layer class for persistent loading and saving of projects.
PersistentProject2PLPConverter	Stores the information of a `PersistentProject` in a `PLPInfo` to simplify the load process.
PLP2ProjectConverter	Stores the information of a `PLPInfo` in a `PersistentProject` to simplify the save process.
PLPInfo	Carries basic information about a product line project.
PLPWorkspaceListener	ChangeListener for the workspace, informs the SPLsManger, if ProductLineProjects were added or remove to the workspace.
Pool<T>	Implements a simple pool for explicit memory management of frequently created elements.
PredecessorSelectionDialog	Dialog for (de-)selecting predecessor projects.
PrefixSearchVisitor	Realizes a visitor which searches for a given prefix in a given context and returns all matching model elements.
Println	Debug / printing support.
ProductLineConfigurationEditorContributor	Manages the installation/deinstallation of global actions for multi-page editors.
ProductLineEditorInput	Editor Input for the ProductLine Configuration Editor of the EASy-Producer tool suite.
ProductLineHeaderMenu	Header menu holding buttons for product line editor page. This buttons allow the user to: Validate constraints Pull the configuration from predecessors Add/remove predecessors Derive new member
ProductLineProject	This class holds all models, controllers and attributes (which are not stored in a model) related to one product lien project.
ProgressNotifier	Allows VIL/VTL to notify the user about actual progress.
ProgressObserver	Observes the progress of a longer lasting task.
ProgressObserver.ISubtask	Marker interface for a subtask.
ProgressObserver.ITask	Marker interface for a task.
Project	Just a placeholder.
Project	Represents the physical project we are operating on.
Project	This class holds the project imports, the containable model-, and attributable elements.
ProjectAlreadyExistsException	Exception which will be thrown, if a projectname of project, which should be created, already exists.
ProjectConfigurationPage	Page for editing the current project.
ProjectConfigurationRegistry	Registry for `AbstractProjectCreationDescriptor`s to allow EASy projects directly configured as arbitrary Eclipse projects.
ProjectConstants	Constants which are globally used.
ProjectContainer	`ModelContainer` for holding a Project and its configuration.
ProjectConverter	Converter for `Project` within VIL or VTL files.
ProjectCopyVisitor	Creates a deep copy of a `Project`.
ProjectCreationException	Exception if a project should be created, but could not be created.
ProjectCreationResult	Result of `Persistencer.createProject(String, File, String, boolean)`.
ProjectCreator	Creates a new Project with the given parameters.
ProjectDecisionVariableDeclaration	Facilitates attribute propagation to parent project.
ProjectDescriptor	Implements the mapping of relevant information from EASy projects to VIL projects.
ProjectElement	Representation of an abstract project element.
ProjectFilter	A project-based filter, i.e., all `elements` contained in a project shall be included by this filter.
ProjectImport	Defines an import and his restrictions.
ProjectInterface	ProjectInterface class.
ProjectInterfaceFinder	Searches for defined `ProjectInterface`s.
ProjectRewriteVisitor	Visitor for modifying a (copied) project.
ProjectSettings	Interface for Java settings.
ProjectType	Implements a private datatype class which represents the (pseudo) type of a project.
ProjectUtils	Utilities on Eclipse project level interferring with UI.
PseudoAny	A type which can be assigned to any type.
PseudoBoolean	A class representing the Boolean type.
PseudoInteger	A pseudo integer type for VIL.
PseudoIterator<T>	Implements a pseudo class for iterators (handled internally).
PseudoReal	Implements a pseudo class for reals.
PseudoString	Implements a pseudo class for strings.
PseudoType	Just a type for types.
PseudoVersion	Represents the internal type "Version".
PseudoVoid	Just the void type, i.e., nothing, in extreme cases not resolvable.
PTNSelectionDialogContentProvider	Content Provider for the `PredecessorSelectionDialog`.
PTNSelectionDialogLabelProvider	LabelProvider for the `PredecessorSelectionDialog`.
QualifiedNameMode	Defines modes for considering the qualified name.
QueryCache	A cache for `ConfigQuery`s based on a `Configuration`.
RandomDouble	A random "instantiator" for VIL.
RandomInteger	A random "instantiator" for VIL.
RealOperations	Implements real operations.
RealType	Creates the BasisDatatype Real.
RealValue	This class holds the value for the real.
Reasoner	This class is the EASy Producer Reasoner implementation for reasoning over IVML projects and configurations.
ReasonerAdapter	Abstracts over instance-based and full reasoning.
ReasonerAdapter.IReasonerAdapter	Defines the interface of an abstracting reasoner adapter.
ReasonerConfiguration	Describes the configuration to be passed via the `ReasonerFrontend` to the individual reasoners.
ReasonerConfiguration.IAdditionalInformationLogger	Describes an information logger.
ReasonerDescriptor	Represents descriptive information about a reasoner.
ReasonerFrontend	The main interface to the reasoner core infrastructure.
ReasonerHelper	Some helpful methods for reasoners.
ReasonerInterceptorAdaptor	Default empty implementation.
ReasonerMessage	Implements the internal message among reasoners.
ReasonerPreferencePage	Implements the preference page.
ReasonerRegistry	A class for registering installed reasoners.
ReasonerSettings	Some UI elements for defining the project specific reasoner settings.
ReasoningErrorCodes	Specifies to witch kind of error belongs failed constraint in the message generated by the reasoner.
ReasoningException	An exception class for all reasoning exceptions.
ReasoningOperation	Specifies which kind of reasoning should be performed by the reasoner.
ReasoningProcess	Delegate for starting a reasoning.
ReasoningProgressObserver	(Graphical) observer for reasoning steps.
ReasoningResult	Result of (one) reasoning step.
ReasoningUtils	Utility methods for reasoning/constraint resolution.
RefByCheckVisitor	A simple visitor checking whether an expression can be dereferenced.
Reference	A reference allows the definition of individual configurations of an (external) element for the referencing element.
ReferenceOperations	Implements reference operations.
ReferenceValue	Reference value class.
ReferenceValuesFinder	Class for finding relevant `AbstractVariable`s matching to the data type of a given `Reference`.
ReflectionConstructorDescriptor	Implements a reflection constructor descriptor.
ReflectionFieldDescriptor	Implements a reflection field descriptor.
ReflectionOperationDescriptor	Represents an individual operation available to the VIL languages based on reflection analysis of the underlying class.
ReflectionOperationDescriptorConverter	Converter for the `ReflectionOperationDescriptor`.
ReflectionOperationParameter	Implements a simple operation parameter descriptor filled by reflection.
ReflectionResolver	Resolves reflective types.
ReflectionTypeDescriptor<T>	Represents an actual type based on reflection analysis of the underlying class.
ReflectionTypeDescriptorConverter	Converter for the `ReflectionTypeDescriptor`.
Registration	Registers the ANT additions to VIL.
Registration	Registers the Java additions to VIL.
Registration	Registers the Java additions to VIL.
Registration	Registers the Java additions to VIL.
Registration	Registers the serialization additions to VIL.
RescheduleValueChangeVisitor	Reschedules value changes.
ResolutionContext<M extends IModel>	Defines an internal class representing the context of a model import resolution.
ResolutionListener	Is notified upon a later resolution of a variability model identifier expression.
ResolvableOperationCallExpression	Represents a call to a resolvable operation, i.e., a "function pointer".
ResolvableOperationExpression	Represents a resolved operation in terms of a function pointer.
ResolvableOperationType	Implements the type denoting a VIL operation (rule, def).
ResolvedVariable	Carries a resolved variable.
Resolver	A specific resolver for the rule-based build language.
Resolver<M extends IResolvableModel<V,M>,O extends IResolvableOperation<V>,E extends ModelCallExpression<V,M,O>,V extends IMetaParameterDeclaration>	A common resolver.
Resolver<V extends IResolvable>	A basic implementation for a hierarchical resolver.
Resolver	Implements the resolver for VIL templates.
Resolver	Constraint identifier, resolver and executor.
Resolver.ContextType	Defines the contexts for the VIL build language.
Resolver.ContextType	Defines the context types for the VIL template language.
Resolver.DefaultConstraints	Storage for two sub-types of default constraints, namely primary default constraints that can be evaluated directly, e.g., constants (`Resolver.DefaultConstraints.defaultConstraints`) and more complex constraints with dependencies (`Resolver.DefaultConstraints.deferredDefaultConstraints`).
Resolver.IContextType	Defines a type for contexts (i.e., constants).
Resolver.Level<V extends IResolvable>	Represents a (nested) resolution level.
Resolver.ReasonerState	Represents the state of the resolver/reasoner to be kept in case of incremental reasoning.
ResourceRegistry	Registers type registries for resource (URIs).
ResourcesMgmt	Resources abstraction layer.
RestrictionEvaluationException	An exception thrown when then evaluation of a restriction fails.
ResultEntry	A result entry consisting of an xtext and a result model.
RewriteContext	Used as part of `ProjectRewriteVisitor` to store translated Objects.
Rule	Represents a VIL build rule (production strategy).
Rule.Side	Defines the rule sides.
RuleBlock	Defines a rule block, i.e., a set of rule elements.
RuleBodyExecutor	An instance being able to execute a rule body.
RuleCallExpression	Represents the explicit execution of a rule (precondition, rule body).
RuleCallExpressionTreeNode	Implements an element node for rule call expressions.
RuleDescriptor	Defines the complex parts of a rule.
RuleDescriptorException	Defines a specific exception for failing rule conditions carrying the index of the failing expression.
RuleExecutionContext	Implements an execution context for a rule.
RuleExecutionContext.FailState	Defines possible fail states.
RuleExecutionResult	Denotes the result of a rule execution.
RuleExecutionResult.Status	Denotes the execution status.
RuleInfo<D extends org.eclipse.emf.ecore.EObject,R extends Rule>	Stores (temporary) information about the relation of an ECore and an Rule model instance.
RuleTreeNode	Implements a rule node.
RuleTreeVilVisitor	A visitor turning a VIL script into a tree suitable for SWT display.
RuntimeEnvironment	A specific runtime environment containing the global OTHERPROJECTS variable.
RuntimeEnvironment<V extends VariableDeclaration,M extends IModel>	Provides the runtime environment for executing a VIL models.
RuntimeEnvironment	Implements the specialized runtime environment for VTL.
RuntimeEnvironment.Level<V extends VariableDeclaration>	Defines a nested level of value assignments.
ScopeAssignments	Class contains variables that were assigned in a specific scope..
Script	Creates a project which is the top-level element of a build script VIL-model.
Script.ScriptDescriptor<S extends Script>	A descriptor class used for creating scripts (maximum parameter constraint).
ScriptContainer	`ModelContainer` for holding a build `Script`.
SearchContext	Defines some search contexts, i.e.
SearchResult	Describes a search result.
Self	Represents the a compound itself (for constraints within compounds).
SemanticErrorDescription	Data class for describing semantic errors occurred during parsing a Model file.
Sequence<T>	Defines the interface representing a sequence.
Sequence	Realizes a sequence container.
SequenceOperations	Common operations for sequences.
SequenceOperations	Implements sequence operations.
SequenceVariable	Decision variable for `Sequences`s.
Set<T>	Defines the interface representing a set.
Set	Realizes a set container.
SetOperations	Specific reusable operations for sets.
SetOperations	Implements set operations.
SetReturningOperation	Describes an operation that returns a set as collection, i.e., that does not dynamically choose, e.g., based on the operand type.
SetSet<T>	A VIL set wrapper based on a Java set.
SettingsInitializerRegistry	Implementation of `ISettingsInitializer`.
SetVariable	Decision variable for `Set`s.
SetVariablesFilter	Enables only variables in the given map.
SharedQueryCache	Alternative `QueryCache` if the same cache should be shared between two `Configuration`s.
SignatureUtils	Some signature utilities.
SimpleArtifact	The (abstract) top-level non-decomposable artifact.
SimpleStatementBlock	Represents a simple statement as block (without brackets).
SPLsManager	This class manages all available ProductLineProjects.
StandaloneActivator	The activator class controls the plug-in life cycle.
StandaloneInitializer	Defines a standalone resource initializer.
StandaloneProjectDescriptor	Implements a descriptor for the source and target VIL project locations.
StartPathElement	The start of a resolution path at a top-level variable.
Startup	This class registers a startup mechanism for the plug-in, which enables the startup after the workbench was initialized.
StaticAccessFinder	Finds variables with static access in the given expression.
Status	Defines basic message types for messages.
StorageConnector	General interface for this creation of arbitrary connectors, able to save `Models` persistently.
StorageType	Possibilities to store the configuration of a project.
StrategyCallExpression	Implements a strategy call.
StrategyCallExpression.Type	Defines some exclusive types of strategy calls.
StrategyCallExpressionTreeNode	Implements an element node for strategy call expressions.
StreamGobbler	Implements a stream Gobbler that emits to the `instantiator tracer`.
StreamGobbler.IMsgManipulator	Allows to manipulate messages.
StreamTracer	Implements a simple stream-based execution tracer.
StreamTracer	Implements a simple stream-based execution tracer.
StreamTracer	Implements a simple stream-based execution tracer.
StreamTracer	Implements a simple stream-based execution tracer.
StreamVilTracer	Implements the VIL tracer for print streams.
StringCollectionHandler	Class to handle string collections and their format in editor.
StringExecutableOperandType	An executable operand type for Strings.
StringExpression	Represents an expression within a string to be used for resolved content statements and strings.
StringMatchExpression	Denotes the special expression regarding a path match.
StringOperations	Implements string operations.
StringOperations.CaseChange	Implements the case change operations.
StringOperations.CompareOperation	Implements the string compare operations.
StringParser<P,I extends VariableDeclaration,R extends Resolver<I>>	A generic parser and replacer for values ($name) and expressions (${expression}) in strings.
StringParser.State	The parser states.
StringProvider	Turns model (parts) into strings.
StringReplacer<I extends VariableDeclaration,R extends Resolver<I>>	A parser and replacer for values ($name) and expressions (${expression}) in string values.
StringReplacer.Positions	Stores in-place command positions for replacing.
StringReplacerFactory	An extended template language string resolver factory.
StringResolver<I extends VariableDeclaration,R extends Resolver<I>,E extends ExpressionStatement>	StringResolver to resolve variables and expressions on compiling.
StringResolver.IExpressionTranslator<I extends VariableDeclaration,R extends Resolver<I>>	The general interface of an expression translator.
StringResolverFactory	The default template language string resolver factory.
StringType	Defines the basis datatype String.
StringUtils	Some string utility functions.
StringValue	This class holds the value for the string.
StringValueConverter	Converts strings recognized by the grammar to float values.
StringValueHelper	Helps turning an object into a string.
StringWithPosition	A helper class for string comparisons.
StructuredComment	Defines a structured comment which stores relations between nested model elements of the following model element and the comments stored in this comment.
StructuredDatatype	Class to specify the container and compound.
StructuredValue	Super class of `ContainerValue` and `CompoundValue`.
StructuredVariable	Abstract super class for variables of `StructuredDatatype`'s.
SubstitutionVisitor	Substitutes variables in a constraint syntax tree by copying the syntax tree.
SwitchStatement	Implements a value switch.
SwitchStatement.Alternative	A switch alternative.
Template	Represents a VIL template.
TemplateBlock	Implements a template block.
TemplateCallExpression	Represents the explicit execution of a template.
TemplateDescriptor	Carries the information for creating a template (just a temporary instance).
TemplateLangConfig	Stores some global configuration values.
TemplateLangDescriptionLabelProvider	Provides labels for a IEObjectDescriptions and IResourceDescriptions.
TemplateLangExecution	Implements the execution of the template language.
TemplateLangFormatter	This class contains custom formatting description.
TemplateLangJavaValidator
TemplateLangLabelProvider	Provides labels for a EObjects.
TemplateLangModelUtility	Provides language-wide functionality.
TemplateLangOutlineTreeProvider	customization of the default outline structure.
TemplateLangProposalProvider	see http://www.eclipse.org/Xtext/documentation/latest/xtext.html#contentAssist on how to customize content assistant
TemplateLangProposalProviderUtility	A utility class for determining different elements in the VTL build model based on the more generic information provided by the Xtext UI functionalities (typically EObject, etc.)
TemplateLangQuickfixProvider
TemplateLangRuntimeModule	Use this class to register components to be used at runtime / without the Equinox extension registry.
TemplateLangScopeProvider	This class contains custom scoping description.
TemplateLangStandaloneSetup	Initialization support for running Xtext languages without equinox extension registry
TemplateLangUiModule	Use this class to register components to be used within the IDE.
TemplateLangWriter	For writing a template language model to a print stream.
TemplateModel	Provides mechanisms for loading, linking, referring, searching and storing template models according to their name, their version and their location.
TemplateModel.VtlModelRepository	Refined model repository for IVML.
TemplateModelListener	A `de.uni_hildesheim.sse.easy_producer.instantiator.model.templateModel.Template` listener, which receives notifications about changes of the template model and then forces an update of the `de.uni_hildesheim.sse.ui.XtextEditor` instance that is used to edit the corresponding document in which the template is defined.
TemplateSubstitutionExecution	A specific template language execution for replacting VTL expressions/variables.
Text	The textual representation of an artifact (if there is any).
TextGUICellEditor	Implements an updating text cell editor.
TextGUICellEditor.AbstractStringValueConverter<T>	Implements an abstract string value converter for turning an object into an UI string.
TextGUICellEditor.DoubleValueConverter	Implements a simple double converter (currently ignoring input failures).
TextGUICellEditor.FloatValueConverter	Implements a simple float converter (currently ignoring input failures).
TextGUICellEditor.IntegerValueConverter	Implements a simple integer converter (currently ignoring input failures).
TextGUICellEditor.ValueConverter<T>	Allows to perform specific value conversions to/from strings behind UI elements.
TextGUIEditor	Implements a GUI editor representation for Text.
TextTreeNode	Represents a simple text tree node.
ToggleEASyNatureAction	Toggles the EASY nature.
TooltipCreator	Created a tooltip for a given variable.
TopLevelExecutionTraceFilter	A filter that only emits top-level language-unit execution and failure messages, but execution of operations or/in user-defined functions.
TopLevelModelAccessor	Defines the generic access to the top-level model.
TopLevelModelAccessor.AbstractDefaultModelAccessor<M extends IModel>	Implements the register methods empty.
TopLevelModelAccessor.AbstractModelAccessor<M extends IModel>	Basic implementation of `TopLevelModelAccessor.IModelAccessor` performing model loader registration and location registration.
TopLevelModelAccessor.IModelAccessor<M extends IModel>	Defines the interface for the model accessor.
ToplevelVarConfigProvider	`VariableConfigProvider` for not nested variables.
TracerFactory	A factory for the VIL language execution tracers.
TracerFactory.DefaultTracerFactory	The default tracer factory returning tracer instances which do not trace anything (NoTracer).
TracerFactory.TaskData	Stores information about the current task of a progress observer.
TracerHelper	Helper methods for the tracers.
Tracing	Allows enabling or disabling tracing from VIL/VTL.
TranslationResult<R>	Represents the result of a translation.
TranslatorException	Defines a specific model translator exception which carries information about the context where the error occurred.
TreeNode	A display tree node.
TreeNode.Insertable	Language elements to be inserted.
TreeNode.InsertionPoint	Denotes insertion points around this node.
TreeUtils	Some tree utility methods.
TypeCache	Implements a type cache to avoid repeatedly identifying, iterating over and collecting constraints for complex types.
TypeCache.IConstraintTarget	Specifies the interface that an object receiving constraints from this class must provide.
TypeContext	Defines a type context which consists of all variables defined in a project and additionally variables which can be added to the context in a layered manner.
TypedConstraint	Reasoner specific constraint type indicating a typed constraint, e.g., a default constraint or a constraint originating from a constraint variable.
Typedef	Implements the typedef element, actually a type alias.
TypeDef	A specific typedef version for VIL.
TypeDef	A specific typedef version for VTL.
TypeDescriptor<T>	Represents an actual VIL type, its meta information, fields and operations.
TypeHelper	Generic type operations.
TypeMapper	Maps singleton type instances to unique names and back again.
TypeQueries	Provides some utility operations, also due to the split in the inheritance hierarchy.
TypeRegistry	Used to register the actual types (also replacements by extensions).
TypeRegistryConverter	A type converter for the TypeRegistry.
Types	Collects all types defined for IVML.
TypeSelectionDialog	Implements a type selection dialog.
TypeSelectionDialog.TypeLabelProvider	Implements a type label provider.
TypeSpecialization	Mark a method as type specialization method.
UncopiedElement	Containes description over elements which could not be copied by the `ProjectCopyVisitor`.
UncopiedElementsContainer	Stores elements of the `ProjectCopyVisitor`, which could not be copied completely as dependent elements are not copied, yet.
UncopiedElementsContainer.UnresolvedAnnotationAssignment	Container for holding `AttributeAssignment.Assignment`, which could not copied so far.
UncopiedElementsContainer.UnresolvedSyntaxContainer	Fallback for resolving elements containing constraint syntax trees This container is a tuple of (translated parent, original default value).
UnixOperations	Utility functions for operations on a Unix/Linux/(Mac) operating system.
Unjar	Unpacks JAR files.
UnknownOperationException	An exception signaling an unknown operation.
UnknownTypeException	Thrown in case of an unknown type.
UnknownTypeException	A specific exception thrown in case that a type cannot be resolved.
UnknownVariableException	Thrown in case of an unknown variable.
UnmodifiableMap<K,V>	Represents an unmodifiable map.
UnmodifiableSequence<T>	Implements an unmodifiable wrapper for sequences.
UnmodifiableSet<T>	Implements an unmodifiable set wrapper.
UnresolvedExpression	Denotes an expression (tree) which is currently unresolved due to deferred imports, e.g.
Unzip	Unpacks ZIP files.
Util	Some utility methods.
Utils	Some public utility methods.
Utils	Some utility methods.
Utils	Some model utilities.
Utils	Some VTL utility methods.
Utils	Some utility functions.
Utils	Some utility methods.
Utils	Common utility method for Eclipse-based tool integrations.
Utils.SplitResult	The result of splitting a contents object.
ValidationMessage	A specific message for model validation purposes.
ValidationUtils	Some validation helper methods.
ValidationUtils.IModelValidationCallback<R,T>	Defines a validation callback to provide the information required for validation.
ValidationUtils.MessageType	Defines common xText error types.
ValidationVisitor	Visits a given expression and returns whether this is a valid assignment.
ValidProjectNameType	Returns types for `EASyProjectCreatorFactory#isValidProjectName()`.
Value	Basis value class.
ValueAssignmentExpression	Represents a value assignment.
ValueCopy	Filters a given `Value` and creates a copy without filtered elements.
ValueCopyVisitor	Parts of `CSTCopyVisitor` and `ProjectCopyVisitor`, to create a deep copy of `Value`s.
ValueCreationResult	Denotes the result of creating a value of an IVML variable through the reasoner considering the relevant constraints.
ValueDoesNotMatchTypeException	An exception which signals that a given value does not match the specified type.
ValueFactory	The ValueFactory provides easy access to the Values.
ValueFactory.IValueCreator	Private interface for calling the constructor of the right value type.
ValueFilter	A value filter for assigned IVML configuration values.
ValueVisitor	Turns IVML values into VIL compatible values.
ValueVisitorAdapter	Adapts the value visitor interface with an empty implementation.
VariabilityFragment	A top-level class for variability fragments, i.e., fragments combined with other types of fragments to explicitly express variability in generic artifacts.
Variable	Class for a variable value.
VariableAccessor	Implements an accessor for decision variables.
VariableCollector	A variable collector used to collect the (configured) variables of a variability model.
VariableConfigProvider	Delegate for handling the value and state of a `IDecisionVariable`.
VariableConfigProviderFactory	Factory class for creating `VariableConfigProvider`s.
VariableContainer	Stores the `VariableImportance` to each variable of a configuration.
VariableCreator	Factory for converting `AbstractVariable` into `DecisionVariable`.
VariableDeclaration	Represents a variable declaration.
VariableDeclaration	Represents a variable declaration.
VariableDeclaration	Represents a variable declaration.
VariableDeclarationTreeNode	Implements an element node for variable declarations.
VariableEx	An expression denoting that a variable is used.
VariableExpression	An expression denoting that a variable is used.
VariableFinder	Searches whether given variables are used.
VariableLookUpTable	Part of the `RewriteContext` to speed up `IDecisionVariable` retrieval.
VariablePool	Utility class for caching / pooling variables in order to save memory.
VariablesInConstraintFinder	Searches for used `IDecisionVariable`s and their states inside a `ConstraintSyntaxTree`.
VariablesInConstraintFinder	Searches for used `IDecisionVariable`s and their states inside a `ConstraintSyntaxTree`.
VariablesInNotSimpleAssignmentConstraintsFinder	A visitor to retrieve variables from constraints.
VariablesMap	Represents all variable and constraint relationships.
VariableUsage	Collects the variable usage in order to determine those variables that can be written in an unqualified way.
VariableValueCopier	Copies specified variable values, i.e., single variables to a single variable or a compatible container or a container to a container.
VariableValueCopier.CopySpec	Defines a copy specification.
VariableValueCopier.EnumAttributeFreezeProvider	A default freeze provider for but-expressions based on attributes of type enum.
VariableValueCopier.IAssignmentListener	Optional listener interface to generically track primary value assignments.
VariableValueCopier.IFreezeProvider	An interface providing information to create freeze blocks for new variables.
VariableValueCopier.SourceBasedFreezeProvider	A freeze provider based on known frozen assignment states.
VariableValueMapping	Stores overriding values for IVML elements.
VarModel	The variability model, the central class holding all project instances and being responsible for import resolution.
VarModel.IvmlModelRepository	Refined model repository for IVML.
VarModelIdentifierExpression	Represents an identifier in a variability model.
VarModelListener	A `de.uni_hildesheim.sse.model.varModel.Project` listener, which receives notifications about changes of the variability model and then forces an update of the `de.uni_hildesheim.sse.ui.XtextEditor` instance that is used to edit the corresponding document in which the variability model is defined.
VelocityCompoundAccess	Context which allows retrieval of nested values of a compound via `getByName(<slot name>)`.
VelocityContainerItem	`VelocityContextItem` for container, i.e., sets and sequences.
VelocityContextInitializer	Converts an `IDecisionVariable` into flat `VelocityContextItem`, because Velocity needs a simple (name, value) tuple for instantiation.
VelocityContextItem	Datatype for initializing velocity's context.
VelocityInstantiator	A VIL instantiator for velocity.
Version	Represents the version of an import.
VersionedModelInfos<M extends IModel>	Stores model information objects of the same version.
VersionFormatException	A version format exception.
VersionOperations	Implements version operations.
VersionOperations.IVersionResultConverter	A version evaluation result validator.
VersionOperations.VersionEvaluator	Evaluates a version operation.
VersionType	Defines the basis (internal) datatype "Version".
VersionValue	This class holds the value for a version.
VersionValueConverter	Converts version numbers by removing the leading "v".
VilArgumentProvider	An argument provider for VIL execution.
VilBuildLangProposalProviderUtility	A utility class for determining different elements in the VIL build model based on the more generic information provided by the Xtext UI functionalities (typically EObject, etc.) Please note if multiple VIL scripts are defined in the same file, the proposals of the content assist may be wrong!
VilBuildLanguageDescriptionLabelProvider	Provides labels for a IEObjectDescriptions and IResourceDescriptions.
VilBuildLanguageFormatter	This class contains custom formatting description.
VilBuildLanguageJavaValidator
VilBuildLanguageLabelProvider	Provides labels for a EObjects.
VilBuildLanguageOutlineTreeProvider	customization of the default outline structure.
VilBuildLanguageProposalProvider	see http://www.eclipse.org/Xtext/documentation/latest/xtext.html#contentAssist on how to customize content assistant
VilBuildLanguageQuickfixProvider
VilBuildLanguageRuntimeModule	Use this class to register components to be used at runtime / without the Equinox extension registry.
VilBuildLanguageScopeProvider	This class contains custom scoping description.
VilBuildLanguageStandaloneSetup	Initialization support for running Xtext languages without equinox extension registry
VilBuildLanguageUiModule	Use this class to register components to be used within the IDE.
VilBundleId	Stores data about the containing OSGi bundle (static bundle without activator).
VilClasspathProvider	A parameter provider which adds the project's classpath as a given parameter name to the main VIL call.
VilEcoreModelFinder	A Ecore model element finder for VIL.
VilEcoreModelQuery	VIL Ecore model queries.
VilException	Defines a specific exception issued when building up the model fails for some reason.
VilExecutionThread	Responsible class for the execution of VIL scripts, i.e., instantiation of product line artifacts.
VilExpressionParser	Provides an expression parser for VIL.
VILFiletypeWizard	This is a sample new wizard.
VILFiletypeWizardPage	The "New" wizard page allows setting the container for the new file as well as the file name.
VilHighlightingCalculator	This class enables the customization of syntax-highlighting in the VIL build and template language editors.
VilHighlightingConfiguration	This class represents the initial configuration of the customized highlighting.
VilHyperlinkFactory	VIL hyperlink factory.
VilHyperlinkHelper	This class enables the creation of hyperlinks for any VIL-element in an VIL-file if the user selects such an element either via pressing the "F3"-key or by clicking on that element while pressing the "CTRL"-key.
VilModelAccessor	Implements a model accessor for the top level IVML project.
VILModelLoader	Loader for VIL.
VilModelQuery	VIL Model Query implementation.
VILPageCreator	Creates the contents of the `VILFiletypeWizard`.
VilTemplateProcessor	Implements the default VIL template processor.
VilTracer	Implements a combined tracer for VIL and VTL with common indentation.
VilTypeExpression	Represents a VIL type.
VilValueConverters	Factory for the value converters.
VILWizardPageDescriptor	Specification of the `VILFiletypeWizardPage`.
VirtualOutlineNode	That class is for creating a virtual node.
VirtualOutlineNode	That class is for creating a virtual node.
VoidType	The AnyType is the "Object" of OCL, a type to which all types are compatible.
VtlArgumentProviderPreferencePage	Implements the providers - preference - page.
VtlBundleId	Stores data about the containing OSGi bundle (static bundle without activator).
VtlEcoreModelQuery
VtlExpressionParser	Provides an expression parser for VTL.
VtlFileArtifact	Defines an artifact for VTL.
VtlFileArtifactCreator	The artifact creator for VTL files.
VTLFiletypeWizard	This is a sample new wizard.
VTLFiletypeWizardPage	The "New" wizard page allows setting the container for the new file as well as the file name.
VtlHyperlinkFactory	VIL hyperlink factory.
VtlHyperlinkHelper	This class enables the creation of hyperlinks for any VIL-element in an VIL-file if the user selects such an element either via pressing the "F3"-key or by clicking on that element while pressing the "CTRL"-key.
VTLModelLoader	Loader for VTL.
VtlModelQuery	VTL Model Query implementation.
VTLPageCreator	Creates the contents of the `VTLFiletypeWizard`.
VtlRule	Maps a VTL rule into VIL.
VTLTypeConverter	Type converter for vtl types.
VTLWizardPageDescriptor	Specification of the `VTLFiletypeWizardPage`.
WhileStatement	Implements a VIL while statement.
WhileStatement	Representation of a loop-statement in VIL which allows multiple processing of a `WorkflowElementBlock` instance.
WhileTreeNode	Implements an element node for while statements.
WriterVisitor<V extends VariableDeclaration>	A writer for VIL languages.
XmlAttribute	Represents a parsed XML attribute.
XmlComment	Represents an XML comment.
XmlConnector	This class implements a StorageConnector for XML-file-based storages.
XMLConstants	XML Constants for the XML Connector.
XmlElement	Represents a parsed XML element with contained attributes.
XmlElement.NodeComparator	A (attribute) node comparator based on XML attributes.
XmlFileArtifact	Represents a parsed XML file artifact.
XmlIo	Supports storing projects (and referenced projects) into XML format.
XmlIo.Model	Defines the top level element in the XML.
XmlNode	An abstract fragment representing a XML node.
XmlRootElement	A specific root element storing the relation to the containing file artifact.
XtextEditor	A specific editor class for VIL.
XtextEditor	A specific editor class for VTL.
XVCLInstantiator	Registers and calls the XVCL instantiatior from VIL.
XvclTransformatorEngine	The XVCL instantiator implementation.
Zip	Creates ZIP files.
ZipHandler	Implements a handler function for ZIP files (which is prepared for handling JAR files in a similar way).
ZipUpgrader	An upgrader for zip and file input locations.