Data.kt

  1. package com.hexagonkt.core

  3. import kotlin.reflect.KProperty1

  5. /**
  6.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  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.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  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.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  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.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  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.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  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.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  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.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  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.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  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.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  101.  *
  102.  * Mermaid test:
  103.  * ```mermaid
  104.  * graph LR
  105.  *   A --> B
  106.  * ```
  107.  *
  108.  * @param mapA .
  109.  * @param mapB .
  110.  * @return .
  111.  */
  112. fun merge(mapA: Map<*, *>, mapB: Map<*, *>): Map<*, *> =
  113.     (mapA.entries + mapB.entries)
  114.         .groupBy { it.key }
  115.         .mapValues { (_, v) -> v.map { it.value } }
  116.         .mapValues { (_, v) ->
  117.             val isCollection = v.all { it is Collection<*> }
  118.             val isMap = v.all { it is Map<*, *> }
  119.             when {
  120.                 isCollection -> v.map { it as Collection<*> }.reduce { a, b -> a + b }
  121.                 isMap -> v.map { it as Map<*, *> }.reduce { a, b -> merge(a, b) }
  122.                 else -> v.last()
  123.             }
  124.         }

  126. /**
  127.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  128.  *
  129.  * @param maps .
  130.  * @return .
  131.  */
  132. fun merge(maps: Collection<Map<*, *>>): Map<*, *> =
  133.     maps.reduce { a, b -> merge(a, b) }

  135. /**
  136.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  137.  *
  138.  * @receiver .
  139.  * @return .
  140.  */
  141. fun <K, V> Map<K, Collection<V>>.pairs(): Collection<Pair<K, V>> =
  142.     flatMap { (k, v) -> v.map { k to it } }

  144. /**
  145.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  146.  *
  147.  * @receiver .
  148.  * @return .
  149.  */
  150. fun <K, V> Map<K, V?>.filterNotEmpty(): Map<K, V> =
  151.     this.filterValues(::notEmpty).mapValues { (_, v) -> v ?: fail }

  153. /**
  154.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  155.  *
  156.  * @receiver .
  157.  * @return .
  158.  */
  159. fun <V> Collection<V?>.filterNotEmpty(): Collection<V> =
  160.     this.filter(::notEmpty).map { it ?: fail }

  162. /**
  163.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  164.  *
  165.  * @receiver .
  166.  * @return .
  167.  */
  168. fun Map<*, *>.filterNotEmptyRecursive(): Map<*, *> =
  169.     mapValues { (_, v) ->
  170.         when (v) {
  171.             is Collection<*> -> v.filterNotEmptyRecursive()
  172.             is Map<*, *> -> v.filterNotEmptyRecursive()
  173.             else -> v
  174.         }
  175.     }
  176.         .filterNotEmpty()

  178. /**
  179.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  180.  *
  181.  * @receiver .
  182.  * @return .
  183.  */
  184. fun Collection<*>.filterNotEmptyRecursive(): Collection<*> =
  185.     map {
  186.         when (it) {
  187.             is Collection<*> -> it.filterNotEmptyRecursive()
  188.             is Map<*, *> -> it.filterNotEmptyRecursive()
  189.             else -> it
  190.         }
  191.     }
  192.         .filterNotEmpty()

  194. /**
  195.  * [TODO](https://github.com/hexagontk/hexagon/issues/271).
  196.  *
  197.  * @param value .
  198.  * @return .
  199.  */
  200. fun <V> notEmpty(value: V?): Boolean {
  201.     return when (value) {
  202.         null -> false
  203.         is Collection<*> -> value.isNotEmpty()
  204.         is Map<*, *> -> value.isNotEmpty()
  205.         else -> true
  206.     }
  207. }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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