public/openhab-addons
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Java 17 features (H-M) (#15520)

Browse Source 
- add missing @override
- Java style array syntax
- remove redundant modifiers
- always move String constants to left side in comparisons
- simplify lambda expressions and return statements
- use replace instead of replaceAll w/o regex
- instanceof matching and multiline strings
- remove null check before instanceof

Signed-off-by: Holger Friedrich <mail@holger-friedrich.de>
This commit is contained in:
Holger Friedrich
2023-09-08 14:36:59 +02:00
committed by GitHub
parent 3751fd0646
commit edaf17b345
519 changed files with 2703 additions and 2660 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
bundles/org.openhab.binding.modbus/src/main/java/org/openhab/binding/modbus/discovery/internal/ModbusEndpointDiscoveryService.java
View File

@@ -52,8 +52,8 @@ public class ModbusEndpointDiscoveryService implements ModbusThingHandlerDiscove
@Override
public void setThingHandler(@Nullable ThingHandler handler) {
if (handler instanceof ModbusEndpointThingHandler) {
this.handler = (ModbusEndpointThingHandler) handler;
if (handler instanceof ModbusEndpointThingHandler thingHandler) {
this.handler = thingHandler;
}
}

4
bundles/org.openhab.binding.modbus/src/main/java/org/openhab/binding/modbus/handler/BaseModbusThingHandler.java
View File

@@ -185,8 +185,8 @@ public abstract class BaseModbusThingHandler extends BaseThingHandler {
BridgeHandler handler = bridge.getHandler();
if (handler instanceof ModbusEndpointThingHandler) {
return (ModbusEndpointThingHandler) handler;
if (handler instanceof ModbusEndpointThingHandler thingHandler) {
return thingHandler;
} else {
throw new IllegalStateException("Not a Modbus Bridge: " + handler);
}

9
bundles/org.openhab.binding.modbus/src/main/java/org/openhab/binding/modbus/handler/ModbusPollerThingHandler.java
View File

@@ -225,9 +225,8 @@ public class ModbusPollerThingHandler extends BaseBridgeHandler {
return null;
}
if (handler instanceof ModbusEndpointThingHandler) {
ModbusEndpointThingHandler slaveEndpoint = (ModbusEndpointThingHandler) handler;
return slaveEndpoint;
if (handler instanceof ModbusEndpointThingHandler thingHandler) {
return thingHandler;
} else {
logger.debug("Unexpected bridge handler: {}", handler);
return null;
@@ -385,8 +384,8 @@ public class ModbusPollerThingHandler extends BaseBridgeHandler {
@Override
public void childHandlerInitialized(ThingHandler childHandler, Thing childThing) {
if (childHandler instanceof ModbusDataThingHandler) {
this.childCallbacks.add((ModbusDataThingHandler) childHandler);
if (childHandler instanceof ModbusDataThingHandler modbusDataThingHandler) {
this.childCallbacks.add(modbusDataThingHandler);
}
}

3
bundles/org.openhab.binding.modbus/src/main/java/org/openhab/binding/modbus/internal/CascadedValueTransformationImpl.java
View File

@@ -13,7 +13,6 @@
package org.openhab.binding.modbus.internal;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
@@ -38,7 +37,7 @@ public class CascadedValueTransformationImpl implements ValueTransformation {
.filter(s -> !s.isEmpty()).map(transformation -> new SingleValueTransformation(transformation))
.collect(Collectors.toList());
if (localTransformations.isEmpty()) {
localTransformations = Collections.singletonList(new SingleValueTransformation(transformationString));
localTransformations = List.of(new SingleValueTransformation(transformationString));
}
transformations = localTransformations;
}

3
bundles/org.openhab.binding.modbus/src/main/java/org/openhab/binding/modbus/internal/SingleValueTransformation.java
View File

@@ -168,8 +168,7 @@ public class SingleValueTransformation implements ValueTransformation {
}
public static Optional<Command> tryConvertToCommand(String transformed) {
Optional<Command> transformedCommand = Optional.ofNullable(TypeParser.parseCommand(DEFAULT_TYPES, transformed));
return transformedCommand;
return Optional.ofNullable(TypeParser.parseCommand(DEFAULT_TYPES, transformed));
}
@Override

22
bundles/org.openhab.binding.modbus/src/main/java/org/openhab/binding/modbus/internal/handler/ModbusDataThingHandler.java
View File

@@ -211,7 +211,7 @@ public class ModbusDataThingHandler extends BaseThingHandler {
return;
}
if (!transformedCommand.isPresent()) {
if (transformedCommand.isEmpty()) {
// transformation failed, return
logger.warn("Cannot process command {} (of type {}) with channel {} since transformation was unsuccessful",
command, command.getClass().getSimpleName(), channelUID);
@@ -277,7 +277,7 @@ public class ModbusDataThingHandler extends BaseThingHandler {
}
if (writeType.equals(WRITE_TYPE_COIL)) {
Optional<Boolean> commandAsBoolean = ModbusBitUtilities.translateCommand2Boolean(transformedCommand);
if (!commandAsBoolean.isPresent()) {
if (commandAsBoolean.isEmpty()) {
logger.warn(
"Cannot process command {} with channel {} since command is not OnOffType, OpenClosedType or Decimal trying to write to coil. Do not know how to convert to 0/1. Transformed command was '{}'",
origCommand, channelUID, transformedCommand);
@@ -417,9 +417,7 @@ public class ModbusDataThingHandler extends BaseThingHandler {
bridge.getLabel());
throw new ModbusConfigurationException(errmsg);
}
if (bridgeHandler instanceof ModbusEndpointThingHandler) {
// Write-only thing, parent is endpoint
ModbusEndpointThingHandler endpointHandler = (ModbusEndpointThingHandler) bridgeHandler;
if (bridgeHandler instanceof ModbusEndpointThingHandler endpointHandler) {
slaveId = endpointHandler.getSlaveId();
comms = endpointHandler.getCommunicationInterface();
childOfEndpoint = true;
@@ -691,7 +689,7 @@ public class ModbusDataThingHandler extends BaseThingHandler {
@Nullable
ModbusReadRequestBlueprint readRequest = this.readRequest;
ValueType readValueType = this.readValueType;
if (!readIndex.isPresent() || readRequest == null) {
if (readIndex.isEmpty() || readRequest == null) {
return;
}
assert readValueType != null;
@@ -721,7 +719,7 @@ public class ModbusDataThingHandler extends BaseThingHandler {
String errmsg = String.format(
"readStart=X.Y notation is not allowed to be used with value types larger than 16bit! Use readStart=X instead.");
throw new ModbusConfigurationException(errmsg);
} else if (!bitQuery && valueTypeBitCount < 16 && !readSubIndex.isPresent()) {
} else if (!bitQuery && valueTypeBitCount < 16 && readSubIndex.isEmpty()) {
// User has specified value type which is less than register width (16 bits).
// readStart=X.Y notation must be used to define which data to extract from the 16 bit register.
String errmsg = String
@@ -753,7 +751,7 @@ public class ModbusDataThingHandler extends BaseThingHandler {
private void validateWriteIndex() throws ModbusConfigurationException {
@Nullable
ModbusReadRequestBlueprint readRequest = this.readRequest;
if (!writeStart.isPresent() || !writeSubIndex.isPresent()) {
if (writeStart.isEmpty() || writeSubIndex.isEmpty()) {
//
// this validation is really about writeStart=X.Y validation
//
@@ -786,15 +784,11 @@ public class ModbusDataThingHandler extends BaseThingHandler {
}
private boolean containsOnOff(List<Class<? extends State>> channelAcceptedDataTypes) {
return channelAcceptedDataTypes.stream().anyMatch(clz -> {
return clz.equals(OnOffType.class);
});
return channelAcceptedDataTypes.stream().anyMatch(clz -> clz.equals(OnOffType.class));
}
private boolean containsOpenClosed(List<Class<? extends State>> acceptedDataTypes) {
return acceptedDataTypes.stream().anyMatch(clz -> {
return clz.equals(OpenClosedType.class);
});
return acceptedDataTypes.stream().anyMatch(clz -> clz.equals(OpenClosedType.class));
}
public synchronized void onReadResult(AsyncModbusReadResult result) {

4
bundles/org.openhab.binding.modbus/src/main/java/org/openhab/binding/modbus/internal/handler/ModbusSerialThingHandler.java
View File

@@ -13,8 +13,8 @@
package org.openhab.binding.modbus.internal.handler;
import java.util.Collection;
import java.util.Collections;
import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.binding.modbus.discovery.internal.ModbusEndpointDiscoveryService;
@@ -111,6 +111,6 @@ public class ModbusSerialThingHandler
@Override
public Collection<Class<? extends ThingHandlerService>> getServices() {
return Collections.singleton(ModbusEndpointDiscoveryService.class);
return Set.of(ModbusEndpointDiscoveryService.class);
}
}

4
bundles/org.openhab.binding.modbus/src/main/java/org/openhab/binding/modbus/internal/handler/ModbusTcpThingHandler.java
View File

@@ -13,8 +13,8 @@
package org.openhab.binding.modbus.internal.handler;
import java.util.Collection;
import java.util.Collections;
import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.openhab.binding.modbus.discovery.internal.ModbusEndpointDiscoveryService;
@@ -101,6 +101,6 @@ public class ModbusTcpThingHandler
@Override
public Collection<Class<? extends ThingHandlerService>> getServices() {
return Collections.singleton(ModbusEndpointDiscoveryService.class);
return Set.of(ModbusEndpointDiscoveryService.class);
}
}

29
bundles/org.openhab.binding.modbus/src/main/java/org/openhab/binding/modbus/internal/profiles/ModbusGainOffsetProfile.java
View File

@@ -104,18 +104,18 @@ public class ModbusGainOffsetProfile<Q extends Quantity<Q>> implements StateProf
@Override
public void onCommandFromItem(Command command) {
Type result = applyGainOffset(command, false);
if (result instanceof Command) {
if (result instanceof Command cmd) {
logger.trace("Command '{}' from item, sending converted '{}' state towards handler.", command, result);
callback.handleCommand((Command) result);
callback.handleCommand(cmd);
}
}
@Override
public void onCommandFromHandler(Command command) {
Type result = applyGainOffset(command, true);
if (result instanceof Command) {
if (result instanceof Command cmd) {
logger.trace("Command '{}' from handler, sending converted '{}' command towards item.", command, result);
callback.sendCommand((Command) result);
callback.sendCommand(cmd);
}
}
@@ -141,23 +141,22 @@ public class ModbusGainOffsetProfile<Q extends Quantity<Q>> implements StateProf
QuantityType<Dimensionless> pregainOffsetQt = localPregainOffset.get();
String formula = towardsItem ? String.format("( '%s' + '%s') * '%s'", state, pregainOffsetQt, gain)
: String.format("'%s'/'%s' - '%s'", state, gain, pregainOffsetQt);
if (state instanceof QuantityType) {
if (state instanceof QuantityType quantityState) {
try {
if (towardsItem) {
@SuppressWarnings("unchecked") // xx.toUnit(ONE) returns null or QuantityType<Dimensionless>
@Nullable
QuantityType<Dimensionless> qtState = (QuantityType<Dimensionless>) (((QuantityType<?>) state)
QuantityType<Dimensionless> qtState = (QuantityType<Dimensionless>) (quantityState
.toUnit(Units.ONE));
if (qtState == null) {
logger.warn("Profile can only process plain numbers from handler. Got unit {}. Returning UNDEF",
((QuantityType<?>) state).getUnit());
quantityState.getUnit());
return UnDefType.UNDEF;
}
QuantityType<Dimensionless> offsetted = qtState.add(pregainOffsetQt);
result = applyGainTowardsItem(offsetted, gain);
} else {
final QuantityType<?> qtState = (QuantityType<?>) state;
result = applyGainTowardsHandler(qtState, gain).subtract(pregainOffsetQt);
result = applyGainTowardsHandler(quantityState, gain).subtract(pregainOffsetQt);
}
} catch (UnconvertibleException | UnsupportedOperationException e) {
@@ -166,8 +165,7 @@ public class ModbusGainOffsetProfile<Q extends Quantity<Q>> implements StateProf
gain, pregainOffsetQt, state, formula, towardsItem, e.getMessage());
return UnDefType.UNDEF;
}
} else if (state instanceof DecimalType) {
DecimalType decState = (DecimalType) state;
} else if (state instanceof DecimalType decState) {
return applyGainOffset(new QuantityType<>(decState, Units.ONE), towardsItem);
} else if (state instanceof RefreshType) {
result = state;
@@ -188,17 +186,16 @@ public class ModbusGainOffsetProfile<Q extends Quantity<Q>> implements StateProf
Object parameterValue, @Nullable Unit<QU> assertUnit) {
Optional<QuantityType<QU>> result = Optional.empty();
Unit<QU> sourceUnit = null;
if (parameterValue instanceof String) {
if (parameterValue instanceof String str) {
try {
QuantityType<QU> qt = new QuantityType<>((String) parameterValue);
QuantityType<QU> qt = new QuantityType<>(str);
result = Optional.of(qt);
sourceUnit = qt.getUnit();
} catch (IllegalArgumentException e) {
logger.error("Cannot convert value '{}' of parameter '{}' into a QuantityType.", parameterValue,
parameterName);
}
} else if (parameterValue instanceof BigDecimal) {
BigDecimal parameterBigDecimal = (BigDecimal) parameterValue;
} else if (parameterValue instanceof BigDecimal parameterBigDecimal) {
result = Optional.of(new QuantityType<QU>(parameterBigDecimal.toString()));
} else {
logger.error("Parameter '{}' is not of type String or BigDecimal", parameterName);
@@ -248,7 +245,7 @@ public class ModbusGainOffsetProfile<Q extends Quantity<Q>> implements StateProf
private static Object orDefault(Object defaultValue, @Nullable Object value) {
if (value == null) {
return defaultValue;
} else if (value instanceof String && ((String) value).isBlank()) {
} else if (value instanceof String str && str.isBlank()) {
return defaultValue;
} else {
return value;

17
bundles/org.openhab.binding.modbus/src/test/java/org/openhab/binding/modbus/internal/profiles/ModbusGainOffsetProfileTest.java
View File

@@ -137,8 +137,8 @@ public class ModbusGainOffsetProfileTest {
final Type actualStateUpdateTowardsItem;
if (stateUpdateFromHandler) {
final State updateFromHandler;
if (updateFromHandlerObj instanceof String) {
updateFromHandler = new QuantityType((String) updateFromHandlerObj);
if (updateFromHandlerObj instanceof String str) {
updateFromHandler = new QuantityType(str);
} else {
assertTrue(updateFromHandlerObj instanceof State);
updateFromHandler = (State) updateFromHandlerObj;
@@ -151,8 +151,8 @@ public class ModbusGainOffsetProfileTest {
actualStateUpdateTowardsItem = capture.getValue();
} else {
final Command updateFromHandler;
if (updateFromHandlerObj instanceof String) {
updateFromHandler = new QuantityType((String) updateFromHandlerObj);
if (updateFromHandlerObj instanceof String str) {
updateFromHandler = new QuantityType(str);
} else {
assertTrue(updateFromHandlerObj instanceof State);
updateFromHandler = (Command) updateFromHandlerObj;
@@ -165,8 +165,7 @@ public class ModbusGainOffsetProfileTest {
actualStateUpdateTowardsItem = capture.getValue();
}
Type expectedStateUpdateTowardsItem = (expectedUpdateTowardsItemObj instanceof String)
? new QuantityType((String) expectedUpdateTowardsItemObj)
Type expectedStateUpdateTowardsItem = (expectedUpdateTowardsItemObj instanceof String s) ? new QuantityType(s)
: (Type) expectedUpdateTowardsItemObj;
assertEquals(expectedStateUpdateTowardsItem, actualStateUpdateTowardsItem);
verifyNoMoreInteractions(callback);
@@ -218,7 +217,7 @@ public class ModbusGainOffsetProfileTest {
ProfileCallback callback = mock(ProfileCallback.class);
ModbusGainOffsetProfile profile = createProfile(callback, gain, preGainOffset);
Command commandFromItem = (commandFromItemObj instanceof String) ? new QuantityType((String) commandFromItemObj)
Command commandFromItem = (commandFromItemObj instanceof String str) ? new QuantityType(str)
: (Command) commandFromItemObj;
profile.onCommandFromItem(commandFromItem);
@@ -227,8 +226,8 @@ public class ModbusGainOffsetProfileTest {
ArgumentCaptor<Command> capture = ArgumentCaptor.forClass(Command.class);
verify(callback, times(1)).handleCommand(capture.capture());
Command actualCommandTowardsHandler = capture.getValue();
Command expectedCommandTowardsHandler = (expectedCommandTowardsHandlerObj instanceof String)
? new QuantityType((String) expectedCommandTowardsHandlerObj)
Command expectedCommandTowardsHandler = (expectedCommandTowardsHandlerObj instanceof String str)
? new QuantityType(str)
: (Command) expectedCommandTowardsHandlerObj;
assertEquals(expectedCommandTowardsHandler, actualCommandTowardsHandler);
verifyNoMoreInteractions(callback);