Resolves checkstyle errors for abstract-document abstract-factory acyclic-visitor adapter aggregator-microservices (iluwatar#1080)

* Reduces checkstyle errors in abstract-document

* Reduces checkstyle errors in abstract-factory

* Reduces checkstyle errors in acyclic-visitor

* Reduces checkstyle errors in adapter

* Reduces checkstyle errors in aggregator-microservices

Author: anuragagarwal561994

abstract-document/src/main/java/com/iluwatar/abstractdocument/AbstractDocument.java

@@ -31,7 +31,7 @@
 import java.util.stream.Stream;
 
 /**
- * Abstract implementation of Document interface
+ * Abstract implementation of Document interface.
  */
 public abstract class AbstractDocument implements Document {
 
@@ -64,7 +64,8 @@ public <T> Stream<T> children(String key, Function<Map<String, Object>, T> const
   public String toString() {
     var builder = new StringBuilder();
     builder.append(getClass().getName()).append("[");
-    properties.forEach((key, value) -> builder.append("[").append(key).append(" : ").append(value).append("]"));
+    properties.forEach((key, value) -> builder.append("[").append(key).append(" : ").append(value)
+        .append("]"));
     builder.append("]");
     return builder.toString();
   }

abstract-document/src/main/java/com/iluwatar/abstractdocument/App.java

@@ -25,58 +25,56 @@
 
 import com.iluwatar.abstractdocument.domain.Car;
 import com.iluwatar.abstractdocument.domain.enums.Property;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import java.util.List;
 import java.util.Map;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
- * The Abstract Document pattern enables handling additional, non-static
- * properties. This pattern uses concept of traits to enable type safety and
- * separate properties of different classes into set of interfaces.
- * <p>
- * <p>
- * In Abstract Document pattern,({@link AbstractDocument}) fully implements
- * {@link Document}) interface. Traits are then defined to enable access to
- * properties in usual, static way.
+ * The Abstract Document pattern enables handling additional, non-static properties. This pattern
+ * uses concept of traits to enable type safety and separate properties of different classes into
+ * set of interfaces.
+ *
+ * <p>In Abstract Document pattern,({@link AbstractDocument}) fully implements {@link Document})
+ * interface. Traits are then defined to enable access to properties in usual, static way.
  */
 public class App {
 
   private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
 
   /**
-   * Executes the App
+   * Executes the App.
    */
   public App() {
     LOGGER.info("Constructing parts and car");
 
     var wheelProperties = Map.of(
-            Property.TYPE.toString(), "wheel",
-            Property.MODEL.toString(), "15C",
-            Property.PRICE.toString(), 100L);
+        Property.TYPE.toString(), "wheel",
+        Property.MODEL.toString(), "15C",
+        Property.PRICE.toString(), 100L);
 
     var doorProperties = Map.of(
-            Property.TYPE.toString(), "door",
-            Property.MODEL.toString(), "Lambo",
-            Property.PRICE.toString(), 300L);
+        Property.TYPE.toString(), "door",
+        Property.MODEL.toString(), "Lambo",
+        Property.PRICE.toString(), 300L);
 
     var carProperties = Map.of(
-            Property.MODEL.toString(), "300SL",
-            Property.PRICE.toString(), 10000L,
-            Property.PARTS.toString(), List.of(wheelProperties, doorProperties));
+        Property.MODEL.toString(), "300SL",
+        Property.PRICE.toString(), 10000L,
+        Property.PARTS.toString(), List.of(wheelProperties, doorProperties));
 
     var car = new Car(carProperties);
 
     LOGGER.info("Here is our car:");
     LOGGER.info("-> model: {}", car.getModel().get());
     LOGGER.info("-> price: {}", car.getPrice().get());
     LOGGER.info("-> parts: ");
-    car.getParts().forEach(p -> LOGGER.info("\t{}/{}/{}", p.getType().get(), p.getModel().get(), p.getPrice().get()));
+    car.getParts().forEach(p -> LOGGER
+        .info("\t{}/{}/{}", p.getType().get(), p.getModel().get(), p.getPrice().get()));
   }
 
   /**
-   * Program entry point
+   * Program entry point.
    *
    * @param args command line args
    */

abstract-document/src/main/java/com/iluwatar/abstractdocument/Document.java

@@ -28,12 +28,12 @@
 import java.util.stream.Stream;
 
 /**
- * Document interface
+ * Document interface.
  */
 public interface Document {
 
   /**
-   * Puts the value related to the key
+   * Puts the value related to the key.
    *
    * @param key   element key
    * @param value element value
@@ -42,15 +42,15 @@ public interface Document {
   Void put(String key, Object value);
 
   /**
-   * Gets the value for the key
+   * Gets the value for the key.
    *
    * @param key element key
    * @return value or null
    */
   Object get(String key);
 
   /**
-   * Gets the stream of child documents
+   * Gets the stream of child documents.
    *
    * @param key         element key
    * @param constructor constructor of child class

abstract-document/src/main/java/com/iluwatar/abstractdocument/domain/Car.java

@@ -23,12 +23,11 @@
 
 package com.iluwatar.abstractdocument.domain;
 
-import java.util.Map;
-
 import com.iluwatar.abstractdocument.AbstractDocument;
+import java.util.Map;
 
 /**
- * Car entity
+ * Car entity.
  */
 public class Car extends AbstractDocument implements HasModel, HasPrice, HasParts {
 

abstract-document/src/main/java/com/iluwatar/abstractdocument/domain/HasModel.java

@@ -23,13 +23,12 @@
 
 package com.iluwatar.abstractdocument.domain;
 
-import java.util.Optional;
-
 import com.iluwatar.abstractdocument.Document;
 import com.iluwatar.abstractdocument.domain.enums.Property;
+import java.util.Optional;
 
 /**
- * HasModel trait for static access to 'model' property
+ * HasModel trait for static access to 'model' property.
  */
 public interface HasModel extends Document {
 

abstract-document/src/main/java/com/iluwatar/abstractdocument/domain/HasParts.java

@@ -23,13 +23,12 @@
 
 package com.iluwatar.abstractdocument.domain;
 
-import java.util.stream.Stream;
-
 import com.iluwatar.abstractdocument.Document;
 import com.iluwatar.abstractdocument.domain.enums.Property;
+import java.util.stream.Stream;
 
 /**
- * HasParts trait for static access to 'parts' property
+ * HasParts trait for static access to 'parts' property.
  */
 public interface HasParts extends Document {
 

abstract-document/src/main/java/com/iluwatar/abstractdocument/domain/HasPrice.java

@@ -23,13 +23,12 @@
 
 package com.iluwatar.abstractdocument.domain;
 
-import java.util.Optional;
-
 import com.iluwatar.abstractdocument.Document;
 import com.iluwatar.abstractdocument.domain.enums.Property;
+import java.util.Optional;
 
 /**
- * HasPrice trait for static access to 'price' property
+ * HasPrice trait for static access to 'price' property.
  */
 public interface HasPrice extends Document {
 

abstract-document/src/main/java/com/iluwatar/abstractdocument/domain/HasType.java

@@ -23,13 +23,12 @@
 
 package com.iluwatar.abstractdocument.domain;
 
-import java.util.Optional;
-
 import com.iluwatar.abstractdocument.Document;
 import com.iluwatar.abstractdocument.domain.enums.Property;
+import java.util.Optional;
 
 /**
- * HasType trait for static access to 'type' property
+ * HasType trait for static access to 'type' property.
  */
 public interface HasType extends Document {
 

abstract-document/src/main/java/com/iluwatar/abstractdocument/domain/Part.java

@@ -23,12 +23,11 @@
 
 package com.iluwatar.abstractdocument.domain;
 
-import java.util.Map;
-
 import com.iluwatar.abstractdocument.AbstractDocument;
+import java.util.Map;
 
 /**
- * Part entity
+ * Part entity.
  */
 public class Part extends AbstractDocument implements HasType, HasModel, HasPrice {
 

abstract-document/src/main/java/com/iluwatar/abstractdocument/domain/enums/Property.java

@@ -24,9 +24,7 @@
 package com.iluwatar.abstractdocument.domain.enums;
 
 /**
- * 
- * Enum To Describe Property type
- *
+ * Enum To Describe Property type.
  */
 public enum Property {
 

abstract-factory/src/main/java/com/iluwatar/abstractfactory/App.java

@@ -23,25 +23,23 @@
 
 package com.iluwatar.abstractfactory;
 
+import com.iluwatar.abstractfactory.App.FactoryMaker.KingdomType;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import com.iluwatar.abstractfactory.App.FactoryMaker.KingdomType;
-
 /**
- * 
- * The Abstract Factory pattern provides a way to encapsulate a group of individual factories that have a common theme
- * without specifying their concrete classes. In normal usage, the client software creates a concrete implementation of
- * the abstract factory and then uses the generic interface of the factory to create the concrete objects that are part
- * of the theme. The client does not know (or care) which concrete objects it gets from each of these internal
- * factories, since it uses only the generic interfaces of their products. This pattern separates the details of
- * implementation of a set of objects from their general usage and relies on object composition, as object creation is
- * implemented in methods exposed in the factory interface.
- * <p>
- * The essence of the Abstract Factory pattern is a factory interface ({@link KingdomFactory}) and its implementations (
- * {@link ElfKingdomFactory}, {@link OrcKingdomFactory}). The example uses both concrete implementations to create a
- * king, a castle and an army.
- * 
+ * The Abstract Factory pattern provides a way to encapsulate a group of individual factories that
+ * have a common theme without specifying their concrete classes. In normal usage, the client
+ * software creates a concrete implementation of the abstract factory and then uses the generic
+ * interface of the factory to create the concrete objects that are part of the theme. The client
+ * does not know (or care) which concrete objects it gets from each of these internal factories,
+ * since it uses only the generic interfaces of their products. This pattern separates the details
+ * of implementation of a set of objects from their general usage and relies on object composition,
+ * as object creation is implemented in methods exposed in the factory interface.
+ *
+ * <p>The essence of the Abstract Factory pattern is a factory interface ({@link KingdomFactory})
+ * and its implementations ( {@link ElfKingdomFactory}, {@link OrcKingdomFactory}). The example uses
+ * both concrete implementations to create a king, a castle and an army.
  */
 public class App {
 
@@ -52,14 +50,14 @@ public class App {
   private Army army;
 
   /**
-   * Creates kingdom
+   * Creates kingdom.
    */
   public void createKingdom(final KingdomFactory factory) {
     setKing(factory.createKing());
     setCastle(factory.createCastle());
     setArmy(factory.createArmy());
   }
-  
+
   King getKing(final KingdomFactory factory) {
     return factory.createKing();
   }
@@ -71,7 +69,7 @@ public King getKing() {
   private void setKing(final King king) {
     this.king = king;
   }
-  
+
   Castle getCastle(final KingdomFactory factory) {
     return factory.createCastle();
   }
@@ -83,7 +81,7 @@ public Castle getCastle() {
   private void setCastle(final Castle castle) {
     this.castle = castle;
   }
-  
+
   Army getArmy(final KingdomFactory factory) {
     return factory.createArmy();
   }
@@ -125,9 +123,8 @@ public static KingdomFactory makeFactory(KingdomType type) {
 
   /**
    * Program entry point.
-   * 
-   * @param args
-   *          command line args
+   *
+   * @param args command line args
    */
   public static void main(String[] args) {
 

abstract-factory/src/main/java/com/iluwatar/abstractfactory/Army.java

@@ -24,9 +24,7 @@
 package com.iluwatar.abstractfactory;
 
 /**
- * 
- * Army interface
- *
+ * Army interface.
  */
 public interface Army {
 

abstract-factory/src/main/java/com/iluwatar/abstractfactory/Castle.java

@@ -24,9 +24,7 @@
 package com.iluwatar.abstractfactory;
 
 /**
- * 
- * Castle interface
- *
+ * Castle interface.
  */
 public interface Castle {
 

abstract-factory/src/main/java/com/iluwatar/abstractfactory/ElfArmy.java

@@ -24,9 +24,7 @@
 package com.iluwatar.abstractfactory;
 
 /**
- * 
- * ElfArmy
- *
+ * ElfArmy.
  */
 public class ElfArmy implements Army {
 

abstract-factory/src/main/java/com/iluwatar/abstractfactory/ElfCastle.java

@@ -24,9 +24,7 @@
 package com.iluwatar.abstractfactory;
 
 /**
- * 
- * ElfCastle
- *
+ * ElfCastle.
  */
 public class ElfCastle implements Castle {
 

abstract-factory/src/main/java/com/iluwatar/abstractfactory/ElfKing.java

@@ -24,9 +24,7 @@
 package com.iluwatar.abstractfactory;
 
 /**
- * 
- * ElfKing
- *
+ * ElfKing.
  */
 public class ElfKing implements King {
 

abstract-factory/src/main/java/com/iluwatar/abstractfactory/ElfKingdomFactory.java

@@ -24,9 +24,7 @@
 package com.iluwatar.abstractfactory;
 
 /**
- * 
  * ElfKingdomFactory concrete factory.
- * 
  */
 public class ElfKingdomFactory implements KingdomFactory {
 

abstract-factory/src/main/java/com/iluwatar/abstractfactory/King.java

@@ -24,9 +24,7 @@
 package com.iluwatar.abstractfactory;
 
 /**
- * 
- * King interface
- *
+ * King interface.
  */
 public interface King {