Remove mutability property

Author: charphi

README.md

@@ -78,7 +78,6 @@ Main properties:
 - [`#batchType`](#batch-type-property): bridge different services and generate providers on the fly
 
 Advanced properties:
-- [`#mutability`](#mutability-property): on-demand set and reload
 - [`#backend` `#cleaner`](#backend-and-cleaner-properties): custom service loader
 
 #### Quantifier property
@@ -247,14 +246,6 @@ Constraints:
 1. Batch type must be an interface or an abstract class.
 2. Batch method must be unique.
 
-#### Mutability property
-
-The `#mutability` property allows **on-demand set and reload** of a loader.
-
-_Example: [nbbrd/service/examples/Messenger.java](java-service-examples/src/main/java/nbbrd/service/examples/Messenger.java)_
-
-⚠️ _This is a complex mechanism that targets specific usages. It will be removed and/or simplified in a future release._
-
 #### Backend and cleaner properties
 
 The `#backend` and `#cleaner` properties allow to use a **custom service loader** such as [NetBeans Lookup](https://bits.netbeans.org/dev/javadoc/org-openide-util-lookup/index.html) instead of JDK `ServiceLoader`.

java-service-annotation/src/main/java/nbbrd/service/ServiceDefinition.java

@@ -20,8 +20,6 @@
 import java.util.ServiceLoader;
 import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.function.UnaryOperator;
-import java.util.stream.Stream;
 
 /**
  * Declarative definition of a service that generates a specialized service
@@ -83,15 +81,6 @@
      */
     Class<?> batchType() default Void.class;
 
-    /**
-     * Specifies the mutability of the loader.
-     *
-     * @return a non-null mutability
-     * @deprecated This is a complex mechanism that targets specific usages. It will be removed and/or simplified in a future release.
-     */
-    @Deprecated
-    Mutability mutability() default Mutability.NONE;
-
     /**
      * Specifies the class that creates a service loader.
      * <br>The default backend uses {@link ServiceLoader#load(Class)}.

java-service-examples/src/main/java/nbbrd/service/examples/Messenger.java

@@ -3,18 +3,38 @@
 import internal.nbbrd.service.examples.FileTypeSpiLoader;
 import org.junit.jupiter.api.Test;
 
+import java.util.List;
+import java.util.ServiceLoader;
+import java.util.stream.StreamSupport;
+
+import static java.util.stream.Collectors.toList;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.atIndex;
+import static org.assertj.core.api.Assertions.assertThatCode;
 
 public class FileTypeSpiTest {
 
     @Test
     public void test() {
         FileTypeSpiLoader x = new FileTypeSpiLoader();
+
         assertThat(x.get())
                 .containsExactlyElementsOf(x.get())
-                .hasSize(2)
-                .satisfies(o -> assertThat(o).isInstanceOf(FileType.ByMagicNumberProbe.class), atIndex(0))
-                .satisfies(o -> assertThat(o).isInstanceOf(FileType.ByExtensionProbe.class), atIndex(1));
+                .hasExactlyElementsOfTypes(FileType.ByMagicNumberProbe.class, FileType.ByExtensionProbe.class)
+                .extracting(FileTypeSpiTest::getTypeName)
+                .containsExactlyElementsOf(toTypeNames(FileTypeSpiLoader.load()))
+                .containsExactlyInAnyOrderElementsOf(toTypeNames(ServiceLoader.load(FileType.FileTypeSpi.class)));
+
+        assertThatCode(x::reload)
+                .doesNotThrowAnyException();
+    }
+
+    private static List<String> toTypeNames(Iterable<?> iterable) {
+        return StreamSupport.stream(iterable.spliterator(), false)
+                .map(FileTypeSpiTest::getTypeName)
+                .collect(toList());
+    }
+
+    private static String getTypeName(Object fileTypeSpi) {
+        return fileTypeSpi.getClass().getName();
     }
 }

java-service-examples/src/test/java/nbbrd/service/examples/FileTypeSpiTest.java

@@ -41,9 +41,6 @@ class LoadDefinition {
     @lombok.NonNull
     Quantifier quantifier;
 
-    @lombok.NonNull
-    Lifecycle lifecycle;
-
     @lombok.NonNull
     ClassName serviceType;
 

java-service-examples/src/test/java/nbbrd/service/examples/MessengerTest.java

@@ -113,7 +113,6 @@ private LoadDefinition definitionOf(TypeElement serviceType) {
         return LoadDefinition
                 .builder()
                 .quantifier(annotation.quantifier())
-                .lifecycle(Lifecycle.of(annotation.mutability()))
                 .serviceType(ClassName.get(serviceType))
                 .fallback(fallback)
                 .loaderName(annotation.loaderName())

java-service-processor/src/main/java/internal/nbbrd/service/definition/LoadDefinition.java

@@ -25,7 +25,6 @@
 
 import javax.lang.model.type.TypeMirror;
 import java.util.*;
-import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.regex.Pattern;
@@ -119,17 +118,12 @@ public TypeSpec generateLoader(boolean nested) {
             result.addModifiers(STATIC).build();
         }
 
-        if (definition.getLifecycle().isModifiable()) {
-            FieldSpec cleanerField = newCleanerField();
-            result.addField(cleanerField);
-            result.addMethod(newSetMethod(resourceField, quantifierType));
-            result.addMethod(newReloadMethod(sourceField, batchField, cleanerField, doLoadMethod));
-            result.addMethod(newResetMethod(sourceField, doLoadMethod));
-        }
+        FieldSpec cleanerField = newCleanerField();
+        result.addField(cleanerField);
+        result.addMethod(newSetMethod(resourceField, quantifierType));
+        result.addMethod(newReloadMethod(sourceField, batchField, cleanerField, doLoadMethod));
 
-        if (definition.getLifecycle() == Lifecycle.IMMUTABLE) {
-            result.addMethod(newLoadMethod(className, quantifierType, getMethod));
-        }
+        result.addMethod(newLoadMethod(className, quantifierType, getMethod));
 
         return result.build();
     }
@@ -138,13 +132,11 @@ private CodeBlock getMainJavadoc() {
         return CodeBlock
                 .builder()
                 .add("Custom service loader for $L.\n", toJavadocLink(definition.getServiceType()))
-                .add("<br>This class $L thread-safe.\n", definition.getLifecycle().isThreadSafe() ? "is" : "is not")
                 .add("<p>Properties:\n")
                 .add("<ul>\n")
                 .add("<li>Quantifier: $L</li>\n", definition.getQuantifier())
                 .add("<li>Fallback: $L</li>\n", toJavadocLink(definition.getFallback()))
                 .add("<li>Preprocessing: $L</li>\n", getPreprocessingJavadoc())
-                .add("<li>Mutability: $L</li>\n", definition.getLifecycle().toMutability())
                 .add("<li>Name: $L</li>\n", definition.getLoaderName().isEmpty() ? "null" : definition.getLoaderName())
                 .add("<li>Backend: $L</li>\n", definition.getBackend().map(HasTypeMirror::getTypeName).orElse("null"))
                 .add("<li>Cleaner: $L</li>\n", definition.getCleaner().map(HasTypeMirror::getTypeName).orElse("null"))
@@ -401,23 +393,11 @@ private FieldSpec getResourceField(MethodSpec doLoadMethod, TypeName quantifierT
     }
 
     private FieldSpec.Builder getResourceFieldBuilder(TypeName quantifierType) {
-        String name = "resource";
-        switch (definition.getLifecycle()) {
-            case IMMUTABLE:
-                return FieldSpec.builder(quantifierType, name, PRIVATE, FINAL);
-            case MUTABLE:
-                return FieldSpec.builder(quantifierType, name, PRIVATE);
-            case CONCURRENT:
-                return FieldSpec.builder(typeOf(AtomicReference.class, quantifierType), name, PRIVATE, FINAL);
-            default:
-                throw new Unreachable();
-        }
+        return FieldSpec.builder(quantifierType, "resource", PRIVATE);
     }
 
     private CodeBlock getResourceInitializer(MethodSpec doLoadMethod) {
-        return definition.getLifecycle().isAtomicReference()
-                ? CodeBlock.of("new $T<>($N())", ClassName.get(AtomicReference.class), doLoadMethod)
-                : CodeBlock.of("$N()", doLoadMethod);
+        return CodeBlock.of("$N()", doLoadMethod);
     }
 
     private MethodSpec getGetMethod(FieldSpec resourceField, TypeName quantifierType) {
@@ -426,7 +406,6 @@ private MethodSpec getGetMethod(FieldSpec resourceField, TypeName quantifierType
                 .addJavadoc(CodeBlock
                         .builder()
                         .add(getGetDescription())
-                        .add(getThreadSafetyComment())
                         .add("@return the current non-null value\n")
                         .build())
                 .addModifiers(PUBLIC)
@@ -449,9 +428,7 @@ private CodeBlock getGetDescription() {
     }
 
     private CodeBlock getGetterStatement(FieldSpec resourceField) {
-        return definition.getLifecycle().isAtomicReference()
-                ? CodeBlock.of("return $N.get()", resourceField)
-                : CodeBlock.of("return $N", resourceField);
+        return CodeBlock.of("return $N", resourceField);
     }
 
     private MethodSpec newSetMethod(FieldSpec resourceField, TypeName quantifierType) {
@@ -460,10 +437,9 @@ private MethodSpec newSetMethod(FieldSpec resourceField, TypeName quantifierType
                 .addJavadoc(CodeBlock
                         .builder()
                         .add(getSetDescription())
-                        .add(getThreadSafetyComment())
                         .add("@param newValue new non-null value\n")
                         .build())
-                .addModifiers(PUBLIC)
+                .addModifiers(PRIVATE)
                 .addParameter(quantifierType, "newValue")
                 .addStatement(getSetterStatement(resourceField))
                 .build();
@@ -483,9 +459,7 @@ private CodeBlock getSetDescription() {
     }
 
     private CodeBlock getSetterStatement(FieldSpec resourceField) {
-        return definition.getLifecycle().isAtomicReference()
-                ? CodeBlock.of("$N.set($T.requireNonNull(newValue))", resourceField, Objects.class)
-                : CodeBlock.of("$N = $T.requireNonNull(newValue)", resourceField, Objects.class);
+        return CodeBlock.of("$N = $T.requireNonNull(newValue)", resourceField, Objects.class);
     }
 
     private MethodSpec newReloadMethod(
@@ -499,47 +473,14 @@ private MethodSpec newReloadMethod(
                 .addJavadoc(CodeBlock
                         .builder()
                         .add("Reloads the content by clearing the cache and fetching available providers.\n")
-                        .add(getThreadSafetyComment())
                         .build())
                 .addModifiers(PUBLIC)
                 .addExceptions(getQuantifierException());
 
-        if (definition.getLifecycle().isAtomicReference()) {
-            result.beginControlFlow("synchronized($N)", sourceField);
-        }
-
         result.addStatement("$N.accept($N)", cleanerField, sourceField);
         batchField.ifPresent(fieldSpec -> result.addStatement("$N.accept($N)", cleanerField, fieldSpec));
         result.addStatement("set($N())", loaderMethod);
 
-        if (definition.getLifecycle().isAtomicReference()) {
-            result.endControlFlow();
-        }
-
-        return result.build();
-    }
-
-    private MethodSpec newResetMethod(FieldSpec sourceField, MethodSpec loaderMethod) {
-        MethodSpec.Builder result = MethodSpec
-                .methodBuilder("reset")
-                .addJavadoc(CodeBlock
-                        .builder()
-                        .add("Resets the content without clearing the cache.\n")
-                        .add(getThreadSafetyComment())
-                        .build())
-                .addModifiers(PUBLIC)
-                .addExceptions(getQuantifierException());
-
-        if (definition.getLifecycle().isAtomicReference()) {
-            result.beginControlFlow("synchronized($N)", sourceField);
-        }
-
-        result.addStatement("set($N())", loaderMethod);
-
-        if (definition.getLifecycle().isAtomicReference()) {
-            result.endControlFlow();
-        }
-
         return result.build();
     }
 
@@ -553,7 +494,6 @@ private MethodSpec newLoadMethod(String className, TypeName quantifierType, Meth
                         .add(getGetDescription())
                         .add("<br>This is equivalent to the following code: <code>$L</code>\n", mainStatement)
                         .add("<br>Therefore, the returned value might be different at each call.\n")
-                        .add(getThreadSafetyComment())
                         .add("@return a non-null value\n")
                         .build())
                 .addModifiers(PUBLIC, STATIC)
@@ -565,19 +505,14 @@ private MethodSpec newLoadMethod(String className, TypeName quantifierType, Meth
         return result.build();
     }
 
-
     private Optional<FieldSpec> getIdPatternField() {
-        return ids.size() == 1 && !ids.get(0).getPattern().isEmpty() ? Optional.of(FieldSpec
-                                                                                   .builder(Pattern.class, "ID_PATTERN")
-                                                                                   .addModifiers(PUBLIC, STATIC, FINAL)
-                                                                                   .initializer("$T.compile(\"$N\")", Pattern.class, ids.get(0).getPattern())
-                                                                                   .build()) : Optional.empty();
-    }
-
-    private CodeBlock getThreadSafetyComment() {
-        return definition.getLifecycle().isThreadSafe()
-                ? CodeBlock.of("<br>This method is thread-safe.\n")
-                : CodeBlock.of("<br>This method is not thread-safe.\n");
+        return ids.size() == 1 && !ids.get(0).getPattern().isEmpty()
+                ? Optional.of(FieldSpec
+                              .builder(Pattern.class, "ID_PATTERN")
+                              .addModifiers(PUBLIC, STATIC, FINAL)
+                              .initializer("$T.compile(\"$N\")", Pattern.class, ids.get(0).getPattern())
+                              .build())
+                : Optional.empty();
     }
 
     private static ParameterizedTypeName typeOf(Class<?> rawType, TypeName typeArgument) {