* @param schema the actual schema declaration, either a string or as <code>LS schema LE</code>
*/
public void addSchemaDeclaration(final String name, final String version, final String uuid,
- final String description, final String flavour, final String schema) {
+ final String description, final String flavour, final String schema) {
final ST st = stg.getInstanceOf("schemaDecl");
st.add(NAME, name);
st.add(VERSION, version);
/**
* Adds a new context album declaration to the model.
*
- * @param codeGenCliEditorBuilder
+ * @param codeGenCliEditorBuilder The parameters for the context album
*/
- public void addContextAlbumDeclaration(
- CodeGenCliEditorBuilder codeGenCliEditorBuilder) {
+ public void addContextAlbumDeclaration(CodeGenCliEditorBuilder codeGenCliEditorBuilder) {
final ST st = stg.getInstanceOf("ctxAlbumDecl");
st.add(NAME, codeGenCliEditorBuilder.getName());
st.add(VERSION, codeGenCliEditorBuilder.getVersion());
* @return a CLI command for event field definition
*/
public ST createEventFieldDefinition(final String eventName, final String version, final String fieldName,
- final String fieldSchema, final String fieldSchemaVersion, final boolean optional) {
+ final String fieldSchema, final String fieldSchemaVersion, final boolean optional) {
final ST st = stg.getInstanceOf("eventDefField");
st.add(EVENT_NAME, eventName);
st.add(VERSION, version);
* @param taskName the name of the task
* @param version the task version
* @param flavour the flavour, e.g. JAVA or JAVASCRIPT
- * @param logic the actual logic (use either a string or a multi-line with
- * <code>LS some code LE</code>
+ * @param logic the actual logic (use either a string or a multi-line with <code>LS some code LE</code>
* @return a CLI command for task definition, logic
*/
public ST createTaskDefLogic(final String taskName, final String version, final String flavour,
- final String logic) {
+ final String logic) {
final ST st = stg.getInstanceOf("taskDefLogic");
st.add(TASK_NAME, taskName);
st.add(VERSION, version);
* @param fields any event fields
*/
public void addEventDeclaration(final String name, final String version, final String uuid,
- final String description, final String nameSpace, final String source, final String target,
- final List<ST> fields) {
+ final String description, final String nameSpace, final String source, final String target,
+ final List<ST> fields) {
final ST st = stg.getInstanceOf("eventDecl");
st.add(NAME, name);
st.add(VERSION, version);
* @param contextRefs any context reference
*/
public void addTaskDeclaration(final String name, final String version, final String uuid, final String description,
- final List<ST> infields, final List<ST> outfields, final ST logic, final List<ST> parameters,
- final List<ST> contextRefs) {
+ final List<ST> infields, final List<ST> outfields, final ST logic, final List<ST> parameters,
+ final List<ST> contextRefs) {
final ST st = stg.getInstanceOf("taskDecl");
st.add(NAME, name);
st.add(VERSION, version);
* @param states all policy states
*/
public void addPolicyDefinition(final String name, final String version, final String uuid,
- final String description, final String template, final String firstState, final List<ST> states) {
+ final String description, final String template, final String firstState, final List<ST> states) {
final ST st = stg.getInstanceOf("policyDef");
st.add(NAME, name);
st.add(VERSION, version);
* @return a CLI command for task infield definition
*/
public ST createTaskDefinitionInfields(final String taskName, final String version, final String fieldName,
- final String fieldSchema, final String fieldSchemaVersion) {
+ final String fieldSchema, final String fieldSchemaVersion) {
final ST st = stg.getInstanceOf("taskDefInputFields");
st.add(TASK_NAME, taskName);
st.add(VERSION, version);
* @return a CLI command for task outfield definition
*/
public ST createTaskDefinitionOutfields(final String taskName, final String version, final String fieldName,
- final String fieldSchema, final String fieldSchemaVersion) {
+ final String fieldSchema, final String fieldSchemaVersion) {
final ST st = stg.getInstanceOf("taskDefOutputFields");
st.add(TASK_NAME, taskName);
st.add(VERSION, version);
* @return a CLI command for a task parameter definition
*/
public ST createTaskDefinitionParameters(final String name, final String version, final String parName,
- final String defaultValue) {
+ final String defaultValue) {
final ST st = stg.getInstanceOf("taskDefParameter");
st.add(NAME, name);
st.add(VERSION, version);
* @return a CLI command for a task context reference definition
*/
public ST createTaskDefinitionContextRef(final String name, final String version, final String albumName,
- final String albumVersion) {
+ final String albumVersion) {
final ST st = stg.getInstanceOf("taskDefCtxRef");
st.add(NAME, name);
st.add(VERSION, version);
}
/**
- * Creates a new policy state task definition for a task which belongs to a state which belongs
- * to a policy.
+ * Creates a new policy state task definition for a task which belongs to a state which belongs to a policy.
*
* @param policyName the name of the policy
* @param version the version of the policy
* @return a CLI command for a policy state task definition
*/
public ST createPolicyStateTask(final String policyName, final String version, final String stateName,
- final String taskLocalName, final String taskName, final String taskVersion, final String outputType,
- final String outputName) {
+ final String taskLocalName, final String taskName, final String taskVersion,
+ final String outputType, final String outputName) {
final ST st = stg.getInstanceOf("policyStateTask");
st.add(POLICY_NAME, policyName);
st.add(VERSION, version);
* @return a CLI command for a state output definition
*/
public ST createPolicyStateOutput(final String policyName, final String version, final String stateName,
- final String outputName, final String eventName, final String eventVersion, final String nextState) {
+ final String outputName, final String eventName, final String eventVersion,
+ final String nextState) {
final ST st = stg.getInstanceOf("policyStateOutput");
st.add(POLICY_NAME, policyName);
st.add(VERSION, version);
* @return a CLI command for a policy state definition
*/
public ST createPolicyStateDef(final String policyName, final String version, final String stateName,
- final String triggerName, final String triggerVersion, final String defaultTask,
- final String defaultTaskVersion, final List<ST> outputs, final List<ST> tasks, final List<ST> tsLogic,
- final List<ST> finalizerLogics, final List<ST> ctxRefs) {
+ final String triggerName, final String triggerVersion, final String defaultTask,
+ final String defaultTaskVersion, final List<ST> outputs, final List<ST> tasks,
+ final List<ST> tsLogic, final List<ST> finalizerLogics, final List<ST> ctxRefs) {
final ST st = stg.getInstanceOf("policyStateDef");
st.add(POLICY_NAME, policyName);
st.add(VERSION, version);
* @param version the version of the policy
* @param stateName the name of the state
* @param logicFlavour the flavour, e.g. JAVA or JAVASCRIPT
- * @param logic the actual logic (use either a string or a multi-line with
- * <code>LS some code LE</code>
+ * @param logic the actual logic (use either a string or a multi-line with <code>LS some code LE</code>
* @return a CLI command for task selection logic definition
*/
public ST createPolicyStateDefTaskSelLogic(final String name, final String version, final String stateName,
- final String logicFlavour, final String logic) {
+ final String logicFlavour, final String logic) {
final ST st = stg.getInstanceOf("policyStateTaskSelectionLogic");
st.add(NAME, name);
st.add(VERSION, version);
* @param stateName the name of the state
* @param finalizerLogicName name of the finalizer logic
* @param logicFlavour the flavour, e.g. JAVA or JAVASCRIPT
- * @param logic the actual logic (use either a string or a multi-line with
- * <code>LS some code LE</code>
+ * @param logic the actual logic (use either a string or a multi-line with <code>LS some code LE</code>
* @return a CLI command for finalizer definition
*/
public ST createPolicyStateDefFinalizerLogic(final String name, final String version, final String stateName,
- final String finalizerLogicName, final String logicFlavour, final String logic) {
+ final String finalizerLogicName, final String logicFlavour, final String logic) {
final ST st = stg.getInstanceOf("policyStateFinalizerLogic");
st.add(NAME, name);
st.add(VERSION, version);
* @return a CLI command for state context reference
*/
public ST createPolicyStateDefContextRef(final String name, final String version, final String stateName,
- final String albumName, final String albumVersion) {
+ final String albumName, final String albumVersion) {
final ST st = stg.getInstanceOf("policyStateContextRef");
st.add(NAME, name);
st.add(VERSION, version);
import org.onap.policy.apex.model.utilities.Assertions;
/**
- * This class holds the definition of a single state in a policy. A state is a single stage in a
- * policy. A state has a single input event, its trigger. A state can output many events, but can
- * only output one event on a single execution. After it executes, a state can pass control to
- * another state or can simply emit its event to an external system. In the case where a state
- * passes control to another state, the output event of the state becomes the input event of the
- * next state. The outputs of a state {@link AxStateOutput} are held as a map in the state. Each
- * state output contains the outgoing event of the state and optionally the next state to pass
- * control to.
+ * This class holds the definition of a single state in a policy. A state is a single stage in a policy. A state has a
+ * single input event, its trigger. A state can output many events, but can only output one event on a single execution.
+ * After it executes, a state can pass control to another state or can simply emit its event to an external system. In
+ * the case where a state passes control to another state, the output event of the state becomes the input event of the
+ * next state. The outputs of a state {@link AxStateOutput} are held as a map in the state. Each state output contains
+ * the outgoing event of the state and optionally the next state to pass control to.
*
- * <p>A state uses tasks {@link AxTask} to execute its logic. A state holds its tasks in a map and must
- * have at least one task. A state uses Task Selection Logic {@link AxTaskSelectionLogic} to select
- * which task should be executed in a given execution cycle. Optional Task Selection Logic can use
- * fields on the incoming event and information from the context albums available on the state to
- * decide what task to execute in a given context. The default task of a state is the task that is
- * executed when task Selection Logic is not specified. In cases where only a single task is
+ * <p>A state uses tasks {@link AxTask} to execute its logic. A state holds its tasks in a map and must have at least
+ * one task. A state uses Task Selection Logic {@link AxTaskSelectionLogic} to select which task should be executed in a
+ * given execution cycle. Optional Task Selection Logic can use fields on the incoming event and information from the
+ * context albums available on the state to decide what task to execute in a given context. The default task of a state
+ * is the task that is executed when task Selection Logic is not specified. In cases where only a single task is
* specified on a state, the default task must be that task and the state always executes that task.
*
- * <p>What happens when a state completes its execution cycle depends on the task that is selected for
- * execution by the state. Therefore, the action to be performed a state on execution of each task
- * must be defined in the state as a {@link AxStateTaskReference} instance for each task defined in
- * the state. The {@link AxStateTaskReference} instance defines the action to be performed as either
- * a {@link AxStateTaskOutputType} of {@link AxStateTaskOutputType#DIRECT} or
- * {@link AxStateTaskOutputType#LOGIC} and contains an {@link AxReferenceKey} reference to the
- * instance that will complete the state output.
+ * <p>What happens when a state completes its execution cycle depends on the task that is selected for execution by the
+ * state. Therefore, the action to be performed a state on execution of each task must be defined in the state as a
+ * {@link AxStateTaskReference} instance for each task defined in the state. The {@link AxStateTaskReference} instance
+ * defines the action to be performed as either a {@link AxStateTaskOutputType} of {@link AxStateTaskOutputType#DIRECT}
+ * or {@link AxStateTaskOutputType#LOGIC} and contains an {@link AxReferenceKey} reference to the instance that will
+ * complete the state output.
*
- * <p>In the case of direct output, the {@link AxReferenceKey} reference in the
- * {@link AxStateTaskReference} instance is a reference to an {@link AxStateOutput} instance. The
- * state output defines the event to be emitted by the state and the next state to pass control to
- * if any. All fields of the executed task are marshaled onto the outgoing event automatically by
- * Apex.
+ * <p>In the case of direct output, the {@link AxReferenceKey} reference in the {@link AxStateTaskReference} instance is
+ * a reference to an {@link AxStateOutput} instance. The state output defines the event to be emitted by the state and
+ * the next state to pass control to if any. All fields of the executed task are marshaled onto the outgoing event
+ * automatically by Apex.
*
- * <p>In the case of logic output, the {@link AxReferenceKey} reference in the
- * {@link AxStateTaskReference} instance is a reference to State Finalizer Logic in an
- * {@link AxStateFinalizerLogic} instance, which selects the {@link AxStateOutput} that the state
- * will use. The state finalizer logic uses fields emitted by the executed task and information from
- * the context albums available on the state to decide what {@link AxStateOutput} to select in a
- * given context. The state output defines the event to be emitted by the state and the next state
- * to pass control to if any. The State Finalizer Logic instances for the state are held in a map in
- * the state. State Finalizer Logic must marshal the fields of the output event in whatever manner
- * it wishes; Apex does not automatically transfer the output fields from the task directly to the
- * output event.
+ * <p>In the case of logic output, the {@link AxReferenceKey} reference in the {@link AxStateTaskReference} instance is
+ * a reference to State Finalizer Logic in an {@link AxStateFinalizerLogic} instance, which selects the
+ * {@link AxStateOutput} that the state will use. The state finalizer logic uses fields emitted by the executed task and
+ * information from the context albums available on the state to decide what {@link AxStateOutput} to select in a given
+ * context. The state output defines the event to be emitted by the state and the next state to pass control to if any.
+ * The State Finalizer Logic instances for the state are held in a map in the state. State Finalizer Logic must marshal
+ * the fields of the output event in whatever manner it wishes; Apex does not automatically transfer the output fields
+ * from the task directly to the output event.
*
- * <p>The Task Selection Logic instance or State Finalizer Logic instances in a state may use
- * information in context albums to arrive at their task or state output selections. The context
- * albums that the state uses and that should be made available to the state by Apex policy
- * distribution are held as a set of references to context albums in the state.
+ * <p>The Task Selection Logic instance or State Finalizer Logic instances in a state may use information in context
+ * albums to arrive at their task or state output selections. The context albums that the state uses and that should be
+ * made available to the state by Apex policy distribution are held as a set of references to context albums in the
+ * state.
*
- * <p>During validation of a state, the validation checks listed below are executed:
- * <ol>
- * <li>The policy key must not be a null key and must be valid, see validation in
- * {@link AxReferenceKey}
- * <li>The trigger event key must not be a null key and must be valid, see validation in
- * {@link AxArtifactKey}
- * <li>At least one state output must be defined
- * <li>Each state output in a state must have that state as its parent
- * <li>Each state output must be valid, see validation in {@link AxStateOutput}
- * <li>The next state defined in a state output must be unique in a state
- * <li>The default task key must not be a null key and must be valid, see validation in
- * {@link AxArtifactKey}
- * <li>The default task must appear in the task map of the state
- * <li>At least one task must be defined on the state
- * <li>Each task key on the task map for the state must not be a null key and must be valid, see
- * validation in {@link AxArtifactKey}
- * <li>All state task references for each task in the state must exist and must be valid, see
- * validation in {@link AxStateTaskReference}
- * <li>Each state task reference in a state must have that state as its parent
- * <li>For direct state outputs from tasks, the state output must be defined on the state
- * <li>For logic state outputs from tasks, the State Finalizer Logic must be defined on the state
- * <li>An observation is issued for each state output defined on the state that is not used as a
- * direct output on a task
- * <li>An observation is issued for each state finalizer logic instance defined on the state that is
- * not used as an output on a task
- * <li>Each context album key on the context album set for the state must not be a null key and must
- * be valid, see validation in {@link AxArtifactKey}
- * <li>Task Selection logic in a state must have that state as its parent
- * <li>Task Selection logic in a state must be valid, see validation in {@link AxTaskSelectionLogic}
- * <li>Each State Finalizer logic instance in a state must have that state as its parent
- * <li>Each State Finalizer logic instance in a state must be valid, see validation in
- * {@link AxStateFinalizerLogic}
+ * <p>During validation of a state, the validation checks listed below are executed: <ol> <li>The policy key must not be
+ * a null key and must be valid, see validation in {@link AxReferenceKey} <li>The trigger event key must not be a null
+ * key and must be valid, see validation in {@link AxArtifactKey} <li>At least one state output must be defined <li>Each
+ * state output in a state must have that state as its parent <li>Each state output must be valid, see validation in
+ * {@link AxStateOutput} <li>The next state defined in a state output must be unique in a state <li>The default task key
+ * must not be a null key and must be valid, see validation in {@link AxArtifactKey} <li>The default task must appear in
+ * the task map of the state <li>At least one task must be defined on the state <li>Each task key on the task map for
+ * the state must not be a null key and must be valid, see validation in {@link AxArtifactKey} <li>All state task
+ * references for each task in the state must exist and must be valid, see validation in {@link AxStateTaskReference}
+ * <li>Each state task reference in a state must have that state as its parent <li>For direct state outputs from tasks,
+ * the state output must be defined on the state <li>For logic state outputs from tasks, the State Finalizer Logic must
+ * be defined on the state <li>An observation is issued for each state output defined on the state that is not used as a
+ * direct output on a task <li>An observation is issued for each state finalizer logic instance defined on the state
+ * that is not used as an output on a task <li>Each context album key on the context album set for the state must not be
+ * a null key and must be valid, see validation in {@link AxArtifactKey} <li>Task Selection logic in a state must have
+ * that state as its parent <li>Task Selection logic in a state must be valid, see validation in
+ * {@link AxTaskSelectionLogic} <li>Each State Finalizer logic instance in a state must have that state as its parent
+ * <li>Each State Finalizer logic instance in a state must be valid, see validation in {@link AxStateFinalizerLogic}
* </ol>
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlRootElement(name = "apexState", namespace = "http://www.onap.org/policy/apex-pdp")
-@XmlType(name = "AxState", namespace = "http://www.onap.org/policy/apex-pdp",
- propOrder = {"key", "trigger", "stateOutputs", "contextAlbumReferenceSet", "taskSelectionLogic",
- "stateFinalizerLogicMap", "defaultTask", "taskReferenceMap"})
+@XmlType(name = "AxState", namespace = "http://www.onap.org/policy/apex-pdp", propOrder =
+ { "key", "trigger", "stateOutputs", "contextAlbumReferenceSet", "taskSelectionLogic", "stateFinalizerLogicMap",
+ "defaultTask", "taskReferenceMap" })
public class AxState extends AxConcept {
private static final String DOES_NOT_EQUAL_STATE_KEY = " does not equal state key";
// @formatter:on
/**
- * The Default Constructor creates a state with a null reference key and with default values for
- * all other fields.
+ * The Default Constructor creates a state with a null reference key and with default values for all other fields.
*/
public AxState() {
this(new AxReferenceKey());
}
/**
- * The Keyed Constructor creates a state with the given reference key and with default values
- * for all other fields.
+ * The Keyed Constructor creates a state with the given reference key and with default values for all other fields.
*
* @param key the reference key of the state
*/
public AxState(final AxReferenceKey key) {
- this( // Key
- // Trigger Reference
- // State Outputs
- // Context Album References
- // Task Selection Logic
- // State Finalizer Logics
- // Default Task
- // Task References
- new AxStateParamsBuilder().key(key).trigger(AxArtifactKey.getNullKey())
- .stateOutputs(new TreeMap<String, AxStateOutput>())
- .contextAlbumReferenceSet(new TreeSet<AxArtifactKey>())
- .taskSelectionLogic(new AxTaskSelectionLogic())
- .stateFinalizerLogicMap(new TreeMap<String, AxStateFinalizerLogic>())
- .defaultTask(AxArtifactKey.getNullKey())
- .taskReferenceMap(new TreeMap<AxArtifactKey, AxStateTaskReference>()));
+ // @formatter:off
+ this(new AxStateParamsBuilder()
+ .key(key) // Key
+ .trigger(AxArtifactKey.getNullKey()) // Trigger Reference
+ .stateOutputs(new TreeMap<String, AxStateOutput>()) // State Outputs
+ .contextAlbumReferenceSet(new TreeSet<AxArtifactKey>()) // Context Album Refs
+ .taskSelectionLogic(new AxTaskSelectionLogic()) // Task Selection Logic
+ .stateFinalizerLogicMap(new TreeMap<String, AxStateFinalizerLogic>()) // State Finalizer Logics
+ .defaultTask(AxArtifactKey.getNullKey()) // Default Task
+ .taskReferenceMap(new TreeMap<AxArtifactKey, AxStateTaskReference>()) // Task References
+ );
+ // @formatter:on
}
/**
* This Constructor creates a state with all its fields defined.
*
- * @param axStateParams
+ * @param axStateParams parameters for state creation
*/
// CHECKSTYLE:OFF: checkstyle:parameterNumber
public AxState(AxStateParamsBuilder axStateParams) {
Assertions.argumentNotNull(axStateParams.getTrigger(), "trigger may not be null");
Assertions.argumentNotNull(axStateParams.getStateOutputs(), "stateOutputs may not be null");
Assertions.argumentNotNull(axStateParams.getContextAlbumReferenceSet(),
- "contextAlbumReferenceSet may not be null");
+ "contextAlbumReferenceSet may not be null");
Assertions.argumentNotNull(axStateParams.getTaskSelectionLogic(), "taskSelectionLogic may not be null");
Assertions.argumentNotNull(axStateParams.getStateFinalizerLogicMap(), "stateFinalizerLogicMap may not be null");
Assertions.argumentNotNull(axStateParams.getDefaultTask(), "defaultTask may not be null");
// CHECKSTYLE:ON: checkstyle:parameterNumber
/**
- * When a state is unmarshalled from disk or from the database, the parent of contained objects
- * is not defined. This method is called by JAXB after unmarshaling and is used to set the
- * parent keys of all {@link AxTaskSelectionLogic}, {@link AxStateOutput}, and
- * {@link AxStateFinalizerLogic} instance in the state.
+ * When a state is unmarshalled from disk or from the database, the parent of contained objects is not defined. This
+ * method is called by JAXB after unmarshaling and is used to set the parent keys of all
+ * {@link AxTaskSelectionLogic}, {@link AxStateOutput}, and {@link AxStateFinalizerLogic} instance in the state.
*
* @param unmarshaler the unmarshaler that is unmarshaling the model
- * @param parent the parent object of this object in the unmarshaler
+ * @param parent the parent object of this object in the unmarshaler
*/
public void afterUnmarshal(final Unmarshaller unmarshaler, final Object parent) {
if (!taskSelectionLogic.getKey().getLocalName().equals(AxKey.NULL_KEY_NAME)) {
/**
* Gets the names of all the states that this state may pass control to.
*
- * @return the list of possible states that may receive control when this state completes
- * execution
+ * @return the list of possible states that may receive control when this state completes execution
*/
public Set<String> getNextStateSet() {
final Set<String> nextStateSet = new TreeSet<>();
}
/**
- * Gets the context album reference set defines the context that may be used by Task Selection
- * Logic and State Finalizer Logic in the state.
+ * Gets the context album reference set defines the context that may be used by Task Selection Logic and State
+ * Finalizer Logic in the state.
*
- * @return the context album reference set defines the context that may be used by Task
- * Selection Logic and State Finalizer Logic in the state
+ * @return the context album reference set defines the context that may be used by Task Selection Logic and State
+ * Finalizer Logic in the state
*/
public Set<AxArtifactKey> getContextAlbumReferences() {
return contextAlbumReferenceSet;
}
/**
- * Sets the context album reference set defines the context that may be used by Task Selection
- * Logic and State Finalizer Logic in the state.
+ * Sets the context album reference set defines the context that may be used by Task Selection Logic and State
+ * Finalizer Logic in the state.
*
- * @param contextAlbumReferences the context album reference set defines the context that may be
- * used by Task Selection Logic and State Finalizer Logic in the state
+ * @param contextAlbumReferences the context album reference set defines the context that may be used by Task
+ * Selection Logic and State Finalizer Logic in the state
*/
public void setContextAlbumReferences(final Set<AxArtifactKey> contextAlbumReferences) {
Assertions.argumentNotNull(contextAlbumReferences, "contextAlbumReferenceSet may not be null");
/**
* Sets the task selection logic that selects the task a state executes in an execution cycle.
*
- * @param taskSelectionLogic the task selection logic that selects the task a state executes in
- * an execution cycle
+ * @param taskSelectionLogic the task selection logic that selects the task a state executes in an execution cycle
*/
public void setTaskSelectionLogic(final AxTaskSelectionLogic taskSelectionLogic) {
Assertions.argumentNotNull(taskSelectionLogic, "taskSelectionLogic may not be null");
}
/**
- * Gets the state finalizer logic instances that selects the state output to use after a task
- * executes in a state execution cycle.
+ * Gets the state finalizer logic instances that selects the state output to use after a task executes in a state
+ * execution cycle.
*
- * @return the state finalizer logic instances that selects the state output to use after a task
- * executes in a state execution cycle
+ * @return the state finalizer logic instances that selects the state output to use after a task executes in a state
+ * execution cycle
*/
public Map<String, AxStateFinalizerLogic> getStateFinalizerLogicMap() {
return stateFinalizerLogicMap;
}
/**
- * Sets the state finalizer logic instances that selects the state output to use after a task
- * executes in a state execution cycle.
+ * Sets the state finalizer logic instances that selects the state output to use after a task executes in a state
+ * execution cycle.
*
- * @param stateFinalizerLogicMap the state finalizer logic instances that selects the state
- * output to use after a task executes in a state execution cycle
+ * @param stateFinalizerLogicMap the state finalizer logic instances that selects the state output to use after a
+ * task executes in a state execution cycle
*/
public void setStateFinalizerLogicMap(final Map<String, AxStateFinalizerLogic> stateFinalizerLogicMap) {
Assertions.argumentNotNull(stateFinalizerLogicMap, "stateFinalizerLogic may not be null");
/**
* Gets the default task that will execute in a state if Task Selection Logic is not specified.
*
- * @return the default task that will execute in a state if Task Selection Logic is not
- * specified
+ * @return the default task that will execute in a state if Task Selection Logic is not specified
*/
public AxArtifactKey getDefaultTask() {
return defaultTask;
/**
* Sets the default task that will execute in a state if Task Selection Logic is not specified.
*
- * @param defaultTask the default task that will execute in a state if Task Selection Logic is
- * not specified
+ * @param defaultTask the default task that will execute in a state if Task Selection Logic is not specified
*/
public void setDefaultTask(final AxArtifactKey defaultTask) {
Assertions.argumentNotNull(defaultTask, "defaultTask may not be null");
}
/**
- * Gets the task reference map that defines the tasks for the state and how the task outputs are
- * handled.
+ * Gets the task reference map that defines the tasks for the state and how the task outputs are handled.
*
- * @return the task reference map that defines the tasks for the state and how the task outputs
- * are handled
+ * @return the task reference map that defines the tasks for the state and how the task outputs are handled
*/
public Map<AxArtifactKey, AxStateTaskReference> getTaskReferences() {
return taskReferenceMap;
}
/**
- * Sets the task reference map that defines the tasks for the state and how the task outputs are
- * handled.
+ * Sets the task reference map that defines the tasks for the state and how the task outputs are handled.
*
- * @param taskReferences the task reference map that defines the tasks for the state and how the
- * task outputs are handled
+ * @param taskReferences the task reference map that defines the tasks for the state and how the task outputs are
+ * handled
*/
public void setTaskReferences(final Map<AxArtifactKey, AxStateTaskReference> taskReferences) {
Assertions.argumentNotNull(taskReferences, "taskReferenceMap may not be null");
/*
* (non-Javadoc)
*
- * @see
- * org.onap.policy.apex.model.basicmodel.concepts.AxConcept#validate(org.onap.policy.apex.model.
+ * @see org.onap.policy.apex.model.basicmodel.concepts.AxConcept#validate(org.onap.policy.apex.model.
* basicmodel.concepts.AxValidationResult)
*/
@Override
AxValidationResult result = resultIn;
if (key.equals(AxReferenceKey.getNullKey())) {
- result.addValidationMessage(
- new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID, "key is a null key"));
+ result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
+ "key is a null key"));
}
result = key.validate(result);
if (trigger.equals(AxArtifactKey.getNullKey())) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "trigger is a null key: " + trigger));
+ "trigger is a null key: " + trigger));
}
result = trigger.validate(result);
if (stateOutputs.size() == 0) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "stateOutputs may not be empty"));
+ "stateOutputs may not be empty"));
} else {
validateStateOutputs(result);
}
if (defaultTask.equals(AxArtifactKey.getNullKey())) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "default task has a null key: " + defaultTask));
+ "default task has a null key: " + defaultTask));
}
result = defaultTask.validate(result);
if (taskReferenceMap.size() == 0) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "taskReferenceMap may not be empty"));
+ "taskReferenceMap may not be empty"));
} else {
validateStateTaskReferences(result);
}
for (final Entry<String, AxStateOutput> stateOutputEntry : stateOutputs.entrySet()) {
if (stateOutputEntry.getValue() == null) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "null state output value found on state output " + stateOutputEntry.getKey()));
+ "null state output value found on state output " + stateOutputEntry.getKey()));
} else {
if (!stateOutputEntry.getValue().getKey().getParentReferenceKey().equals(key)) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "parent key on state output " + stateOutputEntry.getKey() + DOES_NOT_EQUAL_STATE_KEY));
+ "parent key on state output " + stateOutputEntry.getKey()
+ + DOES_NOT_EQUAL_STATE_KEY));
}
if (stateOutputEntry.getValue().getNextState().getLocalName().equals(key.getLocalName())) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "state output next state " + stateOutputEntry.getValue().getNextState().getLocalName()
- + " may not be this state"));
+ "state output next state "
+ + stateOutputEntry.getValue().getNextState().getLocalName()
+ + " may not be this state"));
}
if (nextStateNameSet.contains(stateOutputEntry.getValue().getNextState().getLocalName())) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "duplicate state output next state name "
- + stateOutputEntry.getValue().getNextState().getLocalName() + " found"));
+ "duplicate state output next state name "
+ + stateOutputEntry.getValue().getNextState().getLocalName()
+ + " found"));
} else {
nextStateNameSet.add(stateOutputEntry.getValue().getNextState().getLocalName());
}
for (final AxArtifactKey contextAlbumReference : contextAlbumReferenceSet) {
if (contextAlbumReference.equals(AxArtifactKey.getNullKey())) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "key on context album reference entry " + contextAlbumReference.getKey()
- + " may not be the null key"));
+ "key on context album reference entry " + contextAlbumReference.getKey()
+ + " may not be the null key"));
}
result = contextAlbumReference.validate(result);
if (!taskSelectionLogic.getKey().equals(AxReferenceKey.getNullKey())) {
if (!taskSelectionLogic.getKey().getParentReferenceKey().equals(key)) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "taskSelectionLogic key " + taskSelectionLogic.getKey().getId() + DOES_NOT_EQUAL_STATE_KEY));
+ "taskSelectionLogic key " + taskSelectionLogic.getKey().getId()
+ + DOES_NOT_EQUAL_STATE_KEY));
}
result = taskSelectionLogic.validate(result);
}
for (final Entry<String, AxStateFinalizerLogic> stateFinalizerLogicEntry : stateFinalizerLogicMap.entrySet()) {
if (stateFinalizerLogicEntry.getValue() == null) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "null state finalizer logic value found on state finalizer entry "
- + stateFinalizerLogicEntry.getKey()));
+ "null state finalizer logic value found on state finalizer entry "
+ + stateFinalizerLogicEntry.getKey()));
} else {
if (!stateFinalizerLogicEntry.getValue().getKey().getParentReferenceKey().equals(key)) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "stateFinalizerLogic parent key " + stateFinalizerLogicEntry.getValue().getKey().getId()
- + DOES_NOT_EQUAL_STATE_KEY));
+ "stateFinalizerLogic parent key "
+ + stateFinalizerLogicEntry.getValue().getKey().getId()
+ + DOES_NOT_EQUAL_STATE_KEY));
}
result = stateFinalizerLogicEntry.getValue().validate(result);
for (final Entry<AxArtifactKey, AxStateTaskReference> taskRefEntry : taskReferenceMap.entrySet()) {
if (taskRefEntry.getKey().equals(AxArtifactKey.getNullKey())) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "task has a null key: " + taskRefEntry.getKey()));
+ "task has a null key: " + taskRefEntry.getKey()));
}
result = taskRefEntry.getKey().validate(result);
if (taskRefEntry.getValue() == null) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "null task reference value found on task reference " + taskRefEntry.getKey()));
+ "null task reference value found on task reference " + taskRefEntry.getKey()));
} else {
result = validateStateTaskReference(taskRefEntry.getKey(), taskRefEntry.getValue(),
- usedStateOutputNameSet, usedStateFinalizerLogicNameSet, result);
+ usedStateOutputNameSet, usedStateFinalizerLogicNameSet, result);
}
}
unUsedStateOutputNameSet.removeAll(usedStateOutputNameSet);
for (final String unUsedStateOutputName : unUsedStateOutputNameSet) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.OBSERVATION,
- "state output " + unUsedStateOutputName + " is not used directly by any task"));
+ "state output " + unUsedStateOutputName + " is not used directly by any task"));
}
final Set<String> usnUedStateFinalizerLogicNameSet = new TreeSet<>(stateFinalizerLogicMap.keySet());
usnUedStateFinalizerLogicNameSet.removeAll(usedStateFinalizerLogicNameSet);
for (final String unusedStateFinalizerLogicName : usnUedStateFinalizerLogicNameSet) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.OBSERVATION,
- "state finalizer logic " + unusedStateFinalizerLogicName + " is not used by any task"));
+ "state finalizer logic " + unusedStateFinalizerLogicName + " is not used by any task"));
}
if (!taskReferenceMap.containsKey(defaultTask)) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "defaultTask " + defaultTask + " not found in taskReferenceMap"));
+ "defaultTask " + defaultTask + " not found in taskReferenceMap"));
}
}
/**
* Validate the references of a task used in a state.
*
- * @param taskKey The key of the task
- * @param taskReference the task reference of the task
- * @param stateOutputNameSet State outputs that have been used so far, will be appended for this
- * task reference
- * @param stateFinalizerLogicNameSet State finalizers that have been used so far, may be
- * appended if this task reference uses a finalzier
- * @param result the validation result to append to
+ * @param taskKey The key of the task
+ * @param taskReference the task reference of the task
+ * @param stateOutputNameSet State outputs that have been used so far, will be appended for this task reference
+ * @param stateFinalizerLogicNameSet State finalizers that have been used so far, may be appended if this task
+ * reference uses a finalzier
+ * @param result the validation result to append to
* @return the result of the validation
*/
private AxValidationResult validateStateTaskReference(final AxArtifactKey taskKey,
- final AxStateTaskReference taskReference, Set<String> stateOutputNameSet,
- Set<String> stateFinalizerLogicNameSet, AxValidationResult result) {
+ final AxStateTaskReference taskReference, Set<String> stateOutputNameSet,
+ Set<String> stateFinalizerLogicNameSet, AxValidationResult result) {
if (!taskReference.getKey().getParentReferenceKey().equals(key)) {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "stateTaskReference parent key " + taskReference.getKey().getId() + DOES_NOT_EQUAL_STATE_KEY));
+ "stateTaskReference parent key " + taskReference.getKey().getId()
+ + DOES_NOT_EQUAL_STATE_KEY));
}
if (taskReference.getStateTaskOutputType().equals(AxStateTaskOutputType.DIRECT)) {
stateOutputNameSet.add(taskReference.getOutput().getLocalName());
} else {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "state output for task " + taskKey + " not found in stateOutputs"));
+ "state output for task " + taskKey + " not found in stateOutputs"));
}
} else if (taskReference.getStateTaskOutputType().equals(AxStateTaskOutputType.LOGIC)) {
if (stateFinalizerLogicMap.containsKey(taskReference.getOutput().getLocalName())) {
stateFinalizerLogicNameSet.add(taskReference.getOutput().getLocalName());
} else {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "state finalizer logic for task " + taskKey + " not found in stateFinalizerLogicMap"));
+ "state finalizer logic for task " + taskKey + " not found in stateFinalizerLogicMap"));
}
} else {
result.addValidationMessage(new AxValidationMessage(key, this.getClass(), ValidationResult.INVALID,
- "stateTaskReference task output type " + taskReference.getStateTaskOutputType() + " is invalid"));
+ "stateTaskReference task output type " + taskReference.getStateTaskOutputType()
+ + " is invalid"));
}
return taskReference.validate(result);
/*
* (non-Javadoc)
*
- * @see
- * org.onap.policy.apex.model.basicmodel.concepts.AxConcept#copyTo(org.onap.policy.apex.model.
+ * @see org.onap.policy.apex.model.basicmodel.concepts.AxConcept#copyTo(org.onap.policy.apex.model.
* basicmodel.concepts.AxConcept)
*/
@Override
final Map<String, AxStateFinalizerLogic> newStateFinalizerLogicMap = new TreeMap<>();
for (final Entry<String, AxStateFinalizerLogic> stateFinalizerLogicEntry : stateFinalizerLogicMap.entrySet()) {
newStateFinalizerLogicMap.put(stateFinalizerLogicEntry.getKey(),
- new AxStateFinalizerLogic(stateFinalizerLogicEntry.getValue()));
+ new AxStateFinalizerLogic(stateFinalizerLogicEntry.getValue()));
}
copy.setStateFinalizerLogicMap(newStateFinalizerLogicMap);
final Map<AxArtifactKey, AxStateTaskReference> newTaskReferenceMap = new TreeMap<>();
for (final Entry<AxArtifactKey, AxStateTaskReference> taskReferenceEntry : taskReferenceMap.entrySet()) {
newTaskReferenceMap.put(new AxArtifactKey(taskReferenceEntry.getKey()),
- new AxStateTaskReference(taskReferenceEntry.getValue()));
+ new AxStateTaskReference(taskReferenceEntry.getValue()));
}
copy.setTaskReferences(newTaskReferenceMap);
return this.hashCode() - otherObj.hashCode();
}
- final AxState other = (AxState) otherObj;
+ return compareObjectFields((AxState) otherObj);
+ }
+
+ /**
+ * Compare the object fields on this state to another state.
+ *
+ * @param the other state to compare with
+ * @return the result of the comparison
+ */
+ private int compareObjectFields(final AxState other) {
if (!key.equals(other.key)) {
return key.compareTo(other.key);
}
if (!taskReferenceMap.equals(other.taskReferenceMap)) {
return (taskReferenceMap.hashCode() - other.taskReferenceMap.hashCode());
}
-
+
return 0;
}
}
assertNotNull(new AxState());
assertNotNull(new AxState(new AxReferenceKey()));
- assertNotNull(new AxState(
- new AxStateParamsBuilder().key(new AxReferenceKey()).trigger(new AxArtifactKey())
+ assertNotNull(new AxState(new AxStateParamsBuilder().key(new AxReferenceKey()).trigger(new AxArtifactKey())
.stateOutputs(soEmptyMap).contextAlbumReferenceSet(ctxtEmptySet)
.taskSelectionLogic(new AxTaskSelectionLogic()).stateFinalizerLogicMap(sflEmptyMap)
.defaultTask(new AxArtifactKey()).taskReferenceMap(trEmptyMap)));
assertEquals("PolicyName:0.0.1:NULL:StateName", state.getKeys().get(0).getId());
final AxStateOutput so0 = new AxStateOutput(new AxReferenceKey(stateKey, "SO0"), triggerKey,
- new AxReferenceKey());
+ new AxReferenceKey());
final AxStateOutput soU = new AxStateOutput(new AxReferenceKey(stateKey, "SOU"), triggerKey, stateKeyNext);
final AxStateOutput soSame = new AxStateOutput(new AxReferenceKey(stateKey, "SOU"), triggerKey, stateKey);
final AxArtifactKey cr0 = new AxArtifactKey("ContextReference", "0.0.1");
final AxStateFinalizerLogic sfl = new AxStateFinalizerLogic(stateKey, "SFLogicName", "LogicFlavour", "Logic");
final AxStateFinalizerLogic sflU = new AxStateFinalizerLogic(stateKey, "UnusedSFLogicName", "LogicFlavour",
- "Logic");
+ "Logic");
final AxStateTaskReference str0 = new AxStateTaskReference(new AxReferenceKey(stateKey, "STR0"),
- AxStateTaskOutputType.DIRECT, so0.getKey());
+ AxStateTaskOutputType.DIRECT, so0.getKey());
final AxStateTaskReference str1 = new AxStateTaskReference(new AxReferenceKey(stateKey, "STR1"),
- AxStateTaskOutputType.DIRECT, so0.getKey());
+ AxStateTaskOutputType.DIRECT, so0.getKey());
final AxStateTaskReference str2 = new AxStateTaskReference(new AxReferenceKey(stateKey, "STR2"),
- AxStateTaskOutputType.LOGIC, sfl.getKey());
+ AxStateTaskOutputType.LOGIC, sfl.getKey());
final AxStateTaskReference strBadState = new AxStateTaskReference(new AxReferenceKey(stateKeyBad, "STR2"),
- AxStateTaskOutputType.LOGIC, sfl.getKey());
+ AxStateTaskOutputType.LOGIC, sfl.getKey());
final AxStateTaskReference strBadStateOutput = new AxStateTaskReference(new AxReferenceKey(stateKey, "STR2"),
- AxStateTaskOutputType.UNDEFINED, sfl.getKey());
+ AxStateTaskOutputType.UNDEFINED, sfl.getKey());
final AxStateTaskReference strBadStateFinalizerLogic = new AxStateTaskReference(
- new AxReferenceKey(stateKeyBad, "STR2"), AxStateTaskOutputType.LOGIC,
- new AxReferenceKey(stateKey, "SomeSFL"));
+ new AxReferenceKey(stateKeyBad, "STR2"), AxStateTaskOutputType.LOGIC,
+ new AxReferenceKey(stateKey, "SomeSFL"));
soMap.put(so0.getKey().getLocalName(), so0);
ctxtSet.add(cr0);
assertTrue(state.equals(state));
assertTrue(state.equals(clonedState));
assertFalse(state.equals(null));
- assertFalse(state.equals("Hello"));
- assertFalse(state.equals(
- new AxState(new AxStateParamsBuilder().key(new AxReferenceKey()).trigger(triggerKey)
+ assertFalse(state.equals((Object)"Hello"));
+ assertFalse(state.equals(new AxState(new AxStateParamsBuilder().key(new AxReferenceKey()).trigger(triggerKey)
.stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertFalse(state.equals(
- new AxState(new AxStateParamsBuilder().key(stateKey).trigger(new AxArtifactKey())
+ .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap))));
+ assertFalse(state.equals(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(new AxArtifactKey())
.stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertFalse(state.equals(
- new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs
- (soEmptyMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertFalse(state.equals(
- new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs
- (soMap).contextAlbumReferenceSet(ctxtEmptySet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertFalse(state.equals(new AxState(
- new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs(soMap)
- .contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(new AxTaskSelectionLogic())
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertFalse(state.equals(
- new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs
- (soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflEmptyMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertFalse(state.equals(
- new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs
- (soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(new AxArtifactKey())
- .taskReferenceMap(trMap))));
- assertFalse(state.equals(
- new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs
- (soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trEmptyMap)
- )));
+ .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap))));
+ assertFalse(state.equals(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soEmptyMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap))));
+ assertFalse(state.equals(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtEmptySet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap))));
+ assertFalse(state.equals(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet)
+ .taskSelectionLogic(new AxTaskSelectionLogic()).stateFinalizerLogicMap(sflMap)
+ .defaultTask(defTaskKey).taskReferenceMap(trMap))));
+ assertFalse(state.equals(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflEmptyMap).defaultTask(defTaskKey).taskReferenceMap(trMap))));
+ assertFalse(state.equals(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflMap).defaultTask(new AxArtifactKey()).taskReferenceMap(trMap))));
+ assertFalse(state.equals(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trEmptyMap))));
assertTrue(state.equals(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
- .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap))));
assertEquals(0, state.compareTo(state));
assertEquals(0, state.compareTo(clonedState));
assertNotEquals(0, state.compareTo(new AxArtifactKey()));
assertNotEquals(0, state.compareTo(null));
- assertNotEquals(0, state.compareTo(
- new AxState(new AxStateParamsBuilder().key(new AxReferenceKey()).trigger(triggerKey)
- .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertNotEquals(0, state.compareTo(
- new AxState(
- new AxStateParamsBuilder().key(stateKey).trigger(new AxArtifactKey()).stateOutputs(soMap)
- .contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertNotEquals(0, state.compareTo(
- new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs(soEmptyMap)
- .contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertNotEquals(0, state.compareTo(
- new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs(soMap)
- .contextAlbumReferenceSet(ctxtEmptySet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertNotEquals(0, state.compareTo(new AxState(
- new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs(soMap)
- .contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(new AxTaskSelectionLogic())
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertNotEquals(0, state.compareTo(
- new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs(soMap)
- .contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflEmptyMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
- assertNotEquals(0, state.compareTo(
- new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs(soMap)
- .contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(new AxArtifactKey())
+ assertNotEquals(0,
+ state.compareTo(new AxState(new AxStateParamsBuilder().key(new AxReferenceKey())
+ .trigger(triggerKey).stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet)
+ .taskSelectionLogic(tsl).stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey)
+ .taskReferenceMap(trMap))));
+ assertNotEquals(0, state.compareTo(new AxState(new AxStateParamsBuilder().key(stateKey)
+ .trigger(new AxArtifactKey()).stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet)
+ .taskSelectionLogic(tsl).stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey)
.taskReferenceMap(trMap))));
- assertNotEquals(0, state.compareTo(
- new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs(soMap)
- .contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trEmptyMap)
- )));
- assertEquals(0, state
- .compareTo(new AxState(
- new AxStateParamsBuilder().key(stateKey).trigger(triggerKey).stateOutputs(soMap)
- .contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
- .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap)
- )));
+ assertNotEquals(0, state.compareTo(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soEmptyMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap))));
+ assertNotEquals(0, state.compareTo(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtEmptySet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap))));
+ assertNotEquals(0,
+ state.compareTo(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet)
+ .taskSelectionLogic(new AxTaskSelectionLogic()).stateFinalizerLogicMap(sflMap)
+ .defaultTask(defTaskKey).taskReferenceMap(trMap))));
+ assertNotEquals(0, state.compareTo(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflEmptyMap).defaultTask(defTaskKey).taskReferenceMap(trMap))));
+ assertNotEquals(0, state.compareTo(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflMap).defaultTask(new AxArtifactKey()).taskReferenceMap(trMap))));
+ assertNotEquals(0, state.compareTo(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trEmptyMap))));
+ assertEquals(0, state.compareTo(new AxState(new AxStateParamsBuilder().key(stateKey).trigger(triggerKey)
+ .stateOutputs(soMap).contextAlbumReferenceSet(ctxtSet).taskSelectionLogic(tsl)
+ .stateFinalizerLogicMap(sflMap).defaultTask(defTaskKey).taskReferenceMap(trMap))));
assertNotNull(state.getKeys());
}
Code Review / policy / apex-pdp.git / commitdiff