Add updateTypes to TypedByteArray and bump version to 0.3.6

Introduced an `updateTypes` method to dynamically update type definitions in `TypedByteArray`. Made `definition` private and initialized type/index maps in `createTypeAndIndexMap`. Updated project version for release.

build.gradle.kts

@@ -8,7 +8,7 @@ plugins {
 }
 
 group = "nl.astraeus"
-version = "0.3.3-SNAPSHOT"
+version = "0.3.6"
 
 repositories {
     mavenCentral()

src/commonMain/kotlin/nl/astraeus/tba/ByteArrayDefinition.kt

@@ -1,5 +1,7 @@
 package nl.astraeus.tba
 
+import kotlin.math.max
+
 enum class DataType(
   val size: Int,
   val bytesUsedInternally: Int = 0
@@ -36,6 +38,8 @@ open class ByteArrayDefinition(
   val types: List<Type> = types.toList()
 
   val size: Int by lazy {
-    this.types.sumOf { it.size }
+    this.types.sumOf {
+      max(0, it.size)
+    }
   }
 }

src/commonMain/kotlin/nl/astraeus/tba/SlicedByteArray.kt

@@ -188,7 +188,7 @@ class SlicedByteArray(
   fun slice(offset: Int, length: Int): SlicedByteArray {
     check(offset >= 0) { "Offset must be non-negative" }
     check(length >= 0) { "Length must be non-negative" }
-    check(offset + length <= this.length) { "Offset + length exceeds array bounds (offset: $offset, length: $length, array length: ${this.length})" }
+    check(offset + length <= this.data.size) { "Offset + length exceeds array bounds (offset: $offset, length: $length, array length: ${this.data.size})" }
 
     return SlicedByteArray(data, this.offset + offset, length)
   }

src/commonMain/kotlin/nl/astraeus/tba/TypedByteArray.kt

@@ -28,7 +28,7 @@ open class TypedByteArray(
   /**
    * The definition of the byte array structure.
    */
-  val definition: ByteArrayDefinition = ByteArrayDefinition(*types)
+  private var definition: ByteArrayDefinition = ByteArrayDefinition(*types)
 
   /**
    * The handler for the underlying byte array data.
@@ -47,14 +47,38 @@ open class TypedByteArray(
   val indexMap = mutableMapOf<String, Int>()
 
   init {
+    createTypeAndIndexMap()
+  }
+
+  fun definitionSize() = definition.size
+
+  /**
+   * Updates the internal structures with the provided types. This method reinitializes
+   * the necessary definitions, data handlers, and mapping structures based on the input types.
+   *
+   * @param types The list of types to update the internal data structures. Each type specifies
+   * its name, data type, and size. At least one type should be provided.
+   *
+   * WARNING: This method is not thread-safe and should be used with extreme caution.
+   * Updating types at runtime can lead to data corruption and inconsistencies if not handled properly.
+   */
+  fun updateTypes(vararg types: Type) {
+    definition = ByteArrayDefinition(*types)
+    data = MutableByteArrayHandler(SlicedByteArray(definition.size))
+    indexMap.clear()
+    typeMap.clear()
+    createTypeAndIndexMap()
+  }
+
+  private fun createTypeAndIndexMap() {
     check(definition.size <= data.buffer.length) {
       "Size of data can not be smaller then size of definition"
     }
 
     var index = 0
     for (type in definition.types) {
-      check (!typeMap.containsKey(type.name)) { "Duplicate type name ${type.name}" }
-      check (!indexMap.containsKey(type.name)) { "Duplicate type name ${type.name}" }
+      check(!typeMap.containsKey(type.name)) { "Duplicate type name ${type.name}" }
+      check(!indexMap.containsKey(type.name)) { "Duplicate type name ${type.name}" }
 
       typeMap[type.name] = type
       indexMap[type.name] = index