docs: add JavaDocs for remaining product-related classes

Author: AlexanderSchultheiss

src/main/java/de/hub/mse/variantsync/boosting/product/Product.java

@@ -18,6 +18,14 @@
 import java.util.Objects;
 import java.util.stream.Collectors;
 
+/**
+ * Represents a product with features and an abstract syntax tree (AST).
+ * 
+ * This class defines a product with a set of features and a product
+ * AST.
+ * It also stores the AST nodes of the main tree that correspond to the AST
+ * nodes of the product AST.
+ */
 public class Product implements Serializable {
     private final EccoSet<Feature> features;
     private final String name;
@@ -27,6 +35,14 @@ public class Product implements Serializable {
     // product AST
     private EccoSet<ASTNode> astNodesMainTree;
 
+    /**
+     * Constructs a new Product object with the given parameters.
+     * 
+     * @param name             the name of the product
+     * @param astNodesMainTree the main tree of AST nodes for the product
+     * @param productAST       the abstract syntax tree for the product
+     * @param features         the set of features associated with the product
+     */
     public Product(final String name, final EccoSet<ASTNode> astNodesMainTree, final AbstractAST productAST,
             final EccoSet<Feature> features) {
         this.name = name;
@@ -35,52 +51,92 @@ public Product(final String name, final EccoSet<ASTNode> astNodesMainTree, final
         this.features = features;
     }
 
+    /**
+     * Creates a new Product object by copying the contents of another Product
+     * object.
+     * 
+     * @param other The Product object to copy from
+     * @throws UnsupportedOperationException if the productAST type is not JavaAST
+     *                                       or LineAST
+     */
     public Product(final Product other) {
+        // Copy the name from the other Product object
         this.name = other.name;
+
+        // Create a new set of ASTNodes to copy from the other Product object
         final EccoSet<ASTNode> nodesToCopy = new EccoSet<>(other.astNodesMainTree);
         nodesToCopy.addAll(other.productAST.getAstNodes());
         nodesToCopy.add(other.productAST.getRoot());
+
+        // Create a mapping of original ASTNodes to copied ASTNodes
         final Map<ASTNode, ASTNode> originalToCopyMap = copyAstNodes(nodesToCopy);
 
+        // Copy the ASTNodes from the other Product object and update the main tree
         final EccoSet<ASTNode> astNodes = new EccoSet<>(
                 other.astNodesMainTree
                         .stream()
                         .map(originalToCopyMap::get)
                         .collect(Collectors.toCollection(EccoSet::new)));
         this.astNodesMainTree = new EccoSet<>(astNodes);
 
+        // Copy the ASTNodes from the other Product object and update the tree
         final EccoSet<ASTNode> treeNodes = new EccoSet<>(
                 other.productAST.getAstNodes()
                         .stream()
                         .map(originalToCopyMap::get)
                         .collect(Collectors.toCollection(EccoSet::new)));
+
+        // Create a new productAST object based on the type of the other Product
+        // object's productAST
         if (other.productAST instanceof JavaAST) {
             final JavaAST ast = (JavaAST) other.productAST;
             this.productAST = new JavaAST(originalToCopyMap.get(ast.getRoot()), treeNodes);
         } else if (other.productAST instanceof LineAST) {
             final LineAST ast = (LineAST) other.productAST;
             this.productAST = new LineAST(originalToCopyMap.get(ast.getRoot()), treeNodes);
         } else {
-            throw new UnsupportedOperationException();
+            throw new UnsupportedOperationException("Unsupported productAST type");
         }
+
+        // Copy the features from the other Product object
         this.features = new EccoSet<>(other.getFeatures());
     }
 
+    /**
+     * Clears the product Abstract Syntax Tree (AST) by setting it to null.
+     */
     public void forgetAST() {
         this.productAST = null;
     }
 
+    /**
+     * Retrieves the set of features associated with the product.
+     *
+     * @return The set of features associated with the product.
+     */
     public EccoSet<Feature> getFeatures() {
         return features;
     }
 
+    /**
+     * Returns the set of AST nodes in the main tree.
+     * 
+     * @return EccoSet<ASTNode> - a set of AST nodes in the main tree
+     */
     public EccoSet<ASTNode> getAstNodesMainTree() {
         return astNodesMainTree;
     }
 
-    // returns the mapping of the node at given position in the product or (if it
-    // was already merged into the main tree) the mapping of the corresponding node
-    // in the main tree
+    /**
+     * Returns the mapping of the node at the given position in the product AST or,
+     * if it has already been merged into the main tree, the mapping of the
+     * corresponding
+     * node in the main tree.
+     *
+     * @param position The position of the node to find the mapping for
+     * @return The mapping of the node at the given position, or null if no node is
+     *         found
+     */
     public Formula getMappingFromPosition(final Position position) {
         // look for the right node in the product AST's nodes
         for (final ASTNode oldNode : productAST.getAstNodes()) {
@@ -97,12 +153,24 @@ public Formula getMappingFromPosition(final Position position) {
         return null;
     }
 
+    /**
+     * Returns the name of the object.
+     *
+     * @return the name of the object as a String
+     */
     public String getName() {
         return name;
     }
 
-    // returns the node at given position in the product or (if it was already
-    // merged into the main tree) the corresponding node in the main tree
+    /**
+     * Returns the ASTNode at the given position in the product AST or, if it has
+     * already been merged into the main tree,
+     * returns the corresponding node in the main tree.
+     *
+     * @param position The position to search for in the product AST.
+     * @return The ASTNode at the given position in the product AST, or the
+     *         corresponding node in the main tree if merged.
+     */
     public ASTNode getNodeFromPosition(final Position position) {
         // look for the right node in the product AST's nodes
         for (final ASTNode oldNode : productAST.getAstNodes()) {
@@ -119,10 +187,20 @@ public ASTNode getNodeFromPosition(final Position position) {
         return null;
     }
 
+    /**
+     * Returns the Abstract Syntax Tree (AST) representing the product.
+     *
+     * @return the AST representing the product
+     */
     public AbstractAST getProductAst() {
         return productAST;
     }
 
+    /**
+     * Sets the AST nodes for the main tree.
+     *
+     * @param astNodesMainTree the AST nodes for the main tree
+     */
     public void setAstNodesMainTree(final EccoSet<ASTNode> astNodesMainTree) {
         this.astNodesMainTree = astNodesMainTree;
     }

src/main/java/de/hub/mse/variantsync/boosting/product/ProductLoader.java

@@ -8,11 +8,32 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 
+/**
+ * A class that implements an Iterator for loading products using multiple
+ * threads.
+ * 
+ * This class takes a list of ProductLoadTask objects and a number of threads to
+ * use for loading the products.
+ * It then creates a thread pool with the specified number of threads and
+ * submits tasks to load products.
+ * 
+ * @param loadTasks a list of ProductLoadTask objects representing the tasks to
+ *                  load products
+ * @param nThreads  the number of threads to use for loading products
+ */
 public class ProductLoader implements Iterator<Product> {
     private final List<ProductLoadTask> remainingTasks;
     private final List<Future<ProductLoadTask.LoadResult>> futures;
     private final ExecutorService threadPool;
 
+    /**
+     * Constructs a ProductLoader with the specified list of load tasks and number
+     * of threads.
+     * 
+     * @param loadTasks a list of ProductLoadTask objects representing the tasks to
+     *                  load products
+     * @param nThreads  the number of threads to use for loading products
+     */
     public ProductLoader(final List<ProductLoadTask> loadTasks, final int nThreads) {
         this.remainingTasks = new LinkedList<>(loadTasks);
         this.threadPool = Executors.newFixedThreadPool(nThreads);
@@ -24,11 +45,22 @@ public ProductLoader(final List<ProductLoadTask> loadTasks, final int nThreads)
         }
     }
 
+    /**
+     * Checks if there are more products to load.
+     * 
+     * @return true if there are more products to load, false otherwise
+     */
     @Override
     public boolean hasNext() {
         return !futures.isEmpty();
     }
 
+    /**
+     * Loads the next product using a thread from the thread pool.
+     * 
+     * @return the next product to load
+     * @throws RuntimeException if an error occurs while loading the product
+     */
     @Override
     public Product next() {
         if (!this.remainingTasks.isEmpty()) {

src/main/java/de/hub/mse/variantsync/boosting/product/ProductPassport.java

@@ -2,25 +2,52 @@
 
 import java.nio.file.Path;
 
+/**
+ * Represents a product passport, containing information about the product name,
+ * sources root, and configuration path.
+ */
 public class ProductPassport {
     private final String name;
     private final Path sourcesRoot;
     private final Path configuration;
 
+    /**
+     * Constructs a new ProductPassport with the given name, sources root, and
+     * configuration path.
+     *
+     * @param name          the name of the product
+     * @param sourcesRoot   the root path for the product sources
+     * @param configuration the path to the product configuration
+     */
     public ProductPassport(final String name, final Path sourcesRoot, final Path configuration) {
         this.name = name;
         this.sourcesRoot = sourcesRoot;
         this.configuration = configuration;
     }
 
+    /**
+     * Returns the root path for the product sources.
+     *
+     * @return the root path for the product sources
+     */
     public Path getSourcesRoot() {
         return sourcesRoot;
     }
 
+    /**
+     * Returns the path to the product configuration.
+     *
+     * @return the path to the product configuration
+     */
     public Path getConfiguration() {
         return configuration;
     }
 
+    /**
+     * Returns the name of the product.
+     *
+     * @return the name of the product
+     */
     public String getName() {
         return name;
     }