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 Chain

All Superinterfaces:
  GraphicalM4Object, M4Data, M4Object

All Known Implementing Classes:
  Chain

public interface Chain
extends GraphicalM4Object

Version:
  $Id: Chain.java,v 1.4 2006/04/11 14:10:12 euler Exp $
Author:
  Timm Euler, Daniel Hakenjos

Method Summary
`void` | `addStep(Step step)` Adds a `Step` to this `Chain` and takes care about back-reference integrity.
`void` | `addSubChain(Chain chain)` Adds a `Chain` to this `Chain` and takes care about back-reference integrity.
`Chain` | `copy(Case newCase)` Copies a chain.
`Chain` | `createSubChain(java.lang.String name, java.util.Collection stepsAndChains)` Creates a Chain that subsumes the given steps and chains.
`boolean` | `dependencyExists(Chain toChain)` This method checks if there is a dependency between any of the steps of this chain (including all steps of all direct or indirect subchains), and any of the steps of the given chain (again including all steps of all direct or indirect subchains).
`boolean` | `dependencyExists(Step toStep)` This method checks if there is a dependency between any of the steps of this chain (including all steps of all direct or indirect subchains), and the given step.
`java.util.Collection` | `getAllChains()` Active getter of the chains embedded in this chain.
`java.util.Collection` | `getAllSteps()` Active getter of the steps embedded in this chain.
`java.util.Collection` | `getAllTransitionsToChain(Chain toChain)` This method returns pairs of Steps.
`java.lang.String` | `getDescription()` Gets the description.
`java.util.Collection` | `getDirectSubChains()` Active getter of the chains embedded in this chain.
`java.util.Collection` | `getInvolvedConcepts()` Returns a Collection of the Concepts that are used as input or output in any of the top level steps of this chain.
`Chain` | `getParentChain()` If this chain has a parent chain, that parent chain is returned.
`java.util.Collection` | `getPredecessors(Step toStep)` This method returns all steps in this chain, including steps in subchains etc., that are a direct predecessor of the given Step.
`java.util.Collection` | `getSuccessors(Step fromStep)` This method returns all steps in this chain, including steps in subchains etc., that are a direct successor of the given Step.
`Case` | `getTheCase()` Gets the Case.
`java.util.Collection` | `getTopLevelSteps()` Active getter of the top level steps of this chain.
`java.util.Iterator` | `getTopLevelStepsSequentialised()` Active getter of the steps embedded in this chain.
`boolean` | `hasPredecessorOutside()` This method returns TRUE iff a Step exists in this Chain that is a successor of a Step outside this Chain.
`boolean` | `hasSuccessorOutside()` This method returns TRUE iff a Step exists in this Chain that is a predecessor of a Step outside this Chain.
`boolean` | `removeStep(Step step)` Removes a `Step` from this `Chain` and takes care about back-reference integrity.
`void` | `resolveSubChain(Chain chain)` If the given `Chain` is a direct subchain of this `Chain`, it is resolved, ie its `Step`s and subchains become steps and direct subchains of this chain.
`void` | `setDescription(java.lang.String description)` Sets the description.
`void` | `setParentChain(Chain parentChain)` Sets the parent chain of this chain to the given parentChain.
`void` | `setTheCase(Case m4Case)` Sets a new `Case` object and cares about back-reference integrity.

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`

Method Detail

### getAllSteps

    public java.util.Collection getAllSteps()
                                     throws M4Exception

  Active getter of the steps embedded in this chain. Attention: this method returns ALL steps of ALL subchains (including subchains of subchains, etc.)! To get only the steps that belong to this chain, ie the top level steps, use the method `getTopSteps()`.

  Returns:
    a `Collection` of `Step`s
  Throws:
    `M4Exception`

### getTopLevelSteps

    public java.util.Collection getTopLevelSteps()
                                          throws M4Exception

  Active getter of the top level steps of this chain. Attention: this method returns ONLY the steps of this chain; no step that belongs to subchains is returned. To get all steps, including those of subchains of subchains etc., use the method `getSteps()`.

  Returns:
    a `Collection` of `Step`s
  Throws:
    `M4Exception`

### getTopLevelStepsSequentialised

    public java.util.Iterator getTopLevelStepsSequentialised()
                                                      throws M4Exception

  Active getter of the steps embedded in this chain. Only the steps belonging directly to this chain are returned. Steps of subchains are not included in the returned iterator. The iterator iterates through the Steps in the right sequential order. If there are no top level steps, NULL is returned.

  Returns:
    an `Iterator` through `Step`s, or NULL.
  Throws:
    `M4Exception`

### getInvolvedConcepts

    public java.util.Collection getInvolvedConcepts()
                                             throws M4Exception

  Returns a Collection of the Concepts that are used as input or output in any of the top level steps of this chain. Steps of subchains are not involved.

  Returns:
    a Collection of Concepts
  Throws:
    `M4Exception`

### getPredecessors

    public java.util.Collection getPredecessors(Step toStep)
                                         throws M4Exception

  This method returns all steps in this chain, including steps in subchains etc., that are a direct predecessor of the given Step.

  Parameters:
    `toStep` - the Step whose predecessors are returned
  Returns:
    a Collection of Steps
  Throws:
    `M4Exception`

### hasPredecessorOutside

    public boolean hasPredecessorOutside()
                                  throws M4Exception

  This method returns TRUE iff a Step exists in this Chain that is a successor of a Step outside this Chain.

  Returns:
    TRUE iff this Chain has a predecessor Step outside this Chain.
  Throws:
    `M4Exception`

### hasSuccessorOutside

    public boolean hasSuccessorOutside()
                                throws M4Exception

  This method returns TRUE iff a Step exists in this Chain that is a predecessor of a Step outside this Chain.

  Returns:
    TRUE iff this Chain has a successor Step outside this Chain.
  Throws:
    `M4Exception`

### getSuccessors

    public java.util.Collection getSuccessors(Step fromStep)
                                       throws M4Exception

  This method returns all steps in this chain, including steps in subchains etc., that are a direct successor of the given Step.

  Parameters:
    `fromStep` - the Step whose successors are returned
  Returns:
    a Collection of Steps
  Throws:
    `M4Exception`

### getAllTransitionsToChain

    public java.util.Collection getAllTransitionsToChain(Chain toChain)
                                                  throws M4Exception

  This method returns pairs of Steps. In each pair, the first Step belongs to this Chain, or one of its direct or indirect subchains, and the second to the given Chain or one of its subchains, and there is a direct dependency (transition) between them. This method returns a Collection of Arrays of Steps. Each Array has exactly two elements. The one with index 0 is a Step from this Chain, the one with index 1 is a Step from the given Chain, and a direct dependeny between the Steps exists.

  Parameters:
    `toChain` - the given Chain
  Returns:
    a Collection of two-element Arrays of Steps
  Throws:
    `M4Exception`

### getAllChains

    public java.util.Collection getAllChains()
                                      throws M4Exception

  Active getter of the chains embedded in this chain. Attention: this method returns ALL subchains (including subchains of subchains, etc.)! To get only the direct subchains, use the method `getDirectSubChains()`.

  Returns:
    a `Collection` of `Chain`s
  Throws:
    `M4Exception`

### getDirectSubChains

    public java.util.Collection getDirectSubChains()
                                            throws M4Exception

  Active getter of the chains embedded in this chain. Attention: this method returns ONLY the direct subchains! To get all subchains, including subchains of subchains etc., use the method `getAllChains()`.

  Returns:
    a `Collection` of `Chain`s
  Throws:
    `M4Exception`

### getParentChain

    public Chain getParentChain()
                         throws M4Exception

  If this chain has a parent chain, that parent chain is returned. Otherwise, this method returns NULL.

  Returns:
    the direct parent chain if it exists, or `null` if no parent chain exists.
  Throws:
    `M4Exception`

### dependencyExists

    public boolean dependencyExists(Chain toChain)
                             throws M4Exception

  This method checks if there is a dependency between any of the steps of this chain (including all steps of all direct or indirect subchains), and any of the steps of the given chain (again including all steps of all direct or indirect subchains). Attention: only the direction from this chain to the given chain is tested, not the backwards direction!

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

### dependencyExists

    public boolean dependencyExists(Step toStep)
                             throws M4Exception

  This method checks if there is a dependency between any of the steps of this chain (including all steps of all direct or indirect subchains), and the given step. Attention: only the direction from this chain to the given step is tested, not the backwards direction!

  Parameters:
    `toStep` - the destination step
  Returns:
    TRUE iff any of the steps in this chain is a predecessor of the given step.
  Throws:
    `M4Exception`

### getTheCase

    public Case getTheCase()

  Gets the Case.

  Returns:
    Returns a Case

### getDescription

    public java.lang.String getDescription()

  Gets the description.

  Returns:
    Returns a String

### setTheCase

    public void setTheCase(Case m4Case)
                    throws M4Exception

  Sets a new `Case` object and cares about back-reference integrity.

  Parameters:
    `m4Case` - the `Case` to be set
  Throws:
    `M4Exception`

### setDescription

    public void setDescription(java.lang.String description)

  Sets the description.

  Parameters:
    `description` - The description to set

### addStep

    public void addStep(Step step)
                 throws M4Exception

  Adds a `Step` to this `Chain` and takes care about back-reference integrity. The new step is added to the top level, not to any subchains.

  Parameters:
    `step` - the `Step` to be added
  Throws:
    `M4Exception`

### addSubChain

    public void addSubChain(Chain chain)
                     throws M4Exception

  Adds a `Chain` to this `Chain` and takes care about back-reference integrity. The given Chain will be a direct subchain of this chain.

  Throws:
    `M4Exception`

### resolveSubChain

    public void resolveSubChain(Chain chain)
                         throws M4Exception

  If the given `Chain` is a direct subchain of this `Chain`, it is resolved, ie its `Step`s and subchains become steps and direct subchains of this chain.

  Parameters:
    `chain` - the `Chain` to be resolved
  Throws:
    `M4Exception`

### createSubChain

    public Chain createSubChain(java.lang.String name,
                                java.util.Collection stepsAndChains)
                         throws M4Exception

  Creates a Chain that subsumes the given steps and chains. It will be a direct subchain of this Chain.

  Parameters:
    `name` - the name to be given to the new chain
    `stepsAndChains` - a `Collection` of `Step`s and/or `Chain`s.
  Returns:
    the created chain
  Throws:
    `M4Exception`

### setParentChain

    public void setParentChain(Chain parentChain)
                        throws M4Exception

  Sets the parent chain of this chain to the given parentChain.

  Parameters:
    `parentChain` - the new parent chain of this chain.
  Throws:
    `M4Exception`

### removeStep

    public boolean removeStep(Step step)
                       throws M4Exception

  Removes a `Step` from this `Chain` and takes care about back-reference integrity.

  Parameters:
    `step` - the `Step` to be removed
  Throws:
    `M4Exception`

### copy

    public Chain copy(Case newCase)
               throws M4Exception

  Copies a chain.

  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