docs: add JavaDocs for threading classes

Author: AlexanderSchultheiss

src/main/java/de/hub/mse/variantsync/ecco/threading/ProductInitializationTask.java

@@ -15,23 +15,58 @@
 import java.util.List;
 import java.util.concurrent.Callable;
 
+/**
+ * A Callable task for initializing a product with the given parameters.
+ * 
+ * @param productNumber The number of the product to initialize.
+ * @param productName   The name of the product to initialize.
+ * @param configPath    The path to the configuration file for the product.
+ * @param sourcePath    The path to the source files for the product.
+ * @param allFeatures   The set of all features implemented by the product.
+ * @param usedLanguage  The primary language used in the product.
+ * @return An InitResult object representing the result of the initialization
+ *         task.
+ * @throws Exception If an error occurs during the initialization process.
+ */
 public class ProductInitializationTask implements Callable<ProductInitializationTask.InitResult> {
     private final int productNumber;
     private final String productName;
     private final File configPath;
     private final File sourcePath;
     private final EccoSet<Feature> allFeatures;
-    private final ESupportedLanguages targetLanguage;
+    private final ESupportedLanguages usedLanguage;
 
-    public ProductInitializationTask(final int productNumber, final ProductPassport passport, final ESupportedLanguages targetLanguage) {
+    /**
+     * Initializes a ProductInitializationTask with the given product number,
+     * product passport, and target language.
+     * 
+     * @param productNumber  the product number to assign to the task
+     * @param passport       the product passport containing information about the
+     *                       product
+     * @param targetLanguage the target language for the task
+     */
+    public ProductInitializationTask(final int productNumber, final ProductPassport passport,
+            final ESupportedLanguages targetLanguage) {
         this.productNumber = productNumber;
         this.productName = passport.getName();
         this.configPath = passport.getConfiguration().toFile();
         this.sourcePath = passport.getSourcesRoot().toFile();
         this.allFeatures = new EccoSet<>();
-        this.targetLanguage = targetLanguage;
+        this.usedLanguage = targetLanguage;
     }
 
+    /**
+     * Parses the sources and creates an InitResult with the created product.
+     * 
+     * This method reads a configuration file specified by the configPath parameter,
+     * parses the features listed in the file,
+     * creates a product AST based on the target language specified, and returns an
+     * InitResult object containing the parsed information.
+     *
+     * @return InitResult - an object containing the parsed information
+     * @throws Exception - if an error occurs during parsing or creating the
+     *                   InitResult object
+     */
     @Override
     public InitResult call() throws Exception {
         Logger.info("Parsing variant " + productNumber + "...");
@@ -52,7 +87,7 @@ public InitResult call() throws Exception {
         }
         final AbstractAST productAst;
         try {
-            switch (targetLanguage) {
+            switch (usedLanguage) {
                 case C:
                     productAst = new CAST(sourcePath);
                     break;
@@ -63,20 +98,45 @@ public InitResult call() throws Exception {
                     productAst = new LineAST(sourcePath);
                     break;
                 default:
-                    throw new IllegalStateException("Unexpected value: " + targetLanguage);
+                    throw new IllegalStateException("Unexpected value: " + usedLanguage);
             }
         } catch (final Exception e) {
             throw new RuntimeException("Was not able to parse " + sourcePath, e);
         }
 
-        return new InitResult(productNumber, allFeatures, new Product(productName, new EccoSet<>(), productAst, productFeatures));
+        return new InitResult(productNumber, allFeatures,
+                new Product(productName, new EccoSet<>(), productAst, productFeatures));
     }
 
+    /**
+     * Represents the result of initializing a product.
+     * Contains the ID of the initialization, a set of all features, and the product
+     * associated with the initialization.
+     */
     public static class InitResult {
+        /**
+         * The ID of the initialization.
+         */
         public final int id;
+
+        /**
+         * A set of all features associated with the initialization.
+         */
         public final EccoSet<Feature> allFeatures;
+
+        /**
+         * The product associated with the initialization.
+         */
         public final Product product;
 
+        /**
+         * Constructs a new InitResult with the specified ID, set of all features, and
+         * product.
+         * 
+         * @param id          The ID of the initialization.
+         * @param allFeatures A set of all features associated with the initialization.
+         * @param product     The product associated with the initialization.
+         */
         public InitResult(final int id, final EccoSet<Feature> allFeatures, final Product product) {
             this.id = id;
             this.allFeatures = allFeatures;

src/main/java/de/hub/mse/variantsync/ecco/threading/ProductLoadTask.java

@@ -10,21 +10,45 @@
 import java.nio.file.Path;
 import java.util.concurrent.Callable;
 
+/**
+ * A Callable task that loads a product from a given file path.
+ * The task reads the product object from the file using ObjectInputStream and
+ * returns a LoadResult object.
+ * 
+ * @param productPath The file path of the product to load
+ * @return LoadResult An object containing the loaded product ID and product
+ *         object
+ * @throws UncheckedIOException If an IOException occurs while reading the file
+ * @throws RuntimeException     If the Product class is not found
+ */
 public class ProductLoadTask implements Callable<ProductLoadTask.LoadResult> {
     private static int processedCount = 0;
     private final Path productPath;
     private final int id;
 
+    /**
+     * Constructs a ProductLoadTask with the given product file path.
+     * Parses the product ID from the file name.
+     * 
+     * @param productPath The file path of the product to load
+     */
     public ProductLoadTask(final Path productPath) {
         this.productPath = productPath;
-        // Retrieve the products index in the product array from the file name
         this.id = Integer.parseInt(productPath.getFileName().toString().split("\\.")[0].split("-")[1]);
     }
 
+    /**
+     * Loads the product from the file and returns a LoadResult object.
+     * 
+     * @return LoadResult An object containing the loaded product ID and product
+     *         object
+     * @throws UncheckedIOException If an IOException occurs while reading the file
+     * @throws RuntimeException     If the Product class is not found
+     */
     @Override
     public LoadResult call() throws Exception {
         try (final ObjectInputStream in = new ObjectInputStream(new FileInputStream(productPath.toFile()))) {
-            synchronized (ProductLoadTask.class){
+            synchronized (ProductLoadTask.class) {
                 Logger.info("#" + processedCount + ": Loading product " + id + " from " + productPath);
                 processedCount++;
             }
@@ -38,10 +62,17 @@ public LoadResult call() throws Exception {
         }
     }
 
+    /**
+     * Resets the processed count to zero.
+     */
     public static void resetProcessedCount() {
         ProductLoadTask.processedCount = 0;
     }
 
+    /**
+     * Represents the result of loading a product, containing the product ID and
+     * product object.
+     */
     public static class LoadResult {
         public final int id;
         public final Product product;

src/main/java/de/hub/mse/variantsync/ecco/threading/ProductSaveTask.java

@@ -10,23 +10,38 @@
 import java.nio.file.Files;
 import java.nio.file.Paths;
 
+/**
+ * A class representing a task to save a product to a file.
+ * This class implements the Runnable interface to be executed as a thread.
+ */
 public class ProductSaveTask implements Runnable {
     private static int processedCount = 0;
     private final Product product;
     private final String folderName;
     private final int id;
 
+    /**
+     * Constructor for ProductSaveTask.
+     * 
+     * @param product    The product to be saved.
+     * @param folderName The name of the folder where the product will be saved.
+     * @param id         The unique identifier of the product.
+     */
     public ProductSaveTask(final Product product, final String folderName, final int id) {
         this.product = product;
         this.folderName = folderName;
         this.id = id;
     }
 
-
+    /**
+     * Saves the product to a file.
+     * Creates directories if they do not exist and writes the product object to a
+     * file.
+     */
     @Override
     public void run() {
         final String filePath = folderName + "/" + product.getName().replaceAll("Variant", "product-") + ".product";
-        synchronized (ProductSaveTask.class){
+        synchronized (ProductSaveTask.class) {
             Logger.info("#" + processedCount + ": Saving product " + id + " to " + filePath);
             processedCount++;
         }
@@ -44,6 +59,9 @@ public void run() {
         }
     }
 
+    /**
+     * Reset the processed count to zero.
+     */
     public static void resetProcessedCount() {
         ProductSaveTask.processedCount = 0;
     }