Utils

inline fun <reified T> T.getLogger(): Logger {
  return LoggerFactory.getLogger(T::class.java)
}

infix fun RoutingContext.jsonReply(obj: Any?) {
  response().putHeader(HttpHeaders.CONTENT_TYPE, "application/json; charset=utf-8")
    .end(if (obj is String) obj else Json.encode(obj))
}

fun JsonObject.getOrDef(key: String, def: String) = this.getString(key) ?: def

inline fun <T> Iterable<T>.forEachMultithreading(nThreads: Int = 5, crossinline funWorker: (T) -> Any?) {
  val coroutineDispatcher = Executors.newFixedThreadPool(nThreads).asCoroutineDispatcher()
  runBlocking {
    coroutineDispatcher.use {
      launch {
        forEachIndexed { index, arg ->
          // CoroutineContext coroutineDispatcher
          async(coroutineDispatcher) {
            funWorker(arg)
          }
        }
      }.join()
    }
  }
}

inline fun <T> Iterable<T>.mapMultithreading(nThreads: Int = 5, crossinline funWorker: (T) -> Any?): Iterable<Any?> {
  val results = arrayOfNulls<Any>(count())
  val coroutineDispatcher = Executors.newFixedThreadPool(nThreads).asCoroutineDispatcher()

  runBlocking {
    coroutineDispatcher.use {
      launch {
        forEachIndexed { index, arg ->
          // CoroutineContext coroutineDispatcher
          async(coroutineDispatcher) {
            funWorker(arg).let {
              results[index] = it
            }
          }
        }
      }.join()
    }
  }
  return results.asIterable()
}

InfixDemo.kt

package com.citi.ocean.ktdemo

import io.vertx.kotlin.core.json.json
import io.vertx.kotlin.core.json.obj

/**
 * @Author hw83770
 * @Date 11:53 2020/4/17
 *
 *
 * Kotlin: Improve readability by using the infix notation
 * https://www.deadcoderising.com/kotlin-improve-readability-by-using-the-infix-notation/
 *
 */
fun main() {

  val msg = json {
    obj(
      "timerId" to "123",
      "bool" to true,
      "num" to 1,
      "test1" to "test1"
    )
  }
  println(msg)

  // ---------------
  val map1 = mapOf(
    1 to "one",
    2.to("two"),
    Pair(3, "three")
//    new Pair(3, "three")
  )
  println(map1)

  val hashMap = hashMapOf(
    1 to "one",
    2 to "two",
    3 to "three"
  )
  println(hashMap)

  listOf(1, 2, 3, 4, 5) subtract listOf(2, 3)
  listOf(1, 2, 3, 4, 5) union listOf(6, 7)
  listOf(1, 2, 3, 4, 5) zip listOf(2, 3, 4, 5, 6)
  listOf(1, 2, 3, 4, 5) intersect listOf(2, 3)

  "Hello world" matches "\\w+\\s\\w+".toRegex()

  val randomNumbers = RandomNumbers(listOf(1, 2, 3, 4, 5, 6))
  randomNumbers take 3
}


class RandomNumbers(val list: List<Int>) {

  infix fun take(nrOfElements: Int): List<Int> {
    return list.shuffled().take(nrOfElements);
  }
}

DelegatesStudy.kt

package com.citi.ocean.ktdemo

import kotlin.properties.Delegates
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty

/**
 * @Author hw83770
 * @Date 12:00 2019/8/29
 *
 */

class Raindy {
  val weather by lazy(LazyThreadSafetyMode.PUBLICATION) { "Raindy" }
  var name by PringDelegate()
}

class User(map: Map<String, Any>) {
  val name: String by map
  val age: Int by map
}

// 自定义 delegates, 将一些操作封装成一个属性，例如将Raindy的 value 属性设置成一个文件，
// 那么Raindy name set get操作都会是一个文件的 读写
class PringDelegate : ReadWriteProperty<Any, String> {

  private var value: String? = null
  override fun getValue(thisRef: Any, property: KProperty<*>): String {
    println("getValue: $thisRef -> ${property.name} ${property.returnType} $value")
    return value ?: ""
  }

  override fun setValue(thisRef: Any, property: KProperty<*>, value: String) {
    println("setValue: $thisRef -> ${property.name} = $value")
    this.value = value
  }
}

fun main() {
  var name by Delegates.observable(initialValue = "<no name>") { prop, old, new ->
    println("old val: $old, new val: $new")
  }
  name = "d"
  name = "a"
//  println("current name is $name")

  // ----------------
  var name2: String by Delegates.vetoable(initialValue = "test name2") { _, oldValue, newValue ->
    println("old val: $oldValue, new val: $newValue")
    return@vetoable newValue.contains("1")
  }
  name2 = "data1"
  name2 = "data2"
//  println("current name is $name2")

  var name3: String by Delegates.notNull()
//  name3 = "te"
//  println(name3)

  // -------------------
  val lazyData: Double by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
    println("Initializing lazyData")
    2.0
  }
//  println("--------")
//  println(lazyData)

  val userName = User(mapOf("name" to "ken", "age" to 20)).name
  println(userName)

//  val a = Raindy()
//  println(a.weather)
//  println(a.name)
//  a.name = "123"
//  println("now: " + a.name)


//  val b = BaseImpl(10)
//  Derived(b).print()
}

interface Base {
  fun print()
}

class BaseImpl(val x: Int) : Base {
  override fun print() {
    print(x)
  }
}

class Derived(b: Base) : Base by b

KotlinSTD.kt

package com.citi.ocean.ktdemo

/**
 * @Author hw83770
 * @Date 12:19 2020/4/17
 *
 */

// also
data class Person(var name: String) {
  var tutorial: String? = null
  var age: Int = 0
}

fun main() {

  val person = Person("ken").apply {
    age = 14
    tutorial = "kotlin"
  }
  println(person)

  val person2 = Person("ken2").let {
    it.age = 14
    it.tutorial = "java"
    return@let it
  }
  println(person2)

  // let -->  if not null
  val listWithNull = listOf("A", "S", null)
  println(listWithNull)
  for (item in listWithNull) {
    item?.let { print(it) }
  }

  val per: Person? = Person("ken")
  per?.let { person ->
    println(person.age)
    //    person.tutorial.substring(2)
    person.tutorial?.substring(2)
  }

  // null point
  var str: String? = "hellow fsdf"
  val len: Int? = str?.length
  println("length is $len")
}

BenchMarks.kt

package com.citi.ocean.ktdemo

import java.io.File
import java.util.concurrent.Semaphore

/**
 * @Author hw83770
 * @Date 10:26 2019/12/2
 *
 */

private val PRINT_REFIX = "[TimeTest]"


// sync funtion measureTime
fun measureTime(tag: String, testCount: Int, warmCount: Int, block: () -> Unit) {

  println("$PRINT_REFIX $tag =======  start")
  // warm up
  for (i in 0 until warmCount) {
    block()
  }
  println("$PRINT_REFIX $tag =======  warm done")

  // testing
  val startTime = System.currentTimeMillis()
  for (i in 0 until testCount) {
    block()
  }
  val totalTime = System.currentTimeMillis() - startTime

  println("$PRINT_REFIX $tag ======= total time: ${totalTime}ms")
  println("$PRINT_REFIX $tag ======= average time: ${totalTime / testCount}ms")
}


// async funtion measureTime
fun measureTimeAsync(tag: String, testCount: Int, warmCount: Int, asyncBlock: (Semaphore) -> Unit) {

  println("$PRINT_REFIX $tag =======  start")

  // warm up
  val semaphoreWarm = Semaphore(0)
  for (i in 0 until warmCount) {
    asyncBlock(semaphoreWarm)
  }
  semaphoreWarm.acquire(warmCount)
  println("$PRINT_REFIX $tag =======  warm done")

  // testing
  val semaphoreTest = Semaphore(0)
  val startTime = System.currentTimeMillis()
  for (i in 0 until testCount) {
    asyncBlock(semaphoreTest)
  }
  semaphoreTest.acquire(testCount)
  val totalTime = System.currentTimeMillis() - startTime

  println("$PRINT_REFIX $tag ======= total ${totalTime}ms")
  println("$PRINT_REFIX $tag ======= average ${totalTime / testCount}ms")
}


fun main() {
  measureTime(tag = "fun execute", testCount = 3, warmCount = 3) { testFun() }
}

fun testFun() {
  var sum = 0
  val file = File("test.txt")
  repeat(times = 1000) {
    sum = sum + it
    file.writeText(text = "sum is $sum")
  }
}