Uses of Class
net.ssehub.easy.varModel.model.AbstractVariable

Packages that use AbstractVariable

Package	Description
de.uni_hildesheim.sse.translation	The mechanisms needed to translate an IVML Ecore model into an IVML object model.
net.ssehub.easy.instantiation.core.model.vilTypes.configuration	All classes related to the EASy integration of configuration and decisions.
net.ssehub.easy.producer.ui.confModel	This package holds a GUI representation of the configuration with methods and additional information as needed by the Eclipse UI.
net.ssehub.easy.reasoning.core.frontend	Frontend to access reasoner information as well as to execute reasoning tasks.
net.ssehub.easy.reasoning.core.impl	Hidden implementation stuff.
net.ssehub.easy.reasoning.core.reasoner	All classes and interfaces needed to implement a reasoner. How to write a reasoner: Create an Eclipse Plugin project with Activator (even if "empty"). Add org.eclipse.equinox.ds to the required plugins and org.osgi.service.component to the imported packages as your reasoner will be linked using OSGi descriptive services (DS) to the reasoner core.
net.ssehub.easy.reasoning.sseReasoner	Package contains the EASy-Producer reasoner implementation classes.
net.ssehub.easy.reasoning.sseReasoner.functions	Package contains custom functions for IVML.
net.ssehub.easy.reasoning.sseReasoner.model	Package for creating a reasoning model: constraint container, project hierachy evaluator and other.
net.ssehub.easy.varModel.confModel	This package represents a specific variability model configuration.
net.ssehub.easy.varModel.confModel.paths	Support for deferred resolution paths.
net.ssehub.easy.varModel.cst	Package for elements of the constraint syntax tree.
net.ssehub.easy.varModel.cstEvaluation	Implements the evaluation of constraint syntax trees.
net.ssehub.easy.varModel.model	Base package for the variability model.
net.ssehub.easy.varModel.model.filter	This package contains utility classes for filtering the model for specific model elements.
net.ssehub.easy.varModel.model.filter.mandatoryVars	Filter for finding mandatory declarations.
net.ssehub.easy.varModel.model.rewrite	Classes for creating an (adapted) copy of the Project.
net.ssehub.easy.varModel.model.rewrite.modifier	Modifier for the ProjectRewriteVisitor.
net.ssehub.easy.varModel.model.values	Instances of the datatypes.
net.ssehub.easy.varModel.persistency	These package is for reading and saving the variability model and the configuration. Currently supported file formats: EASy-Producer 2.0 config files (xml) IVML
net.ssehub.easy.varModel.validation	Classes for validating e variability model, e.g.

Uses of AbstractVariable in de.uni_hildesheim.sse.translation

Methods in de.uni_hildesheim.sse.translation that return AbstractVariable

Modifier and Type	Method	Description
AbstractVariable	TypeContext.findVariable(java.lang.String name, java.lang.Class<? extends AbstractVariable> type)	Searches for a specified variable.

Methods in de.uni_hildesheim.sse.translation with parameters of type AbstractVariable

Modifier and Type	Method	Description
Variable	TypeContext.obtainVariable(AbstractVariable decl)	Obtains a CTS variable node for a given variable declaration, i.e., creates it or returns it from the variable pool of this context.

Method parameters in de.uni_hildesheim.sse.translation with type arguments of type AbstractVariable

Modifier and Type	Method	Description
AbstractVariable	TypeContext.findVariable(java.lang.String name, java.lang.Class<? extends AbstractVariable> type)	Searches for a specified variable.

Uses of AbstractVariable in net.ssehub.easy.instantiation.core.model.vilTypes.configuration

Fields in net.ssehub.easy.instantiation.core.model.vilTypes.configuration declared as AbstractVariable

Modifier and Type	Field	Description
private AbstractVariable	AbstractIvmlFieldDescriptor.var
private AbstractVariable	IvmlDeclaration.variable

Methods in net.ssehub.easy.instantiation.core.model.vilTypes.configuration that return AbstractVariable

Modifier and Type	Method	Description
AbstractVariable	AbstractIvmlVariable.DecVar.getDeclaration()
protected AbstractVariable	AbstractIvmlFieldDescriptor.getVariable()	Returns the underlying IVML variable.

Methods in net.ssehub.easy.instantiation.core.model.vilTypes.configuration that return types with arguments of type AbstractVariable

Modifier and Type	Method	Description
private java.util.Map<AbstractVariable,java.util.List<IDecisionVariable>>	ConfigurationContextResolver.collectReferences()	Collects all references in the configuration.

Method parameters in net.ssehub.easy.instantiation.core.model.vilTypes.configuration with type arguments of type AbstractVariable

Modifier and Type	Method	Description
private void	ConfigurationContextResolver.collectReference(IDecisionVariable var, Value val, java.util.Map<AbstractVariable,java.util.List<IDecisionVariable>> references)	Collects the references for a variable and a single value (entry in case of a collection).
private void	ConfigurationContextResolver.collectReferences(IDecisionVariable var, java.util.Map<AbstractVariable,java.util.List<IDecisionVariable>> references)	Collects the references for a single variable.

Constructors in net.ssehub.easy.instantiation.core.model.vilTypes.configuration with parameters of type AbstractVariable

Constructor	Description
AbstractIvmlFieldDescriptor(TypeDescriptor<?> declaringType, AbstractVariable var, TypeRegistry registry)	Creates the field descriptor.
IvmlConfigurationFieldDescriptor(TypeDescriptor<?> declaringType, AbstractVariable var, TypeRegistry registry)	Creates the field descriptor.
IvmlDeclaration(AbstractVariable variable)	Creates a new declaration instance.

Uses of AbstractVariable in net.ssehub.easy.producer.ui.confModel

Fields in net.ssehub.easy.producer.ui.confModel with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.Map<java.lang.String,AbstractVariable>	MultipleSelectionEditor.possibleVariables
private java.util.List<AbstractVariable>	MultipleSelectionEditor.selectedValues
private java.util.Map<AbstractVariable,GUIVariable>	ErrorSetter.variableMap

Methods in net.ssehub.easy.producer.ui.confModel that return types with arguments of type AbstractVariable

Modifier and Type	Method	Description
private java.util.Map<AbstractVariable,GUIVariable>	GUIConfiguration.toHashMap()	Converts the nested GUIVariable's into a temporary Map.

Method parameters in net.ssehub.easy.producer.ui.confModel with type arguments of type AbstractVariable

Modifier and Type	Method	Description
private static void	GUIConfiguration.determineVisible(AttributeAssignment block, java.util.Set<AbstractVariable> visible)	Part of GUIConfiguration.determineVisible(IResolutionScope, Set, Set), which handles AttributeAssignment blocks recursively.
private static void	GUIConfiguration.determineVisible(IResolutionScope scope, java.util.Set<AbstractVariable> visible, java.util.Set<IResolutionScope> done)	Determines the actually visible variables for the given resolution scope.

Constructor parameters in net.ssehub.easy.producer.ui.confModel with type arguments of type AbstractVariable

Constructor	Description
ErrorSetter(java.util.Map<AbstractVariable,GUIVariable> variableMap, Configuration config)	Sole constructor for setting error messages by this class.

Uses of AbstractVariable in net.ssehub.easy.reasoning.core.frontend

Methods in net.ssehub.easy.reasoning.core.frontend with parameters of type AbstractVariable

Modifier and Type	Method	Description
ValueCreationResult	IReasonerInstance.createValue(AbstractVariable var, IDatatype type, ProgressObserver observer)	Creates the value for a certain IVML type/variable.
ValueCreationResult	ReasonerAdapter.createValue(Configuration cfg, AbstractVariable var, IDatatype type, ReasonerConfiguration reasonerConfiguration, ProgressObserver observer)	Creates the value for a certain IVML type/variable.
ValueCreationResult	ReasonerAdapter.FrontendReasonerAdapter.createValue(Configuration cfg, AbstractVariable var, IDatatype type, ReasonerConfiguration reasonerConfiguration, ProgressObserver observer)
ValueCreationResult	ReasonerAdapter.InstanceReasonerAdapter.createValue(Configuration cfg, AbstractVariable var, IDatatype type, ReasonerConfiguration reasonerConfiguration, ProgressObserver observer)
ValueCreationResult	ReasonerAdapter.IReasonerAdapter.createValue(Configuration cfg, AbstractVariable var, IDatatype type, ReasonerConfiguration reasonerConfiguration, ProgressObserver observer)	Creates the value for a certain IVML type/variable.
ValueCreationResult	ReasonerFrontend.createValue(Configuration cfg, AbstractVariable var, IDatatype type, ReasonerConfiguration reasonerConfiguration, ProgressObserver observer)	Creates the value for a certain IVML type/variable.

Uses of AbstractVariable in net.ssehub.easy.reasoning.core.impl

Methods in net.ssehub.easy.reasoning.core.impl with parameters of type AbstractVariable

Modifier and Type	Method	Description
static ValueCreationResult	ReasonerHelper.createValue(Configuration cfg, AbstractVariable var, IDatatype type, ReasonerConfiguration reasonerConfiguration, ProgressObserver observer)	Creates the value for a certain IVML type/variable.

Uses of AbstractVariable in net.ssehub.easy.reasoning.core.reasoner

Fields in net.ssehub.easy.reasoning.core.reasoner with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.List<java.util.Set<AbstractVariable>>	Message.variablesInConstraints

Methods in net.ssehub.easy.reasoning.core.reasoner that return types with arguments of type AbstractVariable

Modifier and Type	Method	Description
java.util.List<java.util.Set<AbstractVariable>>	Message.getConstraintVariables()	Method for returning a list of AbstractVariables that are involved in each failed constraint.

Methods in net.ssehub.easy.reasoning.core.reasoner with parameters of type AbstractVariable

Modifier and Type	Method	Description
ValueCreationResult	DelegatingReasonerInstance.createValue(AbstractVariable var, IDatatype type, ProgressObserver observer)
ValueCreationResult	IReasoner.createValue(Configuration cfg, AbstractVariable var, IDatatype type, ReasonerConfiguration reasonerConfiguration, ProgressObserver observer)	Creates the value for a certain IVML type/variable.
boolean	AttributeValues.hasValue(AbstractVariable attribute, Value value)	Returns whether there is an assignment of value to attribute.

Method parameters in net.ssehub.easy.reasoning.core.reasoner with type arguments of type AbstractVariable

Modifier and Type	Method	Description
void	Message.addConstraintVariables(java.util.List<java.util.Set<AbstractVariable>> variables)	Method for adding a list of AbstractVariables that are involved in each failed constraint.
private java.lang.String	Message.problemPointsToString(java.util.Set<AbstractVariable> vars)	Turns given variables into a problem points description.

Uses of AbstractVariable in net.ssehub.easy.reasoning.sseReasoner

Fields in net.ssehub.easy.reasoning.sseReasoner declared as AbstractVariable

Modifier and Type	Field	Description
private AbstractVariable	Resolver.OtherConstraintsProcessor.self

Fields in net.ssehub.easy.reasoning.sseReasoner with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.List<java.util.Set<AbstractVariable>>	Engine.variablesInConstraints

Methods in net.ssehub.easy.reasoning.sseReasoner with parameters of type AbstractVariable

Modifier and Type	Method	Description
private void	Resolver.addDefaultConstraint(AbstractVariable decl, ConstraintSyntaxTree defaultValue, Resolver.DefaultConstraints tmp, boolean enable, IDecisionVariable var)	Adds a default constraint.
private static ConstraintSyntaxTree	Resolver.checkTypeCast(IDatatype declType, IDatatype actType, AbstractVariable decl, ConstraintSyntaxTree cAcc)	Inserts a type cast if needed.
private void	Resolver.conflictingDefault(AbstractVariable decl)	Will be called after a failure was detected in a default constraint of an AbstractVariable.
(package private) boolean	Resolver.contextContainsMapping(AbstractVariable var)	Returns whether the current context contains a mapping for var.
(package private) void	Resolver.contextRegisterMapping(AbstractVariable var, ConstraintSyntaxTree acc)	Registers a mapping between the variable var and its actual access expression acc into the current top-most context.
(package private) Constraint	Resolver.createConstraintVariableConstraint(ConstraintSyntaxTree cst, ConstraintSyntaxTree selfEx, AbstractVariable self, IModelElement parent, IDecisionVariable variable)	Creates a constraint for a (nested) constraint variable adding the result to #constraintVariablesConstraints.
(package private) Constraint	Resolver.createConstraintVariableConstraint(ConstraintSyntaxTree cst, AbstractVariable self, boolean checkForInitializers, IModelElement parent, IDecisionVariable variable)	Creates a constraint for a (nested) constraint variable adding the result to Resolver.otherConstraints.
(package private) void	Resolver.createContainerConstraintValueConstraints(ContainerValue val, ConstraintSyntaxTree selfEx, AbstractVariable self, IModelElement parent, IDecisionVariable nestedVariable)	Checks a container value for nested constraint values, i.e., values of nested constraint variables.
ValueCreationResult	Reasoner.createValue(Configuration cfg, AbstractVariable var, IDatatype type, ReasonerConfiguration reasonerConfiguration, ProgressObserver observer)
ValueCreationResult	Reasoner.ReasonerInstance.createValue(AbstractVariable var, IDatatype type, ProgressObserver observer)
private ConstraintSyntaxTree	Resolver.getNestedAccessor(AbstractVariable nestedDecl, ConstraintSyntaxTree cAcc)	Returns the accessor for a nested variable declaration.
void	Resolver.notifyResolved(AbstractVariable declaration, IDecisionVariable resolved)
private void	Resolver.processCompoundEvals(Compound cmpType, ConstraintSyntaxTree selfEx, AbstractVariable self, IDecisionVariable variable)	Method for extracting constraints from compounds eval blocks (also refined compounds).
private void	Resolver.processEvalConstraints(PartialEvaluationBlock evalBlock, ConstraintSyntaxTree selfEx, AbstractVariable self, IDecisionVariable variable)	Method for handling eval blocks - searching for nested eval blocks and extracting constraints.
(package private) void	Resolver.reschedule(AbstractVariable declaration)	Tries rescheduling the given constraints.
private void	Resolver.OtherConstraintsProcessor.setParameter(ConstraintSyntaxTree selfEx, AbstractVariable self, IDecisionVariable variable)	Sets the parameters for processing.
(package private) ConstraintSyntaxTree	Resolver.substituteVariables(ConstraintSyntaxTree cst, ConstraintSyntaxTree selfEx, AbstractVariable self, ConstraintSyntaxTree acc)	Method for using SubstitutionVisitor for constraint transformation.
private void	Resolver.translateAnnotationDeclarations(AbstractVariable decl, IDecisionVariable variable, ConstraintSyntaxTree cAcc)	Translates annotation declarations.
private void	Resolver.translateCompoundContainer(AbstractVariable decl, Compound type, IDatatype declaredContainedType, ConstraintSyntaxTree cAcc)	Translates an entire compound container decl including defaults and constraints for the specific type cmpType (iterate through all relevant types).
private void	Resolver.translateCompoundContent(AbstractVariable decl, IDecisionVariable variable, Compound type, ConstraintSyntaxTree cAcc)	Translates the compound content.
private int	Resolver.translateCompoundDeclaration(AbstractVariable decl, IDecisionVariable variable, ConstraintSyntaxTree cAcc, Compound type, int mode)	Translates translating compound type declarations, but only if not ContextStack.alreadyProcessed(IDatatype) in nested collection/compound types.
private void	Resolver.translateContainerDeclaration(AbstractVariable decl, IDecisionVariable var, IDatatype type, ConstraintSyntaxTree cAcc)	Translates the (transitive) defaults and type constraints for a container declaration.
private void	Resolver.translateDeclaration(AbstractVariable decl, IDecisionVariable var, ConstraintSyntaxTree cAcc)	Translates the (transitive) defaults and type constraints for a declaration.
private void	Resolver.translateDerivedDatatypeConstraints(AbstractVariable decl, IDatatype type, DecisionVariableDeclaration localDecl, IModelElement parent, int refCounter, ConstraintSyntaxTree cAcc)	Extracts, translates and collects the internal constraints of type (if derived or, transitively, a reference datatype) and stores the constraints in #derivedTypeConstraints.

Uses of AbstractVariable in net.ssehub.easy.reasoning.sseReasoner.functions

Fields in net.ssehub.easy.reasoning.sseReasoner.functions with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.Set<AbstractVariable>	ConstraintFunctions.TransitiveConstraintFinder.candidates
private java.util.Map<AbstractVariable,FailedElementDetails>	FailedElements.problemVariables	Map of failed AbstractVariables and FailedElementDetailss behind it.
private java.util.Set<AbstractVariable>	ConstraintFunctions.TransitiveConstraintFinder.scheduled
private java.util.Set<AbstractVariable>	ConstraintFunctions.TransitiveConstraintFinder.variables

Methods in net.ssehub.easy.reasoning.sseReasoner.functions that return types with arguments of type AbstractVariable

Modifier and Type	Method	Description
java.util.Map<AbstractVariable,FailedElementDetails>	FailedElements.getProblemVariableMap()	Returns a map of problem AbstractVariables and associated FailedElementDetailss.
java.util.Iterator<AbstractVariable>	FailedElements.getProblemVariables()	Returns a Iterator - problem AbstractVariables.

Methods in net.ssehub.easy.reasoning.sseReasoner.functions with parameters of type AbstractVariable

Modifier and Type	Method	Description
static void	ConstraintFunctions.addConstraintsToProject(AbstractVariable var, Project scope, Project target)	Adds constraints related to var and transitively related constraints and variables in scope to target although the parent relationships of the added variables/constraints are then not correct.
void	FailedElements.addProblemVariable(AbstractVariable variable, FailedElementDetails details)	Method for adding failed variable and associated IDecisionVariable.
private void	ConstraintFunctions.TransitiveConstraintFinder.addToVariables(AbstractVariable var)	Adds a variable to ConstraintFunctions.TransitiveConstraintFinder.variables.
private void	ConstraintFunctions.TransitiveConstraintFinder.handle(AbstractVariable variable)	Handles the occurrence of a variable.
void	ConstraintFunctions.TransitiveConstraintFinder.visit(AbstractVariable var)	Call for the top-level variable to be visited.

Uses of AbstractVariable in net.ssehub.easy.reasoning.sseReasoner.model

Fields in net.ssehub.easy.reasoning.sseReasoner.model declared as AbstractVariable

Modifier and Type	Field	Description
private AbstractVariable	TypeCache.Entry.origvar
private AbstractVariable	ContextStack.Context.self	The underlying variable being translated, used for fallback lookups in on-demand accessor instantiation through ContextStack.Context.fallback.
private AbstractVariable	SubstitutionVisitor.self

Fields in net.ssehub.easy.reasoning.sseReasoner.model with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.Map<AbstractVariable,java.util.Set<Constraint>>	VariablesMap.declConstraintMapping
private java.util.Map<AbstractVariable,ConstraintSyntaxTree>	SubstitutionVisitor.mapping
private java.util.Map<AbstractVariable,ConstraintSyntaxTree>	ContextStack.Context.varMap	Variable-accessor mapping.
private java.util.Map<AbstractVariable,ConstraintSyntaxTree>	TypeCache.Entry.varMap

Methods in net.ssehub.easy.reasoning.sseReasoner.model with parameters of type AbstractVariable

Modifier and Type	Method	Description
void	VariablesMap.add(AbstractVariable declaration, Constraint constraint)	Adds a relationship between variable and constraint.
void	VariablesMap.addAll(AbstractVariable declaration, ConstraintList constraints)	Relates all constraints to declaration.
void	ContextStack.addAsParentCache(IDatatype type, TypeCache.IConstraintTarget target, IDecisionVariable register, AbstractVariable var)	Adds the type cache of type as parent to the type cache that is currently in construction.
void	TypeCache.Entry.addParent(TypeCache.Entry entry, TypeCache.IConstraintTarget target, IDecisionVariable register, AbstractVariable var)	Adds a parent to this entry and causes constraint transfer.
SubstitutionVisitor	SubstitutionVisitor.addVariableMapping(AbstractVariable orig, ConstraintSyntaxTree ex)	Adds a variable mapping to be considered during substitution.
SubstitutionVisitor	SubstitutionVisitor.addVariableMapping(AbstractVariable orig, AbstractVariable dest, int derefCount)	Adds a variable mapping to be considered during substitution.
SubstitutionVisitor	SubstitutionVisitor.clearVariableMapping(AbstractVariable var)	Clears the mapping for a given variable.
boolean	ContextStack.containsMapping(AbstractVariable var)	Returns whether the current context contains a mapping for var.
boolean	TypeCache.Entry.containsMapping(AbstractVariable var)	Returns whether the current context contains a mapping for var.
TypeCache.Entry	TypeCache.createEntryFor(IDatatype type, AbstractVariable var)	Creates a type cache entry.
ConstraintSyntaxTree	TypeCache.Entry.getLocalMapping(java.lang.String name, AbstractVariable self)	Returns the local mapping for the given variable name just from the current context.
ConstraintSyntaxTree	ContextStack.getMapping(AbstractVariable var)	Returns the mapped access expression for var taking into account all current contexts of the stack starting with the current top-most one.
ConstraintSyntaxTree	TypeCache.Entry.getMapping(AbstractVariable var, AbstractVariable self)	Returns the mapped access expression for var taking into account all current contexts of the stack starting with the current top-most one.
java.util.Set<Constraint>	VariablesMap.getRelevantConstraints(AbstractVariable declaration)	Returns all constraints, where the specifies declaration was used inside.
static Value	ReasoningUtils.getRelevantValue(AbstractVariable decl, IDecisionVariable var, boolean incremental)	Returns the relevant value for reasoning.
static <D extends Value> D	ReasoningUtils.getRelevantValue(AbstractVariable decl, IDecisionVariable var, boolean incremental, java.lang.Class<D> filter)	Returns the relevant value for reasoning.
private ConstraintSyntaxTree	TypeCache.Entry.instantiate(ConstraintSyntaxTree cst, AbstractVariable var)	Instantiates a the given constraint.
static boolean	ReasoningUtils.isOverriddenSlot(AbstractVariable decl)	Returns whether decl is an overridden slot.
private void	VariablesInNotSimpleAssignmentConstraintsFinder.modifyRelation(AbstractVariable variable, Constraint constraint)	Modifies the relationship between variable and constraint due to VariablesInNotSimpleAssignmentConstraintsFinder.add.
private java.util.Set<Constraint>	VariablesMap.obtainConstraintSet(AbstractVariable declaration)	Returns the constraint set for declaration.
void	ContextStack.pushContext(AbstractVariable decl, boolean recordProcessedTypes)	Pushes a new (compound) context to the stack.
void	ContextStack.pushContext(AbstractVariable decl, ConstraintSyntaxTree container, DecisionVariableDeclaration iterator, boolean recordProcessedTypes)	Pushes a new container context to the stack.
void	ContextStack.registerForTypeCache(IDatatype type, AbstractVariable var)	Registers the given type and the prototypical template variable var as type in the type cache.
void	ContextStack.registerMapping(AbstractVariable var, ConstraintSyntaxTree acc)	Registers a mapping between the variable var and its actual access expression acc into the current top-most context.
void	VariablesMap.remove(AbstractVariable declaration, Constraint constraint)	Removes a relationship between variable and constraint.
void	VariablesMap.removeAll(AbstractVariable declaration, java.util.Collection<Constraint> constraints)	Unrelates all constraints from declaration.
SubstitutionVisitor	SubstitutionVisitor.setSelf(AbstractVariable self)	Defines self in terms of a variable declaration.
private void	TypeCache.ConstraintTemplate.transfer(TypeCache.IConstraintTarget target, IDecisionVariable register, AbstractVariable var, AbstractVariable self)	Transfers the stored constraint into the context of self.
boolean	ContextStack.transferConstraints(IDatatype type, TypeCache.IConstraintTarget target, IDecisionVariable register, AbstractVariable var)	Transfers all constraints from the associated type cache entry into their respective target constraint sets.
private boolean	TypeCache.Entry.transferConstraints(TypeCache.IConstraintTarget target, IDecisionVariable register, AbstractVariable var)	Transfers constraints.
boolean	TypeCache.transferConstraints(IDatatype type, TypeCache.IConstraintTarget target, IDecisionVariable register, AbstractVariable var)	Transfers collected constraints for type.
void	ContextStack.transferToContext(IDatatype type, AbstractVariable var)	Indicates that mapping information from the type cache shall be transferred into the current context.
void	TypeCache.transferToContext(IDatatype type, ContextStack contexts, AbstractVariable var)	Transfers all accessors stored in TypeCache.Entry.varMap into the actual context in contexts by instantiating them.
void	ContextStack.unregisterMapping(AbstractVariable var)	Unregisters a mapping for the variable var from the current context.

Method parameters in net.ssehub.easy.reasoning.sseReasoner.model with type arguments of type AbstractVariable

Modifier and Type	Method	Description
void	TypeCache.transferContext(IDatatype type, java.util.Map<AbstractVariable,ConstraintSyntaxTree> varMap, java.util.Map<java.lang.String,ConstraintSyntaxTree> nameMap)	Transfers the mappings of the given context into the cache entry of type.

Constructors in net.ssehub.easy.reasoning.sseReasoner.model with parameters of type AbstractVariable

Constructor	Description
Entry(AbstractVariable var)	Creates a type cache entry.

Uses of AbstractVariable in net.ssehub.easy.varModel.confModel

Fields in net.ssehub.easy.varModel.confModel declared as AbstractVariable

Modifier and Type	Field	Description
private AbstractVariable	DecisionVariable.declaration
private AbstractVariable	VariableCreator.varDecl

Fields in net.ssehub.easy.varModel.confModel with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.Map<AbstractVariable,IDecisionVariable>	CompoundValueSetter.decisions
private java.util.LinkedHashMap<AbstractVariable,IDecisionVariable>	Configuration.decisions

Methods in net.ssehub.easy.varModel.confModel that return AbstractVariable

Modifier and Type	Method	Description
AbstractVariable	ICollectionElementVariable.getBaseVariable()	The base variable representing the collection.
protected AbstractVariable	CompoundItemConfigProvider.getDeclaration()
AbstractVariable	Configuration.getDeclaration()	Returns the declaration of the variable.
protected AbstractVariable	ContainerItemConfigProvider.getDeclaration()
AbstractVariable	DecisionVariable.getDeclaration()
AbstractVariable	IConfigurationElement.getDeclaration()	Returns the declaration of the variable.
protected AbstractVariable	ToplevelVarConfigProvider.getDeclaration()	Returns the Declaration of the related IDecisionVariable.
protected abstract AbstractVariable	VariableConfigProvider.getDeclaration()	Returns the declaration of the related IDecisionVariable.

Methods in net.ssehub.easy.varModel.confModel that return types with arguments of type AbstractVariable

Modifier and Type	Method	Description
(package private) java.util.Map<AbstractVariable,IDecisionVariable>	Configuration.getConfiguredDecisions()	Returns the saved (AbstractVariable, IDecisionVariable) mapping.

Methods in net.ssehub.easy.varModel.confModel with parameters of type AbstractVariable

Modifier and Type	Method	Description
protected void	AssignmentResolver.conflictingDefault(AbstractVariable decl)	Will be called after a failure was detected in a default constraint of an AbstractVariable.
protected ConstraintSyntaxTree	ConfigurationSaver.createAssignmentConstraint(Project dstProject, AbstractVariable decl, IDecisionVariable var, Value value)	Creates an assignment constraint.
IDecisionVariable	Configuration.createDecision(AbstractVariable decl)	Creates a visible decision in this configuration.
private IDecisionVariable	Configuration.createDecision(AbstractVariable decl, boolean visible)	Creates a decision in this configuration.
private IDecisionVariable	CompoundVariable.createNestedElement(AbstractVariable decl, boolean isVisible, boolean isAttribute, boolean force)	Creates a nested element due to its declaration and registers it.
protected ConstraintSyntaxTree	ConfigurationSaver.deriveOperand(AbstractVariable decl, IDecisionVariable var)	Derives the operand expression for turning a configuration into a project.
abstract boolean	DisplayNameProvider.enableNullValueInConfiguration(AbstractVariable variable)	Returns whether IMVL null values shall be visible in the configuration editor.
private void	Configuration.freezeValues(AbstractVariable var, IFreezeSelector selector)	Sets AssignmentState.FROZEN state to the given variables var.
IDecisionVariable	Configuration.getDecision(AbstractVariable declaration)
IDecisionVariable	IConfiguration.getDecision(AbstractVariable declaration)	Returns the specified IDecisionVariable.
abstract java.lang.String	DisplayNameProvider.getDisplayName(AbstractVariable variable)	Returns the display name of a variable.
abstract java.lang.String	DisplayNameProvider.getNullName(AbstractVariable variable)	Returns the name to be used for an IVML null value, possibly dependent on the given variable.
abstract java.lang.String	DisplayNameProvider.getParentNames(AbstractVariable variable)	Returns the display names of the parents.
private boolean	CompoundVariable.isDirectTypeRecursive(AbstractVariable slot)	Returns whether slot has a directly recursive type (same or somehow refined) to the containing type.
private int	ConfigurationSaver.processAssignment(Project confProject, java.lang.StringBuilder errors, AbstractVariable decl, IDecisionVariable var, Value value)	Processes an assignment.
protected boolean	AssignmentResolver.resolveDefaultValueForDeclaration(AbstractVariable decl, IDecisionVariable variable)	Resolves default values of a particular declaration.
protected static boolean	AssignmentResolver.resolveDefaultValueForDeclaration(AbstractVariable decl, IDecisionVariable variable, EvaluationVisitor evaluator, IConfiguration config, AssignmentResolver conflictHandler)	Resolves default values of a particular declaration.

Method parameters in net.ssehub.easy.varModel.confModel with type arguments of type AbstractVariable

Modifier and Type	Method	Description
private void	Configuration.addVariables(java.util.List<AbstractVariable> topLevelDeclarations, boolean visible)	Creates IDecisionVariables for all given AbstractVariables and adds them to the configuration.

Constructors in net.ssehub.easy.varModel.confModel with parameters of type AbstractVariable

Constructor	Description
BasisVariable(IConfigurationElement parent, AbstractVariable varDeclaration, boolean isVisible, boolean isAttribute)	Sole constructor for creating IDecisionVariable's which do not contain nested Elements.
CompoundVariable(IConfigurationElement parent, AbstractVariable varDeclaration, boolean isVisible, boolean isAttribute)	Sole constructor for creating ContainerVariable's.
ContainerVariable(IConfigurationElement parent, AbstractVariable varDeclaration, boolean isVisible, boolean isAttribute)	Sole constructor for this class.
DecisionVariable(IConfigurationElement parent, AbstractVariable varDeclaration, boolean isVisible, boolean isAttribute)	Creates a new decision variable representing a specific decision.
SequenceVariable(AbstractVariable varDecl, IConfigurationElement parent, boolean isVisible, boolean isAttribute)	Sole Constructor for this class.
SetVariable(AbstractVariable varDecl, IConfigurationElement parent, boolean isVisible, boolean isAttribute)	Sole Constructor for this class.
StructuredVariable(IConfigurationElement parent, AbstractVariable varDeclaration, boolean isVisible, boolean isAttribute)	Sole constructor for this class.
VariableCreator(AbstractVariable varDecl, IConfigurationElement parent, boolean isVisible, boolean isAttribute)	Sole constructor for this class.

Constructor parameters in net.ssehub.easy.varModel.confModel with type arguments of type AbstractVariable

Constructor	Description
CompoundValueSetter(OCLFeatureCall ocl, java.util.Map<AbstractVariable,IDecisionVariable> decisions)	Sole constructor for this class.

Uses of AbstractVariable in net.ssehub.easy.varModel.confModel.paths

Fields in net.ssehub.easy.varModel.confModel.paths declared as AbstractVariable

Modifier and Type	Field	Description
private AbstractVariable	StartPathElement.decl

Constructors in net.ssehub.easy.varModel.confModel.paths with parameters of type AbstractVariable

Constructor	Description
StartPathElement(AbstractVariable decl)	Creates a path start.

Uses of AbstractVariable in net.ssehub.easy.varModel.cst

Fields in net.ssehub.easy.varModel.cst declared as AbstractVariable

Modifier and Type	Field	Description
private AbstractVariable	Variable.nestedVariable
private AbstractVariable	CompoundAccess.slot
private AbstractVariable[]	CompoundInitializer.slotDecls

Fields in net.ssehub.easy.varModel.cst with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.Map<AbstractVariable,AbstractVariable>	CopyVisitor.mapping
private java.util.Map<AbstractVariable,AbstractVariable>	CopyVisitor.mapping
private java.util.Map<AbstractVariable,AbstractVariable>	ConstraintReplacer.varMapping
private java.util.Map<AbstractVariable,AbstractVariable>	ConstraintReplacer.varMapping

Methods in net.ssehub.easy.varModel.cst that return AbstractVariable

Modifier and Type	Method	Description
AbstractVariable	CompoundAccess.getResolvedSlot()	Returns the resolved compound slot.
AbstractVariable	CompoundInitializer.getSlotDeclaration(int index)	Returns the declaration of the specified slot.
AbstractVariable	Variable.getVariable()	Getter for the nestedVariable.
private AbstractVariable	ConstraintReplacer.map(AbstractVariable var)	Maps an abstract variable for proper copying.
protected AbstractVariable	BasicCopyVisitor.mapVariable(AbstractVariable var)	Maps a variable.
protected AbstractVariable	CopyVisitor.mapVariable(AbstractVariable var)

Methods in net.ssehub.easy.varModel.cst that return types with arguments of type AbstractVariable

Modifier and Type	Method	Description
protected java.util.Map<AbstractVariable,AbstractVariable>	CopyVisitor.getMapping()	Returns the specified variable mapping.
protected java.util.Map<AbstractVariable,AbstractVariable>	CopyVisitor.getMapping()	Returns the specified variable mapping.

Methods in net.ssehub.easy.varModel.cst with parameters of type AbstractVariable

Modifier and Type	Method	Description
static java.lang.Integer	VariablePool.keyObject(AbstractVariable decl)	Returns the key object for hashes, also for tests.
boolean	VariablePool.knowsVariable(AbstractVariable decl)	Returns whether this pool knows a certain variable.
private AbstractVariable	ConstraintReplacer.map(AbstractVariable var)	Maps an abstract variable for proper copying.
protected AbstractVariable	BasicCopyVisitor.mapVariable(AbstractVariable var)	Maps a variable.
protected AbstractVariable	CopyVisitor.mapVariable(AbstractVariable var)
Variable	VariablePool.obtainVariable(AbstractVariable decl)	Returns a Variable for the given AbstractVariable.

Constructors in net.ssehub.easy.varModel.cst with parameters of type AbstractVariable

Constructor	Description
CompoundInitializer(Compound type, java.lang.String[] slots, AbstractVariable[] slotDecls, ConstraintSyntaxTree[] expressions)	Creates a new compound initializer.
Variable(AbstractVariable nestedVariable)	The constructor for this class.

Constructor parameters in net.ssehub.easy.varModel.cst with type arguments of type AbstractVariable

Constructor	Description
CopyVisitor(java.util.Map<AbstractVariable,AbstractVariable> mapping)	Creates a copy visitor with explicit mapping.
CopyVisitor(java.util.Map<AbstractVariable,AbstractVariable> mapping)	Creates a copy visitor with explicit mapping.

Uses of AbstractVariable in net.ssehub.easy.varModel.cstEvaluation

Subclasses of AbstractVariable in net.ssehub.easy.varModel.cstEvaluation

Modifier and Type	Class	Description
(package private) class	CollectionElementVariable	A temporary variable representing a value of a container.

Fields in net.ssehub.easy.varModel.cstEvaluation declared as AbstractVariable

Modifier and Type	Field	Description
private AbstractVariable	CollectionElementVariable.base

Fields in net.ssehub.easy.varModel.cstEvaluation with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.List<AbstractVariable>	EvaluationUtils.VariableReplacer.decls
private java.util.Map<AbstractVariable,IDecisionVariable>	LocalConfiguration.map
private java.util.Set<AbstractVariable>	StaticAccessFinder.result
private java.util.Map<AbstractVariable,IDecisionVariable>	EvaluationVisitor.varMapping

Methods in net.ssehub.easy.varModel.cstEvaluation that return AbstractVariable

Modifier and Type	Method	Description
AbstractVariable	CollectionElementVariable.getBaseVariable()
AbstractVariable	LocalDecisionVariable.getDeclaration()
AbstractVariable	EvaluationVisitor.Message.getVariable()	Getter for the variable declaration.

Methods in net.ssehub.easy.varModel.cstEvaluation that return types with arguments of type AbstractVariable

Modifier and Type	Method	Description
java.util.Iterator<AbstractVariable>	StaticAccessFinder.getResults()	Returns the static accesses found.
(package private) static java.util.Map<IDatatype,java.util.List<AbstractVariable>>	EvaluationUtils.groupQuantors(java.util.Iterator<AbstractVariable> staticIter)	Turns the statically accessed variables into groups of variables belonging to the same compound.

Methods in net.ssehub.easy.varModel.cstEvaluation with parameters of type AbstractVariable

Modifier and Type	Method	Description
(package private) void	EvaluationVisitor.addMapping(AbstractVariable decl, IDecisionVariable var)	Adds an explicit mapping of a declaration to a decision variable taking precedence over the configuration.
VariableAccessor	VariableAccessor.bind(AbstractVariable variable, EvaluationContext context)	Binds the accessor to the given variable and context.
(package private) static IDecisionVariable	EvaluationUtils.findAttribute(IDecisionVariable var, AbstractVariable decl, boolean byName)	Finds an attribute decision variable for the given decision variable and attribute declaration.
IDecisionVariable	EvaluationVisitor.EvaluationContextImpl.getDecision(AbstractVariable variable)
IDecisionVariable	LocalConfiguration.getDecision(AbstractVariable declaration)
(package private) static Compound	EvaluationUtils.getDeclaringCompound(AbstractVariable decl)	Returns the declaring compound type.
void	IResolutionListener.notifyResolved(AbstractVariable declaration, IDecisionVariable resolved)	Is called to notify about the resolution of the declaration decl to the actual variable var.
(package private) void	EvaluationVisitor.removeMapping(AbstractVariable decl)	Removes an explicit mapping of a declaration to a decision variable as counterpart for EvaluationVisitor.addMessage(Message).

Method parameters in net.ssehub.easy.varModel.cstEvaluation with type arguments of type AbstractVariable

Modifier and Type	Method	Description
private ConstraintSyntaxTree	EvaluationVisitor.bindFreeVarsByQuantors(ConstraintSyntaxTree cst, java.util.Map<IDatatype,java.util.List<AbstractVariable>> quantorGroups)	Binds the free variables by one quantor per quantor group.
(package private) static java.util.Map<IDatatype,java.util.List<AbstractVariable>>	EvaluationUtils.groupQuantors(java.util.Iterator<AbstractVariable> staticIter)	Turns the statically accessed variables into groups of variables belonging to the same compound.

Constructors in net.ssehub.easy.varModel.cstEvaluation with parameters of type AbstractVariable

Constructor	Description
CollectionElementVariable(AbstractVariable base, IDatatype type, IResolutionPathElement path, int index)	Creates a collection element variable.

Constructor parameters in net.ssehub.easy.varModel.cstEvaluation with type arguments of type AbstractVariable

Constructor	Description
VariableReplacer(DecisionVariableDeclaration iter, java.util.List<AbstractVariable> decls)	Creates a variable replacer.

Uses of AbstractVariable in net.ssehub.easy.varModel.model

Subclasses of AbstractVariable in net.ssehub.easy.varModel.model

Modifier and Type	Class	Description
class	Attribute	Defines an attribute.
class	ConstantDecisionVariableDeclaration	Defines a constant decision variable declaration.
class	DecisionVariableDeclaration	Implements a decision variable.
class	DotAttribute	Special form of attribute specified by ".".
class	ExplicitTypeVariableDeclaration	Represents an explicitly typed declarator in a set operation.
class	ProjectDecisionVariableDeclaration	Facilitates attribute propagation to parent project.

Fields in net.ssehub.easy.varModel.model declared as AbstractVariable

Modifier and Type	Field	Description
private AbstractVariable	CompoundAccessStatement.compoundVariable

Methods in net.ssehub.easy.varModel.model that return AbstractVariable

Modifier and Type	Method	Description
private static AbstractVariable	ModelQuery.findVariable(Compound compound, java.lang.String name)	Searches for a variable of name in a given compound.
static AbstractVariable	ModelQuery.findVariable(IResolutionScope elements, java.lang.String name, java.lang.Class<? extends AbstractVariable> type)	Searches for a specified variable.
private static AbstractVariable	ModelQuery.getAttribute(IAttributableElement element, java.lang.String name)	Finds an attribute with name on element.
AbstractVariable	CompoundAccessStatement.getCompoundVariable()	Returns the underlying compound variable.
AbstractVariable	CompoundAccessStatement.getSlotDeclaration()	Returns the slot declaration.

Methods in net.ssehub.easy.varModel.model with parameters of type AbstractVariable

Modifier and Type	Method	Description
boolean	AbstractVariable.isSame(AbstractVariable var)	Returns whether two variables are considered as being the same (same name/type).

Method parameters in net.ssehub.easy.varModel.model with type arguments of type AbstractVariable

Modifier and Type	Method	Description
static AbstractVariable	ModelQuery.findVariable(IResolutionScope elements, java.lang.String name, java.lang.Class<? extends AbstractVariable> type)	Searches for a specified variable.

Constructors in net.ssehub.easy.varModel.model with parameters of type AbstractVariable

Constructor	Description
CompoundAccessStatement(AbstractVariable compoundVariable, java.lang.String slotName, IModelElement parent)	Creates a compound access statement.

Uses of AbstractVariable in net.ssehub.easy.varModel.model.filter

Fields in net.ssehub.easy.varModel.model.filter with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.List<AbstractVariable>	DeclarationFinder.allDeclarations
private java.util.Set<AbstractVariable>	DeclrationInConstraintFinder.declarations
private java.util.List<AbstractVariable>	DeclarationFinder.hiddenDeclarations
private java.util.Stack<java.util.Set<AbstractVariable>>	DeclarationFinder.interfaces
private java.util.List<AbstractVariable>	DeclarationFinder.visibleDeclarations

Methods in net.ssehub.easy.varModel.model.filter that return types with arguments of type AbstractVariable

Modifier and Type	Method	Description
static java.util.List<AbstractVariable>	ReferenceValuesFinder.findPossibleValues(Project project, IDatatype type)	Searches inside the whole Project for AbstractVariables, which are of the specified type.
static java.util.List<AbstractVariable>	ReferenceValuesFinder.findPossibleValues(Project project, Reference refType)	Searches inside the whole Project for AbstractVariables, which can be referenced by IDecisionVariables of the given Reference type.
java.util.Set<AbstractVariable>	DeclrationInConstraintFinder.getDeclarations()	Returns all AbstractVariable's inside the given ConstraintSyntaxTree.
java.util.List<AbstractVariable>	DeclarationFinder.getVariableDeclarations(DeclarationFinder.VisibilityType type)	Getter for returning all DecisionVariableDeclarations of a Project.

Methods in net.ssehub.easy.varModel.model.filter with parameters of type AbstractVariable

Modifier and Type	Method	Description
private void	DeclarationFinder.addDeclaration(AbstractVariable decl)	Adds a visited AbstractVariable to the correct list of found declarations, depending on whether the variable is visible (no interface or exported by an interface) or is hidden.
protected void	AbstractStateVariablesInConstraintFinder.addVariable(AbstractVariable declaration)	Adds the related IDecisionVariable and their state to the result.
protected abstract void	AbstractVariableInConstraintFinder.addVariable(AbstractVariable declaration)	Handle a discovered declaration.
protected void	DeclrationInConstraintFinder.addVariable(AbstractVariable declaration)
protected void	IDecisionVariableInConstraintFinder.addVariable(AbstractVariable declaration)
private boolean	DeclarationFinder.isVisible(AbstractVariable decl)	Checks whether a given variables is hidden by an interface or visible.

Uses of AbstractVariable in net.ssehub.easy.varModel.model.filter.mandatoryVars

Fields in net.ssehub.easy.varModel.model.filter.mandatoryVars with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.Map<IDatatype,java.util.List<AbstractVariable>>	MandatoryDeclarationClassifier.declarationsByType

Methods in net.ssehub.easy.varModel.model.filter.mandatoryVars that return types with arguments of type AbstractVariable

Modifier and Type	Method	Description
private java.util.List<AbstractVariable>	MandatoryDeclarationClassifier.getDeclarationsByType(IDatatype type)	Find all declarations for the given IDatatype, also not top level declarations.

Methods in net.ssehub.easy.varModel.model.filter.mandatoryVars with parameters of type AbstractVariable

Modifier and Type	Method	Description
private java.lang.String	MandatoryDeclarationClassifier.getSlotOfCompound(AbstractVariable slotDeclaration)	Retrieves the instance for the given declaration for the compound which was visited before.
private boolean	VariableContainer.hasMandatoryTypeOrParent(AbstractVariable declaration)	Checks whether the given declaration is mandatory because of its type, or while the parent specifies that all nested elements shall be mandatory.
boolean	VariableContainer.isMandatory(AbstractVariable declaration)	Checks whether the given AbstractVariable is mandatory.
private void	MandatoryDeclarationClassifier.setImportanceForAllInstancesOfDeclaration(AbstractVariable decl, Importance importance)	Changes the VariableImportance for all instances of the given AbstractVariable.

Uses of AbstractVariable in net.ssehub.easy.varModel.model.rewrite

Fields in net.ssehub.easy.varModel.model.rewrite with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.Map<AbstractVariable,java.util.Set<ContainableModelElement>>	VariableLookUpTable.constraintReusers	List model elements, reusing a constraint variable (declaration).
private java.util.Map<AbstractVariable,AbstractVariable>	ProjectCopyVisitor.copiedDeclarations	Sub set of ProjectCopyVisitor.copiedElements with (oldDeclaration, copiedDeclaration).
private java.util.Map<AbstractVariable,AbstractVariable>	ProjectCopyVisitor.copiedDeclarations	Sub set of ProjectCopyVisitor.copiedElements with (oldDeclaration, copiedDeclaration).
private java.util.Set<AbstractVariable>	VariableLookUpTable.definedDeclarations	List model elements, calling a constraint variable (declaration).
private java.util.Map<AbstractVariable,java.util.Set<IDecisionVariable>>	VariableLookUpTable.instancesPerDeclaration	List of instances for a given declaration.
private java.util.Set<AbstractVariable>	UncopiedElementsContainer.unresolvedDeclarations	AbstractVariables which could not be translated due to a missing data type.

Methods in net.ssehub.easy.varModel.model.rewrite that return AbstractVariable

Modifier and Type	Method	Description
private AbstractVariable	CSTCopyVisitor.mapAnnotation(Attribute var)	Part of CSTCopyVisitor.mapVariable(AbstractVariable) to map Attributes.
protected AbstractVariable	CSTCopyVisitor.mapVariable(AbstractVariable var)

Methods in net.ssehub.easy.varModel.model.rewrite that return types with arguments of type AbstractVariable

Modifier and Type	Method	Description
(package private) java.util.Map<AbstractVariable,AbstractVariable>	ProjectCopyVisitor.getDeclarationMapping()	Returns the currently copied declarations, must not be modified from out side.
(package private) java.util.Map<AbstractVariable,AbstractVariable>	ProjectCopyVisitor.getDeclarationMapping()	Returns the currently copied declarations, must not be modified from out side.
(package private) java.util.Set<AbstractVariable>	UncopiedElementsContainer.getDeclarationsWithMissingTypes()	Returns the set of original declarations, which could not be translated due to missing CustomDatatypes.

Methods in net.ssehub.easy.varModel.model.rewrite with parameters of type AbstractVariable

Modifier and Type	Method	Description
(package private) void	UncopiedElementsContainer.addUnresolvedDeclarationType(AbstractVariable declWithUnresolvedType)	Adds an AbstractVariable, which could not be translated so far (due to missing type).
private void	ProjectCopyVisitor.copyDefaultValue(AbstractVariable decl, AbstractVariable copiedDecl)	Copies the default value from the original declaration to the copied declaration.
(package private) boolean	RewriteContext.declarationKnown(AbstractVariable declaration)	Checks whether the declaration is known or whether the declaration is a local declaration used as an iterator of a constraint.
(package private) boolean	VariableLookUpTable.declarationKnown(AbstractVariable declaration)	Checks whether the declaration is known or whether the declaration is a local declaration used as an iterator of a constraint.
java.util.Set<IDecisionVariable>	RewriteContext.getInstancesForDeclaration(Configuration config, AbstractVariable declaration)	Returns the set of instances of the given AbstractVariable declaration.
(package private) java.util.Set<IDecisionVariable>	VariableLookUpTable.getInstancesForDeclaration(AbstractVariable declaration)	Returns the set of instances of the given AbstractVariable declaration.
protected AbstractVariable	CSTCopyVisitor.mapVariable(AbstractVariable var)
(package private) void	VariableLookUpTable.putConstraintOccurrence(AbstractVariable constraintDecl, ContainableModelElement referringElement)	Stores that the given constraint declaration was used inside the referring element.

Constructor parameters in net.ssehub.easy.varModel.model.rewrite with type arguments of type AbstractVariable

Constructor	Description
CSTCopyVisitor(java.util.Map<AbstractVariable,AbstractVariable> mapping, ProjectCopyVisitor copyier)	Creates a copy visitor with explicit mapping.
CSTCopyVisitor(java.util.Map<AbstractVariable,AbstractVariable> mapping, ProjectCopyVisitor copyier)	Creates a copy visitor with explicit mapping.

Uses of AbstractVariable in net.ssehub.easy.varModel.model.rewrite.modifier

Methods in net.ssehub.easy.varModel.model.rewrite.modifier with parameters of type AbstractVariable

Modifier and Type	Method	Description
protected boolean	AbstractFrozenChecker.allInstancesAreFrozen(AbstractVariable declaration, RewriteContext context)	Checks whether all instances of the given declaration are already frozen.
protected IDecisionVariable	AbstractFrozenChecker.getVariable(AbstractVariable declaration)	Returns the specified IDecisionVariable.

Uses of AbstractVariable in net.ssehub.easy.varModel.model.values

Fields in net.ssehub.easy.varModel.model.values declared as AbstractVariable

Modifier and Type	Field	Description
private AbstractVariable	ReferenceValue.value

Methods in net.ssehub.easy.varModel.model.values that return AbstractVariable

Modifier and Type	Method	Description
AbstractVariable	ReferenceValue.getValue()

Uses of AbstractVariable in net.ssehub.easy.varModel.persistency

Fields in net.ssehub.easy.varModel.persistency with type parameters of type AbstractVariable

Modifier and Type	Field	Description
private java.util.Map<java.lang.String,AbstractVariable>	VariableUsage.mapping

Methods in net.ssehub.easy.varModel.persistency with parameters of type AbstractVariable

Modifier and Type	Method	Description
private int	VariableUsage.getImportPos(AbstractVariable variable)	Returns a pseudo position index for variable according to its import position.
private boolean	IVMLWriter.needsQualification(AbstractVariable var)	Determines whether (on-demand) qualification of the given var is needed, i.e., whether its qualified name shall be printed out.
boolean	VariableUsage.needsQualification(AbstractVariable var)	Returns whether var needs qualification.
private boolean	IVMLWriter.needsQualificationThroughContext(java.lang.Object context, java.lang.String name, AbstractVariable var, boolean exclude)	Returns whether the variable name name of var needs qualification within its context context.

Uses of AbstractVariable in net.ssehub.easy.varModel.validation

Methods in net.ssehub.easy.varModel.validation with parameters of type AbstractVariable

Modifier and Type	Method	Description
private void	IvmlValidationVisitor.checkDeclaration(AbstractVariable decl)	Check whether the IDatatype of an AbstractVariable is part of the Project.