Clean up converted Kotlin

Author: jhh

telemetry/build.gradle

@@ -41,6 +41,7 @@ dependencies {
 }
 
 task dokkaJavadoc(type: org.jetbrains.dokka.gradle.DokkaTask) {
+    includes = ['packages.md']
     outputFormat = 'javadoc'
     outputDirectory = javadoc.destinationDir
     jdkVersion = 8

telemetry/src/main/kotlin/org/strykeforce/thirdcoast/telemetry/AbstractInventory.kt

@@ -2,80 +2,61 @@ package org.strykeforce.thirdcoast.telemetry
 
 import com.squareup.moshi.JsonWriter
 import okio.BufferedSink
-import org.strykeforce.thirdcoast.telemetry.grapher.Measure
 import org.strykeforce.thirdcoast.telemetry.item.Item
 import java.io.IOException
-import java.util.*
 
 /**
  * An abstract base class intended to be subclassed by concrete implmentations of [Inventory].
  */
 abstract class AbstractInventory(items: Collection<Item>) : Inventory {
 
-    protected val items = items.toMutableList().also { it.sort() }
+    protected val items = items.sorted()
 
-    override fun itemForId(id: Int): Item {
-        return items[id]
-    }
+    override fun itemForId(id: Int) = items[id]
 
     @Throws(IOException::class)
     override fun writeInventory(sink: BufferedSink) {
         val writer = JsonWriter.of(sink)
         writer.indent = "  "
         writer.beginObject()
-        writer.name("items")
-        writeItems(writer)
-        writer.name("measures")
-        writeMeasures(writer)
-        writer.endObject()
+            .name("items")
+            .writeItems(items)
+            .name("measures")
+            .writeMeasures(items)
+            .endObject()
     }
 
-    @Throws(IOException::class)
-    internal fun writeItems(writer: JsonWriter) {
-        writer.beginArray()
-        for (i in items.indices) {
-            writer.beginObject()
-            writer.name("id").value(i.toLong())
-            writer.name("type").value(items[i].type)
-            writer.name("description").value(items[i].description)
-            writer.endObject()
-        }
-        writer.endArray()
-    }
+    override fun toString() = "AbstractInventory(items=$items)"
+}
 
-    @Throws(IOException::class)
-    internal fun writeMeasures(writer: JsonWriter) {
-        val measures = HashMap<String, Set<Measure>>()
-        items.forEach { it -> (measures.putIfAbsent(it.type, it.measures)) }
-        writer.beginArray()
-        for ((key, value) in measures) {
-            writeDeviceMeasures(writer, key, value)
-        }
-        writer.endArray()
+private fun JsonWriter.writeItems(items: List<Item>): JsonWriter {
+    beginArray()
+    items.forEachIndexed { index, item ->
+        beginObject()
+        name("id").value(index)
+        name("type").value(item.type)
+        name("description").value(item.description)
+        endObject()
     }
+    return endArray()
+}
 
-    @Throws(IOException::class)
-    internal fun writeDeviceMeasures(writer: JsonWriter, type: String, measures: Set<Measure>) {
-        writer.beginObject()
-        writer.name("deviceType").value(type)
-        writer.name("deviceMeasures")
-        writer.beginArray()
-        for (m in measures) {
-            writeMeasure(writer, m)
+private fun JsonWriter.writeMeasures(items: List<Item>): JsonWriter {
+    beginArray()
+    items.associateBy({ it.type }, { it.measures }).forEach { type, measures ->
+        beginObject()
+        name("deviceType").value(type)
+        name("deviceMeasures")
+        beginArray()
+        measures.forEach {
+            beginObject()
+            name("id").value(it.name)
+            name("description").value(it.description)
+            endObject()
         }
-        writer.endArray()
-        writer.endObject()
-    }
-
-    @Throws(IOException::class)
-    internal fun writeMeasure(writer: JsonWriter, measure: Measure) {
-        writer.beginObject()
-        writer.name("id").value(measure.name)
-        writer.name("description").value(measure.description)
-        writer.endObject()
-    }
-
-    override fun toString(): String {
-        return "AbstractInventory{" + "items=" + items + '}'.toString()
+        endArray()
+        endObject()
     }
+    return endArray()
 }
+

telemetry/src/main/kotlin/org/strykeforce/thirdcoast/telemetry/grapher/ClientHandler.kt

@@ -2,7 +2,6 @@ package org.strykeforce.thirdcoast.telemetry.grapher
 
 import mu.KotlinLogging
 import okio.Buffer
-import java.io.IOException
 import java.net.DatagramPacket
 import java.net.DatagramSocket
 import java.net.InetSocketAddress
@@ -24,23 +23,18 @@ class ClientHandler(private val port: Int, private val socket: DatagramSocket) {
     fun start(subscription: Subscription) {
         if (scheduler != null) return
 
+        val address = InetSocketAddress(subscription.client, port)
+        val packet = DatagramPacket(ByteArray(0), 0, address)
+        val buffer = Buffer()
+        val runnable = {
+            subscription.measurementsToJson(buffer)
+            val bytes = buffer.readByteArray()
+            packet.setData(bytes, 0, bytes.size)
+            socket.send(packet)
+        }
+
         scheduler = Executors.newSingleThreadScheduledExecutor().also {
-            it.scheduleAtFixedRate(
-                {
-                    val buffer = Buffer()
-                    try {
-                        subscription.measurementsToJson(buffer)
-                        val bytes = buffer.readByteArray()
-                        val packet = DatagramPacket(bytes, bytes.size, InetSocketAddress(subscription.client, port))
-                        socket.send(packet)
-                    } catch (e: IOException) {
-                        logger.error("Exception sending grapher data", e)
-                    }
-                },
-                0,
-                5,
-                MILLISECONDS
-            )
+            it.scheduleAtFixedRate(runnable, 0, 5, MILLISECONDS)
         }
         logger.info { "sending graph data to ${subscription.client}:$port" }
     }

telemetry/src/main/kotlin/org/strykeforce/thirdcoast/telemetry/grapher/Subscription.kt

@@ -33,52 +33,38 @@ class Subscription(inventory: Inventory, val client: String, requestJson: String
 
     @Throws(IOException::class)
     fun measurementsToJson(sink: BufferedSink) {
-        val ts = System.currentTimeMillis()
         val writer = JsonWriter.of(sink)
         writer.beginObject()
-        writer.name("timestamp").value(ts)
-        writer.name("data")
-        writer.beginArray()
-        for (m in measurements) {
-            writer.value(m.asDouble)
-        }
+            .name("timestamp").value(System.currentTimeMillis())
+            .name("data").beginArray()
+        measurements.forEach { writer.value(it.asDouble) }
         writer.endArray()
-        writer.endObject()
+            .endObject()
     }
 
     @Throws(IOException::class)
     fun toJson(sink: BufferedSink) {
-        val ts = System.currentTimeMillis()
         val writer = JsonWriter.of(sink)
         writer.beginObject()
-        writer.name("type").value("subscription")
-        writer.name("timestamp").value(ts)
-        writer.name("descriptions")
-        writer.beginArray()
-        for (d in descriptions) {
-            writer.value(d)
-        }
+            .name("type").value("subscription")
+            .name("timestamp").value(System.currentTimeMillis())
+            .name("descriptions").beginArray()
+        descriptions.forEach { writer.value(it) }
         writer.endArray()
-        writer.endObject()
+            .endObject()
     }
 
     internal class RequestJson {
 
         var type: String = "start"
         var subscription: List<Item> = emptyList()
 
-        override fun toString(): String {
-            return "RequestJson{" + "type='" + type + '\''.toString() + ", subscription=" + subscription + '}'.toString()
-        }
-
         internal class Item {
 
             var itemId: Int = 0
             lateinit var measurementId: String
 
-            override fun toString(): String {
-                return "Item{" + "itemId=" + itemId + ", measurementId=" + measurementId + '}'.toString()
-            }
+            override fun toString() = "Item(itemId=$itemId, measurementId='$measurementId')"
         }
 
         companion object {
@@ -94,5 +80,7 @@ class Subscription(inventory: Inventory, val client: String, requestJson: String
                 return adapter.fromJson(json)
             }
         }
+
+        override fun toString() = "RequestJson(type='$type', subscription=$subscription)"
     }
 }

telemetry/src/main/kotlin/org/strykeforce/thirdcoast/telemetry/grapher/package-info.kt

@@ -13,37 +13,10 @@ class TalonItem @JvmOverloads constructor(
 
     override val deviceId = talon.deviceID
     override val type = "talon"
-    override val measures = setOf(
-        CLOSED_LOOP_TARGET,
-        OUTPUT_CURRENT,
-        OUTPUT_VOLTAGE,
-        OUTPUT_PERCENT,
-        SELECTED_SENSOR_POSITION,
-        SELECTED_SENSOR_VELOCITY,
-        ACTIVE_TRAJECTORY_POSITION,
-        ACTIVE_TRAJECTORY_VELOCITY,
-        CLOSED_LOOP_ERROR,
-        BUS_VOLTAGE,
-        ERROR_DERIVATIVE,
-        INTEGRAL_ACCUMULATOR,
-        ANALOG_IN,
-        ANALOG_RAW,
-        ANALOG_POSITION,
-        ANALOG_VELOCITY,
-        QUAD_POSITION,
-        QUAD_VELOCITY,
-        QUAD_A_PIN,
-        QUAD_B_PIN,
-        QUAD_IDX_PIN,
-        PULSE_WIDTH_POSITION,
-        PULSE_WIDTH_VELOCITY,
-        PULSE_WIDTH_RISE_TO_FALL,
-        PULSE_WIDTH_RISE_TO_RISE,
-        FORWARD_LIMIT_SWITCH_CLOSED,
-        REVERSE_LIMIT_SWITCH_CLOSED
-    )
+    override val measures
+        get() = MEASURES
 
-    private val sensorCollection = talon.sensorCollection
+    private val sensorCollection = requireNotNull(talon.sensorCollection)
 
     override fun measurementFor(measure: Measure): DoubleSupplier {
         return when (measure) {
@@ -91,4 +64,35 @@ class TalonItem @JvmOverloads constructor(
 
     override fun hashCode() = deviceId
 
+    companion object {
+        val MEASURES = setOf(
+            CLOSED_LOOP_TARGET,
+            OUTPUT_CURRENT,
+            OUTPUT_VOLTAGE,
+            OUTPUT_PERCENT,
+            SELECTED_SENSOR_POSITION,
+            SELECTED_SENSOR_VELOCITY,
+            ACTIVE_TRAJECTORY_POSITION,
+            ACTIVE_TRAJECTORY_VELOCITY,
+            CLOSED_LOOP_ERROR,
+            BUS_VOLTAGE,
+            ERROR_DERIVATIVE,
+            INTEGRAL_ACCUMULATOR,
+            ANALOG_IN,
+            ANALOG_RAW,
+            ANALOG_POSITION,
+            ANALOG_VELOCITY,
+            QUAD_POSITION,
+            QUAD_VELOCITY,
+            QUAD_A_PIN,
+            QUAD_B_PIN,
+            QUAD_IDX_PIN,
+            PULSE_WIDTH_POSITION,
+            PULSE_WIDTH_VELOCITY,
+            PULSE_WIDTH_RISE_TO_FALL,
+            PULSE_WIDTH_RISE_TO_RISE,
+            FORWARD_LIMIT_SWITCH_CLOSED,
+            REVERSE_LIMIT_SWITCH_CLOSED
+        )
+    }
 }