Added new Helper VariantBuilder

README.md

@@ -125,7 +125,7 @@ The library will remain open source and MIT licensed and can still be used, fork
 #### Changes
 
 ##### Changes in 5.1.1 (not released yet):
- - Nothing yet
+ - Added new Helper class `VariantBuilder` to allow creating Variants which contain Maps or Collections without messing with the required DBus type arguments
 
 ##### Changes in 5.1.0 (2024-08-01):
  - Use Junit BOM thanks to [spannm](https://github.com/spannm) ([PR#248](https://github.com/hypfvieh/dbus-java/issues/248))

dbus-java-core/src/main/java/org/freedesktop/dbus/Marshalling.java

@@ -240,7 +240,8 @@ private static String[] recursiveGetDBusType(StringBuffer[] _out, Type _dataType
  return sigs;
  } else if (_dataType instanceof ParameterizedType p) {
  if (p.getRawType().equals(Map.class)) {
- _out[_level].append("a{");
+ _out[_level].append(ArgumentType.ARRAY_STRING)
+ .append(ArgumentType.DICT_ENTRY1_STRING);
  Type[] t = p.getActualTypeArguments();
  try {
  String[] s = recursiveGetDBusType(_out, t[0], true, _level + 1);
@@ -257,7 +258,7 @@ private static String[] recursiveGetDBusType(StringBuffer[] _out, Type _dataType
  LOGGER.debug("", _ex);
  throw new DBusException("Map must have 2 parameters");
  }
- _out[_level].append('}');
+ _out[_level].append(ArgumentType.DICT_ENTRY2_STRING);
  } else if (List.class.isAssignableFrom((Class<?>) p.getRawType())) {
  for (Type t : p.getActualTypeArguments()) {
  if (Type.class.equals(t)) {
@@ -323,7 +324,7 @@ private static String[] recursiveGetDBusType(StringBuffer[] _out, Type _dataType
  }
  }
  }
- _out[_level].append(')');
+ _out[_level].append(ArgumentType.STRUCT2_STRING);
 
  } else if (Enum.class.isAssignableFrom(dataTypeClazz)) {
  _out[_level].append((char) ArgumentType.STRING);

dbus-java-core/src/main/java/org/freedesktop/dbus/types/VariantBuilder.java

@@ -0,0 +1,107 @@
+package org.freedesktop.dbus.types;
+
+import org.freedesktop.dbus.Marshalling;
+import org.freedesktop.dbus.messages.constants.ArgumentType;
+
+import java.util.*;
+
+/**
+ * Builder to create Variants for parameterized types like Collections or Maps more easily.
+ * <p>
+ * When working with Variants you can use the default constructor which is taking your
+ * object, but that will not work if you use Maps/Collections because the actual type(s) used inside
+ * of those objects are not known on runtime (due to Java type erasure).
+ * </p><p>
+ * In this case you can use this builder providing the Class type you want to have inside of your
+ * Variant (e.g. Map.class) and the generic class types used inside of the Map.
+ * </p>
+ * <p>
+ * <b>Example:</b>
+ * <pre>
+ * VariantBuilder.of(Map.class).withGenericTypes(String.class, Integer.class).create(myMap);
+ * </pre>
+ * </p>
+ *
+ * @since 5.1.1 - 2024-08-16
+ * @author hypfvieh
+ */
+public final class VariantBuilder {
+ private final Class<?> baseClass;
+
+ private final List<Class<?>> genericTypes = new ArrayList<>();
+
+ private VariantBuilder(Class<?> _baseClass) {
+ baseClass = _baseClass;
+ }
+
+ /**
+ * Create a new instance using the given class as starting point.
+ * <p>
+ * If you want to create Variant containing a Map or List, this would be Map/List.class.
+ * </p>
+ * @param _clz class to use, never null
+ * @return new instance
+ */
+ public static VariantBuilder of(Class<?> _clz) {
+ return new VariantBuilder(Objects.requireNonNull(_clz, "Class required"));
+ }
+
+ /**
+ * Add one or more generic types.
+ * <p>
+ * Use this if you want to create a Variant containing a Map, Collection.
+ * You have to provide the data types used inside of your Map/Collection to this method.
+ * E.g. you have Map&gt;Integer,String&lt; than you have to provide Integer.class and String.class to this method.
+ * </p>
+ *
+ * @param _clz generic classes to add
+ * @return this
+ */
+ public VariantBuilder withGenericTypes(Class<?>... _clz) {
+ if (_clz == null || _clz.length == 0) {
+ return this;
+ }
+ genericTypes.addAll(Arrays.asList(_clz));
+ return this;
+ }
+
+ /**
+ * Create the Variant instance using the provided data object.
+ *
+ * @param <X> Type inside of the Variant
+ * @param _data data to store in Variant
+ *
+ * @return Variant
+ *
+ * @throws IllegalArgumentException when provided data object is not compatible with class given in constuctor
+ * @throws NullPointerException when null is given
+ */
+ public <X> Variant<X> create(X _data) {
+ Objects.requireNonNull(_data, "No data given");
+
+ if (!baseClass.isAssignableFrom(_data.getClass())) {
+ throw new IllegalArgumentException("Given data is not compatible with defined Variant base class");
+ }
+
+ StringBuilder sb = new StringBuilder();
+
+ boolean isMap = false;
+ if (Map.class.isAssignableFrom(baseClass)) {
+ sb.append(ArgumentType.ARRAY_STRING).append(ArgumentType.DICT_ENTRY1_STRING);
+ isMap = true;
+ } else {
+ sb.append(Marshalling.convertJavaClassesToSignature(baseClass));
+ }
+
+ genericTypes.stream()
+ .map(Marshalling::convertJavaClassesToSignature)
+ .forEach(sb::append);
+
+ if (isMap) {
+ sb.append(ArgumentType.DICT_ENTRY2_STRING);
+ }
+
+ return new Variant<>(_data, sb.toString());
+ }
+
+}

dbus-java-tests/src/test/java/org/freedesktop/dbus/types/VariantBuilderTest.java

@@ -0,0 +1,54 @@
+package org.freedesktop.dbus.types;
+
+import org.freedesktop.dbus.Struct;
+import org.freedesktop.dbus.annotations.Position;
+import org.freedesktop.dbus.test.AbstractBaseTest;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+
+public class VariantBuilderTest extends AbstractBaseTest {
+
+ @Test
+ void testBuilder() {
+
+ assertEquals(new Variant<>(List.of("str"), "as"),
+ VariantBuilder.of(List.class)
+ .withGenericTypes(String.class)
+ .create(List.of("str")));
+
+ assertEquals(new Variant<>("foo"),
+ VariantBuilder.of(String.class)
+ .create("foo"));
+
+ assertEquals(new Variant<>(Map.of(1, "str"), "a{is}"),
+ VariantBuilder.of(Map.class)
+ .withGenericTypes(Integer.class, String.class)
+ .create(Map.of(1, "str")));
+
+ assertEquals(new Variant<>(List.of(new VbStruct("test", false)), "a(sb)"),
+ VariantBuilder.of(List.class)
+ .withGenericTypes(VbStruct.class)
+ .create(List.of(new VbStruct("test", false))));
+
+ assertThrows(NullPointerException.class, () -> VariantBuilder.of(String.class).create(null));
+ assertThrows(IllegalArgumentException.class, () -> VariantBuilder.of(String.class).create(1));
+ assertThrows(NullPointerException.class, () -> VariantBuilder.of(null));
+
+ }
+
+ public static class VbStruct extends Struct {
+ @Position(0)
+ private String val1;
+ @Position(1)
+ private boolean val2;
+
+ public VbStruct(String _val1, boolean _val2) {
+ super();
+ val1 = _val1;
+ val2 = _val2;
+ }
+
+ }
+}