Module (runtime-platform 1.1.0 API)

java.lang.Object
- de.codecentric.reedelk.platform.module.Module

All Implemented Interfaces:: State

public class Module
extends Object
implements State

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class Module.Builder

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`static Module.Builder`	`builder()`
`DeSerializedModule`	`deserialize()`
`void`	`error(Exception exception)`
`void`	`error(Collection<Exception> exceptions)`	The transition to error state, depends on the previous state.
`Collection<Exception>`	`errors()`
`String`	`filePath()`
`Collection<Flow>`	`flows()`
`long`	`id()`
`void`	`installed()`
`String`	`name()`
`void`	`resolve(Collection<String> resolvedComponents)`
`Collection<String>`	`resolvedComponents()`
`void`	`start(Collection<Flow> flows)`
`ModuleState`	`state()`
`void`	`stop(Collection<Flow> flows)`
`void`	`unresolve(Collection<String> unresolvedComponents, Collection<String> resolvedComponents)`
`Collection<String>`	`unresolvedComponents()`
`String`	`version()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

builder

public static Module.Builder builder()

id
```
public long id()
```

name
```
public String name()
```

version
```
public String version()
```

filePath
```
public String filePath()
```

unresolve

public void unresolve(Collection<String> unresolvedComponents,
                      Collection<String> resolvedComponents)

resolve

public void resolve(Collection<String> resolvedComponents)

start

public void start(Collection<Flow> flows)

stop

public void stop(Collection<Flow> flows)

installed
```
public void installed()
```

error
```
public void error(Collection<Exception> exceptions)
```
The transition to error state, depends on the previous state. We MUST carry over information about resolvedComponents (when previous state is either Resolved or Stopped). This is required because a module MIGHT transition to Unresolved state from error when a component is unregistered.

Parameters:

exceptions - the exception/s which caused this module to transition to error state.

See Also:

ModuleResolveDependencies.run(de.codecentric.reedelk.platform.module.Module)

error

public void error(Exception exception)

flows
```
public Collection<Flow> flows()
```
Specified by:

flows in interface State

errors
```
public Collection<Exception> errors()
```
Specified by:

errors in interface State

resolvedComponents
```
public Collection<String> resolvedComponents()
```
Specified by:

resolvedComponents in interface State

unresolvedComponents
```
public Collection<String> unresolvedComponents()
```
Specified by:

unresolvedComponents in interface State

state
```
public ModuleState state()
```
Specified by:

state in interface State

deserialize

public DeSerializedModule deserialize()