refactor(redis-client): apply review feedback to Value Commands

- Register argument converters in a static initializer instead of a
  volatile flag with double-checked locking; register() remains as an
  explicit class-initialization trigger.
- Rework the SetArgs/GetExArgs token loops to arrow-style switches over
  an iterator, with a helper that consumes and validates keyword values,
  replacing the tokens.get(++i) side effect.
- Hardcode the "map" parameter name in requireNonEmpty and drop the
  redundant @SuppressWarnings("deprecation") on getset.

Author: vchomakov

extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/client/lettuce/value/LettuceReactiveValueCommandsImpl.java

@@ -103,7 +103,6 @@ public Uni<String> getrange(K key, long start, long end) {
     }
 
     @Override
-    @SuppressWarnings("deprecation")
     public Uni<V> getset(K key, V value) {
         nonNull(key, "key");
         nonNull(value, "value");
@@ -167,13 +166,13 @@ private Map<K, V> toOrderedMap(List<KeyValue<K, V>> results) {
 
     @Override
     public Uni<Void> mset(Map<K, V> map) {
-        requireNonEmpty(map, "map");
+        requireNonEmpty(map);
         return LettuceResult.toUni(() -> async.mset(map)).replaceWithVoid();
     }
 
     @Override
     public Uni<Boolean> msetnx(Map<K, V> map) {
-        requireNonEmpty(map, "map");
+        requireNonEmpty(map);
         return LettuceResult.toUni(() -> async.msetnx(map));
     }
 
@@ -267,9 +266,9 @@ private static boolean isOk(String response) {
         return "OK".equals(response);
     }
 
-    private static <K, V> void requireNonEmpty(Map<K, V> map, String name) {
+    private static <K, V> void requireNonEmpty(Map<K, V> map) {
         if (map == null || map.isEmpty()) {
-            throw new IllegalArgumentException("`" + name + "` must not be null or empty");
+            throw new IllegalArgumentException("`map` must not be null or empty");
         }
     }
 }

extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/client/lettuce/value/LettuceValueCommandsConverters.java

@@ -1,6 +1,6 @@
 package io.quarkus.redis.runtime.client.lettuce.value;
 
-import java.util.List;
+import java.util.Iterator;
 
 import io.quarkus.redis.datasource.value.GetExArgs;
 import io.quarkus.redis.datasource.value.SetArgs;
@@ -9,34 +9,30 @@
 /**
  * Converters bridging Quarkus Value Command argument types to their Lettuce equivalents.
  * <p>
- * Registers itself with {@link LettuceConverterRegistry} on first use.
+ * Registration with {@link LettuceConverterRegistry} happens in this class's static initializer.
  */
 public final class LettuceValueCommandsConverters {
 
-    private static volatile boolean registered;
+    static {
+        LettuceConverterRegistry.registerArgConverter(SetArgs.class,
+                LettuceValueCommandsConverters::toLettuceSetArgs);
+        LettuceConverterRegistry.registerArgConverter(GetExArgs.class,
+                LettuceValueCommandsConverters::toLettuceGetExArgs);
+    }
 
     private LettuceValueCommandsConverters() {
         // Utility class
     }
 
     /**
-     * Register all Value Command converters with {@link LettuceConverterRegistry}.
-     * Idempotent and thread-safe.
+     * Ensures the Value Command converters are registered with {@link LettuceConverterRegistry}.
+     * <p>
+     * The registration itself runs in this class's static initializer; calling this method simply
+     * forces class initialization at a well-defined point. It is therefore idempotent and
+     * thread-safe by virtue of the JVM's class-initialization guarantees.
      */
     public static void register() {
-        if (registered) {
-            return;
-        }
-        synchronized (LettuceValueCommandsConverters.class) {
-            if (registered) {
-                return;
-            }
-            LettuceConverterRegistry.registerArgConverter(SetArgs.class,
-                    LettuceValueCommandsConverters::toLettuceSetArgs);
-            LettuceConverterRegistry.registerArgConverter(GetExArgs.class,
-                    LettuceValueCommandsConverters::toLettuceGetExArgs);
-            registered = true;
-        }
+        // No-op: registration is performed in the static initializer.
     }
 
     /**
@@ -49,36 +45,21 @@ public static void register() {
      */
     public static io.lettuce.core.SetArgs toLettuceSetArgs(SetArgs quarkus) {
         io.lettuce.core.SetArgs lettuce = new io.lettuce.core.SetArgs();
-        List<Object> tokens = quarkus.toArgs();
-        for (int i = 0; i < tokens.size(); i++) {
-            String token = tokens.get(i).toString();
+        Iterator<Object> tokens = quarkus.toArgs().iterator();
+        while (tokens.hasNext()) {
+            String token = tokens.next().toString();
             switch (token) {
-                case "EX":
-                    lettuce.ex(Long.parseLong(tokens.get(++i).toString()));
-                    break;
-                case "EXAT":
-                    lettuce.exAt(Long.parseLong(tokens.get(++i).toString()));
-                    break;
-                case "PX":
-                    lettuce.px(Long.parseLong(tokens.get(++i).toString()));
-                    break;
-                case "PXAT":
-                    lettuce.pxAt(Long.parseLong(tokens.get(++i).toString()));
-                    break;
-                case "NX":
-                    lettuce.nx();
-                    break;
-                case "XX":
-                    lettuce.xx();
-                    break;
-                case "KEEPTTL":
-                    lettuce.keepttl();
-                    break;
-                case "GET":
-                    // Handled via the dedicated setGet() method on the Lettuce API
-                    break;
-                default:
-                    throw new IllegalStateException("Unexpected SetArgs token: " + token);
+                case "EX" -> lettuce.ex(nextLong(tokens, token));
+                case "EXAT" -> lettuce.exAt(nextLong(tokens, token));
+                case "PX" -> lettuce.px(nextLong(tokens, token));
+                case "PXAT" -> lettuce.pxAt(nextLong(tokens, token));
+                case "NX" -> lettuce.nx();
+                case "XX" -> lettuce.xx();
+                case "KEEPTTL" -> lettuce.keepttl();
+                // GET is handled via the dedicated setGet() method on the Lettuce API.
+                case "GET" -> {
+                }
+                default -> throw new IllegalStateException("Unexpected SetArgs token: " + token);
             }
         }
         return lettuce;
@@ -89,29 +70,28 @@ public static io.lettuce.core.SetArgs toLettuceSetArgs(SetArgs quarkus) {
      */
     public static io.lettuce.core.GetExArgs toLettuceGetExArgs(GetExArgs quarkus) {
         io.lettuce.core.GetExArgs lettuce = new io.lettuce.core.GetExArgs();
-        List<Object> tokens = quarkus.toArgs();
-        for (int i = 0; i < tokens.size(); i++) {
-            String token = tokens.get(i).toString();
+        Iterator<Object> tokens = quarkus.toArgs().iterator();
+        while (tokens.hasNext()) {
+            String token = tokens.next().toString();
             switch (token) {
-                case "EX":
-                    lettuce.ex(Long.parseLong(tokens.get(++i).toString()));
-                    break;
-                case "EXAT":
-                    lettuce.exAt(Long.parseLong(tokens.get(++i).toString()));
-                    break;
-                case "PX":
-                    lettuce.px(Long.parseLong(tokens.get(++i).toString()));
-                    break;
-                case "PXAT":
-                    lettuce.pxAt(Long.parseLong(tokens.get(++i).toString()));
-                    break;
-                case "PERSIST":
-                    lettuce.persist();
-                    break;
-                default:
-                    throw new IllegalStateException("Unexpected GetExArgs token: " + token);
+                case "EX" -> lettuce.ex(nextLong(tokens, token));
+                case "EXAT" -> lettuce.exAt(nextLong(tokens, token));
+                case "PX" -> lettuce.px(nextLong(tokens, token));
+                case "PXAT" -> lettuce.pxAt(nextLong(tokens, token));
+                case "PERSIST" -> lettuce.persist();
+                default -> throw new IllegalStateException("Unexpected GetExArgs token: " + token);
             }
         }
         return lettuce;
     }
+
+    /**
+     * Consume and parse the value token that follows a keyword (e.g. the seconds after {@code EX}).
+     */
+    private static long nextLong(Iterator<Object> tokens, String token) {
+        if (!tokens.hasNext()) {
+            throw new IllegalStateException("Missing value for token: " + token);
+        }
+        return Long.parseLong(tokens.next().toString());
+    }
 }