This is an automated email from the ASF dual-hosted git repository.
zehnder pushed a commit to branch dev
in repository https://gitbox.apache.org/repos/asf/streampipes.git
The following commit(s) were added to refs/heads/dev by this push:
new 70f3e70861 Switch Operator Processors (#3640)
70f3e70861 is described below
commit 70f3e70861eaa5e79a038a46a3050a9c0fc5c2af
Author: Matthew <[email protected]>
AuthorDate: Fri Jun 6 01:15:38 2025 -0500
Switch Operator Processors (#3640)
* feat: Created processor to perform the "switch" operator in streampipes
pipelines.
- define "Switch" input. e.g. switch(event.switch_input)
- define "cases" which output string types
- define "default" case which evaluates if all other cases fail
- creates "switch-filter-result" output
- add SwitchOperatorProcessor to TransformationExtensionModuleExport
* feat: Add documentation and localization for Switch Operator processor
- added documentation.md based on generated template
- added strings.en resources
- added new icon of switch to indicate function of processor
chore: Rename the processor to use the correct format of org.apache.org...
* chore: Unit testing for SwitchOperatorProcessorTest
- Need to fix test issues of Mockito not being able to mock
* test: Refactor and enhance unit tests for SwitchOperatorProcessor
* feat: Enhance SwitchOperatorProcessor to support multiple output types
- Update to return primitive data types based on user selection
- Updated tests to cover functionality
* feat: Update documentation for Switch Operator processor to include
output type options and examples
* feat: Implement LogicalOperator and SwitchBooleanInputProcessor with
enhanced output type handling
* feat: Add SwitchNumericalInputProcessor and SwitchStringInputProcessor
for enhanced switch functionality
* feat: Add Switch Operator documentation and refactor processor interfaces
for improved clarity
* feat: Add license headers to switch operator processor files for
compliance
* feat: Remove unused constants from Switch input processors for cleaner
code
* feat: Introduce AbstractSwitchOperatorProcessor and refactor switch input
processors for improved structure and maintainability
- Refactored to use AbstractSwitchOperatorProcessor to pull out common
methods
- Overall Renaming of methods and names for better consistency and
descriptions of functionality
- moved general implementation of onEvent() to
AbstractSwitchOperatorProcessor which utilizes findMatchingResult which is then
given class specific implementations
* feat: Refactor switch operator processors to use common constants and add
unit tests for boolean, numerical, and string input processors
* feat: Add support for boolean, numerical, and string inputs in Switch
Operator with updated documentation and license headers
- Updated documentation.md and strings.en to reflect the changes made in
optimization refactor
- Unit tests added to cover general functionality and edge cases
- Utilized ProcessingElementTestExecutor for the unit tests
- Added Licenses to top of Test files and new optimized classes
* chore: checkstyle updates
* docs: Add README for StreamPipes Switch Operators with detailed overview
and usage instructions
* chore: Add missing license headers in processor classes and README
---
.../jvm/TransformationExtensionModuleExport.java | 6 +
.../AbstractSwitchOperatorProcessor.java | 149 +++++++++
.../IStreamPipesSwitchProcessor.java | 28 ++
.../processor/switchoperator/LogicalOperator.java | 103 +++++++
.../switchoperator/NumericalSwitchCaseEntry.java | 32 ++
.../jvm/processor/switchoperator/README.md | 119 ++++++++
.../processor/switchoperator/SwitchCaseEntry.java | 37 +++
.../SwitchOperatorBooleanInputProcessor.java | 123 ++++++++
.../SwitchOperatorNumericalInputProcessor.java | 139 +++++++++
.../SwitchOperatorStringInputProcessor.java | 120 ++++++++
.../documentation.md | 78 +++++
.../icon.png | Bin 0 -> 214427 bytes
.../strings.en | 40 +++
.../documentation.md | 84 ++++++
.../icon.png | Bin 0 -> 214427 bytes
.../strings.en | 43 +++
.../documentation.md | 78 +++++
.../icon.png | Bin 0 -> 214427 bytes
.../strings.en | 40 +++
.../TestSwitchOperatorBooleanInputProcessor.java | 330 ++++++++++++++++++++
.../TestSwitchOperatorNumericalInputProcessor.java | 333 +++++++++++++++++++++
.../TestSwitchOperatorStringInputProcessor.java | 295 ++++++++++++++++++
.../change/TestChangedValueDetectionProcessor.java | 2 +-
23 files changed, 2178 insertions(+), 1 deletion(-)
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/TransformationExtensionModuleExport.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/TransformationExtensionModuleExport.java
index 61d775d217..69b0bc5760 100644
---
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/TransformationExtensionModuleExport.java
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/TransformationExtensionModuleExport.java
@@ -45,6 +45,9 @@ import
org.apache.streampipes.processors.transformation.jvm.processor.staticmeta
import
org.apache.streampipes.processors.transformation.jvm.processor.stringoperator.counter.StringCounterProcessor;
import
org.apache.streampipes.processors.transformation.jvm.processor.stringoperator.state.StringToStateProcessor;
import
org.apache.streampipes.processors.transformation.jvm.processor.stringoperator.timer.StringTimerProcessor;
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.booleaninput.SwitchOperatorBooleanInputProcessor;
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.numericalinput.SwitchOperatorNumericalInputProcessor;
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.stringinput.SwitchOperatorStringInputProcessor;
import
org.apache.streampipes.processors.transformation.jvm.processor.task.TaskDurationProcessor;
import
org.apache.streampipes.processors.transformation.jvm.processor.timestampextractor.TimestampExtractorProcessor;
import
org.apache.streampipes.processors.transformation.jvm.processor.transformtoboolean.TransformToBooleanProcessor;
@@ -83,6 +86,9 @@ public class TransformationExtensionModuleExport implements
IExtensionModuleExpo
new StaticMetaDataEnrichmentProcessor(),
new StringTimerProcessor(),
new SignalEdgeFilterProcessor(),
+ new SwitchOperatorBooleanInputProcessor(),
+ new SwitchOperatorStringInputProcessor(),
+ new SwitchOperatorNumericalInputProcessor(),
new BooleanToStateProcessor(),
new NumberLabelerProcessor(),
new StringToStateProcessor(),
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/AbstractSwitchOperatorProcessor.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/AbstractSwitchOperatorProcessor.java
new file mode 100644
index 0000000000..c1e1ba1746
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/AbstractSwitchOperatorProcessor.java
@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator;
+
+import org.apache.streampipes.extensions.api.pe.param.IDataProcessorParameters;
+import org.apache.streampipes.extensions.api.pe.routing.SpOutputCollector;
+import org.apache.streampipes.model.runtime.Event;
+import org.apache.streampipes.model.staticproperty.CollectionStaticProperty;
+import org.apache.streampipes.model.staticproperty.StaticProperty;
+import org.apache.streampipes.model.staticproperty.StaticPropertyGroup;
+import org.apache.streampipes.sdk.extractor.StaticPropertyExtractor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class AbstractSwitchOperatorProcessor implements
IStreamPipesSwitchProcessor {
+ // Common Constants (moved from individual processors)
+ public static final String SWITCH_FILTER_OUTPUT_KEY = "switch-filter-result";
+ public static final String SWITCH_FILTER_INPUT_FIELD_KEY =
"switch-filter-key";
+ public static final String SWITCH_CASE_VALUE_KEY = "switch-case-value"; //
General name for case value key
+ public static final String SWITCH_CASE_OPERATOR_KEY =
"switch-case-value-operator"; // Specific to numerical,
+ // but declared here for common parsing
+ public static final String SWITCH_CASE_OUTPUT_VALUE_KEY =
"switch-case-value-output";
+ public static final String SWITCH_CASE_GROUP_KEY = "switch-case-group";
+ public static final String OUTPUT_TYPE_SELECTION_KEY = "output-type";
+ public static final String DEFAULT_OUTPUT_VALUE_KEY =
"switch-case-value-default-output";
+
+ // Common Instance Fields
+ protected String selectedSwitchField;
+ protected String selectedOutputType;
+ protected List<SwitchCaseEntry> switchCaseEntries;
+ protected String defaultOutputValue;
+
+ // Common Methods
+
+ /**
+ * Extracts properties from a StaticPropertyGroup.
+ * This helper is used internally when parsing collections of static
properties.
+ * @param staticProperty The StaticProperty to extract from.
+ * @return A StaticPropertyExtractor instance for the given StaticProperty.
+ */
+ protected StaticPropertyExtractor getPropertyExtractor(StaticProperty
staticProperty) {
+ return StaticPropertyExtractor.from(
+ ((StaticPropertyGroup) staticProperty).getStaticProperties(),
+ new ArrayList<>()
+ );
+ }
+
+ /**
+ * Parses the collection of switch cases from the processor parameters.
+ * @param params The IDataProcessorParameters containing the static property
configurations.
+ * @return A list of SwitchCaseEntry objects.
+ **/
+ protected List<SwitchCaseEntry> getSwitchCases(IDataProcessorParameters
params) {
+ List<SwitchCaseEntry> cases = new ArrayList<>();
+ CollectionStaticProperty csp = (CollectionStaticProperty)
params.extractor()
+ .getStaticPropertyByName(SWITCH_CASE_GROUP_KEY);
+
+ if (csp != null && csp.getMembers() != null) { // Added null checks for
robustness
+ for (StaticProperty sp : csp.getMembers()) {
+ var propExtractor = getPropertyExtractor(sp);
+ SwitchCaseEntry switchCaseEntry = parseSwitchCaseEntry(propExtractor);
// Using new abstract method
+ cases.add(switchCaseEntry);
+ }
+ }
+ return cases;
+ }
+ protected abstract Object findMatchingResult(Event event);
+
+ @Override
+ public void onEvent(Event event, SpOutputCollector collector) {
+ var resultValue = findMatchingResult(event); // Calls the specific
implementation
+
+ // Add the result to the event and forward it
+ switch (this.selectedOutputType) {
+ case "String" -> event.addField(SWITCH_FILTER_OUTPUT_KEY,
resultValue.toString());
+ case "Boolean" -> {
+ try {
+ event.addField(SWITCH_FILTER_OUTPUT_KEY,
Boolean.parseBoolean(resultValue.toString()));
+ } catch (IllegalArgumentException e) {
+ event.addField(SWITCH_FILTER_OUTPUT_KEY, false);
+ }
+ }
+ case "Integer" -> {
+ try {
+ event.addField(SWITCH_FILTER_OUTPUT_KEY,
Integer.parseInt(resultValue.toString()));
+ } catch (NumberFormatException e) {
+ event.addField(SWITCH_FILTER_OUTPUT_KEY, 0);
+ }
+ }
+ default -> throw new IllegalArgumentException("Unsupported output type:
" + this.selectedOutputType);
+ }
+ collector.collect(event);
+ }
+
+ /**
+ * Parses a single SwitchCaseEntry from the provided StaticPropertyExtractor.
+ * This method is abstract because the parsing logic for case value and
operator varies
+ * slightly between Boolean, Numerical, and String processors.
+ * @param staticPropertyExtractor Extractor for the current switch case
group.
+ * @return A SwitchCaseEntry object.
+ */
+ protected SwitchCaseEntry parseSwitchCaseEntry(StaticPropertyExtractor
staticPropertyExtractor) {
+ return null;
+ }
+
+ /**
+ * Determines the default result value based on the selected output type.
+ * This method handles parsing the defaultOutputValue string into the
correct type.
+ * @return The default result value as an Object (String, Boolean, or
Integer).
+ */
+ protected Object getDefaultResult() {
+ return switch (this.selectedOutputType) {
+ case "String" -> this.defaultOutputValue;
+ case "Boolean" -> {
+ if (this.defaultOutputValue != null &&
(this.defaultOutputValue.equalsIgnoreCase("true")
+ || this.defaultOutputValue.equalsIgnoreCase("false"))) {
+ yield Boolean.parseBoolean(this.defaultOutputValue);
+ } else {
+ yield false; // Default boolean value if parsing fails or input is
null
+ }
+ }
+ case "Integer" -> {
+ try {
+ yield Integer.parseInt(this.defaultOutputValue);
+ } catch (NumberFormatException e) {
+ yield 0; // Default integer value if parsing fails
+ }
+ }
+ default -> throw new IllegalArgumentException("Unsupported output type:
" + this.selectedOutputType);
+ };
+ }
+}
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/IStreamPipesSwitchProcessor.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/IStreamPipesSwitchProcessor.java
new file mode 100644
index 0000000000..d90e36d4fb
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/IStreamPipesSwitchProcessor.java
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator;
+
+import org.apache.streampipes.extensions.api.pe.IStreamPipesDataProcessor;
+
+// Interface can be simpler as constants are now in
AbstractSwitchOperatorProcessor
+public interface IStreamPipesSwitchProcessor extends IStreamPipesDataProcessor
{
+ // No constants needed here as they are now in the abstract base class for
implementation details.
+ // If you had methods specific to the "Switch" concept that don't belong to
IStreamPipesDataProcessor,
+ // they would go here. For now, it mostly serves as a marker interface and
base for the abstract class.
+}
\ No newline at end of file
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/LogicalOperator.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/LogicalOperator.java
new file mode 100644
index 0000000000..d9afddae89
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/LogicalOperator.java
@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator;
+
+public class LogicalOperator {
+ private static final String[] EQUALS = {"equals", "=="};
+ private static final String[] NOT_EQUALS = {"notEquals", "!="};
+ private static final String[] GREATER_THAN = {"greaterThan", ">"};
+ private static final String[] LESS_THAN = {"lessThan", "<"};
+ private static final String[] GREATER_THAN_OR_EQUALS =
{"greaterThanOrEquals", ">="};
+ private static final String[] LESS_THAN_OR_EQUALS = {"lessThanOrEquals",
"<="};
+
+ // This method is for string comparisons (e.g., in the StringInputProcessor)
+ public static boolean evaluate(String operator, String inputValue, Object
compareValue) {
+ double eventNumericValue = 0.0;
+ double caseNumericValue = 0.0;
+
+ // Attempt to parse to double for numerical operators, otherwise use
string comparison
+ try {
+ eventNumericValue = Double.parseDouble(inputValue);
+ caseNumericValue = Double.parseDouble(compareValue.toString());
+ } catch (NumberFormatException e) {
+ // If not parseable as number, default to string comparison for "==" and
"!="
+ if (matches(operator, EQUALS)) {
+ return inputValue.equals(compareValue.toString());
+ } else if (matches(operator, NOT_EQUALS)) {
+ return !inputValue.equals(compareValue.toString());
+ } else {
+ // For numerical operators, if values are not numbers, it's an invalid
comparison.
+ // You might want to log this or handle it more gracefully depending
on requirements.
+ throw new IllegalArgumentException(
+ "Cannot perform numerical comparison on non-numeric string values
with operator: " + operator);
+ }
+ }
+
+
+ if (matches(operator, EQUALS)) {
+ return eventNumericValue == caseNumericValue;
+ } else if (matches(operator, NOT_EQUALS)) {
+ return eventNumericValue != caseNumericValue;
+ } else if (matches(operator, GREATER_THAN)) {
+ return eventNumericValue > caseNumericValue;
+ } else if (matches(operator, LESS_THAN)) {
+ return eventNumericValue < caseNumericValue;
+ } else if (matches(operator, GREATER_THAN_OR_EQUALS)) {
+ return eventNumericValue >= caseNumericValue;
+ } else if (matches(operator, LESS_THAN_OR_EQUALS)) {
+ return eventNumericValue <= caseNumericValue;
+ } else {
+ throw new IllegalArgumentException("Unknown operator: " + operator);
+ }
+ }
+
+ // This method is used by the NumericalInputProcessor.
+ public static boolean evaluate(String operator, double inputValue, Object
compareValue) {
+ double caseNumericValue = Double.parseDouble(compareValue.toString()); //
Value from the switch case config
+
+ if (matches(operator, EQUALS)) {
+ return inputValue == caseNumericValue;
+ } else if (matches(operator, NOT_EQUALS)) {
+ return inputValue != caseNumericValue;
+ } else if (matches(operator, GREATER_THAN)) {
+ // FIX APPLIED: inputValue is already a double.
+ return inputValue > caseNumericValue;
+ } else if (matches(operator, LESS_THAN)) {
+ // FIX APPLIED: inputValue is already a double.
+ return inputValue < caseNumericValue;
+ } else if (matches(operator, GREATER_THAN_OR_EQUALS)) {
+ // FIX APPLIED: inputValue is already a double.
+ return inputValue >= caseNumericValue;
+ } else if (matches(operator, LESS_THAN_OR_EQUALS)) {
+ // FIX APPLIED: inputValue is already a double.
+ return inputValue <= caseNumericValue;
+ } else {
+ throw new IllegalArgumentException("Unknown operator: " + operator);
+ }
+ }
+
+ private static boolean matches(String operator, String[] aliases) {
+ for (String alias : aliases) {
+ if (alias.equals(operator)) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/NumericalSwitchCaseEntry.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/NumericalSwitchCaseEntry.java
new file mode 100644
index 0000000000..5625099249
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/NumericalSwitchCaseEntry.java
@@ -0,0 +1,32 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator;
+
+public class NumericalSwitchCaseEntry extends SwitchCaseEntry {
+ private final String operator;
+
+ public NumericalSwitchCaseEntry(String caseValue, Object outputValue, String
operator) {
+ super(caseValue, outputValue); // Call base constructor for common fields
+ this.operator = operator;
+ }
+
+ public String getOperator() {
+ return operator;
+ }
+}
\ No newline at end of file
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/README.md
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/README.md
new file mode 100644
index 0000000000..b0edee462c
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/README.md
@@ -0,0 +1,119 @@
+<!--
+ ~ Licensed to the Apache Software Foundation (ASF) under one or more
+ ~ contributor license agreements. See the NOTICE file distributed with
+ ~ this work for additional information regarding copyright ownership.
+ ~ The ASF licenses this file to You under the Apache License, Version 2.0
+ ~ (the "License"); you may not use this file except in compliance with
+ ~ the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ ~
+ -->
+
+# StreamPipes Switch Operators
+
+This repository contains a suite of custom data processors for Apache
StreamPipes, designed to enable dynamic event routing and data transformation
based on specific field values. These "Switch Operators" allow users to define
conditional logic to alter events, append new fields, or categorize data within
a StreamPipes pipeline.
+
+## Overview
+
+The core idea behind these processors is to inspect a designated input field
within an event and, based on predefined "switch cases," apply a transformation
or assign an output value to the event. This facilitates advanced conditional
processing, enabling more intelligent data flows.
+
+The solution is built around an abstract base class
(`AbstractSwitchOperatorProcessor`) to provide a common structure and shared
logic, while concrete implementations handle the specifics of different data
types (Boolean, Numerical, String).
+
+## Processors Included
+
+1. **`SwitchOperatorBooleanInputProcessor`**: Routes events based on the
`true` or `false` value of a boolean input field.
+2. **`SwitchOperatorNumericalInputProcessor`**: Routes events based on
numerical comparisons (`==`, `!=`, `<`, `<=`, `>`, `>=`) against a numerical
input field.
+3. **`SwitchOperatorStringInputProcessor`**: Routes events based on exact
string matches against a string input field.
+
+## Core Components and How They Work
+
+### `AbstractSwitchOperatorProcessor.java`
+
+This is the abstract base class for all switch operators. It defines the
common structure and shared logic, minimizing code duplication across different
input types.
+
+* **Common Constants**: Defines static strings for property keys (e.g.,
`SWITCH_FILTER_INPUT_FIELD_KEY`, `SWITCH_CASE_GROUP_KEY`,
`SWITCH_FILTER_OUTPUT_KEY`), ensuring consistent naming and easier localization.
+* **Common Instance Fields**: Stores configuration parameters extracted during
pipeline startup, such as `selectedSwitchField`, `selectedOutputType`,
`switchCaseEntries`, and `defaultOutputValue`.
+* **`onEvent(Event event, SpOutputCollector collector)`**: This is the central
method called for every incoming event.
+ * It calls the abstract `findMatchingResult(Event event)` method, which is
implemented by the concrete processor to determine the output value based on
the event's field and the defined switch cases.
+ * Based on the `selectedOutputType` (String, Boolean, or Integer), it
converts the `resultValue` to the appropriate type.
+ * A new field, `switch-filter-result` (defined by
`SWITCH_FILTER_OUTPUT_KEY`), is added to the event with the processed
`resultValue`.
+ * The modified event is then forwarded to the next component in the
pipeline.
+ * Includes `try-catch` blocks for robust type conversion (e.g.,
`NumberFormatException` for Integers, `IllegalArgumentException` for Booleans).
+* **`getSwitchCases(IDataProcessorParameters params)`**: A helper method to
parse the collection of switch case definitions provided by the user in the
StreamPipes UI.
+* **`parseSwitchCaseEntry(StaticPropertyExtractor staticPropertyExtractor)`**:
An abstract method that forces concrete implementations to define how
individual switch case entries are parsed, as this varies slightly depending on
the input type (e.g., numerical cases include an operator).
+* **`getDefaultResult()`**: A helper method that determines the default output
value, converting the user-defined `defaultOutputValue` string into the
`selectedOutputType` (String, Boolean, or Integer).
+
+### `SwitchCaseEntry.java`
+
+A simple POJO (Plain Old Java Object) that represents a single switch case. It
holds:
+
+* `caseValue`: The value to compare against the input field (stored as a
`String`).
+* `outputValue`: The value to be outputted if this case matches (stored as an
`Object`).
+
+### `NumericalSwitchCaseEntry.java`
+
+Extends `SwitchCaseEntry` to specifically cater to numerical comparisons by
adding an `operator` field.
+
+* `operator`: Stores the logical operator (e.g., "==", "<", ">=") to be used
for comparison.
+
+### `LogicalOperator.java`
+
+This utility class provides static methods for evaluating numerical
comparisons.
+
+* **`evaluate(String operator, double inputValue, Object compareValue)`**:
Compares a `double` `inputValue` with a `compareValue` (parsed as `double`)
using the specified `operator`.
+* Supports various operators: `==`, `!=`, `<`, `<=`, `>`, `>=`.
+* Handles `IllegalArgumentException` for unknown operators.
+
+## Specific Processor Implementations
+
+Each concrete processor extends `AbstractSwitchOperatorProcessor` and provides
specific implementations for `declareConfig()`, `onPipelineStarted()`,
`parseSwitchCaseEntry()`, `findMatchingResult()`, and `onPipelineStopped()`.
+
+### `SwitchOperatorBooleanInputProcessor.java`
+
+* **`declareConfig()`**: Defines the UI configuration for a boolean switch. It
requires a boolean input stream property and allows users to define "true" or
"false" cases with corresponding output values.
+* **`parseSwitchCaseEntry()`**: Parses the `caseValue` and `outputValue` from
the static properties, creating a `SwitchCaseEntry`.
+* **`findMatchingResult()`**: Retrieves the boolean value from the event and
iterates through the `switchCaseEntries`. It uses `Boolean.parseBoolean()` to
compare the event's field value with the `caseValue` of each entry.
+
+### `SwitchOperatorNumericalInputProcessor.java`
+
+* **`declareConfig()`**: Defines the UI configuration for a numerical switch.
It requires a numerical input stream property and includes options for
selecting an operator for each case.
+* **`parseSwitchCaseEntry()`**: Parses the `caseValue`, `operator`, and
`outputValue`, creating a `NumericalSwitchCaseEntry`.
+* **`findMatchingResult()`**: Retrieves the numerical value from the event. It
then uses the `LogicalOperator.evaluate()` method to compare the event's field
value with the `caseValue` of each `NumericalSwitchCaseEntry` using the
specified `operator`.
+
+### `SwitchOperatorStringInputProcessor.java`
+
+* **`declareConfig()`**: Defines the UI configuration for a string switch. It
requires a string input stream property.
+* **`parseSwitchCaseEntry()`**: Parses the `caseValue` and `outputValue` from
the static properties, creating a `SwitchCaseEntry`.
+* **`findMatchingResult()`**: Retrieves the string value from the event and
iterates through the `switchCaseEntries`. It uses the `equals()` method for
direct string comparison.
+
+### `IStreamPipesSwitchProcessor.java`
+
+A simple marker interface that `AbstractSwitchOperatorProcessor` implements,
indicating that these classes are StreamPipes Data Processors.
+
+## Output
+
+All switch operators append a new field named `switch-filter-result` to the
outgoing event. The data type of this new field is determined by the `Output
Type` selected in the processor's configuration (`String`, `Boolean`, or
`Integer`).
+
+## Deployment and Usage
+
+These processors are designed to be deployed as extensions within an Apache
StreamPipes environment. Once deployed, they will appear in the StreamPipes UI
under the "Processors" category and can be dragged-and-dropped into pipelines
to perform conditional data transformations.
+
+## File Structure
+```plaintext
+.
+├── AbstractSwitchOperatorProcessor.java
+├── IStreamPipesSwitchProcessor.java
+├── LogicalOperator.java
+├── NumericalSwitchCaseEntry.java
+├── SwitchCaseEntry.java
+├── SwitchOperatorBooleanInputProcessor.java
+├── SwitchOperatorNumericalInputProcessor.java
+└── SwitchOperatorStringInputProcessor.java
+```
\ No newline at end of file
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/SwitchCaseEntry.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/SwitchCaseEntry.java
new file mode 100644
index 0000000000..7e80411805
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/SwitchCaseEntry.java
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator;
+
+public class SwitchCaseEntry {
+ private final String caseValue;
+ private final Object outputValue;
+
+ public SwitchCaseEntry(String caseValue, Object outputValue) {
+ this.caseValue = caseValue;
+ this.outputValue = outputValue;
+ }
+
+ public String getCaseValue() {
+ return caseValue;
+ }
+
+ public Object getOutputValue() {
+ return outputValue;
+ }
+}
\ No newline at end of file
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/booleaninput/SwitchOperatorBooleanInputProcessor.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/booleaninput/SwitchOperatorBooleanInputProcessor.java
new file mode 100644
index 0000000000..d063d3eaeb
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/booleaninput/SwitchOperatorBooleanInputProcessor.java
@@ -0,0 +1,123 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.booleaninput;
+
+import
org.apache.streampipes.extensions.api.pe.config.IDataProcessorConfiguration;
+import
org.apache.streampipes.extensions.api.pe.context.EventProcessorRuntimeContext;
+import org.apache.streampipes.extensions.api.pe.param.IDataProcessorParameters;
+import org.apache.streampipes.extensions.api.pe.routing.SpOutputCollector;
+import org.apache.streampipes.model.DataProcessorType;
+import org.apache.streampipes.model.extensions.ExtensionAssetType;
+import org.apache.streampipes.model.runtime.Event;
+import org.apache.streampipes.model.schema.PropertyScope;
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.AbstractSwitchOperatorProcessor;
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.SwitchCaseEntry;
+import org.apache.streampipes.sdk.StaticProperties;
+import org.apache.streampipes.sdk.builder.PrimitivePropertyBuilder;
+import org.apache.streampipes.sdk.builder.ProcessingElementBuilder;
+import org.apache.streampipes.sdk.builder.StreamRequirementsBuilder;
+import org.apache.streampipes.sdk.builder.processor.DataProcessorConfiguration;
+import org.apache.streampipes.sdk.extractor.StaticPropertyExtractor;
+import org.apache.streampipes.sdk.helpers.EpRequirements;
+import org.apache.streampipes.sdk.helpers.Labels;
+import org.apache.streampipes.sdk.helpers.Locales;
+import org.apache.streampipes.sdk.helpers.Options;
+import org.apache.streampipes.sdk.helpers.OutputStrategies;
+import org.apache.streampipes.sdk.utils.Datatypes;
+
+public class SwitchOperatorBooleanInputProcessor extends
AbstractSwitchOperatorProcessor {
+
+ @Override
+ public IDataProcessorConfiguration declareConfig() {
+ return DataProcessorConfiguration.create(
+ SwitchOperatorBooleanInputProcessor::new,
+
ProcessingElementBuilder.create("org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean"
+ , 0)
+ .withAssets(ExtensionAssetType.DOCUMENTATION,
ExtensionAssetType.ICON)
+ .withLocales(Locales.EN)
+ .category(DataProcessorType.TRANSFORM)
+ .requiredStream(StreamRequirementsBuilder
+ .create()
+ .requiredPropertyWithUnaryMapping(EpRequirements.booleanReq(),
+ Labels.withId(SWITCH_FILTER_INPUT_FIELD_KEY),
+ PropertyScope.MEASUREMENT_PROPERTY)
+ .build()
+ )
+
.requiredSingleValueSelection(Labels.withId(OUTPUT_TYPE_SELECTION_KEY),
Options.from("String", "Boolean",
+ "Integer"))
+ .requiredCollection(Labels.withId(SWITCH_CASE_GROUP_KEY),
+
StaticProperties.singleValueSelection(Labels.withId(SWITCH_CASE_VALUE_KEY),
Options.from("true",
+ "false")),
+
StaticProperties.freeTextProperty(Labels.withId(SWITCH_CASE_OUTPUT_VALUE_KEY),
Datatypes.String))
+ .outputStrategy(OutputStrategies.append(
+ PrimitivePropertyBuilder.create(Datatypes.String,
SWITCH_FILTER_OUTPUT_KEY).build())
+ )
+ .requiredTextParameter(Labels.withId(DEFAULT_OUTPUT_VALUE_KEY), "")
+ .build()
+ );
+ }
+
+ @Override
+ public void onPipelineStarted(IDataProcessorParameters params,
SpOutputCollector collector,
+ EventProcessorRuntimeContext runtimeContext) {
+ // Extract the selected field
+ this.selectedSwitchField =
params.extractor().mappingPropertyValue(SWITCH_FILTER_INPUT_FIELD_KEY);
+ // Extract the output type
+ this.selectedOutputType =
params.extractor().selectedSingleValue(OUTPUT_TYPE_SELECTION_KEY, String.class);
+ // Extract all switch case entries
+ this.switchCaseEntries = this.getSwitchCases(params);
+ // Extract the default output value
+ this.defaultOutputValue =
params.extractor().textParameter(DEFAULT_OUTPUT_VALUE_KEY);
+ }
+
+ @Override
+ protected SwitchCaseEntry parseSwitchCaseEntry(StaticPropertyExtractor
staticPropertyExtractor) {
+ // Specific implementation for BooleanInputProcessor
+ var switchCaseValue =
staticPropertyExtractor.selectedSingleValue(SWITCH_CASE_VALUE_KEY,
String.class);
+ var switchCaseOutput =
staticPropertyExtractor.textParameter(SWITCH_CASE_OUTPUT_VALUE_KEY);
+ return new SwitchCaseEntry(switchCaseValue, switchCaseOutput);
+ }
+
+ @Override
+ protected Object findMatchingResult(Event event) {
+ Boolean switchValue =
event.getFieldBySelector(this.selectedSwitchField).getAsPrimitive().getAsBoolean();
+ Object resultValue = getDefaultResult(); // Initial default result
+
+ try {
+ for (SwitchCaseEntry switchCase : this.switchCaseEntries) {
+ if (switchValue == Boolean.parseBoolean(switchCase.getCaseValue())) {
+ resultValue = switchCase.getOutputValue();
+ break;
+ }
+ }
+ } catch (Exception e) {
+ resultValue = getDefaultResult();
+ }
+ return resultValue;
+ }
+
+
+ @Override
+ public void onPipelineStopped() {
+ this.switchCaseEntries = null;
+ this.selectedOutputType = null;
+ this.selectedSwitchField = null;
+ this.defaultOutputValue = null;
+ }
+}
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/numericalinput/SwitchOperatorNumericalInputProcessor.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/numericalinput/SwitchOperatorNumericalInputProcessor.java
new file mode 100644
index 0000000000..5642c7b990
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/numericalinput/SwitchOperatorNumericalInputProcessor.java
@@ -0,0 +1,139 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.numericalinput;
+
+import
org.apache.streampipes.extensions.api.pe.config.IDataProcessorConfiguration;
+import
org.apache.streampipes.extensions.api.pe.context.EventProcessorRuntimeContext;
+import org.apache.streampipes.extensions.api.pe.param.IDataProcessorParameters;
+import org.apache.streampipes.extensions.api.pe.routing.SpOutputCollector;
+import org.apache.streampipes.model.DataProcessorType;
+import org.apache.streampipes.model.extensions.ExtensionAssetType;
+import org.apache.streampipes.model.runtime.Event;
+import org.apache.streampipes.model.schema.PropertyScope;
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.AbstractSwitchOperatorProcessor;
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.LogicalOperator;
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.NumericalSwitchCaseEntry;
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.SwitchCaseEntry;
+import org.apache.streampipes.sdk.StaticProperties;
+import org.apache.streampipes.sdk.builder.PrimitivePropertyBuilder;
+import org.apache.streampipes.sdk.builder.ProcessingElementBuilder;
+import org.apache.streampipes.sdk.builder.StreamRequirementsBuilder;
+import org.apache.streampipes.sdk.builder.processor.DataProcessorConfiguration;
+import org.apache.streampipes.sdk.extractor.StaticPropertyExtractor;
+import org.apache.streampipes.sdk.helpers.EpRequirements;
+import org.apache.streampipes.sdk.helpers.Labels;
+import org.apache.streampipes.sdk.helpers.Locales;
+import org.apache.streampipes.sdk.helpers.Options;
+import org.apache.streampipes.sdk.helpers.OutputStrategies;
+import org.apache.streampipes.sdk.utils.Datatypes;
+
+public class SwitchOperatorNumericalInputProcessor extends
AbstractSwitchOperatorProcessor {
+
+ @Override
+ public IDataProcessorConfiguration declareConfig() {
+ return DataProcessorConfiguration.create(
+ SwitchOperatorNumericalInputProcessor::new,
+
ProcessingElementBuilder.create("org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical"
+ , 0)
+ .withAssets(ExtensionAssetType.DOCUMENTATION,
ExtensionAssetType.ICON)
+ .withLocales(Locales.EN)
+ .category(DataProcessorType.TRANSFORM)
+ .requiredStream(
+ StreamRequirementsBuilder.create()
+ .requiredPropertyWithUnaryMapping(
+ EpRequirements.datatypeReq(Datatypes.Number),
+ Labels.withId(SWITCH_FILTER_INPUT_FIELD_KEY),
PropertyScope.MEASUREMENT_PROPERTY)
+ .build()
+ )
+ .requiredSingleValueSelection(
+ Labels.withId(OUTPUT_TYPE_SELECTION_KEY),
Options.from("String", "Boolean", "Integer"))
+ .requiredCollection(
+ Labels.withId(SWITCH_CASE_GROUP_KEY),
StaticProperties.doubleFreeTextProperty(
+ Labels.withId(SWITCH_CASE_VALUE_KEY)
+ ),
+ StaticProperties.singleValueSelection(
+ Labels.withId(SWITCH_CASE_OPERATOR_KEY),
+ Options.from("==", "!=", "<", "<=", ">", ">=")
+ ),
+ StaticProperties.freeTextProperty(
+ Labels.withId(SWITCH_CASE_OUTPUT_VALUE_KEY),
+ Datatypes.String
+ )
+ )
+ .outputStrategy(
+ OutputStrategies.append(
+ PrimitivePropertyBuilder.create(Datatypes.String,
SWITCH_FILTER_OUTPUT_KEY).build()
+ )
+ )
+ .requiredTextParameter(Labels.withId(DEFAULT_OUTPUT_VALUE_KEY), "")
+ .build()
+ );
+ }
+
+ @Override
+ public void onPipelineStarted(IDataProcessorParameters params,
SpOutputCollector collector,
+ EventProcessorRuntimeContext runtimeContext) {
+ // Extract the selected field
+ this.selectedSwitchField =
params.extractor().mappingPropertyValue(SWITCH_FILTER_INPUT_FIELD_KEY);
+ // Extract the output type
+ this.selectedOutputType =
params.extractor().selectedSingleValue(OUTPUT_TYPE_SELECTION_KEY, String.class);
+ // Extract all switch case entries
+ this.switchCaseEntries = this.getSwitchCases(params);
+ // Extract the default output value
+ this.defaultOutputValue =
params.extractor().textParameter(DEFAULT_OUTPUT_VALUE_KEY);
+ }
+
+ @Override
+ protected SwitchCaseEntry parseSwitchCaseEntry(StaticPropertyExtractor
staticPropertyExtractor) {
+ // Specific implementation for NumericalInputProcessor
+ var switchCaseValue =
staticPropertyExtractor.textParameter(SWITCH_CASE_VALUE_KEY);
+ var switchCaseOperator =
staticPropertyExtractor.selectedSingleValue(SWITCH_CASE_OPERATOR_KEY,
String.class);
+ var switchCaseOutput =
staticPropertyExtractor.textParameter(SWITCH_CASE_OUTPUT_VALUE_KEY);
+ return new NumericalSwitchCaseEntry(switchCaseValue, switchCaseOutput,
switchCaseOperator);
+ }
+
+ @Override
+ protected Object findMatchingResult(Event event) {
+ Double switchValue =
event.getFieldBySelector(this.selectedSwitchField).getAsPrimitive().getAsDouble();
+ Object resultValue = getDefaultResult();
+
+ try {
+ for (SwitchCaseEntry entry : this.switchCaseEntries) {
+ // Must cast to NumericalSwitchCaseEntry to get the operator
+ if (entry instanceof NumericalSwitchCaseEntry numericalCase) {
+ if (LogicalOperator.evaluate(numericalCase.getOperator(),
switchValue, numericalCase.getCaseValue())) {
+ resultValue = numericalCase.getOutputValue();
+ break;
+ }
+ }
+ }
+ } catch (Exception e) {
+ resultValue = getDefaultResult();
+ }
+ return resultValue;
+ }
+
+ @Override
+ public void onPipelineStopped() {
+ this.switchCaseEntries = null;
+ this.selectedOutputType = null;
+ this.selectedSwitchField = null;
+ this.defaultOutputValue = null;
+ }
+}
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/stringinput/SwitchOperatorStringInputProcessor.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/stringinput/SwitchOperatorStringInputProcessor.java
new file mode 100644
index 0000000000..33ade489ba
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/stringinput/SwitchOperatorStringInputProcessor.java
@@ -0,0 +1,120 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.stringinput;
+
+import
org.apache.streampipes.extensions.api.pe.config.IDataProcessorConfiguration;
+import
org.apache.streampipes.extensions.api.pe.context.EventProcessorRuntimeContext;
+import org.apache.streampipes.extensions.api.pe.param.IDataProcessorParameters;
+import org.apache.streampipes.extensions.api.pe.routing.SpOutputCollector;
+import org.apache.streampipes.model.DataProcessorType;
+import org.apache.streampipes.model.extensions.ExtensionAssetType;
+import org.apache.streampipes.model.runtime.Event;
+import org.apache.streampipes.model.schema.PropertyScope;
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.AbstractSwitchOperatorProcessor;
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.SwitchCaseEntry;
+import org.apache.streampipes.sdk.StaticProperties;
+import org.apache.streampipes.sdk.builder.PrimitivePropertyBuilder;
+import org.apache.streampipes.sdk.builder.ProcessingElementBuilder;
+import org.apache.streampipes.sdk.builder.StreamRequirementsBuilder;
+import org.apache.streampipes.sdk.builder.processor.DataProcessorConfiguration;
+import org.apache.streampipes.sdk.extractor.StaticPropertyExtractor;
+import org.apache.streampipes.sdk.helpers.EpRequirements;
+import org.apache.streampipes.sdk.helpers.Labels;
+import org.apache.streampipes.sdk.helpers.Locales;
+import org.apache.streampipes.sdk.helpers.Options;
+import org.apache.streampipes.sdk.helpers.OutputStrategies;
+import org.apache.streampipes.sdk.utils.Datatypes;
+
+public class SwitchOperatorStringInputProcessor extends
AbstractSwitchOperatorProcessor {
+
+ @Override
+ public IDataProcessorConfiguration declareConfig() {
+ return DataProcessorConfiguration.create(
+ SwitchOperatorStringInputProcessor::new,
+
ProcessingElementBuilder.create("org.apache.streampipes.processors.transformation.jvm.switchoperator.string",
0)
+ .withAssets(ExtensionAssetType.DOCUMENTATION,
ExtensionAssetType.ICON)
+ .withLocales(Locales.EN)
+ .category(DataProcessorType.TRANSFORM)
+ .requiredStream(StreamRequirementsBuilder
+ .create()
+ .requiredPropertyWithUnaryMapping(EpRequirements.stringReq(),
+ Labels.withId(SWITCH_FILTER_INPUT_FIELD_KEY),
+ PropertyScope.MEASUREMENT_PROPERTY)
+ .build()
+ )
+
.requiredSingleValueSelection(Labels.withId(OUTPUT_TYPE_SELECTION_KEY),
Options.from("String", "Boolean",
+ "Integer"))
+ .requiredCollection(Labels.withId(SWITCH_CASE_GROUP_KEY),
+
StaticProperties.freeTextProperty(Labels.withId(SWITCH_CASE_VALUE_KEY),
Datatypes.String),
+
StaticProperties.freeTextProperty(Labels.withId(SWITCH_CASE_OUTPUT_VALUE_KEY),
Datatypes.String))
+ .outputStrategy(OutputStrategies.append(
+ PrimitivePropertyBuilder.create(Datatypes.String,
SWITCH_FILTER_OUTPUT_KEY).build())
+ )
+ .requiredTextParameter(Labels.withId(DEFAULT_OUTPUT_VALUE_KEY), "")
+ .build()
+ );
+ }
+
+ @Override
+ public void onPipelineStarted(IDataProcessorParameters params,
SpOutputCollector collector,
+ EventProcessorRuntimeContext runtimeContext) {
+ // Extract the selected field
+ this.selectedSwitchField =
params.extractor().mappingPropertyValue(SWITCH_FILTER_INPUT_FIELD_KEY);
+ // Extract the output type
+ this.selectedOutputType =
params.extractor().selectedSingleValue(OUTPUT_TYPE_SELECTION_KEY, String.class);
+ // Extract all switch case entries
+ this.switchCaseEntries = this.getSwitchCases(params);
+ // Extract the default output value
+ this.defaultOutputValue =
params.extractor().textParameter(DEFAULT_OUTPUT_VALUE_KEY);
+ }
+
+ @Override
+ protected SwitchCaseEntry parseSwitchCaseEntry(StaticPropertyExtractor
staticPropertyExtractor) {
+ // Specific implementation for StringInputProcessor
+ var switchCaseValue =
staticPropertyExtractor.textParameter(SWITCH_CASE_VALUE_KEY);
+ var switchCaseOutput =
staticPropertyExtractor.textParameter(SWITCH_CASE_OUTPUT_VALUE_KEY);
+ return new SwitchCaseEntry(switchCaseValue, switchCaseOutput);
+ }
+
+ @Override
+ protected Object findMatchingResult(Event event) {
+ String switchValue =
event.getFieldBySelector(this.selectedSwitchField).getAsPrimitive().getAsString();
+ Object resultValue = getDefaultResult();
+
+ try {
+ for (SwitchCaseEntry switchCase : this.switchCaseEntries) {
+ if (switchValue.equals(switchCase.getCaseValue())) {
+ resultValue = switchCase.getOutputValue();
+ break;
+ }
+ }
+ } catch (Exception e) {
+ resultValue = getDefaultResult();
+ }
+ return resultValue;
+ }
+
+ @Override
+ public void onPipelineStopped() {
+ this.switchCaseEntries = null;
+ this.selectedOutputType = null;
+ this.selectedSwitchField = null;
+ this.defaultOutputValue = null;
+ }
+}
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean/documentation.md
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean/documentation.md
new file mode 100644
index 0000000000..f31af89b93
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean/documentation.md
@@ -0,0 +1,78 @@
+<!--
+ ~ Licensed to the Apache Software Foundation (ASF) under one or more
+ ~ contributor license agreements. See the NOTICE file distributed with
+ ~ this work for additional information regarding copyright ownership.
+ ~ The ASF licenses this file to You under the Apache License, Version 2.0
+ ~ (the "License"); you may not use this file except in compliance with
+ ~ the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ ~
+ -->
+
+# Switch Operator (Boolean Input)
+
+<p>
+ <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+## Description
+
+The `Switch Operator (Boolean Input)` is a StreamPipes data processor that
allows you to route events based on the value of a selected boolean field. You
can define multiple "switch cases," each with a specific boolean value (true or
false) and a corresponding output value. If the input boolean field matches a
case, the defined output value will be added to the event. A default output
value is used if no case matches or an error occurs during processing.
+
+## Configuration
+
+### Input Stream Requirements
+
+This processor requires an input stream with at least one boolean property.
+
+### Output Strategy
+
+This processor appends a new field to the event with the processed output
value. The name of the output field is `switch-output`.
+
+### Static Properties
+
+* **Switch Field**: Select the boolean field from the input stream that will
be used for the switch condition.
+* **Output Type**: Choose the data type of the output value. Available options
are:
+ * `String`
+ * `Boolean`
+ * `Integer`
+* **Switch Cases**: Define the different switch conditions and their
corresponding output values. Each switch case consists of:
+ * **Case Value**: The boolean value (`true` or `false`) to match against
the selected switch field.
+ * **Output Value**: The value to output if this case matches. This value
will be converted to the selected `Output Type`.
+* **Default Output Value**: The value to use if none of the defined switch
cases match the input or if an error occurs during processing. This value will
also be converted to the selected `Output Type`.
+
+## Example
+
+Let's say you have an event with a boolean field `isValid` and you want to
output a "Status" string based on its value:
+
+| Original Event |
+| :------------- |
+| `{ "isValid": true }` |
+
+**Configuration:**
+
+* **Switch Field**: `isValid`
+* **Output Type**: `String`
+* **Switch Cases**:
+ * Case Value: `true`, Output Value: `Valid Data`
+ * Case Value: `false`, Output Value: `Invalid Data`
+* **Default Output Value**: `Unknown`
+
+**Output Event when `isValid` is `true`:**
+
+| Processed Event |
+| :-------------- |
+| `{ "isValid": true, "switch-output": "Valid Data" }` |
+
+**Output Event when `isValid` is `false`:**
+
+| Processed Event |
+| :-------------- |
+| `{ "isValid": false, "switch-output": "Invalid Data" }` |
\ No newline at end of file
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean/icon.png
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean/icon.png
new file mode 100644
index 0000000000..082fb3355f
Binary files /dev/null and
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean/icon.png
differ
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean/strings.en
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean/strings.en
new file mode 100644
index 0000000000..1c38d1ca77
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean/strings.en
@@ -0,0 +1,40 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean.title=Switch
Operator (Boolean Input)
+org.apache.streampipes.processors.transformation.jvm.switchoperator.boolean.description=Routes
events based on a boolean input field, allowing for different outputs based on
true/false conditions.
+
+switch-filter-key.title=Switch Field
+switch-filter-key.description=Select the boolean field from the input stream
that will be used for the switch condition.
+
+output-type-key.title=Output Type
+output-type-key.description=Choose the data type of the output value (String,
Boolean, or Integer).
+
+switch-case-group.title=Switch Cases
+switch-case-group.description=Define the different switch conditions and their
corresponding output values.
+
+switch-case-value.title=Case Value
+switch-case-value.description=The boolean value (true or false) to match
against the selected switch field.
+
+switch-case-value-output.title=Output Value
+switch-case-value-output.description=The value to output if this case matches.
This value will be converted to the selected Output Type.
+
+switch-case-value-default-output.title=Default Output Value
+switch-case-value-default-output.description=The value to use if none of the
defined switch cases match the input or if an error occurs.
+
+switch-filter-output-key.title=switch-output
+switch-filter-output-key.description=The output field containing the result of
the switch operation.
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical/documentation.md
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical/documentation.md
new file mode 100644
index 0000000000..c77995a590
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical/documentation.md
@@ -0,0 +1,84 @@
+<!--
+ ~ Licensed to the Apache Software Foundation (ASF) under one or more
+ ~ contributor license agreements. See the NOTICE file distributed with
+ ~ this work for additional information regarding copyright ownership.
+ ~ The ASF licenses this file to You under the Apache License, Version 2.0
+ ~ (the "License"); you may not use this file except in compliance with
+ ~ the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ ~
+ -->
+# Switch Operator (Numerical Input)
+<p>
+ <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+## Description
+
+The `Switch Operator (Numerical Input)` is a StreamPipes data processor that
allows you to route events based on the numerical value of a selected field.
You can define multiple "switch cases," each with a numerical value, an
operator (e.g., `==`, `!=`, `<`, `<=`, `>`, `>=`), and a corresponding output
value. If the input numerical field matches a case based on the specified
operator, the defined output value will be added to the event. A default output
value is used if no case matches o [...]
+
+## Configuration
+
+### Input Stream Requirements
+
+This processor requires an input stream with at least one numerical property.
+
+### Output Strategy
+
+This processor appends a new field to the event with the processed output
value. The name of the output field is `switch-output`.
+
+### Static Properties
+
+* **Switch Field**: Select the numerical field from the input stream that will
be used for the switch condition.
+* **Output Type**: Choose the data type of the output value. Available options
are:
+ * `String`
+ * `Boolean`
+ * `Integer`
+* **Switch Cases**: Define the different switch conditions and their
corresponding output values. Each switch case consists of:
+ * **Case Value**: The numerical value to compare against the selected
switch field.
+ * **Operator**: The logical operator to use for the comparison (e.g., `==`
(equals), `!=` (not equals), `<` (less than), `<=` (less than or equals), `>`
(greater than), `>=` (greater than or equals)).
+ * **Output Value**: The value to output if this case matches. This value
will be converted to the selected `Output Type`.
+* **Default Output Value**: The value to use if none of the defined switch
cases match the input or if an error occurs during processing. This value will
also be converted to the selected `Output Type`.
+
+## Example
+
+Let's say you have an event with a numerical field `temperature` and you want
to output a "Status" string based on its value:
+
+| Original Event |
+| :------------- |
+| `{ "temperature": 25.5 }` |
+
+**Configuration:**
+
+* **Switch Field**: `temperature`
+* **Output Type**: `String`
+* **Switch Cases**:
+ * Case Value: `20`, Operator: `<=`, Output Value: `Cold`
+ * Case Value: `30`, Operator: `>`, Output Value: `Hot`
+ * Case Value: `20`, Operator: `>`, Output Value: `Moderate`
+* **Default Output Value**: `Unknown`
+
+**Output Event when `temperature` is `15`:**
+
+| Processed Event |
+| :-------------- |
+| `{ "temperature": 15.0, "switch-output": "Cold" }` |
+
+**Output Event when `temperature` is `28`:**
+
+| Processed Event |
+| :-------------- |
+| `{ "temperature": 28.0, "switch-output": "Moderate" }` |
+
+**Output Event when `temperature` is `35`:**
+
+| Processed Event |
+| :-------------- |
+| `{ "temperature": 35.0, "switch-output": "Hot" }` |
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical/icon.png
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical/icon.png
new file mode 100644
index 0000000000..082fb3355f
Binary files /dev/null and
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical/icon.png
differ
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical/strings.en
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical/strings.en
new file mode 100644
index 0000000000..dbd84506c9
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical/strings.en
@@ -0,0 +1,43 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical.title=Switch
Operator (Numerical Input)
+org.apache.streampipes.processors.transformation.jvm.switchoperator.numerical.description=Routes
events based on a numerical input field, allowing for different outputs based
on comparison conditions.
+
+switch-filter-key.title=Switch Field
+switch-filter-key.description=Select the numerical field from the input stream
that will be used for the switch condition.
+
+output-type-key.title=Output Type
+output-type-key.description=Choose the data type of the output value (String,
Boolean, or Integer).
+
+switch-case-group.title=Switch Cases
+switch-case-group.description=Define the different switch conditions and their
corresponding output values.
+
+switch-case-value.title=Case Value
+switch-case-value.description=The numerical value to compare against the
selected switch field.
+
+switch-case-value-operator.title=Operator
+switch-case-value-operator.description=The logical operator to use for the
comparison (e.g., ==, !=, <, <=, >, >=).
+
+switch-case-value-output.title=Output Value
+switch-case-value-output.description=The value to output if this case matches.
This value will be converted to the selected Output Type.
+
+switch-case-value-default-output.title=Default Output Value
+switch-case-value-default-output.description=The value to use if none of the
defined switch cases match the input or if an error occurs.
+
+switch-filter-output-key.title=switch-output
+switch-filter-output-key.description=The output field containing the result of
the switch operation.
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.string/documentation.md
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.string/documentation.md
new file mode 100644
index 0000000000..eef3cfb431
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.string/documentation.md
@@ -0,0 +1,78 @@
+<!--
+ ~ Licensed to the Apache Software Foundation (ASF) under one or more
+ ~ contributor license agreements. See the NOTICE file distributed with
+ ~ this work for additional information regarding copyright ownership.
+ ~ The ASF licenses this file to You under the Apache License, Version 2.0
+ ~ (the "License"); you may not use this file except in compliance with
+ ~ the License. You may obtain a copy of the License at
+ ~
+ ~ http://www.apache.org/licenses/LICENSE-2.0
+ ~
+ ~ Unless required by applicable law or agreed to in writing, software
+ ~ distributed under the License is distributed on an "AS IS" BASIS,
+ ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ~ See the License for the specific language governing permissions and
+ ~ limitations under the License.
+ ~
+ -->
+# Switch Operator (String Input)
+
+<p align="center">
+ <img src="icon.png" width="150px;" class="pe-image-documentation"/>
+</p>
+
+## Description
+
+The `Switch Operator (String Input)` is a StreamPipes data processor that
allows you to route events based on the value of a selected string field. You
can define multiple "switch cases," each with a specific string value and a
corresponding output value. If the input string field matches a case, the
defined output value will be added to the event. A default output value is used
if no case matches or an error occurs during processing.
+
+## Configuration
+
+### Input Stream Requirements
+
+This processor requires an input stream with at least one string property.
+
+### Output Strategy
+
+This processor appends a new field to the event with the processed output
value. The name of the output field is `switch-output`.
+
+### Static Properties
+
+* **Switch Field**: Select the string field from the input stream that will be
used for the switch condition.
+* **Output Type**: Choose the data type of the output value. Available options
are:
+ * `String`
+ * `Boolean`
+ * `Integer`
+* **Switch Cases**: Define the different switch conditions and their
corresponding output values. Each switch case consists of:
+ * **Case Value**: The string value to match against the selected switch
field.
+ * **Output Value**: The value to output if this case matches. This value
will be converted to the selected `Output Type`.
+* **Default Output Value**: The value to use if none of the defined switch
cases match the input or if an error occurs during processing. This value will
also be converted to the selected `Output Type`.
+
+## Example
+
+Let's say you have an event with a string field `status` and you want to
output a "Severity" integer based on its value:
+
+| Original Event |
+| :------------- |
+| `{ "status": "Warning" }` |
+
+**Configuration:**
+
+* **Switch Field**: `status`
+* **Output Type**: `Integer`
+* **Switch Cases**:
+ * Case Value: `Critical`, Output Value: `3`
+ * Case Value: `Warning`, Output Value: `2`
+ * Case Value: `Info`, Output Value: `1`
+* **Default Output Value**: `0`
+
+**Output Event when `status` is `Warning`:**
+
+| Processed Event |
+| :-------------- |
+| `{ "status": "Warning", "switch-output": 2 }` |
+
+**Output Event when `status` is `Error` (and not explicitly defined):**
+
+| Processed Event |
+| :-------------- |
+| `{ "status": "Error", "switch-output": 0 }` |
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.string/icon.png
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.string/icon.png
new file mode 100644
index 0000000000..082fb3355f
Binary files /dev/null and
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.string/icon.png
differ
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.string/strings.en
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.string/strings.en
new file mode 100644
index 0000000000..5c74fee92d
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/main/resources/org.apache.streampipes.processors.transformation.jvm.switchoperator.string/strings.en
@@ -0,0 +1,40 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+org.apache.streampipes.processors.transformation.jvm.switchoperator.string.title=Switch
Operator (String Input)
+org.apache.streampipes.processors.transformation.jvm.switchoperator.string.description=Routes
events based on a string input field, allowing for different outputs based on
exact string matches.
+
+switch-filter-key.title=Switch Field
+switch-filter-key.description=Select the string field from the input stream
that will be used for the switch condition.
+
+output-type-key.title=Output Type
+output-type-key.description=Choose the data type of the output value (String,
Boolean, or Integer).
+
+switch-case-group.title=Switch Cases
+switch-case-group.description=Define the different switch conditions and their
corresponding output values.
+
+switch-case-value.title=Case Value
+switch-case-value.description=The string value to match against the selected
switch field.
+
+switch-case-value-output.title=Output Value
+switch-case-value-output.description=The value to output if this case matches.
This value will be converted to the selected Output Type.
+
+switch-case-value-default-output.title=Default Output Value
+switch-case-value-default-output.description=The value to use if none of the
defined switch cases match the input or if an error occurs.
+
+switch-filter-output-key.title=switch-output
+switch-filter-output-key.description=The output field containing the result of
the switch operation.
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/booleaninput/TestSwitchOperatorBooleanInputProcessor.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/booleaninput/TestSwitchOperatorBooleanInputProcessor.java
new file mode 100644
index 0000000000..0dbb842067
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/booleaninput/TestSwitchOperatorBooleanInputProcessor.java
@@ -0,0 +1,330 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.booleaninput;
+
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.AbstractSwitchOperatorProcessor;
+import org.apache.streampipes.test.executors.ProcessingElementTestExecutor;
+import org.apache.streampipes.test.executors.TestConfiguration;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+public class TestSwitchOperatorBooleanInputProcessor {
+ private static final String SWITCH_FILTER_OUTPUT_KEY =
AbstractSwitchOperatorProcessor.SWITCH_FILTER_OUTPUT_KEY;
+ private static final String SWITCH_FILTER_INPUT_FIELD_KEY =
+ AbstractSwitchOperatorProcessor.SWITCH_FILTER_INPUT_FIELD_KEY;
+ private static final String SWITCH_CASE_VALUE_KEY =
AbstractSwitchOperatorProcessor.SWITCH_CASE_VALUE_KEY;
+ private static final String SWITCH_CASE_OUTPUT_VALUE_KEY =
+ AbstractSwitchOperatorProcessor.SWITCH_CASE_OUTPUT_VALUE_KEY;
+ private static final String SWITCH_CASE_GROUP_KEY =
AbstractSwitchOperatorProcessor.SWITCH_CASE_GROUP_KEY;
+ private static final String OUTPUT_TYPE_SELECTION_KEY =
AbstractSwitchOperatorProcessor.OUTPUT_TYPE_SELECTION_KEY;
+ private static final String DEFAULT_OUTPUT_VALUE_KEY =
AbstractSwitchOperatorProcessor.DEFAULT_OUTPUT_VALUE_KEY;
+
+ private SwitchOperatorBooleanInputProcessor processor;
+
+ @BeforeEach
+ void setUp() {
+ this.processor = new SwitchOperatorBooleanInputProcessor();
+ }
+
+ // Helper to create a single switch case configuration for the collection
static property
+ private Map<String, Object> createSingleBooleanSwitchCaseConfig(String
caseValue, String outputValue) {
+ return Map.of(
+ SWITCH_CASE_VALUE_KEY, caseValue, // Use new constant
+ SWITCH_CASE_OUTPUT_VALUE_KEY, outputValue // Use new constant
+ );
+ }
+
+ private List<Map<String, Object>>
createMultipleBooleanSwitchCaseConfigs(Map<String, String> cases) {
+ List<Map<String, Object>> configList = new java.util.ArrayList<>();
+ cases.forEach((caseVal, outputVal) ->
+ configList.add(Map.of(
+ SWITCH_CASE_VALUE_KEY, caseVal, // Use new constant
+ SWITCH_CASE_OUTPUT_VALUE_KEY, outputVal // Use new constant
+ ))
+ );
+ return configList;
+ }
+
+ @Test
+ void onEvent_StringOutputType_MatchingTrueCase() {
+ String inputField = "status";
+ String expectedOutput = "STATUS_ACTIVE";
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField, // Use new constant
+ OUTPUT_TYPE_SELECTION_KEY, "String", // Use new constant
+ SWITCH_CASE_GROUP_KEY,
createMultipleBooleanSwitchCaseConfigs(Map.of("true", expectedOutput, "false",
+ "STATUS_INACTIVE")), // Use new constant
+ DEFAULT_OUTPUT_VALUE_KEY, "UNKNOWN" // Use new constant
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, true)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, true, SWITCH_FILTER_OUTPUT_KEY, expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_StringOutputType_MatchingFalseCase() {
+ String inputField = "status";
+ String expectedOutput = "STATUS_INACTIVE";
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "String",
+ SWITCH_CASE_GROUP_KEY,
createMultipleBooleanSwitchCaseConfigs(Map.of("true", "STATUS_ACTIVE", "false",
+ expectedOutput)),
+ DEFAULT_OUTPUT_VALUE_KEY, "UNKNOWN"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, false)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, false, SWITCH_FILTER_OUTPUT_KEY, expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_StringOutputType_NoMatchingCase_UsesDefault() {
+ String inputField = "status";
+ String defaultOutput = "DEFAULT_STATUS";
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "String",
+ SWITCH_CASE_GROUP_KEY, Collections.emptyList(),
+ DEFAULT_OUTPUT_VALUE_KEY, defaultOutput
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, true)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, true, SWITCH_FILTER_OUTPUT_KEY, defaultOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_BooleanOutputType_MatchingTrueCase() {
+ String inputField = "enable";
+ Boolean expectedOutput = true;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Boolean",
+ SWITCH_CASE_GROUP_KEY,
createMultipleBooleanSwitchCaseConfigs(Map.of("true", "true", "false",
"false")),
+ DEFAULT_OUTPUT_VALUE_KEY, "false"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, true)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, true, SWITCH_FILTER_OUTPUT_KEY, expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_BooleanOutputType_MatchingFalseCase() {
+ String inputField = "enable";
+ Boolean expectedOutput = false;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Boolean",
+ SWITCH_CASE_GROUP_KEY,
createMultipleBooleanSwitchCaseConfigs(Map.of("true", "true", "false",
"false")),
+ DEFAULT_OUTPUT_VALUE_KEY, "true"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, false)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, false, SWITCH_FILTER_OUTPUT_KEY, expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_BooleanOutputType_NoMatchingCase_UsesDefaultFalse() {
+ String inputField = "enable";
+ Boolean defaultOutput = false;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Boolean",
+ SWITCH_CASE_GROUP_KEY,
createMultipleBooleanSwitchCaseConfigs(Map.of("true", "true")),
+ DEFAULT_OUTPUT_VALUE_KEY, "false"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, false)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, false, SWITCH_FILTER_OUTPUT_KEY, defaultOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_IntegerOutputType_MatchingCase() {
+ String inputField = "flag";
+ Integer expectedOutput = 100;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Integer",
+ SWITCH_CASE_GROUP_KEY,
createMultipleBooleanSwitchCaseConfigs(Map.of("true", "100", "false", "50")),
+ DEFAULT_OUTPUT_VALUE_KEY, "0"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, true)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, true, SWITCH_FILTER_OUTPUT_KEY, expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_IntegerOutputType_NoMatchingCase_UsesDefault() {
+ String inputField = "flag";
+ Integer defaultOutput = 999;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Integer",
+ SWITCH_CASE_GROUP_KEY, Collections.emptyList(),
+ DEFAULT_OUTPUT_VALUE_KEY, defaultOutput.toString()
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, false)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, false, SWITCH_FILTER_OUTPUT_KEY, defaultOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_IntegerOutputType_DefaultNotParsable() {
+ String inputField = "count";
+ Integer expectedDefault = 0;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Integer",
+ SWITCH_CASE_GROUP_KEY, Collections.emptyList(),
+ DEFAULT_OUTPUT_VALUE_KEY, "NOT_A_NUMBER"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, true)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, true, SWITCH_FILTER_OUTPUT_KEY, expectedDefault)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_BooleanOutputType_CaseValueNotParsable() {
+ String inputField = "is_valid";
+ Boolean expectedDefault = false;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Boolean",
+ SWITCH_CASE_GROUP_KEY,
createMultipleBooleanSwitchCaseConfigs(Map.of("true", "INVALID_BOOLEAN")),
+ DEFAULT_OUTPUT_VALUE_KEY, "false"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, true)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, true, SWITCH_FILTER_OUTPUT_KEY, expectedDefault)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+}
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/numericalinput/TestSwitchOperatorNumericalInputProcessor.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/numericalinput/TestSwitchOperatorNumericalInputProcessor.java
new file mode 100644
index 0000000000..2db2d0f5e1
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/numericalinput/TestSwitchOperatorNumericalInputProcessor.java
@@ -0,0 +1,333 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.numericalinput;
+
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.AbstractSwitchOperatorProcessor;
+import org.apache.streampipes.test.executors.ProcessingElementTestExecutor;
+import org.apache.streampipes.test.executors.TestConfiguration;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+
+public class TestSwitchOperatorNumericalInputProcessor {
+
+ // Constants from the abstract processor (now used directly in tests)
+ private static final String SWITCH_FILTER_OUTPUT_KEY =
AbstractSwitchOperatorProcessor.SWITCH_FILTER_OUTPUT_KEY;
+ private static final String SWITCH_FILTER_INPUT_FIELD_KEY =
+ AbstractSwitchOperatorProcessor.SWITCH_FILTER_INPUT_FIELD_KEY;
+ private static final String SWITCH_CASE_VALUE_KEY =
AbstractSwitchOperatorProcessor.SWITCH_CASE_VALUE_KEY; // Base
+ // key for value
+ private static final String SWITCH_CASE_OPERATOR_KEY =
AbstractSwitchOperatorProcessor.SWITCH_CASE_OPERATOR_KEY;
+ private static final String SWITCH_CASE_OUTPUT_VALUE_KEY =
+ AbstractSwitchOperatorProcessor.SWITCH_CASE_OUTPUT_VALUE_KEY;
+ private static final String SWITCH_CASE_GROUP_KEY =
AbstractSwitchOperatorProcessor.SWITCH_CASE_GROUP_KEY;
+ private static final String OUTPUT_TYPE_SELECTION_KEY =
AbstractSwitchOperatorProcessor.OUTPUT_TYPE_SELECTION_KEY;
+ private static final String DEFAULT_OUTPUT_VALUE_KEY =
AbstractSwitchOperatorProcessor.DEFAULT_OUTPUT_VALUE_KEY;
+
+
+ private SwitchOperatorNumericalInputProcessor processor;
+
+ @BeforeEach
+ void setUp() {
+ processor = new SwitchOperatorNumericalInputProcessor();
+ }
+
+ // Helper to create a single switch case configuration for the collection
static property
+ private Map<String, Object> createSingleNumericalSwitchCaseConfig(String
caseValue, String operator,
+ String
outputValue) {
+ return Map.of(
+ SWITCH_CASE_VALUE_KEY, caseValue, // Use new constant
+ SWITCH_CASE_OPERATOR_KEY, operator, // Use new constant
+ SWITCH_CASE_OUTPUT_VALUE_KEY, outputValue // Use new constant
+ );
+ }
+
+ // --- Test Cases Using ProcessingElementTestExecutor ---
+
+ @Test
+ void onEvent_StringOutputType_MatchingEqualsCase() {
+ String inputField = "temperature";
+ Double inputTemperature = 25.0;
+ String expectedOutput = "Normal_Temp";
+
+ Map<String, Object> processorConfig = Map.of(SWITCH_FILTER_INPUT_FIELD_KEY,
+ "s0::" + inputField, // Use new constant
+ OUTPUT_TYPE_SELECTION_KEY, "String", // Use new constant
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleNumericalSwitchCaseConfig("25.0", "==",
expectedOutput),
+ createSingleNumericalSwitchCaseConfig("30.0", ">", "High_Temp")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "Unknown_Temp" // Use new constant
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputTemperature)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputTemperature, SWITCH_FILTER_OUTPUT_KEY,
expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_StringOutputType_MatchingGreaterThanCase() {
+ String inputField = "pressure";
+ Double inputPressure = 105.0;
+ String expectedOutput = "High_Pressure";
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "String",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleNumericalSwitchCaseConfig("100.0", ">",
expectedOutput),
+ createSingleNumericalSwitchCaseConfig("50.0", "<", "Low_Pressure")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "Normal_Pressure"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputPressure)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputPressure, SWITCH_FILTER_OUTPUT_KEY,
expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_StringOutputType_NoMatchingCase_UsesDefault() {
+ String inputField = "flowRate";
+ Double inputFlowRate = 75.0;
+ String defaultOutput = "Default_Flow";
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "String",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleNumericalSwitchCaseConfig("100.0", ">", "High_Flow"),
+ createSingleNumericalSwitchCaseConfig("50.0", "<", "Low_Flow")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, defaultOutput
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputFlowRate)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputFlowRate, SWITCH_FILTER_OUTPUT_KEY,
defaultOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_BooleanOutputType_MatchingLessThanOrEqualsCase() {
+ String inputField = "level";
+ Double inputLevel = 10.0;
+ Boolean expectedOutput = true;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Boolean",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleNumericalSwitchCaseConfig("10.0", "<=", "true"),
+ createSingleNumericalSwitchCaseConfig("5.0", ">", "false")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "false"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputLevel)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputLevel, SWITCH_FILTER_OUTPUT_KEY,
expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_BooleanOutputType_NoMatchingCase_UsesDefaultFalse() {
+ String inputField = "speed";
+ Double inputSpeed = 120.0;
+ Boolean defaultOutput = false;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Boolean",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleNumericalSwitchCaseConfig("100.0", "<", "true"),
+ createSingleNumericalSwitchCaseConfig("150.0", ">", "true")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "false"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputSpeed)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputSpeed, SWITCH_FILTER_OUTPUT_KEY, defaultOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_IntegerOutputType_MatchingNotEqualsCase() {
+ String inputField = "errorCode";
+ Double inputErrorCode = 5.0; // Changed input to something not equal to 0.0
+ Integer expectedOutput = 1;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Integer",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleNumericalSwitchCaseConfig("0.0", "!=",
expectedOutput.toString()),
+ createSingleNumericalSwitchCaseConfig("1.0", "==", "0")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "999"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputErrorCode)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputErrorCode, SWITCH_FILTER_OUTPUT_KEY,
expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_IntegerOutputType_NoMatchingCase_UsesDefault() {
+ String inputField = "batteryLevel";
+ Double inputBatteryLevel = 60.0;
+ Integer defaultOutput = -1;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Integer",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleNumericalSwitchCaseConfig("80.0", ">", "1"),
+ createSingleNumericalSwitchCaseConfig("20.0", "<", "-2")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, defaultOutput.toString()
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputBatteryLevel)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputBatteryLevel, SWITCH_FILTER_OUTPUT_KEY,
defaultOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_IntegerOutputType_CaseOutputNotParsable_UsesDefaultZero() {
+ String inputField = "sensorValue";
+ Double inputSensorValue = 10.0;
+ Integer expectedOutput = 0;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Integer",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleNumericalSwitchCaseConfig("10.0", "==",
"NOT_AN_INTEGER")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "5"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputSensorValue)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputSensorValue, SWITCH_FILTER_OUTPUT_KEY,
expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_BooleanOutputType_CaseOutputNotParsable_UsesDefaultFalse() {
+ String inputField = "statusFlag";
+ Double inputStatusFlag = 1.0;
+ Boolean expectedOutput = false;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Boolean",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleNumericalSwitchCaseConfig("1.0", "==",
"INVALID_BOOLEAN_STRING")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "true"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputStatusFlag)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputStatusFlag, SWITCH_FILTER_OUTPUT_KEY,
expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+}
\ No newline at end of file
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/stringinput/TestSwitchOperatorStringInputProcessor.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/stringinput/TestSwitchOperatorStringInputProcessor.java
new file mode 100644
index 0000000000..e60d9eb7d0
--- /dev/null
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/switchoperator/stringinput/TestSwitchOperatorStringInputProcessor.java
@@ -0,0 +1,295 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.stringinput;
+
+import
org.apache.streampipes.processors.transformation.jvm.processor.switchoperator.AbstractSwitchOperatorProcessor;
+import org.apache.streampipes.test.executors.ProcessingElementTestExecutor;
+import org.apache.streampipes.test.executors.TestConfiguration;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+
+public class TestSwitchOperatorStringInputProcessor {
+
+ // Constants from the abstract processor (now used directly in tests)
+ private static final String SWITCH_FILTER_OUTPUT_KEY =
AbstractSwitchOperatorProcessor.SWITCH_FILTER_OUTPUT_KEY;
+ private static final String SWITCH_FILTER_INPUT_FIELD_KEY =
+ AbstractSwitchOperatorProcessor.SWITCH_FILTER_INPUT_FIELD_KEY;
+ private static final String SWITCH_CASE_VALUE_KEY =
AbstractSwitchOperatorProcessor.SWITCH_CASE_VALUE_KEY; // Base
+ // key for value
+ private static final String SWITCH_CASE_OUTPUT_VALUE_KEY =
+ AbstractSwitchOperatorProcessor.SWITCH_CASE_OUTPUT_VALUE_KEY;
+ private static final String SWITCH_CASE_GROUP_KEY =
AbstractSwitchOperatorProcessor.SWITCH_CASE_GROUP_KEY;
+ private static final String OUTPUT_TYPE_SELECTION_KEY =
AbstractSwitchOperatorProcessor.OUTPUT_TYPE_SELECTION_KEY;
+ private static final String DEFAULT_OUTPUT_VALUE_KEY =
AbstractSwitchOperatorProcessor.DEFAULT_OUTPUT_VALUE_KEY;
+
+ private SwitchOperatorStringInputProcessor processor;
+
+ @BeforeEach
+ void setUp() {
+ processor = new SwitchOperatorStringInputProcessor();
+ }
+
+ // Helper to create a single switch case configuration for the collection
static property
+ private Map<String, Object> createSingleStringSwitchCaseConfig(String
caseValue, String outputValue) {
+ return Map.of(
+ SWITCH_CASE_VALUE_KEY, caseValue, // Use new constant
+ SWITCH_CASE_OUTPUT_VALUE_KEY, outputValue // Use new constant
+ );
+ }
+
+ // --- Test Cases Using ProcessingElementTestExecutor ---
+
+ @Test
+ void onEvent_StringOutputType_MatchingCase() {
+ String inputField = "status";
+ String inputValue = "RUNNING";
+ String expectedOutput = "Process_Running";
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField, // Use new constant
+ OUTPUT_TYPE_SELECTION_KEY, "String", // Use new constant
+ SWITCH_CASE_GROUP_KEY,
List.of(createSingleStringSwitchCaseConfig("RUNNING", expectedOutput),
+ createSingleStringSwitchCaseConfig("STOPPED", "Process_Stopped")),
+ DEFAULT_OUTPUT_VALUE_KEY, "Unknown_Status" // Use new constant
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(Map.of(inputField,
inputValue));
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputValue, SWITCH_FILTER_OUTPUT_KEY,
expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_StringOutputType_NoMatchingCase_UsesDefault() {
+ String inputField = "color";
+ String inputValue = "PURPLE";
+ String defaultOutput = "Default_Color";
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "String",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleStringSwitchCaseConfig("RED", "Red_Detected"),
+ createSingleStringSwitchCaseConfig("BLUE", "Blue_Detected")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, defaultOutput
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputValue)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputValue, SWITCH_FILTER_OUTPUT_KEY, defaultOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_BooleanOutputType_MatchingCase_True() {
+ String inputField = "isActive";
+ String inputValue = "ON";
+ Boolean expectedOutput = true;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Boolean",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleStringSwitchCaseConfig("ON", "true"),
+ createSingleStringSwitchCaseConfig("OFF", "false")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "false"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputValue)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputValue, SWITCH_FILTER_OUTPUT_KEY,
expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_BooleanOutputType_NoMatchingCase_UsesDefaultFalse() {
+ String inputField = "isValid";
+ String inputValue = "MAYBE";
+ Boolean defaultOutput = false;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Boolean",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleStringSwitchCaseConfig("YES", "true"),
+ createSingleStringSwitchCaseConfig("NO", "false")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "false"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputValue)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputValue, SWITCH_FILTER_OUTPUT_KEY, defaultOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_BooleanOutputType_CaseOutputNotParsable_UsesDefaultFalse() {
+ String inputField = "state";
+ String inputValue = "ACTIVE";
+ Boolean expectedOutput = false;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Boolean",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleStringSwitchCaseConfig("ACTIVE",
"NOT_A_BOOLEAN_STRING")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "true"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputValue)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputValue, SWITCH_FILTER_OUTPUT_KEY,
expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_IntegerOutputType_MatchingCase() {
+ String inputField = "severity";
+ String inputValue = "CRITICAL";
+ Integer expectedOutput = 10;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Integer",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleStringSwitchCaseConfig("CRITICAL", "10"),
+ createSingleStringSwitchCaseConfig("WARNING", "5")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "0"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputValue)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputValue, SWITCH_FILTER_OUTPUT_KEY,
expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_IntegerOutputType_NoMatchingCase_UsesDefault() {
+ String inputField = "priority";
+ String inputValue = "LOW";
+ Integer defaultOutput = -1;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Integer",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleStringSwitchCaseConfig("HIGH", "1"),
+ createSingleStringSwitchCaseConfig("MEDIUM", "0")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, defaultOutput.toString()
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputValue)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputValue, SWITCH_FILTER_OUTPUT_KEY, defaultOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+
+ @Test
+ void onEvent_IntegerOutputType_CaseOutputNotParsable_UsesDefaultZero() {
+ String inputField = "value";
+ String inputValue = "ABC";
+ Integer expectedOutput = 0;
+
+ Map<String, Object> processorConfig = Map.of(
+ SWITCH_FILTER_INPUT_FIELD_KEY, "s0::" + inputField,
+ OUTPUT_TYPE_SELECTION_KEY, "Integer",
+ SWITCH_CASE_GROUP_KEY, List.of(
+ createSingleStringSwitchCaseConfig("ABC", "NOT_AN_INTEGER")
+ ),
+ DEFAULT_OUTPUT_VALUE_KEY, "5"
+ );
+
+ List<Map<String, Object>> inputEvents = List.of(
+ Map.of(inputField, inputValue)
+ );
+
+ List<Map<String, Object>> expectedOutputEvents = List.of(
+ Map.of(inputField, inputValue, SWITCH_FILTER_OUTPUT_KEY,
expectedOutput)
+ );
+
+ new ProcessingElementTestExecutor(
+ processor,
+ new TestConfiguration(processorConfig, List.of("s0"))
+ ).run(inputEvents, expectedOutputEvents);
+ }
+}
\ No newline at end of file
diff --git
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/value/change/TestChangedValueDetectionProcessor.java
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/value/change/TestChangedValueDetectionProcessor.java
index ec7e9a865b..a2c1a64b28 100644
---
a/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/value/change/TestChangedValueDetectionProcessor.java
+++
b/streampipes-extensions/streampipes-processors-transformation-jvm/src/test/java/org/apache/streampipes/processors/transformation/jvm/processor/value/change/TestChangedValueDetectionProcessor.java
@@ -39,7 +39,7 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
-public class TestChangedValueDetectionProcessor {
+public class TestChangedValueDetectionProcessor {
@Test
public void getDimensionKeyForMultipleDimensionProperties() {
