feat(#358): support List<Map<*,*>> variable factory

extension/core/src/main/kotlin/io/holunda/camunda/bpm/data/CamundaBpmData.kt

@@ -139,6 +139,21 @@ object CamundaBpmData {
         return ListVariableFactory(variableName, clazz)
     }
 
+  /**
+   * Creates a variable factory for list of custom type.
+   *
+   * @param variableName name of the variable.
+   * @param keyClazz     class of specifying the key type.
+   * @param valueClazz   class of specifying the value type.
+   * @param <K>          factory key type.
+   * @param <V>          factory value type.
+   * @return variable factory for given type.
+  </T> */
+  @JvmStatic
+  fun <K, V> listOfMapsVariable(variableName: String, keyClazz: Class<K>, valueClazz: Class<V>): VariableFactory<List<Map<K, V>>> {
+    return ListOfMapsVariableFactory(variableName, keyClazz, valueClazz)
+  }
+
     /**
      * Creates a variable factory for set of custom type.
      *

extension/core/src/main/kotlin/io/holunda/camunda/bpm/data/adapter/list/AbstractListReadWriteAdapter.kt

@@ -33,7 +33,9 @@ abstract class AbstractListReadWriteAdapter<T>(variableName: String, protected v
           @Suppress("UNCHECKED_CAST")
           valueAsList as List<T>
         } else {
-          throw WrongVariableTypeException("Error reading " + variableName + ": Wrong list type detected, expected " + memberClazz.name + ", but was not found in " + valueAsList)
+          throw WrongVariableTypeException(
+            "Error reading $variableName: Wrong list type detected, expected ${memberClazz.name}, but was not found in $valueAsList"
+          )
         }
       }
     }

extension/core/src/main/kotlin/io/holunda/camunda/bpm/data/adapter/listofmaps/AbstractListOfMapsReadWriteAdapter.kt

@@ -0,0 +1,64 @@
+package io.holunda.camunda.bpm.data.adapter.listofmaps
+
+import io.holunda.camunda.bpm.data.adapter.AbstractReadWriteAdapter
+import io.holunda.camunda.bpm.data.adapter.ValueWrapperUtil.getTypedValue
+import io.holunda.camunda.bpm.data.adapter.WrongVariableTypeException
+import org.camunda.bpm.engine.variable.value.TypedValue
+
+/**
+ * Base class for all list of maps read-write adapter.
+ *
+ * @param [K] key type.
+ * @param [V] value type.
+ * @param variableName name of variable.
+ * @param keyClazz key class.
+ * @param valueClazz value class.
+ */
+abstract class AbstractListOfMapsReadWriteAdapter<K, V>(
+    variableName: String,
+    protected val keyClazz: Class<K>,
+    protected val valueClazz: Class<V>
+) : AbstractReadWriteAdapter<List<Map<K, V>>>(variableName) {
+  /**
+   * Read the value of null.
+   *
+   * @param value raw value.
+   * @return list or null.
+   */
+  protected fun getOrNull(value: Any?): List<Map<K, V>>? {
+    if (value == null) {
+      return null
+    }
+    if (MutableList::class.java.isAssignableFrom(value.javaClass)) {
+      val valueAsList = value as List<*>
+      return if (valueAsList.isEmpty()) {
+        emptyList()
+      } else {
+        if (MutableMap::class.java.isAssignableFrom(value.javaClass)) {
+          val valueAsMap = valueAsList.iterator().next() as Map<*, *>
+          val (key, value1) = valueAsMap.entries.iterator().next()
+          if (keyClazz.isAssignableFrom(key!!.javaClass) &&
+              valueClazz.isAssignableFrom(value1!!.javaClass)) {
+            @Suppress("UNCHECKED_CAST")
+            valueAsList as List<Map<K, V>>
+          } else {
+            throw WrongVariableTypeException(
+              "Error reading " + variableName + ": Wrong map type detected, expected Map<"
+                + keyClazz.name + "," + valueClazz.name
+                + ", but was not found in " + valueAsMap
+            )
+          }
+        } else {
+          throw WrongVariableTypeException(
+              "Error reading $variableName: Wrong list type detected, expected mutable list, but was not found in $valueAsList")
+        }
+      }
+    }
+    throw WrongVariableTypeException(
+        "Error reading $variableName: Couldn't read value of type List of Maps from $value")
+  }
+
+  override fun getTypedValue(value: Any?, isTransient: Boolean): TypedValue {
+    return getTypedValue(MutableList::class.java, value, isTransient)
+  }
+}

extension/core/src/main/kotlin/io/holunda/camunda/bpm/data/adapter/listofmaps/ListOfMapsReadAdapterLockedExternalTask.kt

@@ -0,0 +1,64 @@
+package io.holunda.camunda.bpm.data.adapter.listofmaps
+
+import org.camunda.bpm.engine.externaltask.LockedExternalTask
+import org.camunda.bpm.engine.variable.Variables
+import java.util.*
+import kotlin.collections.Map
+
+/**
+ * Read adapter for external task.
+ *
+ * @param [K] key type.
+ * @param [V] value type.
+ */
+class ListOfMapsReadAdapterLockedExternalTask<K, V>(
+  private val lockedExternalTask: LockedExternalTask,
+  variableName: String,
+  keyClazz: Class<K>,
+  valueClazz: Class<V>
+) : AbstractListOfMapsReadWriteAdapter<K, V>(variableName, keyClazz, valueClazz) {
+
+  private val value: Any?
+    get() = Optional.ofNullable(lockedExternalTask.variables)
+      .orElse(Variables.createVariables())[variableName]
+
+  override fun getOptional(): Optional<List<Map<K, V>>> {
+    return Optional.ofNullable(
+      getOrNull(
+        value
+      )
+    )
+  }
+
+  override fun set(value: List<Map<K, V>>, isTransient: Boolean) {
+    throw UnsupportedOperationException("Can't set a variable on an external task")
+  }
+
+  override fun setLocal(value: List<Map<K, V>>, isTransient: Boolean) {
+    throw UnsupportedOperationException("Can't set a local variable on an external task")
+  }
+
+  override fun getLocal(): List<Map<K, V>> {
+    throw UnsupportedOperationException("Can't get a local variable on an external task")
+  }
+
+  override fun getLocalOptional(): Optional<List<Map<K, V>>> {
+    throw UnsupportedOperationException("Can't get a local variable on an external task")
+  }
+
+  override fun getLocalOrDefault(defaultValue: List<Map<K, V>>): List<Map<K, V>> {
+    throw UnsupportedOperationException("Can't get a local variable on an external task")
+  }
+
+  override fun getLocalOrNull(): List<Map<K, V>> {
+    throw UnsupportedOperationException("Can't get a local variable on an external task")
+  }
+
+  override fun remove() {
+    throw UnsupportedOperationException("Can't remove a variable on an external task")
+  }
+
+  override fun removeLocal() {
+    throw UnsupportedOperationException("Can't remove a local variable on an external task")
+  }
+}

extension/core/src/main/kotlin/io/holunda/camunda/bpm/data/adapter/listofmaps/ListOfMapsReadWriteAdapterCaseService.kt

@@ -0,0 +1,61 @@
+package io.holunda.camunda.bpm.data.adapter.listofmaps
+
+import io.holunda.camunda.bpm.data.adapter.ValueWrapperUtil.getTypedValue
+import org.camunda.bpm.engine.CaseService
+import java.util.*
+
+/**
+ * Read write adapter for case service access.
+ *
+ * @param [K] key type.
+ * @param [V] value type.
+ * @param caseService     case service to use.
+ * @param caseExecutionId id of the execution to read from and write to.
+ * @param variableName    name of the variable.
+ * @param keyClazz key class.
+ * @param valueClazz value class.
+ */
+class ListOfMapsReadWriteAdapterCaseService<K, V>(
+  private val caseService: CaseService,
+  private val caseExecutionId: String,
+  variableName: String,
+  keyClazz: Class<K>,
+  valueClazz: Class<V>
+) : AbstractListOfMapsReadWriteAdapter<K, V>(variableName, keyClazz, valueClazz) {
+
+  override fun getOptional(): Optional<List<Map<K, V>>> {
+    return Optional.ofNullable(
+      getOrNull(
+        caseService.getVariable(
+          caseExecutionId, variableName
+        )
+      )
+    )
+  }
+
+  override fun set(value: List<Map<K, V>>, isTransient: Boolean) {
+    caseService.setVariable(caseExecutionId, variableName, getTypedValue(value, isTransient))
+  }
+
+  override fun getLocalOptional(): Optional<List<Map<K, V>>> {
+    return Optional.ofNullable(
+      getOrNull(
+        caseService.getVariableLocal(
+          caseExecutionId, variableName
+        )
+      )
+    )
+  }
+
+  override fun setLocal(value: List<Map<K, V>>, isTransient: Boolean) {
+    caseService.setVariableLocal(caseExecutionId, variableName, getTypedValue(value, isTransient))
+  }
+
+  override fun remove() {
+    caseService.removeVariable(caseExecutionId, variableName)
+  }
+
+  override fun removeLocal() {
+    caseService.removeVariableLocal(caseExecutionId, variableName)
+  }
+}

extension/core/src/main/kotlin/io/holunda/camunda/bpm/data/adapter/listofmaps/ListOfMapsReadWriteAdapterRuntimeService.kt

@@ -0,0 +1,49 @@
+package io.holunda.camunda.bpm.data.adapter.listofmaps
+
+import java.util.*
+import org.camunda.bpm.engine.RuntimeService
+
+/**
+ * Read write adapter for runtime service access.
+ *
+ * @param [K] key type.
+ * @param [V] value type.
+ * @param runtimeService runtime service to use.
+ * @param executionId id of the execution to read from and write to.
+ * @param variableName name of the variable.
+ * @param keyClazz key class.
+ * @param valueClazz value class.
+ */
+class ListOfMapsReadWriteAdapterRuntimeService<K, V>(
+    private val runtimeService: RuntimeService,
+    private val executionId: String,
+    variableName: String,
+    keyClazz: Class<K>,
+    valueClazz: Class<V>
+) : AbstractListOfMapsReadWriteAdapter<K, V>(variableName, keyClazz, valueClazz) {
+
+  override fun getOptional(): Optional<List<Map<K, V>>> {
+    return Optional.ofNullable(getOrNull(runtimeService.getVariable(executionId, variableName)))
+  }
+
+  override fun set(value: List<Map<K, V>>, isTransient: Boolean) {
+    runtimeService.setVariable(executionId, variableName, getTypedValue(value, isTransient))
+  }
+
+  override fun getLocalOptional(): Optional<List<Map<K, V>>> {
+    return Optional.ofNullable(
+        getOrNull(runtimeService.getVariableLocal(executionId, variableName)))
+  }
+
+  override fun setLocal(value: List<Map<K, V>>, isTransient: Boolean) {
+    runtimeService.setVariableLocal(executionId, variableName, getTypedValue(value, isTransient))
+  }
+
+  override fun remove() {
+    runtimeService.removeVariable(executionId, variableName)
+  }
+
+  override fun removeLocal() {
+    runtimeService.removeVariableLocal(executionId, variableName)
+  }
+}

extension/core/src/main/kotlin/io/holunda/camunda/bpm/data/adapter/listofmaps/ListOfMapsReadWriteAdapterTaskService.kt

@@ -0,0 +1,48 @@
+package io.holunda.camunda.bpm.data.adapter.listofmaps
+
+import org.camunda.bpm.engine.TaskService
+import java.util.*
+
+/**
+ * Read write adapter for task service access.
+ *
+ * @param [K] key type.
+ * @param [V] value type.
+ * @param taskService  task service to use.
+ * @param taskId       id of the task to read from and write to.
+ * @param variableName name of the variable.
+ * @param keyClazz key class.
+ * @param valueClazz value class.
+ */
+class ListOfMapsReadWriteAdapterTaskService<K, V>(
+  private val taskService: TaskService,
+  private val taskId: String,
+  variableName: String,
+  keyClazz: Class<K>,
+  valueClazz: Class<V>
+) : AbstractListOfMapsReadWriteAdapter<K, V>(variableName, keyClazz, valueClazz) {
+
+  override fun getOptional(): Optional<List<Map<K, V>>> {
+    return Optional.ofNullable(getOrNull(taskService.getVariable(taskId, variableName)))
+  }
+
+  override fun set(value: List<Map<K, V>>, isTransient: Boolean) {
+    taskService.setVariable(taskId, variableName, getTypedValue(value, isTransient))
+  }
+
+  override fun getLocalOptional(): Optional<List<Map<K, V>>> {
+    return Optional.ofNullable(getOrNull(taskService.getVariableLocal(taskId, variableName)))
+  }
+
+  override fun setLocal(value: List<Map<K, V>>, isTransient: Boolean) {
+    taskService.setVariableLocal(taskId, variableName, getTypedValue(value, isTransient))
+  }
+
+  override fun remove() {
+    taskService.removeVariable(taskId, variableName)
+  }
+
+  override fun removeLocal() {
+    taskService.removeVariableLocal(taskId, variableName)
+  }
+}

extension/core/src/main/kotlin/io/holunda/camunda/bpm/data/adapter/listofmaps/ListOfMapsReadWriteAdapterVariableMap.kt

@@ -0,0 +1,47 @@
+package io.holunda.camunda.bpm.data.adapter.listofmaps
+
+import io.holunda.camunda.bpm.data.adapter.ValueWrapperUtil.getTypedValue
+import org.camunda.bpm.engine.variable.VariableMap
+import java.util.*
+
+/**
+ * Read-write adapter for variable map.
+ *
+ * @param [K] key type.
+ * @param [V] value type.
+ * @param variableMap  variable map to access.
+ * @param variableName variable to access.
+ * @param keyClazz key class.
+ * @param valueClazz value class.
+</T> */
+class ListOfMapsReadWriteAdapterVariableMap<K, V>(
+  private val variableMap: VariableMap,
+  variableName: String,
+  keyClazz: Class<K>,
+  valueClazz: Class<V>
+) : AbstractListOfMapsReadWriteAdapter<K, V>(variableName, keyClazz, valueClazz) {
+
+  override fun getOptional(): Optional<List<Map<K, V>>> {
+    return Optional.ofNullable(getOrNull(variableMap[variableName]))
+  }
+
+  override fun set(value: List<Map<K, V>>, isTransient: Boolean) {
+    variableMap.putValueTyped(variableName, getTypedValue(value, isTransient))
+  }
+
+  override fun getLocalOptional(): Optional<List<Map<K, V>>> {
+    throw UnsupportedOperationException("Can't get a local variable on a variable map")
+  }
+
+  override fun setLocal(value: List<Map<K, V>>, isTransient: Boolean) {
+    throw UnsupportedOperationException("Can't set a local variable on a variable map")
+  }
+
+  override fun remove() {
+    variableMap.remove(variableName)
+  }
+
+  override fun removeLocal() {
+    throw UnsupportedOperationException("Can't set a local variable on a variable map")
+  }
+}