Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## edu.udo.cs.miningmart.m4
Interface Step

All Superinterfaces:
  GraphicalM4Object, M4Data, M4Object

All Known Implementing Classes:
  Step

    public interface Step

extends GraphicalM4Object

Version:
  $Id: Step.java,v 1.20 2006/09/27 14:59:57 euler Exp $
Author:
  Timm Euler, Daniel Hakenjos

Method Summary
`boolean` | `adaptOutputToChangedInput()` Ensures that the output of this step reflects the current state of the input parameters.
`void` | `addDatabaseObjectToTrash(java.lang.String objectName, java.lang.String schemaName, java.lang.String objectType)` Helper method to store the information about a database object in the trash index
`void` | `addParameterTuple(Parameter par)` Adds a parameter to this step's parameter list on tuple level.
`void` | `addPredecessor(Step step)`
`void` | `addReversingStep(Step reversingStep)` The given step is linked as reversing step to this one.
`void` | `addSuccessor(Step step)` This method should only be called from the method `Case.addStepDependency(Step, Step)`!
`void` | `addToTrash(M4Data m4data)` This method should only be called by the compiler after a new M4 object has been created by calling a constructor.
`boolean` | `belongsToChainOrSubChain(Chain theChain)` This method returns TRUE if this Step belongs to the given Chain, or to a direct or indirect subchain of the given Chain.
`java.lang.String` | `checkFeatureRemoval(Concept theInputConcept, Feature theFeature)` This method checks if any problems with the validity of this step would occur if the given feature were removed from the given input concept of this step.
`boolean` | `checkInputParameterEntries()` This method checks, for the current set of values of input parameters in this step, whether they fulfill all parameter contraints.
`boolean` | `checkOutputParameterEntries()` This method checks, for the current set of values of output parameters in this step, whether they fulfill all parameter contraints.
`Step` | `copy(Case newCase, Chain newChain)`
`void` | `createOutput(OpParam theOpParam, java.util.Collection theNames)` This method must only be called if no output objects existed for this Step before!
`Parameter` | `createParameterTuple(java.lang.String name, ParameterObject object, long number, int loopNumber, java.lang.String type)` Creates a Parameter that will be connected to this Step.
`boolean` | `createsConceptualOutput()` Some steps, like those using evaluation operators, do not produce any output concept or attribute.
`Parameter` | `createValueParameterTuple(java.lang.String value, java.lang.String datatype, java.lang.String name, long number, int loopNumber, java.lang.String type)` Creates a Parameter and a Value that will be connected to this Step.
`void` | `deleteDbTrash()` This method takes care of deleting trash objects from the business data schema.
`void` | `deleteM4Trash()` This method realizes the M4Compiler's garbage collection on the objects created during compilation of this `Step`.
`boolean` | `dependencyExists(Chain toChain)` Checks if this step has a successor among any of the steps in the given chain, including steps in any direct or indirect subchain of the given chain.
`java.util.Collection` | `getAllInputConcepts()` This method returns all concepts that are input concept to this step's operator, even those that are attached to an input relation but not modelled by an input parameter.
`java.util.Collection` | `getAllInputRelations()` Returns all relations that are a parameter object of an input parameter of this Step.
`java.util.Collection` | `getAllPredecessors()`
`long` | `getCaseId()` Getter method.
`java.util.Collection` | `getCorrespondingOutputFeatures(Concept theInputConcept, Feature theFeature)` This method finds all features in the output concept of this step that correspond to the given feature in the given input concept of this step.
`java.util.Collection` | `getCrossReferences()`
`java.util.Collection` | `getDependentReversingSteps()` This method returns all steps that have been created automatically to reverse the attribute creation done by this step's operator.
`java.util.Collection` | `getInputConceptsThatAreParameters()` This method returns all concepts that are input concept to this step's operator.
`BaseAttribute[][]` | `getKeysOfRelationshipAssertion()` This method checks if this Step creates a relationship from or to its output concept.
`int` | `getLoopCount()` Getter method.
`java.util.Collection` | `getM4Trash()` Active getter for the compiler's M4 Trash information.
`int` | `getMaximumNumberOfStepsSinceLastMaterialisation()` Returns the greatest number of steps between this step and the last of its predecessors that materialises its output.
`java.lang.String` | `getMultiStepCondition()` Getter method.
`long` | `getNumber()` Getter method.
`java.util.Collection` | `getOpParamsToSelectFeatureParamObjectsFrom(OpParam opParam)` Whenever an input of type BaseAttribute or MultiColumnFeature is expected the possible Concepts the Features may come from are explicitly given by constraints.
`Concept` | `getOutputConcept()` Returns the output concept of this step, if it exists, and NULL otherwise.
`java.util.Collection` | `getParameter(OpParam theOpParam, int loopNr)` Returns the instance of the given `OpParam` that is currently set in this Step.
`ParamDict` | `getParameterDictionary(boolean expectingAllParamsToExist)` Returns the parameter dictionary of the step.
`Parameter` | `getParameterTuple(java.lang.String name, int loopNr)` Return the parameter (tuple) of this step with the given name and loop number.
`java.util.Collection` | `getParameterTuples()` Active getter for the parameters of this `Step` in tuple-wise form (not aggregated by `OpParam` arrays!).
`java.util.Collection` | `getPossibleConceptsForParam(OpParam opParam)` This method returns a Collection of Concepts from which the feature denoted by the given OpParam must be selected.
`java.util.Collection` | `getPossibleInputConcepts()` This method finds all Concepts that are either of type DB or are created as an output concept by a Step that precedes this Step in the chain.
`java.util.Collection` | `getResultingDataModel()` Returns a collection of concepts; these concepts represent the data model that the current Case produced up to this Step.
`Step` | `getReversedStep()` Returns the step whose feature construction is reversed by this step, or null if no such step exists.
`ParameterObject` | `getSingleParameterObject(java.lang.String parameterName)` Returns the parameter object of the first parameter tuple with the given name and loop number 0.
`java.util.Collection` | `getSuccessors()` Active getter for this `Step`'s successors.
`Case` | `getTheCase()` Getter method.
`Chain` | `getTheChain()` Getter method.
`Operator` | `getTheOperator()` Active getter method.
`void` | `handleOldInput()` To be called after changing the input of this step; ensures that old output attributes are removed from a replaced input concept.
`boolean` | `hasOnlyInputConceptsOfTypeDB()` Returns true iff all input concepts of this step are of type DB.
`boolean` | `hasPredecessorOutsideChain()` This method returns TRUE if this Step has a direct predecessor that does not belong to the same chain, nor one of its subchains.
`boolean` | `hasSuccessorOutsideChain()` This method returns TRUE if this Step has a direct successor that does not belong to the same chain, nor one of its subchains.
`boolean` | `inputChangeCanAffectOutput(OpParam theOpParam)` Returns TRUE iff a change to the given input OpParam can have any effect on the output parameters of this Step.
`boolean` | `isAttribToTakeFromFromConcept(OpParam theAttribOpParam, OpParam theRelationOpParam)` Returns TRUE iff there is a constraint indicating that the feature parameter indicated by theAttribOpParam is to be taken from the FromConcept of the relation given by theRelationOpParam.
`boolean` | `isAttribToTakeFromToConcept(OpParam theAttribOpParam, OpParam theRelationOpParam)` Returns TRUE iff there is a constraint indicating that the feature parameter indicated by theAttribOpParam is to be taken from the ToConcept of the relation given by theRelationOpParam.
`boolean` | `isCompiled()` After a `Step` has been successfully compiled a flag in the M4 database is set, which is removed by the next garbage collection.
`boolean` | `isContainedInInputConcept(OpParam outputFeature)` This method must only be called for an output feature.
`boolean` | `isLastStepProducingConceptualOutput()` Returns TRUE iff this step has no successors or if it has only successors that do not produce conceptual output.
`boolean` | `isRelationallyValid()`
`boolean` | `isSuccessorOf(Step previousStep)` Returns TRUE if this Step is a direct or indirect successor of the given Step, according to the step transitions (step dependencies).
`boolean` | `isVisible(Feature theFeature)` This method returns TRUE iff the given Feature may be displayed in the input concept, or in a list of Features to choose from for a parameter.
`boolean` | `materialisesOutput()` Returns true iff this step's operator creates a columnset for the output concept that represents a table, not a view.
`void` | `propagateOutputChanges()` This method should be called after changing some outputs of this Step.
`void` | `removeAllParameterTuples()`
`void` | `removeParameter(java.lang.String parName)`
`boolean` | `removeParameterTuple(Parameter par)` Removes a parameter from this step's parameter list on tuple level.
`void` | `removePredecessor()` Removes the link to the specified Predecessor.
`boolean` | `removeSuccessor(Step step)` Removes a `Step` from this `Step`'s `Collection` of dependent `Step`s.
`boolean` | `removeSuccessor(java.lang.String name)` Removes a `Step` from this `Step`'s `Collection` of dependent `Step`s.
`void` | `renameOutput(OpParam theOpParam, java.util.Collection theNames)` This method changes the names of the output parameter objects; the latter are assumed to exist.
`void` | `setCompiled()` This method may only be called by the control structure!
`void` | `setLoopCount(int lc)` Setter method.
`void` | `setMultiStepCondition(java.lang.String msc)` Setter method.
`void` | `setNumber(long nr)` Setter method.
`java.util.Map` | `setParameter(OpParam theOpParam, java.util.Collection theParameterObjects, int loopNr)` Sets the parameter specified by the given `OpParam`.
`void` | `setTheCase(Case myCase)` Setter method.
`void` | `setTheChain(Chain chain)` Setter method.
`void` | `setTheOperator(Operator theOp)` Setter method.
`void` | `updateOutput(OpParam theOpParam)` This method must only be called if any input parameter of this Step was changed.
`boolean` | `usesAggregation()` Returns true iff this step aggregates rows of its input concept
`boolean` | `usesLoopsForCoordination()` This method returns TRUE if the coordinated parameters in this step (ab)use the loop mechanism for their coordination.

Methods inherited from interface edu.udo.cs.miningmart.m4.GraphicalM4Object
`getPoint, setPoint`

Methods inherited from interface edu.udo.cs.miningmart.m4.M4Data
`deleteSoon, getDocumentation, getValidName, isDirty, isWaitingForDelete, setDocumentation`

Methods inherited from interface edu.udo.cs.miningmart.m4.M4Object
`doPrint, doPrint, equals, executeBusinessSingleValueSqlRead, executeBusinessSingleValueSqlReadL, executeBusinessSqlRead, executeBusinessSqlWrite, executeM4SingleValueSqlRead, executeM4SingleValueSqlReadL, executeM4SqlRead, executeM4SqlWrite, getCasePrintObject, getId, getM4Db, getM4ObjectFromCache, getName, getNextM4SequenceValue, isNew, load, print, putM4ObjectToCache, replaceSpacesInName, setId, setName, setNotNew`

Method Detail

### getTheOperator

    Operator getTheOperator()

  Active getter method.

  Returns:
    the M4 operator object related to this `Step`

### setTheOperator

    void setTheOperator(Operator theOp)

  Setter method. There is no back-reference from `Operator`, so we do not need another primitive setter.

  Parameters:
    `theOp` - The new operator

### getTheChain

    Chain getTheChain()

  Getter method.

  Returns:
    the `Chain` of this `Step`

### setTheChain

    void setTheChain(Chain chain)
                     throws M4Exception

  Setter method.

  Parameters:
    `chain` - The new chain
  Throws:
    `M4Exception`

### getCaseId

    long getCaseId()

  Getter method.

  Returns:
    the id

### getNumber

    long getNumber()

  Getter method.

  Returns:
    the number

### setTheCase

    void setTheCase(Case myCase)
                    throws M4Exception

  Setter method.

  Parameters:
    `myCase` - The new case
  Throws:
    `M4Exception`

### setNumber

    void setNumber(long nr)

  Setter method.

  Parameters:
    `nr` - the new step number

### getLoopCount

    int getLoopCount()

  Getter method.

  Returns:
    the loop count

### getMultiStepCondition

    java.lang.String getMultiStepCondition()

  Getter method.

  Returns:
    the multistep condition

### addParameterTuple

    void addParameterTuple(Parameter par)
                           throws M4Exception

  Adds a parameter to this step's parameter list on tuple level.

  Parameters:
    `par` - the `Parameter` object representing the parameter tuple
  Throws:
    `M4Exception`

### removeParameterTuple

    boolean removeParameterTuple(Parameter par)
                                 throws M4Exception

  Removes a parameter from this step's parameter list on tuple level.

  Parameters:
    `par` - the `Parameter` object representing the parameter tuple
  Returns:
    `true` iff the object was part of the parameter list and could be removed
  Throws:
    `M4Exception`

### removeAllParameterTuples

    void removeAllParameterTuples()
                                  throws M4Exception

  Throws:
    `M4Exception`

### removeParameter

    void removeParameter(java.lang.String parName)
                         throws M4Exception

  Throws:
    `M4Exception`

### dependencyExists

    boolean dependencyExists(Chain toChain)
                             throws M4Exception

  Checks if this step has a successor among any of the steps in the given chain, including steps in any direct or indirect subchain of the given chain.

  Parameters:
    `toChain` - the given chain
  Returns:
    TRUE iff this step has a successor among any of the steps in the given chain.
  Throws:
    `M4Exception`

### setLoopCount

    void setLoopCount(int lc)
                      throws M4Exception

  Setter method.

  Parameters:
    `lc` - the new loop count
  Throws:
    `M4Exception`

### setMultiStepCondition

    void setMultiStepCondition(java.lang.String msc)

  Setter method.

  Parameters:
    `msc` - The new multistep condition

### getAllInputConcepts

    java.util.Collection getAllInputConcepts()
                                             throws M4Exception

  This method returns all concepts that are input concept to this step's operator, even those that are attached to an input relation but not modelled by an input parameter.

  Throws:
    `M4Exception`

### getInputConceptsThatAreParameters

    java.util.Collection getInputConceptsThatAreParameters()
                                                           throws M4Exception

  This method returns all concepts that are input concept to this step's operator. (For Join and other operators, there can be more than one input concept.) Note that concepts attached to an input relation are not returned!

  Throws:
    `M4Exception`

### getAllInputRelations

    java.util.Collection getAllInputRelations()
                                              throws M4Exception

  Returns all relations that are a parameter object of an input parameter of this Step.

  Returns:
    a collection of relations
  Throws:
    `M4Exception`

### getKeysOfRelationshipAssertion

    BaseAttribute[][] getKeysOfRelationshipAssertion()
                                                     throws M4Exception

  This method checks if this Step creates a relationship from or to its output concept. If no, null is returned. If yes, it checks whether the output concept and its features have been created yet. If yes, it returns the BaseAttributes that form the keys of the relationship in a two-dimensional array.

  Returns:
    a two-dimensional array of the BaseAttributes that are the keys of the relationship created by this Step, or null
  Throws:
    `M4Exception`

### getOutputConcept

    Concept getOutputConcept()
                             throws M4Exception

  Returns the output concept of this step, if it exists, and NULL otherwise.

  Returns:
    a concept or NULL
  Throws:
    `M4Exception`

### getTheCase

    Case getTheCase()

  Getter method.

  Returns:
    this step's case

### getParameterTuples

    java.util.Collection getParameterTuples()
                                            throws M4Exception

  Active getter for the parameters of this `Step` in tuple-wise form (not aggregated by `OpParam` arrays!).

  Returns:
    Returns a Collection of `Parameter` objects
  Throws:
    `M4Exception`

### getSuccessors

    java.util.Collection getSuccessors()
                                       throws M4Exception

  Active getter for this `Step`'s successors.

  Returns:
    `Collection` of dependent `Step` objects
  Throws:
    `M4Exception`

### addSuccessor

    void addSuccessor(Step step)
                      throws M4Exception

  This method should only be called from the method `Case.addStepDependency(Step, Step)`! Please use that method instead of this one, because it also efficiently reorders the steps! Adds a `Step` to this `Step`'s `Collection` of dependent `Step`s.

  Parameters:
    `step` - the `Step` to add
  Throws:
    `M4Exception`

### removeSuccessor

    boolean removeSuccessor(Step step)
                            throws M4Exception

  Removes a `Step` from this `Step`'s `Collection` of dependent `Step`s.

  Parameters:
    `step` - the `Step` to remove
  Returns:
    `true` iff the `Step` was found in the `Collection` and could be successfully removed
  Throws:
    `M4Exception`

### removeSuccessor

    boolean removeSuccessor(java.lang.String name)
                            throws M4Exception

  Removes a `Step` from this `Step`'s `Collection` of dependent `Step`s.

  Parameters:
    `name` - the name of the step to remove
  Returns:
    `true` iff the `Step` was found in the `Collection` and could be successfully removed
  Throws:
    `M4Exception`

### getParameterDictionary

    ParamDict getParameterDictionary(boolean expectingAllParamsToExist)
                                     throws M4Exception

  Returns the parameter dictionary of the step. It contains the parameter tuples that are currently known to this steps in aggregated form. A boolean parameter is used to specify whether the calling method expects all parameters of this step (as specified by this step's operator's OpParams) to exist already.

  Parameters:
    `expectingAllParamsToExist` - If true, the caller expects the step to be fully parameterised.
  Returns:
    ParamDict object for the current step
  Throws:
    `M4Exception`

### getCrossReferences

    java.util.Collection getCrossReferences()
                                            throws M4Exception

  Returns:
    a `Collection` of `Step` to `Step` dependencies for sequentializing all `Step`s before writing updates to the database.
  Throws:
    `M4Exception`

### getM4Trash

    java.util.Collection getM4Trash()
                                    throws M4Exception

  Active getter for the compiler's M4 Trash information.

  Returns:
    a `Collection` of `M4Data` objects created by the M4 compiler that have to be removed before this `Step` can be compiled anew.
  Throws:
    `M4Exception`

### addToTrash

    void addToTrash(M4Data m4data)
                    throws M4Exception

  This method should only be called by the compiler after a new M4 object has been created by calling a constructor.

  Parameters:
    `m4data` - the `M4Data` object to be added to the table `M4TRASH_T` for being garbage collected before compiling this `Step` or any of its predecessors.
  Throws:
    `M4Exception`

### deleteM4Trash

    void deleteM4Trash()
                       throws M4Exception

  This method realizes the M4Compiler's garbage collection on the objects created during compilation of this `Step`.

  Throws:
    `M4Exception`

### addDatabaseObjectToTrash

    void addDatabaseObjectToTrash(java.lang.String objectName,
                                  java.lang.String schemaName,
                                  java.lang.String objectType)
                                  throws M4Exception

  Helper method to store the information about a database object in the trash index

  Throws:
    `M4Exception`

### deleteDbTrash

    void deleteDbTrash()
                       throws M4Exception

  This method takes care of deleting trash objects from the business data schema.

  Throws:
    `M4Exception`

### isCompiled

    boolean isCompiled()
                       throws M4Exception

  After a `Step` has been successfully compiled a flag in the M4 database is set, which is removed by the next garbage collection. This method checks, if this flag is set.

  Returns:
    `true` iff this `Step` has been successfully compiled and no garbage collection involving this `Step` has been run afterwards.
  Throws:
    `M4Exception`

### setCompiled

    void setCompiled()
                     throws M4Exception

  This method may only be called by the control structure! It marks this `Step` as successfully compiled. This information is used when it is checked for succeeding `Step`s, if all of the dependent resources are already available.

  Throws:
    `M4Exception`

### isSuccessorOf

    boolean isSuccessorOf(Step previousStep)
                          throws M4Exception

  Returns TRUE if this Step is a direct or indirect successor of the given Step, according to the step transitions (step dependencies).

  Parameters:
    `previousStep` - Possibly a predecessor of this step
  Returns:
    TRUE if this step is a direct or indirect successor of the given step
  Throws:
    `M4Exception`

### usesLoopsForCoordination

    boolean usesLoopsForCoordination()
                                     throws M4Exception

  This method returns TRUE if the coordinated parameters in this step (ab)use the loop mechanism for their coordination.

  Returns:
    TRUE iff parameters of the coordinated parameter groups should be read and set using positive loop numbers.
  Throws:
    `M4Exception`

### usesAggregation

    boolean usesAggregation()
                            throws M4Exception

  Returns true iff this step aggregates rows of its input concept

  Returns:
  Throws:
    `M4Exception`

### materialisesOutput

    boolean materialisesOutput()
                               throws M4Exception

  Returns true iff this step's operator creates a columnset for the output concept that represents a table, not a view.

  Returns:
  Throws:
    `M4Exception`

### hasOnlyInputConceptsOfTypeDB

    boolean hasOnlyInputConceptsOfTypeDB()
                                         throws M4Exception

  Returns true iff all input concepts of this step are of type DB.

  Returns:
  Throws:
    `M4Exception`

### getMaximumNumberOfStepsSinceLastMaterialisation

    int getMaximumNumberOfStepsSinceLastMaterialisation()
                                                        throws M4Exception

  Returns the greatest number of steps between this step and the last of its predecessors that materialises its output. If all direct predecessors materialise their output, or if this step uses only DB Concepts as inputs, 0 is returned. Otherwise the maximum of these results for the predecessors is increased by 1 and returned.

  Throws:
    `M4Exception`

### createsConceptualOutput

    boolean createsConceptualOutput()
                                    throws M4Exception

  Some steps, like those using evaluation operators, do not produce any output concept or attribute. For such steps this method returns FALSE, for all others it returns TRUE.

  Throws:
    `M4Exception`

### isLastStepProducingConceptualOutput

    boolean isLastStepProducingConceptualOutput()
                                                throws M4Exception

  Returns TRUE iff this step has no successors or if it has only successors that do not produce conceptual output.

  Throws:
    `M4Exception`

### isRelationallyValid

    boolean isRelationallyValid()

### copy

    Step copy(Case newCase,
              Chain newChain)
              throws M4Exception

  Throws:
    `M4Exception`

### addPredecessor

    void addPredecessor(Step step)
                        throws M4Exception

  Throws:
    `M4Exception`

### getAllPredecessors

    java.util.Collection getAllPredecessors()
                                            throws M4Exception

  Throws:
    `M4Exception`

### getDependentReversingSteps

    java.util.Collection getDependentReversingSteps()
                                                    throws M4Exception

  This method returns all steps that have been created automatically to reverse the attribute creation done by this step's operator. Such reversing steps are needed for deployment if the target attribute for mining has been changed.

  Returns:
    a collection of steps
  Throws:
    `M4Exception`

### getReversedStep

    Step getReversedStep()
                         throws M4Exception

  Returns the step whose feature construction is reversed by this step, or null if no such step exists.

  Returns:
    a Step
  Throws:
    `M4Exception`

### addReversingStep

    void addReversingStep(Step reversingStep)
                          throws M4Exception

  The given step is linked as reversing step to this one.

  Parameters:
    `reversingStep` -
  Throws:
    `M4Exception`

### getResultingDataModel

    java.util.Collection getResultingDataModel()
                                               throws M4Exception

  Returns a collection of concepts; these concepts represent the data model that the current Case produced up to this Step.

  Returns:
    a collection of concepts
  Throws:
    `M4Exception`

### belongsToChainOrSubChain

    boolean belongsToChainOrSubChain(Chain theChain)
                                     throws M4Exception

  This method returns TRUE if this Step belongs to the given Chain, or to a direct or indirect subchain of the given Chain.

  Parameters:
    `theChain` - the given Chain
  Returns:
    TRUE iff this Step belongs to the given Chain or one of its (direct or indirect) subchains.
  Throws:
    `M4Exception`

### hasPredecessorOutsideChain

    boolean hasPredecessorOutsideChain()
                                       throws M4Exception

  This method returns TRUE if this Step has a direct predecessor that does not belong to the same chain, nor one of its subchains.

  Returns:
    TRUE if a predecessor of this Step exists outside this Step's Chain
  Throws:
    `M4Exception`

### hasSuccessorOutsideChain

    boolean hasSuccessorOutsideChain()
                                     throws M4Exception

  This method returns TRUE if this Step has a direct successor that does not belong to the same chain, nor one of its subchains.

  Returns:
    TRUE if a successor of this Step exists outside this Step's Chain
  Throws:
    `M4Exception`

### getParameterTuple

    Parameter getParameterTuple(java.lang.String name,
                                int loopNr)
                                throws M4Exception

  Return the parameter (tuple) of this step with the given name and loop number.

  Parameters:
    `name` - the Name
    `loopNr` - the loop number as in M4
  Throws:
    `M4Exception`

### getParameter

    java.util.Collection getParameter(OpParam theOpParam,
                                      int loopNr)
                                      throws M4Exception

  Returns the instance of the given `OpParam` that is currently set in this Step. The returned `Collection` contains instances of `ParameterObject`s. For single parameters, only one object is contained in the collection; for array parameters, there can be more; for optional parameters, the collection can be empty.

  Parameters:
    `theOpParam` - an OpParam object specifying the parameter to be returned
    `loopNr` - the loop index for this parameter (ignored for non-loopable parameters)
  Returns:
    a Collection of ParameterObjects
  Throws:
    `M4Exception`

### getSingleParameterObject

    ParameterObject getSingleParameterObject(java.lang.String parameterName)

  Returns the parameter object of the first parameter tuple with the given name and loop number 0. NULL may be returned.

  Parameters:
    `parameterName` - the name of the parameter whose parameter object is to be retrieved
  Returns:
    a ParameterObject

### setParameter

    java.util.Map setParameter(OpParam theOpParam,
                               java.util.Collection theParameterObjects,
                               int loopNr)
                               throws M4Exception

  Sets the parameter specified by the given `OpParam`. Depending on the type of parameter, the given `Collection` can contain exactly one (for a single parameter), or several (for an array parameter), `ParameterObject`s.

  Parameters:
    `theOpParam` - an OpParam object specifying the parameter to be set
    `theParameterObjects` - a Collection of ParameterObjects
    `loopNr` - the loop index for this parameter (ignored for non-loopable parameters)
  Returns:
    a Map that may be null or empty; it maps output feature parameters to the previous names of their parameter objects (so the map is null or empty if the given OpParam is not for output feature parameters, or if no parameter objects existed previously)
  Throws:
    `M4Exception`

### checkInputParameterEntries

    boolean checkInputParameterEntries()
                                       throws M4Exception

  This method checks, for the current set of values of input parameters in this step, whether they fulfill all parameter contraints. If not, an exception is thrown whose message can be used by the GUI as an error message for the user. The user can then correct the corresponding parameter entry, then this method should be called again, until it returns TRUE and does not throw an exception. The method can be called before the output is created, as it will only check the validity of the input parameter values.

  Returns:
    TRUE iff the current set of input parameters is valid for this step, in terms of all constraints holding for the parameters.
  Throws:
    `M4Exception` - An exception carrying a meaningful error message, intended to direct the user to improve the parameter settings.

### checkOutputParameterEntries

    boolean checkOutputParameterEntries()
                                        throws M4Exception

  This method checks, for the current set of values of output parameters in this step, whether they fulfill all parameter contraints. If not, an exception is thrown whose message can be used by the GUI as an error message for the user. The user can then correct the corresponding parameter entry, then this method should be called again, until it returns TRUE and does not throw an exception.

  Returns:
    TRUE iff the current set of output parameters is valid for this step, in terms of all constraints holding for the parameters.
  Throws:
    `M4Exception` - An exception carrying a meaningful error message, intended to direct the user to improve the parameter settings.

### isVisible

    boolean isVisible(Feature theFeature)
                      throws M4Exception

  This method returns TRUE iff the given Feature may be displayed in the input concept, or in a list of Features to choose from for a parameter. If FALSE is returned, it means that the given Feature is constructed by a FeatureConstruction operator in a different branch of the chain of steps, thus the Feature has no meaning for this step.

  Parameters:
    `theFeature` - The feature for which visibility is tested
  Returns:
    TRUE iff the feature can be used in this Step
  Throws:
    `M4Exception`

### checkFeatureRemoval

    java.lang.String checkFeatureRemoval(Concept theInputConcept,
                                         Feature theFeature)
                                         throws M4Exception

  This method checks if any problems with the validity of this step would occur if the given feature were removed from the given input concept of this step. A String describing the problem is returned, or NULL if no problem would occur.

  Parameters:
    `theInputConcept` - input concept in which the feature would be deleted
    `nameOfFeature` -
  Returns:
    a hypothetical error message, or NULL if no error would occur
  Throws:
    `M4Exception`

### getCorrespondingOutputFeatures

    java.util.Collection getCorrespondingOutputFeatures(Concept theInputConcept,
                                                        Feature theFeature)
                                                        throws M4Exception

  This method finds all features in the output concept of this step that correspond to the given feature in the given input concept of this step.

  Parameters:
    `theInputConcept` -
    `theFeature` -
  Returns:
    a collection of features
  Throws:
    `M4Exception`

### createOutput

    void createOutput(OpParam theOpParam,
                      java.util.Collection theNames)
                      throws M4Exception

  This method must only be called if no output objects existed for this Step before! This method creates the output concept or output feature(s) for this step. What is to be created is specified by the given OpParam object. The name(s) for the new object(s) are given in the collection theNames. If there are both output concept AND output feature(s), please call this method FIRST with the concept!

  Parameters:
    `theOpParam` - the OpParam object specifying which output parameter is meant
    `theNames` - a Collection of Strings giving the name(s) for the new object(s)
  Throws:
    `M4Exception`

### renameOutput

    void renameOutput(OpParam theOpParam,
                      java.util.Collection theNames)
                      throws M4Exception

  This method changes the names of the output parameter objects; the latter are assumed to exist. If the input parameters of the step have also changed, call the method `updateOutput` before this one.

  Parameters:
    `theOpParam` - the OpParam object specifying which output parameter is meant
    `theNames` - a Collection of Strings giving the new name(s)
  Throws:
    `M4Exception`

### updateOutput

    void updateOutput(OpParam theOpParam)
                      throws M4Exception

  This method must only be called if any input parameter of this Step was changed. It ensures consistency of the output parameter objects with the input parameter objects. If the name of the output parameter has also changed, call the method `renameOutput` afterwards.

  Parameters:
    `theOpParam` - the OpParam object specifying which output parameter is meant
  Throws:
    `M4Exception`

### propagateOutputChanges

    void propagateOutputChanges()
                                throws M4Exception

  This method should be called after changing some outputs of this Step. It ensures that the following (depending) steps adjust their output, too.

  Throws:
    `M4Exception`

### adaptOutputToChangedInput

    boolean adaptOutputToChangedInput()
                                      throws M4Exception

  Ensures that the output of this step reflects the current state of the input parameters.

  Returns:
    TRUE iff the output has changed at all (on the conceptual level)
  Throws:
    `M4Exception`

### handleOldInput

    void handleOldInput()
                        throws M4Exception

  To be called after changing the input of this step; ensures that old output attributes are removed from a replaced input concept.

  Throws:
    `M4Exception`

### inputChangeCanAffectOutput

    boolean inputChangeCanAffectOutput(OpParam theOpParam)
                                       throws M4Exception

  Returns TRUE iff a change to the given input OpParam can have any effect on the output parameters of this Step. For example, if the NewRangeMin-parameter of a Scaling-Step is changed then the output parameters are not affected. In contrast, if the number of features selected in a manual FeatureSelection step changes, then the output concept must be updated.

  Parameters:
    `theOpParam` - an input OpParam of the operator of this step
  Returns:
    TRUE if the output may have to be updated if the input was updated
  Throws:
    `M4Exception`

### getPossibleConceptsForParam

    java.util.Collection getPossibleConceptsForParam(OpParam opParam)
                                                     throws M4Exception

  This method returns a Collection of Concepts from which the feature denoted by the given OpParam must be selected. NULL is returned if no constraint specifies where to select the feature from. An empty collection is returned when there is such a specifying constraint, but the corresponding concept parameter has not been instantiated yet. For example, a feature given by 'TheTargetAttribute' is usually selected from 'TheInputConcept' but if the latter has not been chosen by the user yet, an empty collection is returned.

  Parameters:
    `opParam` - the `OpParam` parameter referring to an input feature.
  Returns:
    a `Collection` of the `Concept`s this feature is allowed to be selected from (due to an 'IN' constraint).
  Throws:
    `M4Exception`

### getOpParamsToSelectFeatureParamObjectsFrom

    java.util.Collection getOpParamsToSelectFeatureParamObjectsFrom(OpParam opParam)
                                                                    throws M4Exception

  Whenever an input of type BaseAttribute or MultiColumnFeature is expected the possible Concepts the Features may come from are explicitly given by constraints. These constraints refer to the parameter names as used for the OpParam objects. This method returns a Collection of such OpParam names for input Concept parameters, e.g. "TheInputConcept".

  Parameters:
    `opParam` - the `OpParam` parameter referring to an input feature.
  Returns:
    a `Collection` consisting of the `OpParam` names (Strings) of the `Concept`s this feature is allowed to be selected from (due to an 'IN' constraint).
  Throws:
    `M4Exception`

### isAttribToTakeFromFromConcept

    boolean isAttribToTakeFromFromConcept(OpParam theAttribOpParam,
                                          OpParam theRelationOpParam)
                                          throws M4Exception

  Returns TRUE iff there is a constraint indicating that the feature parameter indicated by theAttribOpParam is to be taken from the FromConcept of the relation given by theRelationOpParam.

  Parameters:
    `theAttribOpParam` -
    `theRelationOpParam` -
  Returns:
  Throws:
    `M4Exception`

### isAttribToTakeFromToConcept

    boolean isAttribToTakeFromToConcept(OpParam theAttribOpParam,
                                        OpParam theRelationOpParam)
                                        throws M4Exception

  Returns TRUE iff there is a constraint indicating that the feature parameter indicated by theAttribOpParam is to be taken from the ToConcept of the relation given by theRelationOpParam.

  Parameters:
    `theAttribOpParam` -
    `theRelationOpParam` -
  Returns:
  Throws:
    `M4Exception`

### getPossibleInputConcepts

    java.util.Collection getPossibleInputConcepts()
                                                  throws M4Exception

  This method finds all Concepts that are either of type DB or are created as an output concept by a Step that precedes this Step in the chain.

  Returns:
    a Collection of Concepts
  Throws:
    `M4Exception`

### isContainedInInputConcept

    boolean isContainedInInputConcept(OpParam outputFeature)
                                      throws M4Exception

  This method must only be called for an output feature. It is checked whether the output feature is constrained to be IN the input concept.

  Parameters:
    `outputFeature` - the OpParam representing the output feature
  Returns:
    TRUE iff the outputFeature's name should be selected from the names of the features of the input concept; FALSE if any new name can be given to the outputFeature.
  Throws:
    `M4Exception`

### removePredecessor

    void removePredecessor()
                           throws M4Exception

  Removes the link to the specified Predecessor.

  Throws:
    `M4Exception`

### createParameterTuple

    Parameter createParameterTuple(java.lang.String name,
                                   ParameterObject object,
                                   long number,
                                   int loopNumber,
                                   java.lang.String type)
                                   throws M4Exception

  Creates a Parameter that will be connected to this Step. The name of the Parameter must be unique for this Step.

  Parameters:
    `name` - The name for the new Parameter.
    `object` - The parameter object. It must be a Concept, Relationship , BaseAttribute, MultiColumnFeature or Value
    `number` - the parameter number
    `loopNumber` - the loop number
    `type` - the parameter type. Possible values are Parameter.TYPE_INPUT or Parameter.TYPE_OUTPUT
  Returns:
    The new Parameter object.
  Throws:
    `M4Exception`

### createValueParameterTuple

    Parameter createValueParameterTuple(java.lang.String value,
                                        java.lang.String datatype,
                                        java.lang.String name,
                                        long number,
                                        int loopNumber,
                                        java.lang.String type)
                                        throws M4Exception

  Creates a Parameter and a Value that will be connected to this Step. The name of the Parameter must be unique for this Step. A Value object will be created that will be connected to the created Parameter.

  Parameters:
    `value` - The value for the Value Object.
    `datatype` - The datatype for the value. Use one of the predefined types available for @link DomainDatatype
    `name` - The name for the new Parameter.
    `number` - the parameter number
    `loopNumber` - the loop number
    `type` - the parameter type. Possible values are Parameter.TYPE_INPUT or Parameter.TYPE_OUTPUT
  Returns:
    The new Parameter object.
  Throws:
    `M4Exception`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2001-2005