feat: add comments to code to trees package

Author: RoketFlame

app/src/main/kotlin/composeApp/Controller.kt

@@ -5,17 +5,12 @@
 
 import androidx.compose.ui.awt.ComposeWindow
 import com.google.gson.Gson
-import repo.JsonRepository
-import repo.serialization.SerializableValue
-import repo.serialization.strategies.AVLStrategy
+import repository.JsonRepository
+import repository.serialization.SerializableValue
+import repository.serialization.strategies.AVLStrategy
 import java.awt.FileDialog
 import java.io.File
 
-/*
- * Copyright (c) 2023 teemEight
- * SPDX-License-Identifier: Apache-2.0
- */
-
 class Controller {
     fun openFileDialog(
         window: ComposeWindow, title: String, allowedExtensions: List<String>, allowMultiSelection: Boolean = true
@@ -40,7 +35,7 @@ class Controller {
             return gson.fromJson(string.value, DrawableNode::class.java)!!
         }
 
-        val repo = JsonRepository(AVLStrategy(::drawableNodeToString, ::jsonStringToDrawableNode), dirPath, filename)
+        val repo = JsonRepository(AVLStrategy(::drawableNodeToString, ::jsonStringToDrawableNode), dirPath)
         return repo.getNames()
     }
 

app/src/main/kotlin/composeApp/DrawableNode.kt

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import app.trees.KeyValue
+import trees.KeyValue
 
 class DrawableNode(
     var data: KeyValue<Int, String>,

app/src/main/kotlin/composeApp/MainActivity.kt

@@ -7,7 +7,6 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.ui.awt.ComposeWindow
-import composeApp.OpenTree
 import java.io.File
 
 /*
@@ -48,44 +47,44 @@ fun run(window: ComposeWindow) {
 
     val listNames = remember { mutableStateOf(listOf("test", "main")) }
     val nameState = remember { mutableStateOf("") }
-    when (state.value) {
-        States.OPENING_TREE -> OpenTree(
-            listOfDatabase = listOfDatabase,
-            onTypeOfDatabaseChanged = { newType ->
-                stringTypeOfDatabaseState.value = newType
-                typeOfDatabaseState.value = databases.getOrDefault(stringTypeOfDatabaseState.value, TypeOfDatabase.Json)
-            },
-            typeOfDatabaseState = typeOfDatabaseState,
-            stringTypeOfDatabaseState = stringTypeOfDatabaseState,
-
-            pathState = pathState,
-            file = file,
-            onPathChanged = { newPath -> pathState.value = newPath },
-            onFilePicked = {
-                file.value =
-                    controller.value.openFileDialog(
-                        window,
-                        "Load a file",
-                        listOf(".json"),
-                        allowMultiSelection = false
-                    )
-            },
-
-            listOfNames = listNames.value,
-            nameState = nameState,
-            onNameChanged = { newName -> nameState.value = newName },
-
-            onLoadTree = {
-//                controller.value.loadTree(nameState.value)
-                state.value = States.DRAW_TREE
-            }
-
-
-        )
-
-        else -> {
-            window.setSize(1080, 800)
-            Editor()
-        }
-    }
+//    when (state.value) {
+//        States.OPENING_TREE -> OpenTree(
+//            listOfDatabase = listOfDatabase,
+//            onTypeOfDatabaseChanged = { newType ->
+//                stringTypeOfDatabaseState.value = newType
+//                typeOfDatabaseState.value = databases.getOrDefault(stringTypeOfDatabaseState.value, TypeOfDatabase.Json)
+//            },
+//            typeOfDatabaseState = typeOfDatabaseState,
+//            stringTypeOfDatabaseState = stringTypeOfDatabaseState,
+//
+//            pathState = pathState,
+//            file = file,
+//            onPathChanged = { newPath -> pathState.value = newPath },
+//            onFilePicked = {
+//                file.value =
+//                    controller.value.openFileDialog(
+//                        window,
+//                        "Load a file",
+//                        listOf(".json"),
+//                        allowMultiSelection = false
+//                    )
+//            },
+//
+//            listOfNames = listNames.value,
+//            nameState = nameState,
+//            onNameChanged = { newName -> nameState.value = newName },
+//
+//            onLoadTree = {
+////                controller.value.loadTree(nameState.value)
+//                state.value = States.DRAW_TREE
+//            }
+//
+//
+//        )
+//
+//        else -> {
+//            window.setSize(1080, 800)
+//            Editor()
+//        }
+//    }
 }

lib/src/main/kotlin/trees/AVLTree.kt

@@ -8,23 +8,26 @@ package trees
 import trees.nodes.AVLNode
 
 class AVLTree<T : Comparable<T>> : AbstractTree<T, AVLNode<T>>() {
-
+    //adds a new node to the AVL tree.
     override fun add(data: T) {
         root = balancedAdd(root, AVLNode(data))
         root?.updateHeight()
         root?.parent = null
     }
 
+    //checks if the given value is contained in the AVL tree.
     override fun contains(data: T): Boolean {
         return (contains(root, AVLNode(data)) != null)
     }
 
+    //removes the node with the given value from the AVL tree.
     override fun delete(data: T) {
         root = balancedDelete(root, AVLNode(data))
         root?.updateHeight()
         root?.parent = null
     }
 
+    //method that balances the tree starting from the given node.
     override fun balance(initNode: AVLNode<T>?): AVLNode<T>? {
         if (initNode == null) {
             return null
@@ -54,10 +57,12 @@ class AVLTree<T : Comparable<T>> : AbstractTree<T, AVLNode<T>>() {
         return initNode
     }
 
+    //method that returns the value of the node with the given value.
     fun get(data: T): T? {
         return contains(root, AVLNode(data))?.data
     }
 
+    //helper method of the AVLTree class that updates the height of the passed node's child nodes.
     private fun updateChildrenHeight(node: AVLNode<T>?) {
         node?.left?.updateHeight()
         node?.right?.updateHeight()

lib/src/main/kotlin/trees/AbstractTree.kt

@@ -12,10 +12,16 @@ abstract class AbstractTree<T : Comparable<T>, NodeType : AbstractNode<T, NodeTy
     var root: NodeType? = null
         internal set
 
+    //This function is called after a node has been inserted or removed from the tree,
+    // and is used to balance the tree if necessary.
+    // The default implementation simply returns the starting node without performing any balancing.
     protected open fun balance(initNode: NodeType?): NodeType? {
         return initNode
     }
 
+    //This function is used to add a node to a tree while ensuring that the tree remains balanced.
+    //It recursively traverses the tree until it finds the correct position for the new node,
+    // and then calls balance to balance the tree.
     protected fun balancedAdd(initNode: NodeType?, node: NodeType): NodeType? {
 
         if (initNode == null) {
@@ -32,6 +38,8 @@ abstract class AbstractTree<T : Comparable<T>, NodeType : AbstractNode<T, NodeTy
         return balance(initNode)
     }
 
+    //This function is used to remove a node from a tree while ensuring that the tree remains balanced.
+    // It recursively traverses the tree until it finds the node to be removed, and then calls
     protected fun balancedDelete(initNode: NodeType?, node: NodeType): NodeType? {
         if (initNode == null) {
             return null
@@ -57,6 +65,7 @@ abstract class AbstractTree<T : Comparable<T>, NodeType : AbstractNode<T, NodeTy
         return balance(initNode)
     }
 
+    //This function is used to check if a node matches with the same value as
     protected fun contains(initNode: NodeType?, node: NodeType): NodeType? {
         if (initNode == null) {
             return null
@@ -71,6 +80,7 @@ abstract class AbstractTree<T : Comparable<T>, NodeType : AbstractNode<T, NodeTy
         }
     }
 
+    //This function returns the node with the smallest value in the subtree rooted at the specified node.
     protected fun getMinimal(node: NodeType): NodeType {
         var minNode = node
         while (true) {
@@ -79,6 +89,7 @@ abstract class AbstractTree<T : Comparable<T>, NodeType : AbstractNode<T, NodeTy
         return minNode
     }
 
+    //This function returns the node with the largest value in the subtree rooted at the specified node.
     protected fun getMaximal(node: NodeType): NodeType {
         var maxNode = node
         while (true) {
@@ -87,6 +98,7 @@ abstract class AbstractTree<T : Comparable<T>, NodeType : AbstractNode<T, NodeTy
         return maxNode
     }
 
+    //This function performs a left rotation on the specified node, changing its position to its right child node.
     protected fun rotateLeft(node: NodeType): NodeType? {
         val rightChild = node.right
         val secondSubtree = rightChild?.left
@@ -97,6 +109,7 @@ abstract class AbstractTree<T : Comparable<T>, NodeType : AbstractNode<T, NodeTy
         return rightChild
     }
 
+    //This function performs a right rotation for the specified node, changing its position to its left child.
     protected fun rotateRight(node: NodeType): NodeType? {
         val leftChild = node.left
         val secondSubtree = leftChild?.right
@@ -107,6 +120,7 @@ abstract class AbstractTree<T : Comparable<T>, NodeType : AbstractNode<T, NodeTy
         return leftChild
     }
 
+    //This function replaces the specified child node of a node with a new child node
     protected fun replaceChild(child: NodeType, newChild: NodeType?): NodeType? {
         if (child == root) {
             root = newChild
@@ -122,6 +136,9 @@ abstract class AbstractTree<T : Comparable<T>, NodeType : AbstractNode<T, NodeTy
         return newChild
     }
 
+    //This function returns a preview of the tree as a list of nodes.
+    // It uses the walk internal function to recursively traverse the tree in advance
+    // and add each node to the list.
     fun preOrder(): List<NodeType> {
         val result = mutableListOf<NodeType>()
         fun walk(node: NodeType, lst: MutableList<NodeType>) {

lib/src/main/kotlin/trees/BSTree.kt

@@ -9,20 +9,23 @@ import trees.nodes.BSNode
 
 class BSTree<T : Comparable<T>> : AbstractTree<T, BSNode<T>>() {
 
-
+    //method that adds a new node
     override fun add(data: T) {
         root = balancedAdd(root, BSNode(data))
     }
 
+    //method that checks if the given value is contained
     override fun contains(data: T): Boolean {
         return (contains(root, BSNode(data)) != null)
     }
 
+    //method that removes a node with a given value
     override fun delete(data: T) {
         root = balancedDelete(root, BSNode(data))
         root?.parent = null
     }
 
+    //method that returns the value of the node with the given value.
     fun get(data: T): T? {
         return contains(root, BSNode(data))?.data
     }

lib/src/main/kotlin/trees/KeyValue.kt

@@ -10,21 +10,26 @@ class KeyValue<K : Comparable<K>, V>(
     var value: V?
 ) : Comparable<KeyValue<K, V>> {
 
+    //Compares KeyValue objects based on their keys.
     override fun compareTo(other: KeyValue<K, V>): Int {
         return key.compareTo(other.key)
     }
 
+    //Checks if a KeyValue object is equal to another object.
+    //Two objects are considered equal if their keys are equal.
     override fun equals(other: Any?): Boolean {
         if (other is KeyValue<*, *>) {
             return key == other.key
         }
         return false
     }
 
+    //Returns the string representation of the KeyValue object in "key: value" format.
     override fun toString(): String {
         return "$key: $value"
     }
 
+    //Returns the hash code of the KeyValue object based on the hash code of the key.
     override fun hashCode(): Int {
         return key.hashCode()
     }