docs: fix cassandra javadoc api

Signed-off-by: Otavio Santana <[email protected]>

Author: otaviojava

jnosql-arangodb/src/main/java/org/eclipse/jnosql/databases/arangodb/mapping/DefaultArangoDBTemplate.java

@@ -22,7 +22,6 @@
 import org.eclipse.jnosql.communication.semistructured.DatabaseManager;
 import org.eclipse.jnosql.databases.arangodb.communication.ArangoDBDocumentManager;
 import org.eclipse.jnosql.mapping.core.Converters;
-import org.eclipse.jnosql.mapping.document.DocumentTemplate;
 import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata;
 import org.eclipse.jnosql.mapping.semistructured.AbstractSemistructuredTemplate;
 import org.eclipse.jnosql.mapping.semistructured.EntityConverter;

jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/CassandraConfiguration.java

@@ -22,35 +22,45 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
-
-import static java.util.Objects.requireNonNull;
+import java.util.Objects;
 
 /**
- * The Cassandra implementation to {@link DatabaseConfiguration}  that returns
- * {@link CassandraColumnManagerFactory}
+ * A Cassandra-specific implementation of {@link DatabaseConfiguration}, which provides
+ * {@link CassandraColumnManagerFactory} instances.
  *
  * @see CassandraConfigurations
  */
 public final class CassandraConfiguration implements DatabaseConfiguration {
 
-
+    /**
+     * Retrieves the {@link CassandraColumnManagerFactory} based on the provided configurations.
+     *
+     * @param configurations the configurations for Cassandra
+     * @return a {@link CassandraColumnManagerFactory} instance
+     * @throws NullPointerException if configurations are null
+     */
     private CassandraColumnManagerFactory getManagerFactory(Map<String, String> configurations) {
-        requireNonNull(configurations);
+        Objects.requireNonNull(configurations);
         CassandraProperties properties = CassandraProperties.of(configurations);
         return new CassandraColumnManagerFactory(properties.createCluster(), properties.getQueries());
     }
 
-
+    /**
+     * Applies the settings to create a {@link CassandraColumnManagerFactory}.
+     *
+     * @param settings the settings to apply
+     * @return a {@link CassandraColumnManagerFactory} instance
+     * @throws NullPointerException if settings are null
+     */
     @Override
     public CassandraColumnManagerFactory apply(Settings settings) throws NullPointerException {
-        requireNonNull(settings, "settings is required");
+        Objects.requireNonNull(settings, "Settings is required");
         Map<String, String> configurations = new HashMap<>();
 
         List<String> keys = settings.keySet()
                 .stream()
                 .filter(k -> k.startsWith("jnosql."))
-                .collect(Collectors.toUnmodifiableList());
+                .toList();
 
         for (String key : keys) {
             settings.get(key, String.class).ifPresent(v -> configurations.put(key, v));

jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/CassandraPreparedStatement.java

@@ -23,33 +23,42 @@
 import java.util.stream.Stream;
 
 /**
- * The Diana wrapper to {@link com.datastax.oss.driver.api.core.cql.PreparedStatement}
+ * Wrapper class for {@link com.datastax.oss.driver.api.core.cql.PreparedStatement} in JNoSQL.
+ * Allows execution of CQL queries and binding of parameters.
  */
 public class CassandraPreparedStatement {
 
     private final com.datastax.oss.driver.api.core.cql.PreparedStatement prepare;
-
     private final CqlSession session;
-
     private BoundStatement boundStatement;
 
+    /**
+     * Constructs a new CassandraPreparedStatement.
+     *
+     * @param prepare the underlying Cassandra PreparedStatement
+     * @param session the CQL session
+     */
     CassandraPreparedStatement(com.datastax.oss.driver.api.core.cql.PreparedStatement prepare, CqlSession session) {
         this.prepare = prepare;
         this.session = session;
     }
 
+    /**
+     * Executes the prepared statement as a query and returns the results as a stream of CommunicationEntity.
+     *
+     * @return a stream of CommunicationEntity containing the results of the query
+     */
     public Stream<CommunicationEntity> executeQuery() {
         load();
         ResultSet resultSet = session.execute(boundStatement);
         return resultSet.all().stream().map(CassandraConverter::toDocumentEntity);
     }
 
-
     /**
-     * Bind
+     * Binds values to the prepared statement.
      *
-     * @param values the values
-     * @return this instance
+     * @param values the values to bind
+     * @return this CassandraPreparedStatement instance
      */
     public CassandraPreparedStatement bind(Object... values) {
         boundStatement = prepare.bind(values);
@@ -62,7 +71,11 @@ private void load() {
         }
     }
 
-
+    /**
+     * Returns a string representation of this CassandraPreparedStatement.
+     *
+     * @return a string representation of this CassandraPreparedStatement
+     */
     @Override
     public String toString() {
         return "CassandraPreparedStatement{" +
@@ -71,4 +84,4 @@ public String toString() {
                 ", boundStatement=" + boundStatement +
                 '}';
     }
-}
+}

jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/CassandraQuery.java

@@ -146,7 +146,7 @@ public String toString() {
     /**
      * returns a new instance of {@link CassandraQuery}
      *
-     * @param query the {@link ColumnQuery}
+     * @param query the {@link SelectQuery}
      * @return a new instance
      * @throws NullPointerException when query is null
      */

jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/UDTElementBuilder.java

@@ -17,24 +17,33 @@
 
 import org.eclipse.jnosql.communication.semistructured.Element;
 
+/**
+ * A builder interface for constructing Cassandra User-Defined Types (UDTs).
+ */
 public interface UDTElementBuilder {
 
-
     /**
-     * Adds the udt when the type is just one element
+     * Adds a single UDT element to the builder.
      *
-     * @param udt the elements in a UDT to be added
+     * @param udt the UDT element to be added
      * @return the builder instance
-     * @throws NullPointerException when either the udt or there is a null element
+     * @throws NullPointerException if the udt or any of its elements is null
      */
     UDTFinisherBuilder addUDT(Iterable<Element> udt) throws NullPointerException;
+
     /**
-     * <p>On Cassandra, there is the option to a UDT be part of a list. This implementation holds this option.</p>
-     * <p>eg: CREATE COLUMNFAMILY IF NOT EXISTS contacts ( user text PRIMARY KEY, names list&#60;frozen &#60;fullname&#62;&#62;);</p>
+     * Adds multiple UDTs to the builder, typically used when a UDT is part of a list.
+     * For example:
+     * <pre>
+     *     CREATE COLUMNFAMILY IF NOT EXISTS contacts (
+     *         user text PRIMARY KEY,
+     *         names list&lt;frozen &lt;fullname&gt;&gt;
+     *     );
+     * </pre>
      *
-     * @param udts the UTDs to be added
+     * @param udts the UDTs to be added
      * @return the builder instance
-     * @throws NullPointerException when either the udt or there is a null element
+     * @throws NullPointerException if any of the udts or their elements is null
      */
     UDTFinisherBuilder addUDTs(Iterable<Iterable<Element>> udts) throws NullPointerException;
-}
+}

jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/UDTFinisherBuilder.java

@@ -14,13 +14,16 @@
  */
 package org.eclipse.jnosql.databases.cassandra.communication;
 
+/**
+ * A builder interface for finalizing the creation of a user-defined type (UDT).
+ */
 public interface UDTFinisherBuilder {
 
     /**
-     * Creates a udt instance
+     * Creates a UDT instance based on the previously specified elements.
      *
-     * @return a udt instance
-     * @throws IllegalStateException when there is a null element
+     * @return a new UDT instance
+     * @throws IllegalStateException if any required element is missing
      */
-    UDT build();
-}
+    UDT build() throws IllegalStateException;
+}

jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/communication/UDTNameBuilder.java

@@ -14,7 +14,17 @@
  */
 package org.eclipse.jnosql.databases.cassandra.communication;
 
+/**
+ * A builder interface for creating a user-defined type (UDT) element with the specified name.
+ */
 public interface UDTNameBuilder {
 
+    /**
+     * Specifies the name of the UDT element.
+     *
+     * @param name the name of the UDT element
+     * @return the {@link UDTElementBuilder} instance to continue building the UDT
+     * @throws NullPointerException if {@code name} is {@code null}
+     */
     UDTElementBuilder withName(String name) throws NullPointerException;
 }

jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/mapping/CQL.java

@@ -20,11 +20,16 @@
 import java.lang.annotation.Target;
 
 /**
- * To a dynamic query on CassandraRepository and CassandraRepositoryAsync interfaces.
+ * Annotation used to define a dynamic CQL query method in CassandraRepository and CassandraRepositoryAsync interfaces.
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.METHOD)
 public @interface CQL {
 
+    /**
+     * The CQL query string.
+     *
+     * @return the CQL query string
+     */
     String value();
-}
+}

jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/mapping/CassandraExtension.java

@@ -23,12 +23,19 @@
 import java.util.Set;
 import java.util.logging.Logger;
 
+/**
+ * CDI extension for Cassandra integration.
+ */
 public class CassandraExtension implements Extension {
 
     private static final Logger LOGGER = Logger.getLogger(CassandraExtension.class.getName());
 
+    /**
+     * Observes the AfterBeanDiscovery event to add Cassandra repository beans.
+     *
+     * @param afterBeanDiscovery the AfterBeanDiscovery event
+     */
     void onAfterBeanDiscovery(@Observes final AfterBeanDiscovery afterBeanDiscovery) {
-
         ClassScanner scanner = ClassScanner.load();
         Set<Class<?>> crudTypes = scanner.repositories(CassandraRepository.class);
 
@@ -38,4 +45,4 @@ void onAfterBeanDiscovery(@Observes final AfterBeanDiscovery afterBeanDiscovery)
 
         LOGGER.info("Finished the onAfterBeanDiscovery");
     }
-}
+}

jnosql-cassandra/src/main/java/org/eclipse/jnosql/databases/cassandra/mapping/Param.java

@@ -21,11 +21,17 @@
 
 
 /**
- * Defines a param to a CQL query.
+ * An annotation used to define a parameter in a CQL query.
+ * This annotation is used to specify the name of the parameter.
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.PARAMETER)
 public @interface Param {
 
+    /**
+     * Specifies the name of the parameter.
+     *
+     * @return the name of the parameter
+     */
     String value();
-}
+}