Added missing javadoc

Author: “jklein94”

org-tweetyproject-agents-dialogues/src/main/java/org/tweetyproject/agents/dialogues/examples/GroundedTest.java

@@ -350,7 +350,7 @@ public String call() throws Exception {
 	/**
 	 * Grounded test method
 	 * @param args the args
-	 * @throws ProtocolTerminatedException
+	 * @throws ProtocolTerminatedException error
 	 */
 	public static void main(String[] args) throws ProtocolTerminatedException {
 		// set logging level to "TRACE" to get detailed descriptions

org-tweetyproject-agents-dialogues/src/main/java/org/tweetyproject/agents/dialogues/examples/LotteryDialogueTest.java

@@ -191,7 +191,7 @@ public String call() throws Exception {
 	 * LotteryDialogue test main method
 	 *
 	 * @param args the args
-	 * @throws ProtocolTerminatedException
+	 * @throws ProtocolTerminatedException error
 	 */
 	public static void main(String[] args) throws ProtocolTerminatedException {
 		LotteryDialogueTest.attackProbability = 0.3;

org-tweetyproject-arg-adf/src/main/java/org/tweetyproject/arg/adf/io/KppADFFormatWriter.java

@@ -44,6 +44,11 @@
  */
 public class KppADFFormatWriter {
 
+    /**
+     * Write acceptanceConditions
+     * @param acceptanceConditions condition
+     * @return written string
+     */
     public static String write(Map<Argument,AcceptanceCondition> acceptanceConditions) {
         StringBuilder s = new StringBuilder();
         Map<Argument, String> nameMap = new HashMap<>();
@@ -116,7 +121,7 @@ public static void writeTo(AbstractDialecticalFramework adf, OutputStream out) {
     }
 
     /**
-     *
+     * Write to file
      * @param adf adf
      * @param file file
      * @throws FileNotFoundException File Not Found Exception

org-tweetyproject-arg-adf/src/main/java/org/tweetyproject/arg/adf/reasoner/NaiveReasoner.java

@@ -25,17 +25,16 @@
 import org.tweetyproject.arg.adf.semantics.interpretation.Interpretation;
 import org.tweetyproject.arg.adf.syntax.adf.AbstractDialecticalFramework;
 
-@Deprecated( forRemoval = true, since = "1.19" )
 /**
- * 
+ * NaiveReasoner class
  * @author Mattias Thimm
  *
  */
-
+@Deprecated( forRemoval = true, since = "1.19" )
 public class NaiveReasoner extends AbstractDialecticalFrameworkReasoner {
 
 	/**
-	 * 
+	 *Constructor
 	 * @param solver
 	 *            the underlying sat solver
 	 */

org-tweetyproject-arg-adf/src/main/java/org/tweetyproject/arg/adf/semantics/interpretation/Interpretation.java

@@ -76,8 +76,13 @@ static Interpretation fromMap(Map<Argument, Boolean> assignment) {
 		}
 		return new SetInterpretation(satisfied, unsatisfied, undecided);
 	}
+
 	/**
 	 * 	Interpretation fromSets
+	 * @param satisfied satisfied
+	 * @param unsatisfied unsatisfied
+	 * @param adf adf
+	 * @return 	Interpretation fromSets
 	 */
 	static Interpretation fromSets(Set<Argument> satisfied, Set<Argument> unsatisfied, AbstractDialecticalFramework adf) {
 		Set<Argument> undecided = new HashSet<>();

org-tweetyproject-arg-adf/src/main/java/org/tweetyproject/arg/adf/semantics/link/SimpleLink.java

@@ -48,22 +48,45 @@ public SimpleLink(Argument from, Argument to, LinkType type) {
         this.to = Objects.requireNonNull(to);
         this.type = Objects.requireNonNull(type);
     }
-
+/**
+     * Constructs a new {@code SimpleLink} with the specified source and target arguments.
+     * The link is of type {@code LinkType.DEPENDENT}.
+     *
+     * @param from The source argument from which the link originates.
+     * @param to   The target argument to which the link points.
+     * @throws NullPointerException if either {@code from} or {@code to} is {@code null}.
+     */
     public SimpleLink(Argument from, Argument to) {
         super(from, to);
         this.from = Objects.requireNonNull(from);
         this.to = Objects.requireNonNull(to);
         this.type = LinkType.DEPENDENT;
     }
 
+    /**
+     * Returns the source argument from which the link originates.
+     *
+     * @return The source argument.
+     */
     public Argument getFrom() {
         return from;
     }
 
+    /**
+     * Returns the target argument to which the link points.
+     *
+     * @return The target argument.
+     */
     public Argument getTo() {
         return to;
     }
 
+    /**
+     * Returns the type of the link, indicating the nature of the connection
+     * between the source and target arguments.
+     *
+     * @return The link type.
+     */
     public LinkType getType() {
         return type;
     }

org-tweetyproject-arg-adf/src/main/java/org/tweetyproject/arg/adf/syntax/adf/AbstractDialecticalFramework.java

@@ -277,10 +277,25 @@ default boolean bipolar() {
      */
     interface Builder {
 
+        /**
+         *
+         * Return lazy builder instance
+         * @param linkStrategy linkStrategy
+         * @return lazy builder instance
+         */
         Builder lazy(LinkStrategy linkStrategy);
 
+        /**
+         * provided builder
+         * @return Builder instance
+         */
         Builder provided();
 
+        /**
+         *  Eager builder
+         * @param linkStrategy linkStrategy
+         * @return builder instance
+         */
         Builder eager(LinkStrategy linkStrategy);
 
         /**
@@ -300,6 +315,12 @@ interface Builder {
          */
         Builder add(Link link);
 
+        /**
+         * Removes arg
+         *
+         * @param arg arg to remove
+         * @return this Builder instance
+         */
         Builder remove(Argument arg);
 
         /**

org-tweetyproject-arg-adf/src/main/java/org/tweetyproject/arg/adf/transform/AbstractCollector.java

@@ -77,9 +77,19 @@ public R transform(AcceptanceCondition acc) {
 		return finish(bottomUpData, collection);
 	}
 
-	protected U transform(AcceptanceCondition acc, Consumer<D> userObject) {
-		return acc.accept(visitor, new TopDownData<D>(topLevelPolarity, userObject));
-	}
+/**
+ * Transforms the given acceptance condition using a visitor pattern and additional user-provided data.
+ *
+ *
+ * @param acc The {@code AcceptanceCondition} to be transformed.
+ * @param userObject A {@code Consumer<D>} that provides additional data or operations
+ *                   to be used during the transformation process.
+ * @return The result of the transformation, which is an instance of type {@code U}.
+ */
+protected U transform(AcceptanceCondition acc, Consumer<D> userObject) {
+    return acc.accept(visitor, new TopDownData<D>(topLevelPolarity, userObject));
+}
+
 
 	/*
 	 * (non-Javadoc)

org-tweetyproject-arg-adf/src/main/java/org/tweetyproject/arg/adf/transform/AbstractTransformer.java

@@ -57,10 +57,21 @@ public R transform(AcceptanceCondition acc) {
 		return finish(bottomUpData, userObject);
 	}
 
+	/**
+	 * Transform
+	 * @param acc condition
+	 * @param userObject object
+	 * @return transformed
+	 */
 	protected U transform(AcceptanceCondition acc, D userObject) {
 		return acc.accept(visitor, new TopDownData<D>(topLevelPolarity(), userObject));
 	}
 
+	/**
+	 *
+	 * Return topLevelPolarity
+	 * @return topLevelPolarity
+	 */
 	protected int topLevelPolarity() {
 		return 1;
 	}
@@ -72,25 +83,108 @@ protected int topLevelPolarity() {
 	 */
 	protected abstract D initialize();
 
-	protected abstract R finish(U bottomUpData, D topDownData);
+/**
+ * Finalizes the transformation process and returns the result.
+ *
+ * @param bottomUpData The data accumulated during the bottom-up traversal.
+ * @param topDownData  The data provided during the top-down traversal.
+ * @return The final result of the transformation process, of type {@code R}.
+ */
+protected abstract R finish(U bottomUpData, D topDownData);
+
+/**
+ * Transforms a disjunction of two sub-expressions.
+ *
+ * @param left         The transformed result of the left sub-expression.
+ * @param right        The transformed result of the right sub-expression.
+ * @param topDownData  The data provided during the top-down traversal.
+ * @param polarity     The polarity (e.g., positive or negative) to guide the transformation.
+ * @return The result of transforming the disjunction, of type {@code U}.
+ */
+protected abstract U transformDisjunction(U left, U right, D topDownData, int polarity);
 
-	protected abstract U transformDisjunction(U left, U right, D topDownData, int polarity);
+/**
+ * Transforms a conjunction of two sub-expressions.
+ *
+ * @param left         The transformed result of the left sub-expression.
+ * @param right        The transformed result of the right sub-expression.
+ * @param topDownData  The data provided during the top-down traversal.
+ * @param polarity     The polarity (e.g., positive or negative) to guide the transformation.
+ * @return The result of transforming the conjunction, of type {@code U}.
+ */
+protected abstract U transformConjunction(U left, U right, D topDownData, int polarity);
 
-	protected abstract U transformConjunction(U left, U right, D topDownData, int polarity);
+/**
+ * Transforms an implication between two sub-expressions.
+ *
+ * @param left         The transformed result of the left sub-expression.
+ * @param right        The transformed result of the right sub-expression.
+ * @param topDownData  The data provided during the top-down traversal.
+ * @param polarity     The polarity (e.g., positive or negative) to guide the transformation.
+ * @return The result of transforming the implication, of type {@code U}.
+ */
+protected abstract U transformImplication(U left, U right, D topDownData, int polarity);
 
-	protected abstract U transformImplication(U left, U right, D topDownData, int polarity);
+/**
+ * Transforms an equivalence between two sub-expressions.
+ *
+ * @param left         The transformed result of the left sub-expression.
+ * @param right        The transformed result of the right sub-expression.
+ * @param topDownData  The data provided during the top-down traversal.
+ * @param polarity     The polarity (e.g., positive or negative) to guide the transformation.
+ * @return The result of transforming the equivalence, of type {@code U}.
+ */
+protected abstract U transformEquivalence(U left, U right, D topDownData, int polarity);
 
-	protected abstract U transformEquivalence(U left, U right, D topDownData, int polarity);
+/**
+ * Transforms an exclusive disjunction (XOR) between two sub-expressions.
+ *
+ * @param left         The transformed result of the left sub-expression.
+ * @param right        The transformed result of the right sub-expression.
+ * @param topDownData  The data provided during the top-down traversal.
+ * @param polarity     The polarity (e.g., positive or negative) to guide the transformation.
+ * @return The result of transforming the exclusive disjunction, of type {@code U}.
+ */
+protected abstract U transformExclusiveDisjunction(U left, U right, D topDownData, int polarity);
 
-	protected abstract U transformExclusiveDisjunction(U left, U right, D topDownData, int polarity);
+/**
+ * Transforms a negation of a sub-expression.
+ *
+ * @param child        The transformed result of the sub-expression being negated.
+ * @param topDownData  The data provided during the top-down traversal.
+ * @param polarity     The polarity (e.g., positive or negative) to guide the transformation.
+ * @return The result of transforming the negation, of type {@code U}.
+ */
+protected abstract U transformNegation(U child, D topDownData, int polarity);
 
-	protected abstract U transformNegation(U child, D topDownData, int polarity);
+/**
+ * Transforms an argument within the logical structure.
+ *
+ * @param argument     The argument to be transformed.
+ * @param topDownData  The data provided during the top-down traversal.
+ * @param polarity     The polarity (e.g., positive or negative) to guide the transformation.
+ * @return The result of transforming the argument, of type {@code U}.
+ */
+protected abstract U transformArgument(Argument argument, D topDownData, int polarity);
 
-	protected abstract U transformArgument(Argument argument, D topDownData, int polarity);
+/**
+ * Transforms a contradiction in the logical structure.
+ *
+ * @param topDownData  The data provided during the top-down traversal.
+ * @param polarity     The polarity (e.g., positive or negative) to guide the transformation.
+ * @return The result of transforming the contradiction, of type {@code U}.
+ */
+protected abstract U transformContradiction(D topDownData, int polarity);
 
-	protected abstract U transformContradiction(D topDownData, int polarity);
+/**
+ * Transforms a tautology in the logical structure.
+ *
+ * @param topDownData  The data provided during the top-down traversal.
+ * @param polarity     The polarity (e.g., positive or negative) to guide the transformation.
+ * @return The result of transforming the tautology, of type {@code U}.
+ */
+protected abstract U transformTautology(D topDownData, int polarity);
 
-	protected abstract U transformTautology(D topDownData, int polarity);
 
 	/**
 	 * We encapsulate the Visitor in a separate private class s.t. we do not