merge: Introduce schema for trace API (#88)

This pull request updates the OpenDC trace API to support proper specification 
of a schema of the tables exposed by the traces. This functionality makes it easier 
for the API consumer to understand the types exposed by the API.

## Implementation Notes :hammer_and_pick:

* Introduce type system for trace API
* Add benchmarks for odcvm trace format 
* Add benchmarks for Azure trace format
* Add conformance suite for OpenDC trace API 

## External Dependencies :four_leaf_clover:

* N/A

## Breaking API Changes :warning:

* Removal of typed `TableColumn`. Instead, `TableColumn` instances are now 
   used to describe the columns belonging to some table.
* `TableReader` and `TableWriter` do not support accessing arbitrary objects 
   anymore. Instead, only the types supported by the type system are exposed.

2 files changed, 122 insertions, 8 deletions

diff --git a/opendc-trace/opendc-trace-api/src/main/kotlin/org/opendc/trace/util/CompositeTableReader.kt b/opendc-trace/opendc-trace-api/src/main/kotlin/org/opendc/trace/util/CompositeTableReader.kt
index 11e032c7..c4854265 100644
--- a/opendc-trace/opendc-trace-api/src/main/kotlin/org/opendc/trace/util/CompositeTableReader.kt
+++ b/opendc-trace/opendc-trace-api/src/main/kotlin/org/opendc/trace/util/CompositeTableReader.kt
@@ -22,8 +22,10 @@
 
 package org.opendc.trace.util
 
-import org.opendc.trace.TableColumn
 import org.opendc.trace.TableReader
+import java.time.Duration
+import java.time.Instant
+import java.util.*
 
 /**
  * A helper class to chain multiple [TableReader]s.
@@ -63,11 +65,11 @@ public abstract class CompositeTableReader : TableReader {
         return delegate != null
     }
 
-    override fun resolve(column: TableColumn<*>): Int {
+    override fun resolve(name: String): Int {
         tryStart()
 
         val delegate = delegate
-        return delegate?.resolve(column) ?: -1
+        return delegate?.resolve(name) ?: -1
     }
 
     override fun isNull(index: Int): Boolean {
@@ -75,11 +77,6 @@ public abstract class CompositeTableReader : TableReader {
         return delegate.isNull(index)
     }
 
-    override fun get(index: Int): Any? {
-        val delegate = checkNotNull(delegate) { "Invalid reader state" }
-        return delegate.get(index)
-    }
-
     override fun getBoolean(index: Int): Boolean {
         val delegate = checkNotNull(delegate) { "Invalid reader state" }
         return delegate.getBoolean(index)
@@ -95,11 +92,51 @@ public abstract class CompositeTableReader : TableReader {
         return delegate.getLong(index)
     }
 
+    override fun getFloat(index: Int): Float {
+        val delegate = checkNotNull(delegate) { "Invalid reader state" }
+        return delegate.getFloat(index)
+    }
+
     override fun getDouble(index: Int): Double {
         val delegate = checkNotNull(delegate) { "Invalid reader state" }
         return delegate.getDouble(index)
     }
 
+    override fun getString(index: Int): String? {
+        val delegate = checkNotNull(delegate) { "Invalid reader state" }
+        return delegate.getString(index)
+    }
+
+    override fun getUUID(index: Int): UUID? {
+        val delegate = checkNotNull(delegate) { "Invalid reader state" }
+        return delegate.getUUID(index)
+    }
+
+    override fun getInstant(index: Int): Instant? {
+        val delegate = checkNotNull(delegate) { "Invalid reader state" }
+        return delegate.getInstant(index)
+    }
+
+    override fun getDuration(index: Int): Duration? {
+        val delegate = checkNotNull(delegate) { "Invalid reader state" }
+        return delegate.getDuration(index)
+    }
+
+    override fun <T> getList(index: Int, elementType: Class<T>): List<T>? {
+        val delegate = checkNotNull(delegate) { "Invalid reader state" }
+        return delegate.getList(index, elementType)
+    }
+
+    override fun <T> getSet(index: Int, elementType: Class<T>): Set<T>? {
+        val delegate = checkNotNull(delegate) { "Invalid reader state" }
+        return delegate.getSet(index, elementType)
+    }
+
+    override fun <K, V> getMap(index: Int, keyType: Class<K>, valueType: Class<V>): Map<K, V>? {
+        val delegate = checkNotNull(delegate) { "Invalid reader state" }
+        return delegate.getMap(index, keyType, valueType)
+    }
+
     override fun close() {
         delegate?.close()
     }
diff --git a/opendc-trace/opendc-trace-api/src/main/kotlin/org/opendc/trace/util/TableColumnConversion.kt b/opendc-trace/opendc-trace-api/src/main/kotlin/org/opendc/trace/util/TableColumnConversion.kt
new file mode 100644
index 00000000..8ef080b5
--- /dev/null
+++ b/opendc-trace/opendc-trace-api/src/main/kotlin/org/opendc/trace/util/TableColumnConversion.kt
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2022 AtLarge Research
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+@file:JvmName("TableColumnConversions")
+package org.opendc.trace.util
+
+import org.opendc.trace.TableColumnType
+import java.time.Duration
+import java.time.Instant
+import java.util.UUID
+
+/**
+ * Helper method to convert a [List] into a [List] with elements of [targetElementType].
+ */
+public fun <T> TableColumnType.List.convertTo(value: List<*>?, targetElementType: Class<T>): List<T>? {
+    require(elementType.isCompatible(targetElementType)) { "Target element type is not compatible with $elementType" }
+    @Suppress("UNCHECKED_CAST")
+    return value as List<T>?
+}
+
+/**
+ * Helper method to convert a [Set] into a [Set] with elements of [targetElementType].
+ */
+public fun <T> TableColumnType.Set.convertTo(value: Set<*>?, targetElementType: Class<T>): Set<T>? {
+    require(elementType.isCompatible(targetElementType)) { "Target element type is not compatible with $elementType" }
+    @Suppress("UNCHECKED_CAST")
+    return value as Set<T>?
+}
+
+/**
+ * Helper method to convert a [Map] into a [Map] with [targetKeyType] keys and [targetValueType] values.
+ */
+public fun <K, V> TableColumnType.Map.convertTo(value: Map<*, *>?, targetKeyType: Class<K>, targetValueType: Class<V>): Map<K, V>? {
+    require(keyType.isCompatible(targetKeyType)) { "Target key type $targetKeyType is not compatible with $keyType" }
+    require(valueType.isCompatible(targetValueType)) { "Target value type $targetValueType is not compatible with $valueType" }
+    @Suppress("UNCHECKED_CAST")
+    return value as Map<K, V>?
+}
+
+/**
+ * Helper method to determine [javaType] is compatible with this [TableColumnType].
+ */
+private fun TableColumnType.isCompatible(javaType: Class<*>): Boolean {
+    return when (this) {
+        is TableColumnType.Boolean -> javaType.isAssignableFrom(Boolean::class.java)
+        is TableColumnType.Int -> javaType.isAssignableFrom(Int::class.java)
+        is TableColumnType.Long -> javaType.isAssignableFrom(Long::class.java)
+        is TableColumnType.Float -> javaType.isAssignableFrom(Float::class.java)
+        is TableColumnType.Double -> javaType.isAssignableFrom(Double::class.java)
+        is TableColumnType.String -> javaType.isAssignableFrom(String::class.java)
+        is TableColumnType.UUID -> javaType.isAssignableFrom(UUID::class.java)
+        is TableColumnType.Instant -> javaType.isAssignableFrom(Instant::class.java)
+        is TableColumnType.Duration -> javaType.isAssignableFrom(Duration::class.java)
+        is TableColumnType.List -> javaType.isAssignableFrom(List::class.java)
+        is TableColumnType.Set -> javaType.isAssignableFrom(Set::class.java)
+        is TableColumnType.Map -> javaType.isAssignableFrom(Map::class.java)
+    }
+}