Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

libraries/src/main/java/com/baeldung/akka/FirstActor.java

@@ -0,0 +1,32 @@
+package com.baeldung.akka;
+
+import akka.actor.AbstractActor;
+import akka.actor.Props;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+public class FirstActor extends AbstractActor {
+
+    private final LoggingAdapter log = Logging.getLogger(getContext().getSystem(), this);
+
+    public static Props props() {
+        return Props.create(FirstActor.class);
+    }
+
+    @Override
+    public void preStart() {
+        log.info("Actor started");
+    }
+
+    @Override
+    public void postStop() {
+        log.info("Actor stopped");
+    }
+
+    // Messages will not be handled
+    @Override
+    public Receive createReceive() {
+        return receiveBuilder()
+                .build();
+    }
+}

libraries/src/main/java/com/baeldung/akka/MyActor.java

@@ -0,0 +1,24 @@
+package com.baeldung.akka;
+
+import akka.actor.AbstractActor;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+public class MyActor extends AbstractActor {
+
+    private final LoggingAdapter log = Logging.getLogger(getContext().getSystem(), this);
+
+    @Override
+    public void postStop() {
+        log.info("Stopping actor {}", this);
+    }
+
+    public Receive createReceive() {
+        return receiveBuilder()
+                .matchEquals("printit", p -> {
+                    System.out.println("The address of this actor is: " + getSelf());
+                    getSender().tell("Got Message", getSelf());
+                })
+                .build();
+    }
+}

libraries/src/main/java/com/baeldung/akka/PrinterActor.java

@@ -0,0 +1,45 @@
+package com.baeldung.akka;
+
+import akka.actor.AbstractActor;
+import akka.actor.Props;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+public class PrinterActor extends AbstractActor {
+
+    private final LoggingAdapter log = Logging.getLogger(getContext().getSystem(), this);
+
+    public static Props props(String text) {
+        return Props.create(PrinterActor.class, text);
+    }
+
+    public static final class PrintFinalResult {
+        Integer totalNumberOfWords;
+
+        public PrintFinalResult(Integer totalNumberOfWords) {
+            this.totalNumberOfWords = totalNumberOfWords;
+        }
+    }
+
+    @Override
+    public void preStart() {
+        log.info("Starting PrinterActor {}", this);
+    }
+
+    @Override
+    public void postStop() {
+        log.info("Stopping PrinterActor {}", this);
+    }
+
+
+    @Override
+    public Receive createReceive() {
+        return receiveBuilder()
+                .match(PrinterActor.PrintFinalResult.class,
+                        r -> {
+                            log.info("Received PrintFinalResult message from " + getSender());
+                            log.info("The text has a total number of {} words", r.totalNumberOfWords);
+                        })
+                .build();
+    }
+}

libraries/src/main/java/com/baeldung/akka/ReadingActor.java

@@ -0,0 +1,73 @@
+package com.baeldung.akka;
+
+import akka.actor.AbstractActor;
+import akka.actor.ActorRef;
+import akka.actor.Props;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import static akka.pattern.PatternsCS.ask;
+
+public class ReadingActor extends AbstractActor {
+
+    private final LoggingAdapter log = Logging.getLogger(getContext().getSystem(), this);
+
+    private String text;
+
+    public ReadingActor(String text) {
+        this.text = text;
+    }
+
+    public static Props props(String text) {
+        return Props.create(ReadingActor.class, text);
+    }
+
+    public static final class ReadLines {
+    }
+
+    @Override
+    public void preStart() {
+        log.info("Starting ReadingActor {}", this);
+    }
+
+    @Override
+    public void postStop() {
+        log.info("Stopping ReadingActor {}", this);
+    }
+
+    @Override
+    public Receive createReceive() {
+        return receiveBuilder()
+                .match(ReadLines.class, r -> {
+
+                    log.info("Received ReadLines message from " + getSender());
+
+                    String[] lines = text.split("\n");
+                    List<CompletableFuture> futures = new ArrayList<>();
+
+                    for (int i = 0; i < lines.length; i++) {
+                        String line = lines[i];
+                        ActorRef wordCounterActorRef = getContext().actorOf(Props.create(WordCounterActor.class), "word-counter-" + i);
+
+                        CompletableFuture<Object> future =
+                                ask(wordCounterActorRef, new WordCounterActor.CountWords(line), 1000).toCompletableFuture();
+                        futures.add(future);
+                    }
+
+                    Integer totalNumberOfWords = futures.stream()
+                            .map(CompletableFuture::join)
+                            .mapToInt(n -> (Integer) n)
+                            .sum();
+
+                    ActorRef printerActorRef = getContext().actorOf(Props.create(PrinterActor.class), "Printer-Actor");
+                    printerActorRef.forward(new PrinterActor.PrintFinalResult(totalNumberOfWords), getContext());
+//                    printerActorRef.tell(new PrinterActor.PrintFinalResult(totalNumberOfWords), getSelf());
+
+                })
+                .build();
+    }
+}

libraries/src/main/java/com/baeldung/akka/WordCounterActor.java

@@ -0,0 +1,55 @@
+package com.baeldung.akka;
+
+import akka.actor.AbstractActor;
+import akka.event.Logging;
+import akka.event.LoggingAdapter;
+
+public class WordCounterActor extends AbstractActor {
+
+    private final LoggingAdapter log = Logging.getLogger(getContext().getSystem(), this);
+
+    public static final class CountWords {
+        String line;
+
+        public CountWords(String line) {
+            this.line = line;
+        }
+    }
+
+    @Override
+    public void preStart() {
+        log.info("Starting WordCounterActor {}", this);
+    }
+
+    @Override
+    public Receive createReceive() {
+        return receiveBuilder()
+                .match(CountWords.class, r -> {
+                    try {
+                        log.info("Received CountWords message from " + getSender());
+                        int numberOfWords = countWordsFromLine(r.line);
+                        getSender().tell(numberOfWords, getSelf());
+                    } catch (Exception ex) {
+                        getSender().tell(new akka.actor.Status.Failure(ex), getSelf());
+                        throw ex;
+                    }
+                })
+                .build();
+    }
+
+    private int countWordsFromLine(String line) throws Exception {
+
+        if (line == null) {
+            throw new IllegalArgumentException("The text to process can't be null!");
+        }
+
+        int numberOfWords = 0;
+        String[] words = line.split(" ");
+        for (String possibleWord : words) {
+            if (possibleWord.trim().length() > 0) {
+                numberOfWords++;
+            }
+        }
+        return numberOfWords;
+    }
+}

libraries/src/main/java/com/baeldung/bytebuddy/Bar.java

@@ -0,0 +1,21 @@
+package com.baeldung.bytebuddy;
+
+import net.bytebuddy.implementation.bind.annotation.BindingPriority;
+
+public class Bar {
+
+    @BindingPriority(3)
+    public static String sayHelloBar() {
+        return "Holla in Bar!";
+    }
+
+    @BindingPriority(2)
+    public static String sayBar() {
+        return "bar";
+    }
+
+    public String bar() {
+        return Bar.class.getSimpleName() + " - Bar";
+    }
+
+}

libraries/src/main/java/com/baeldung/bytebuddy/Foo.java

@@ -0,0 +1,9 @@
+package com.baeldung.bytebuddy;
+
+public class Foo {
+
+    public String sayHelloFoo() {
+        return "Hello in Foo!";
+    }
+
+}

libraries/src/main/java/com/baeldung/caffeine/DataObject.java

@@ -0,0 +1,30 @@
+package com.baeldung.caffeine;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+final class DataObject {
+    private final String data;
+
+    private static int objectCounter = 0;
+    private static final Logger log = LoggerFactory.getLogger(DataObject.class);
+
+    private DataObject(String data) {
+        this.data = data;
+    }
+
+    public String getData() {
+        return data;
+    }
+
+    @Override
+    public String toString() {
+        return "DataObject{" + "data='" + data + '\'' + '}';
+    }
+
+    public static DataObject get(String data) {
+        objectCounter++;
+        log.info("Init DataObject#{} with '{}'", objectCounter, data);
+        return new DataObject(data);
+    }
+}

libraries/src/main/java/com/baeldung/cglib/mixin/Class1.java

@@ -0,0 +1,8 @@
+package com.baeldung.cglib.mixin;
+
+public class Class1 implements Interface1 {
+    @Override
+    public String first() {
+        return "first behaviour";
+    }
+}

libraries/src/main/java/com/baeldung/cglib/mixin/Class2.java

@@ -0,0 +1,8 @@
+package com.baeldung.cglib.mixin;
+
+public class Class2 implements Interface2 {
+    @Override
+    public String second() {
+        return "second behaviour";
+    }
+}

libraries/src/main/java/com/baeldung/cglib/mixin/Interface1.java

@@ -0,0 +1,5 @@
+package com.baeldung.cglib.mixin;
+
+public interface Interface1 {
+    String first();
+}

libraries/src/main/java/com/baeldung/cglib/mixin/Interface2.java

@@ -0,0 +1,5 @@
+package com.baeldung.cglib.mixin;
+
+public interface Interface2 {
+    String second();
+}

libraries/src/main/java/com/baeldung/cglib/mixin/MixinInterface.java

@@ -0,0 +1,4 @@
+package com.baeldung.cglib.mixin;
+
+public interface MixinInterface extends Interface1, Interface2 {
+}

libraries/src/main/java/com/baeldung/cglib/proxy/PersonService.java

@@ -0,0 +1,11 @@
+package com.baeldung.cglib.proxy;
+
+public class PersonService {
+    public String sayHello(String name) {
+        return "Hello " + name;
+    }
+
+    public Integer lengthOfName(String name) {
+        return name.length();
+    }
+}

libraries/src/main/java/com/baeldung/chronicle/queue/ChronicleQueue.java

@@ -0,0 +1,21 @@
+package com.baeldung.chronicle.queue;
+
+import java.io.IOException;
+
+import net.openhft.chronicle.Chronicle;
+import net.openhft.chronicle.ExcerptAppender;
+
+public class ChronicleQueue {
+
+    static void writeToQueue(Chronicle chronicle, String stringValue, int intValue, long longValue, double doubleValue) throws IOException {
+        ExcerptAppender appender = chronicle.createAppender();
+        appender.startExcerpt();
+        appender.writeUTF(stringValue);
+        appender.writeInt(intValue);
+        appender.writeLong(longValue);
+        appender.writeDouble(doubleValue);
+        appender.finish();
+        appender.close();
+    }
+
+}

libraries/src/main/java/com/baeldung/distinct/DistinctWithJavaFunction.java

@@ -0,0 +1,15 @@
+package com.baeldung.distinct;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+public class DistinctWithJavaFunction {
+
+    public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
+        Map<Object, Boolean> seen = new ConcurrentHashMap<>();
+        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
+    }
+
+}

libraries/src/main/java/com/baeldung/distinct/Person.java

@@ -0,0 +1,65 @@
+package com.baeldung.distinct;
+
+public class Person {
+    int age;
+    String name;
+    String email;
+
+    public Person(int age, String name, String email) {
+        super();
+        this.age = age;
+        this.name = name;
+        this.email = email;
+    }
+
+    public int getAge() {
+        return age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder builder = new StringBuilder();
+        builder.append("Person [age=");
+        builder.append(age);
+        builder.append(", name=");
+        builder.append(name);
+        builder.append(", email=");
+        builder.append(email);
+        builder.append("]");
+        return builder.toString();
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((email == null) ? 0 : email.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        Person other = (Person) obj;
+        if (email == null) {
+            if (other.email != null)
+                return false;
+        } else if (!email.equals(other.email))
+            return false;
+        return true;
+    }
+
+}

libraries/src/main/java/com/baeldung/eclipsecollections/ConvertContainerToAnother.java

@@ -0,0 +1,19 @@
+package com.baeldung.eclipsecollections;
+
+import java.util.List;
+
+import org.eclipse.collections.impl.set.mutable.UnifiedSet;
+
+public class ConvertContainerToAnother {
+
+    @SuppressWarnings("rawtypes")
+    public static List convertToList() {
+        UnifiedSet<String> cars = new UnifiedSet<>();
+
+        cars.add("Toyota");
+        cars.add("Mercedes");
+        cars.add("Volkswagen");
+
+        return cars.toList();
+    }
+}

libraries/src/main/java/com/baeldung/eclipsecollections/Student.java

@@ -0,0 +1,46 @@
+package com.baeldung.eclipsecollections;
+
+import java.util.List;
+
+public class Student {
+
+    private String firstName;
+    private String lastName;
+    private List<String> addresses;
+
+    public Student(String firstName, String lastName) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+
+    public Student(String firstName, String lastName, List<String> addresses) {
+        super();
+        this.firstName = firstName;
+        this.lastName = lastName;
+        this.addresses = addresses;
+    }
+
+    public String getFirstName() {
+        return this.firstName;
+    }
+
+    public String getLastName() {
+        return this.lastName;
+    }
+
+    public List<String> getAddresses() {
+        return addresses;
+    }
+
+    public void setAddresses(List<String> addresses) {
+        this.addresses = addresses;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+}

libraries/src/main/java/com/baeldung/fj/FunctionalJavaIOMain.java

@@ -0,0 +1,43 @@
+package com.baeldung.fj;
+
+import fj.F;
+import fj.F1Functions;
+import fj.Unit;
+import fj.data.IO;
+import fj.data.IOFunctions;
+
+public class FunctionalJavaIOMain {
+
+    public static IO<Unit> printLetters(final String s) {
+        return () -> {
+            for (int i = 0; i < s.length(); i++) {
+                System.out.println(s.charAt(i));
+            }
+            return Unit.unit();
+        };
+    }
+
+    public static void main(String[] args) {
+
+        F<String, IO<Unit>> printLetters = i -> printLetters(i);
+
+        IO<Unit> lowerCase = IOFunctions.stdoutPrintln("What's your first Name ?");
+
+        IO<Unit> input = IOFunctions.stdoutPrint("First Name: ");
+
+        IO<Unit> userInput = IOFunctions.append(lowerCase, input);
+
+        IO<String> readInput = IOFunctions.stdinReadLine();
+
+        F<String, String> toUpperCase = i -> i.toUpperCase();
+
+        F<String, IO<Unit>> transformInput = F1Functions.<String, IO<Unit>, String> o(printLetters).f(toUpperCase);
+
+        IO<Unit> readAndPrintResult = IOFunctions.bind(readInput, transformInput);
+
+        IO<Unit> program = IOFunctions.bind(userInput, nothing -> readAndPrintResult);
+
+        IOFunctions.toSafe(program).run();
+
+    }
+}

libraries/src/main/java/com/baeldung/fj/FunctionalJavaMain.java

@@ -0,0 +1,48 @@
+package com.baeldung.fj;
+
+import fj.F;
+import fj.Show;
+import fj.data.Array;
+import fj.data.List;
+import fj.data.Option;
+import fj.function.Characters;
+import fj.function.Integers;
+
+public class FunctionalJavaMain {
+
+    public static final F<Integer, Boolean> isEven = i -> i % 2 == 0;
+
+    public static void main(String[] args) {
+
+        List<Integer> fList = List.list(3, 4, 5, 6);
+        List<Boolean> evenList = fList.map(isEven);
+        Show.listShow(Show.booleanShow).println(evenList);
+
+        fList = fList.map(i -> i + 1);
+        Show.listShow(Show.intShow).println(fList);
+
+        Array<Integer> a = Array.array(17, 44, 67, 2, 22, 80, 1, 27);
+        Array<Integer> b = a.filter(Integers.even);
+        Show.arrayShow(Show.intShow).println(b);
+
+        Array<String> array = Array.array("Welcome", "To", "baeldung");
+        Boolean isExist = array.exists(s -> List.fromString(s).forall(Characters.isLowerCase));
+        System.out.println(isExist);
+
+        Array<Integer> intArray = Array.array(17, 44, 67, 2, 22, 80, 1, 27);
+        int sum = intArray.foldLeft(Integers.add, 0);
+        System.out.println(sum);
+
+        Option<Integer> n1 = Option.some(1);
+        Option<Integer> n2 = Option.some(2);
+
+        F<Integer, Option<Integer>> f1 = i -> i % 2 == 0 ? Option.some(i + 100) : Option.none();
+
+        Option<Integer> result1 = n1.bind(f1);
+        Option<Integer> result2 = n2.bind(f1);
+
+        Show.optionShow(Show.intShow).println(result1);
+        Show.optionShow(Show.intShow).println(result2);
+    }
+
+}

libraries/src/main/java/com/baeldung/flips/TestFlipsBean.java

@@ -0,0 +1,4 @@
+package com.baeldung.flips;
+
+public class TestFlipsBean {
+}

libraries/src/main/java/com/baeldung/ftp/FtpClient.java

@@ -0,0 +1,64 @@
+package com.baeldung.ftp;
+
+import org.apache.commons.net.PrintCommandListener;
+import org.apache.commons.net.ftp.FTPClient;
+import org.apache.commons.net.ftp.FTPFile;
+import org.apache.commons.net.ftp.FTPReply;
+
+import java.io.*;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+class FtpClient {
+
+    private final String server;
+    private final int port;
+    private final String user;
+    private final String password;
+    private FTPClient ftp;
+
+    FtpClient(String server, int port, String user, String password) {
+        this.server = server;
+        this.port = port;
+        this.user = user;
+        this.password = password;
+    }
+
+    void open() throws IOException {
+        ftp = new FTPClient();
+
+        ftp.addProtocolCommandListener(new PrintCommandListener(new PrintWriter(System.out)));
+
+        ftp.connect(server, port);
+        int reply = ftp.getReplyCode();
+        if (!FTPReply.isPositiveCompletion(reply)) {
+            ftp.disconnect();
+            throw new IOException("Exception in connecting to FTP Server");
+        }
+
+        ftp.login(user, password);
+    }
+
+    void close() throws IOException {
+        ftp.disconnect();
+    }
+
+    Collection<String> listFiles(String path) throws IOException {
+        FTPFile[] files = ftp.listFiles(path);
+
+        return Arrays.stream(files)
+                .map(FTPFile::getName)
+                .collect(Collectors.toList());
+    }
+
+    void putFileToPath(File file, String path) throws IOException {
+        ftp.storeFile(path, new FileInputStream(file));
+    }
+
+    void downloadFile(String source, String destination) throws IOException {
+        FileOutputStream out = new FileOutputStream(destination);
+        ftp.retrieveFile(source, out);
+        out.close();
+    }
+}

libraries/src/main/java/com/baeldung/javapoet/PersonGenerator.java

@@ -0,0 +1,183 @@
+package com.baeldung.javapoet;
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+
+import javax.lang.model.element.Modifier;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class PersonGenerator {
+
+    private static final String FOUR_WHITESPACES = "    ";
+    private static final String PERSON_PACKAGE_NAME = "com.baeldung.javapoet.test.person";
+
+    private File outputFile;
+
+    public PersonGenerator() {
+        outputFile = new File(getOutputPath().toUri());
+    }
+
+    public static String getPersonPackageName() {
+        return PERSON_PACKAGE_NAME;
+    }
+
+    public Path getOutputPath() {
+        return Paths.get(new File(".").getAbsolutePath() + "/gensrc");
+    }
+
+    public FieldSpec getDefaultNameField() {
+        return FieldSpec
+          .builder(String.class, "DEFAULT_NAME")
+          .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
+          .initializer("$S", "Alice")
+          .build();
+    }
+
+    public MethodSpec getSortByLengthMethod() {
+        return MethodSpec
+          .methodBuilder("sortByLength")
+          .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
+          .addParameter(ParameterSpec
+            .builder(ParameterizedTypeName.get(ClassName.get(List.class), TypeName.get(String.class)), "strings")
+            .build())
+          .addStatement("$T.sort($N, $L)", Collections.class, "strings", getComparatorAnonymousClass())
+          .build();
+    }
+
+    public MethodSpec getPrintNameMultipleTimesMethod() {
+        return MethodSpec
+          .methodBuilder("printNameMultipleTimes")
+          .addModifiers(Modifier.PUBLIC)
+          .addCode(getPrintNameMultipleTimesLambdaImpl())
+          .build();
+    }
+
+    public CodeBlock getPrintNameMultipleTimesImpl() {
+        return CodeBlock
+          .builder()
+          .beginControlFlow("for (int i = $L; i < $L; i++)")
+          .addStatement("System.out.println(name)")
+          .endControlFlow()
+          .build();
+    }
+
+    public CodeBlock getPrintNameMultipleTimesLambdaImpl() {
+        return CodeBlock
+          .builder()
+          .addStatement("$T<$T> names = new $T<>()", List.class, String.class, ArrayList.class)
+          .addStatement("$T.range($L, $L).forEach(i -> names.add(name))", IntStream.class, 0, 10)
+          .addStatement("names.forEach(System.out::println)")
+          .build();
+    }
+
+    public TypeSpec getGenderEnum() {
+        return TypeSpec
+          .enumBuilder("Gender")
+          .addModifiers(Modifier.PUBLIC)
+          .addEnumConstant("MALE")
+          .addEnumConstant("FEMALE")
+          .addEnumConstant("UNSPECIFIED")
+          .build();
+    }
+
+    public TypeSpec getPersonInterface() {
+        return TypeSpec
+          .interfaceBuilder("Person")
+          .addModifiers(Modifier.PUBLIC)
+          .addField(getDefaultNameField())
+          .addMethod(MethodSpec
+            .methodBuilder("getName")
+            .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+            .returns(String.class)
+            .build())
+          .addMethod(MethodSpec
+            .methodBuilder("getDefaultName")
+            .addModifiers(Modifier.PUBLIC, Modifier.DEFAULT)
+            .returns(String.class)
+            .addCode(CodeBlock
+              .builder()
+              .addStatement("return DEFAULT_NAME")
+              .build())
+            .build())
+          .build();
+    }
+
+    public TypeSpec getStudentClass() {
+        return TypeSpec
+          .classBuilder("Student")
+          .addSuperinterface(ClassName.get(PERSON_PACKAGE_NAME, "Person"))
+          .addModifiers(Modifier.PUBLIC)
+          .addField(FieldSpec
+            .builder(String.class, "name")
+            .addModifiers(Modifier.PRIVATE)
+            .build())
+          .addMethod(MethodSpec
+            .methodBuilder("getName")
+            .addAnnotation(Override.class)
+            .addModifiers(Modifier.PUBLIC)
+            .returns(String.class)
+            .addStatement("return this.name")
+            .build())
+          .addMethod(MethodSpec
+            .methodBuilder("setName")
+            .addParameter(String.class, "name")
+            .addModifiers(Modifier.PUBLIC)
+            .addStatement("this.name = name")
+            .build())
+          .addMethod(getPrintNameMultipleTimesMethod())
+          .addMethod(getSortByLengthMethod())
+          .build();
+    }
+
+    public TypeSpec getComparatorAnonymousClass() {
+        return TypeSpec
+          .anonymousClassBuilder("")
+          .addSuperinterface(ParameterizedTypeName.get(Comparator.class, String.class))
+          .addMethod(MethodSpec
+            .methodBuilder("compare")
+            .addModifiers(Modifier.PUBLIC)
+            .addAnnotation(Override.class)
+            .addParameter(String.class, "a")
+            .addParameter(String.class, "b")
+            .returns(int.class)
+            .addStatement("return a.length() - b.length()")
+            .build())
+          .build();
+    }
+
+    public void generateGenderEnum() throws IOException {
+        writeToOutputFile(getPersonPackageName(), getGenderEnum());
+    }
+
+    public void generatePersonInterface() throws IOException {
+        writeToOutputFile(getPersonPackageName(), getPersonInterface());
+    }
+
+    public void generateStudentClass() throws IOException {
+        writeToOutputFile(getPersonPackageName(), getStudentClass());
+    }
+
+    private void writeToOutputFile(String packageName, TypeSpec typeSpec) throws IOException {
+        JavaFile javaFile = JavaFile
+          .builder(packageName, typeSpec)
+          .indent(FOUR_WHITESPACES)
+          .build();
+        javaFile.writeTo(outputFile);
+    }
+
+}

libraries/src/main/java/com/baeldung/javasisst/Point.java

@@ -0,0 +1,16 @@
+package com.baeldung.javasisst;
+
+public class Point {
+    public int x = 0;
+    public int y = 0;
+
+    public Point(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public void move(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+}

libraries/src/main/java/com/baeldung/javasisst/ThreeDimensionalPoint.java

@@ -0,0 +1,18 @@
+package com.baeldung.javasisst;
+
+public class ThreeDimensionalPoint {
+    public int x = 0;
+    public int y = 0;
+    public int z = 0;
+
+    public ThreeDimensionalPoint(int x, int y, int z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    public void move(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+}

libraries/src/main/java/com/baeldung/javers/Address.java

@@ -0,0 +1,10 @@
+package com.baeldung.javers;
+
+public class Address {
+    private String country;
+
+    public Address(String country) {
+        this.country = country;
+    }
+
+}

libraries/src/main/java/com/baeldung/javers/Person.java

@@ -0,0 +1,27 @@
+package com.baeldung.javers;
+
+public class Person {
+    private Integer id;
+    private String name;
+
+    public Person(Integer id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

libraries/src/main/java/com/baeldung/javers/PersonWithAddress.java

@@ -0,0 +1,39 @@
+package com.baeldung.javers;
+
+import java.util.List;
+
+public class PersonWithAddress {
+    private Integer id;
+    private String name;
+    private List<Address> address;
+
+    public PersonWithAddress(Integer id, String name, List<Address> address) {
+        this.id = id;
+        this.name = name;
+        this.address = address;
+    }
+
+    public Integer getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public List<Address> getAddress() {
+        return address;
+    }
+
+    public void setAddress(List<Address> address) {
+        this.address = address;
+    }
+}

libraries/src/main/java/com/baeldung/jctools/MpmcBenchmark.java

@@ -0,0 +1,73 @@
+package com.baeldung.jctools;
+
+import org.jctools.queues.MpmcArrayQueue;
+import org.jctools.queues.atomic.MpmcAtomicArrayQueue;
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Control;
+
+import java.util.Queue;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+@BenchmarkMode(Mode.SampleTime)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@Fork(1)
+@Warmup(iterations = 1)
+@Measurement(iterations = 3)
+@State(Scope.Group)
+public class MpmcBenchmark {
+
+    public static final String PARAM_UNSAFE = "MpmcArrayQueue";
+    public static final String PARAM_AFU = "MpmcAtomicArrayQueue";
+    public static final String PARAM_JDK = "ArrayBlockingQueue";
+
+    public static final int PRODUCER_THREADS_NUMBER = 32;
+    public static final int CONSUMER_THREADS_NUMBER = 32;
+
+    public static final String GROUP_NAME = "MyGroup";
+
+    public static final int CAPACITY = 128;
+
+    @Param({PARAM_UNSAFE, PARAM_AFU, PARAM_JDK})
+    public volatile String implementation;
+
+    public volatile Queue<Long> queue;
+
+    @Setup(Level.Trial)
+    public void setUp() {
+        switch (implementation) {
+            case PARAM_UNSAFE:
+                queue = new MpmcArrayQueue<>(CAPACITY);
+                break;
+            case PARAM_AFU:
+                queue = new MpmcAtomicArrayQueue<>(CAPACITY);
+                break;
+            case PARAM_JDK:
+                queue = new ArrayBlockingQueue<>(CAPACITY);
+                break;
+            default:
+                throw new UnsupportedOperationException("Unsupported implementation " + implementation);
+        }
+    }
+
+
+    @Benchmark
+    @Group(GROUP_NAME)
+    @GroupThreads(PRODUCER_THREADS_NUMBER)
+    public void write(Control control) {
+        //noinspection StatementWithEmptyBody
+        while (!control.stopMeasurement && !queue.offer(1L)) {
+            // Is intentionally left blank
+        }
+    }
+
+    @Benchmark
+    @Group(GROUP_NAME)
+    @GroupThreads(CONSUMER_THREADS_NUMBER)
+    public void read(Control control) {
+        //noinspection StatementWithEmptyBody
+        while (!control.stopMeasurement && queue.poll() == null) {
+            // Is intentionally left blank
+        }
+    }
+}