Data.kt

  1. package com.hexagontk.core

  3. import kotlin.reflect.KProperty1

  5. /**
  6.  * .
  7.  *
  8.  * @receiver .
  9.  * @param keys .
  10.  * @return .
  11.  */
  12. inline fun <reified T : Any> Map<*, *>.getPath(vararg keys: Any): T? {
  13.     val mappedKeys = keys.map {
  14.         when (it) {
  15.             is KProperty1<*, *> -> it.name
  16.             else -> it
  17.         }
  18.     }

  20.     return mappedKeys
  21.         .dropLast(1)
  22.         .fold(this) { result, element ->
  23.             when (val value = result[element]) {
  24.                 is Map<*, *> -> value
  25.                 is Collection<*> -> value.mapIndexed { ii, item -> ii to item }.toMap()
  26.                 else -> emptyMap<Any, Any>()
  27.             }
  28.         }[mappedKeys.last()] as? T
  29. }

  31. /**
  32.  * .
  33.  *
  34.  * @receiver .
  35.  * @param name .
  36.  * @return .
  37.  */
  38. inline fun <reified T : Any> Map<*, *>.requirePath(vararg name: Any): T =
  39.     this.getPath(*name) ?: error("$name required key not found")

  41. /**
  42.  * .
  43.  *
  44.  * @param fields .
  45.  * @return .
  46.  */
  47. fun <T : Any> fieldsMapOf(vararg fields: Pair<KProperty1<T, *>, *>): Map<String, *> =
  48.     fields.associate { it.first.name to it.second }

  50. /**
  51.  * .
  52.  *
  53.  * @param fields .
  54.  * @return .
  55.  */
  56. fun <T : Any> fieldsMapOfNotNull(vararg fields: Pair<KProperty1<T, *>, *>): Map<String, *> =
  57.     fieldsMapOf(*fields).filterValues { it != null }

  59. /**
  60.  * .
  61.  *
  62.  * @param pairs .
  63.  * @return .
  64.  */
  65. fun <K : Any> mapOfNotNull(vararg pairs: Pair<K, *>): Map<K, *> =
  66.     mapOf(*pairs).filterValues { it != null }

  68. /**
  69.  * .
  70.  *
  71.  * @receiver .
  72.  * @param name .
  73.  * @return .
  74.  */
  75. fun <K, V> Map<K, V>.require(name: K): V =
  76.     this[name] ?: error("$name required key not found")

  78. /**
  79.  * .
  80.  *
  81.  * @param T .
  82.  * @param key .
  83.  * @return .
  84.  */
  85. inline operator fun <reified T : Any> Map<*, *>.get(key: KProperty1<*, *>): T? =
  86.     this[key.name] as? T

  88. /**
  89.  * .
  90.  *
  91.  * @param T .
  92.  * @param key .
  93.  * @param default .
  94.  * @return .
  95.  */
  96. inline fun <reified T : Any> Map<*, *>.getOrDefault(key: KProperty1<*, *>, default: T): T =
  97.     this[key] ?: default

  99. /**
  100.  * .
  101.  *
  102.  * @param mapA .
  103.  * @param mapB .
  104.  * @return .
  105.  */
  106. fun merge(mapA: Map<*, *>, mapB: Map<*, *>): Map<*, *> =
  107.     (mapA.entries + mapB.entries)
  108.         .groupBy { it.key }
  109.         .mapValues { (_, v) -> v.map { it.value } }
  110.         .mapValues { (_, v) ->
  111.             val isCollection = v.all { it is Collection<*> }
  112.             val isMap = v.all { it is Map<*, *> }
  113.             when {
  114.                 isCollection -> v.map { it as Collection<*> }.reduce { a, b -> a + b }
  115.                 isMap -> v.map { it as Map<*, *> }.reduce { a, b -> merge(a, b) }
  116.                 else -> v.last()
  117.             }
  118.         }

  120. /**
  121.  * .
  122.  *
  123.  * @param maps .
  124.  * @return .
  125.  */
  126. fun merge(maps: Collection<Map<*, *>>): Map<*, *> =
  127.     maps.reduce { a, b -> merge(a, b) }

  129. /**
  130.  * .
  131.  *
  132.  * @receiver .
  133.  * @return .
  134.  */
  135. fun <K, V> Map<K, Collection<V>>.pairs(): Collection<Pair<K, V>> =
  136.     flatMap { (k, v) -> v.map { k to it } }

  138. /**
  139.  * .
  140.  *
  141.  * @receiver .
  142.  * @return .
  143.  */
  144. fun <K, V> Map<K, V?>.filterNotEmpty(): Map<K, V> =
  145.     this.filterValues(::notEmpty).mapValues { (_, v) -> v ?: fail }

  147. /**
  148.  * .
  149.  *
  150.  * @receiver .
  151.  * @return .
  152.  */
  153. fun <V> Collection<V?>.filterNotEmpty(): Collection<V> =
  154.     this.filter(::notEmpty).map { it ?: fail }

  156. /**
  157.  * .
  158.  *
  159.  * @receiver .
  160.  * @return .
  161.  */
  162. fun Map<*, *>.filterNotEmptyRecursive(): Map<*, *> =
  163.     mapValues { (_, v) ->
  164.         when (v) {
  165.             is Collection<*> -> v.filterNotEmptyRecursive()
  166.             is Map<*, *> -> v.filterNotEmptyRecursive()
  167.             else -> v
  168.         }
  169.     }
  170.         .filterNotEmpty()

  172. /**
  173.  * .
  174.  *
  175.  * @receiver .
  176.  * @return .
  177.  */
  178. fun Collection<*>.filterNotEmptyRecursive(): Collection<*> =
  179.     map {
  180.         when (it) {
  181.             is Collection<*> -> it.filterNotEmptyRecursive()
  182.             is Map<*, *> -> it.filterNotEmptyRecursive()
  183.             else -> it
  184.         }
  185.     }
  186.         .filterNotEmpty()

  188. /**
  189.  * .
  190.  *
  191.  * @param value .
  192.  * @return .
  193.  */
  194. fun <V> notEmpty(value: V?): Boolean {
  195.     return when (value) {
  196.         null -> false
  197.         is Collection<*> -> value.isNotEmpty()
  198.         is Map<*, *> -> value.isNotEmpty()
  199.         else -> true
  200.     }
  201. }

  203. fun Map<*, *>.getInt(key: KProperty1<*, *>): Int? =
  204.     get(key)

  206. fun Map<*, *>.getLong(key: KProperty1<*, *>): Long? =
  207.     get(key)

  209. fun Map<*, *>.getFloat(key: KProperty1<*, *>): Float? =
  210.     get(key)

  212. fun Map<*, *>.getDouble(key: KProperty1<*, *>): Double? =
  213.     get(key)

  215. fun Map<*, *>.getBoolean(key: KProperty1<*, *>): Boolean? =
  216.     get(key)

  218. fun Map<*, *>.getString(key: KProperty1<*, *>): String? =
  219.     get(key)

  221. fun Map<*, *>.getList(key: KProperty1<*, *>): Collection<*>? =
  222.     get(key)

  224. fun Map<*, *>.getMap(key: KProperty1<*, *>): Map<String, *>? =
  225.     get(key)

  227. fun Map<*, *>.getInts(key: KProperty1<*, *>): Collection<Int>? =
  228.     get(key)

  230. fun Map<*, *>.getLongs(key: KProperty1<*, *>): Collection<Long>? =
  231.     get(key)

  233. fun Map<*, *>.getFloats(key: KProperty1<*, *>): Collection<Float>? =
  234.     get(key)

  236. fun Map<*, *>.getDoubles(key: KProperty1<*, *>): Collection<Double>? =
  237.     get(key)

  239. fun Map<*, *>.getBooleans(key: KProperty1<*, *>): Collection<Boolean>? =
  240.     get(key)

  242. fun Map<*, *>.getStrings(key: KProperty1<*, *>): Collection<String>? =
  243.     get(key)

  245. fun Map<*, *>.getLists(key: KProperty1<*, *>): Collection<List<*>>? =
  246.     get(key)

  248. fun Map<*, *>.getMaps(key: KProperty1<*, *>): Collection<Map<String, *>>? =
  249.     get(key)

  251. fun Map<*, *>.getListOrEmpty(key: KProperty1<*, *>): Collection<*> =
  252.     getList(key) ?: emptyList<Any>()

  254. fun Map<*, *>.getMapOrEmpty(key: KProperty1<*, *>): Map<String, *> =
  255.     getMap(key) ?: emptyMap<String, Any>()

  257. fun Map<*, *>.getIntsOrEmpty(key: KProperty1<*, *>): Collection<Int> =
  258.     getInts(key) ?: emptyList()

  260. fun Map<*, *>.getLongsOrEmpty(key: KProperty1<*, *>): Collection<Long> =
  261.     getLongs(key) ?: emptyList()

  263. fun Map<*, *>.getFloatsOrEmpty(key: KProperty1<*, *>): Collection<Float> =
  264.     getFloats(key) ?: emptyList()

  266. fun Map<*, *>.getDoublesOrEmpty(key: KProperty1<*, *>): Collection<Double> =
  267.     getDoubles(key) ?: emptyList()

  269. fun Map<*, *>.getBooleansOrEmpty(key: KProperty1<*, *>): Collection<Boolean> =
  270.     getBooleans(key) ?: emptyList()

  272. fun Map<*, *>.getStringsOrEmpty(key: KProperty1<*, *>): Collection<String> =
  273.     getStrings(key) ?: emptyList()

  275. fun Map<*, *>.getListsOrEmpty(key: KProperty1<*, *>): Collection<Collection<*>> =
  276.     getLists(key) ?: emptyList()

  278. fun Map<*, *>.getMapsOrEmpty(key: KProperty1<*, *>): Collection<Map<String, *>> =
  279.     getMaps(key) ?: emptyList()

  281. inline fun <reified T : Any> Map<*, *>.requireKey(key: KProperty1<*, *>): T =
  282.     get(key)
  283.         ?: error("'${key.name}' key not found, or wrong type (must be ${T::class.qualifiedName})")

  285. fun Map<*, *>.requireInt(key: KProperty1<*, *>): Int =
  286.     requireKey(key)

  288. fun Map<*, *>.requireLong(key: KProperty1<*, *>): Long =
  289.     requireKey(key)

  291. fun Map<*, *>.requireFloat(key: KProperty1<*, *>): Float =
  292.     requireKey(key)

  294. fun Map<*, *>.requireDouble(key: KProperty1<*, *>): Double =
  295.     requireKey(key)

  297. fun Map<*, *>.requireBoolean(key: KProperty1<*, *>): Boolean =
  298.     requireKey(key)

  300. fun Map<*, *>.requireString(key: KProperty1<*, *>): String =
  301.     requireKey(key)

  303. fun Map<*, *>.requireList(key: KProperty1<*, *>): Collection<*> =
  304.     requireKey(key)

  306. fun Map<*, *>.requireMap(key: KProperty1<*, *>): Map<String, *> =
  307.     requireKey(key)

  309. fun Map<*, *>.requireInts(key: KProperty1<*, *>): List<Int> =
  310.     requireKey(key)

  312. fun Map<*, *>.requireLongs(key: KProperty1<*, *>): Collection<Long> =
  313.     requireKey(key)

  315. fun Map<*, *>.requireFloats(key: KProperty1<*, *>): Collection<Float> =
  316.     requireKey(key)

  318. fun Map<*, *>.requireDoubles(key: KProperty1<*, *>): Collection<Double> =
  319.     requireKey(key)

  321. fun Map<*, *>.requireBooleans(key: KProperty1<*, *>): Collection<Boolean> =
  322.     requireKey(key)

  324. fun Map<*, *>.requireStrings(key: KProperty1<*, *>): Collection<String> =
  325.     requireKey(key)

  327. fun Map<*, *>.requireLists(key: KProperty1<*, *>): Collection<Collection<*>> =
  328.     requireKey(key)

  330. fun Map<*, *>.requireMaps(key: KProperty1<*, *>): Collection<Map<String, *>> =
  331.     requireKey(key)
Created with JaCoCo 0.8.12.202403310830