-
Notifications
You must be signed in to change notification settings - Fork 53
Expand file tree
/
Copy pathModule.java
More file actions
199 lines (172 loc) · 6.45 KB
/
Copy pathModule.java
File metadata and controls
199 lines (172 loc) · 6.45 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
/*
* #%L
* SciJava Common shared library for SciJava software.
* %%
* Copyright (C) 2009 - 2026 SciJava developers.
* %%
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
* #L%
*/
package org.scijava.module;
import java.util.Map;
import org.scijava.display.DisplayPostprocessor;
import org.scijava.module.process.ModulePostprocessor;
import org.scijava.module.process.ModulePreprocessor;
import org.scijava.widget.InputHarvester;
/**
* A module is an encapsulated piece of functionality with inputs and outputs.
* <p>
* There are several types of modules, including plugins and scripts, as well as
* workflows, which are directed acyclic graphs consisting of modules whose
* inputs and outputs are connected.
* </p>
* <p>
* The {@code Module} interface represents a specific instance of a module,
* while the corresponding {@link ModuleInfo} represents metadata about that
* module, particularly its input and output names and types.
* </p>
*
* @author Aivar Grislis
* @author Curtis Rueden
*/
public interface Module extends Runnable {
/**
* Computes a preview of the module's execution results, if available. A
* preview is a quick approximation of the results that would be obtained by
* actually executing the module with {@link #run()}. Not all modules support
* previews.
*
* @see ModuleInfo#canPreview()
*/
void preview();
/**
* Performs necessary cleanup in response to cancellation of the module
* execution. This is useful in conjunction with {@link #preview()} to undo
* any changes made as a result of the preview.
*
* @see ModuleInfo#canCancel()
*/
void cancel();
/**
* Initializes the module.
* <p>
* First, the module's global initializer method (if any) is called, followed
* by each individual {@link ModuleItem} initializer method (i.e.,
* {@link ModuleItem#initialize(Module)}).
* </p>
*
* @see ModuleInfo#getInitializer()
* @see ModuleItem#initialize(Module)
*/
void initialize() throws MethodCallException;
/** Gets metadata about this module. */
ModuleInfo getInfo();
/**
* Gets the object containing the module's actual implementation. By
* definition, this is an object whose fully qualified class name is given by
* {@code getInfo().getDelegateClassName()}. This object must possess all
* callback methods specified by {@link ModuleItem#getCallback()}.
* <p>
* The nature of this method is implementation-specific; e.g., a
* {@code CommandModule} will return its associated {@code Command}. For
* modules that are not plugins, the result may be something else. If you are
* implementing this interface directly, a good rule of thumb is to return
* {@code this}.
* </p>
*/
Object getDelegateObject();
/** Gets the value of the input with the given name. */
Object getInput(String name);
/** Gets the value of the output with the given name. */
Object getOutput(String name);
/** Gets a table of input values. */
Map<String, Object> getInputs();
/** Gets a table of output values. */
Map<String, Object> getOutputs();
/** Sets the value of the input with the given name. */
void setInput(String name, Object value);
/** Sets the value of the output with the given name. */
void setOutput(String name, Object value);
/** Sets input values according to the given table. */
void setInputs(Map<String, Object> inputs);
/** Sets output values according to the given table. */
void setOutputs(Map<String, Object> outputs);
/**
* Gets the resolution status of the input with the given name.
*
* @see #resolveInput(String)
*/
boolean isInputResolved(String name);
/**
* Gets the resolution status of the output with the given name.
*
* @see #resolveOutput(String)
*/
boolean isOutputResolved(String name);
/**
* Marks the input with the given name as resolved. A "resolved" input is
* known to have a final, valid value for use with the module.
* <p>
* {@link ModulePreprocessor}s in the module execution chain that populate
* input values (e.g. {@link InputHarvester} plugins) will typically skip over
* inputs which have already been resolved.
* </p>
*/
void resolveInput(String name);
/**
* Marks the output with the given name as resolved. A "resolved" output has
* been handled by the framework somehow, typically displayed to the user.
* <p>
* {@link ModulePostprocessor}s in the module execution chain that handle
* output values (e.g. the {@link DisplayPostprocessor}) will typically skip
* over outputs which have already been resolved.
* </p>
*/
void resolveOutput(String name);
/**
* Marks the input with the given name as unresolved.
*
* @see #resolveInput(String)
*/
void unresolveInput(String name);
/**
* Marks the output with the given name as unresolved.
*
* @see #resolveOutput(String)
*/
void unresolveOutput(String name);
// -- Deprecated --
/** @deprecated Use {@link #isInputResolved(String)} instead. */
@Deprecated
default boolean isResolved(final String name) {
return isInputResolved(name);
}
/**
* @deprecated Use {@link #resolveInput(String)} and
* {@link #unresolveInput(String)} instead.
*/
@Deprecated
default void setResolved(final String name, final boolean resolved) {
if (resolved) resolveInput(name);
else unresolveInput(name);
}
}