MERGE PREP: Renamed "Fluent" to "Transformed"

...to align with branch "redesign2".

Author: rickbw

src/main/java/crud/pattern/ResourceMerger.java

@@ -17,8 +17,8 @@
 import crud.core.ReadableResource;
 import crud.core.Resource;
 import crud.core.WritableResource;
-import crud.transform.FluentReadableResource;
-import crud.transform.FluentWritableResource;
+import crud.transform.TransformedReadableResource;
+import crud.transform.TransformedWritableResource;
 import rx.Observable;
 import rx.functions.Func0;
 import rx.functions.Func1;
@@ -37,7 +37,7 @@
  * back.
  *
  * This class is provided as an alternative to flatMap operations on the
- * {@link FluentReadableResource} and {@link FluentWritableResource} types.
+ * {@link TransformedReadableResource} and {@link TransformedWritableResource} types.
  * In contrast to those hypothetical operations, this class makes explicit the
  * relationship between reading and writing, and encapsulates any side effects
  * in the caller-provided function.
@@ -55,7 +55,7 @@ public abstract class ResourceMerger<RESPONSE> {
     public static <RSRC, RESPONSE> ResourceMerger<RESPONSE> withWriter(
             final ReadableResource<RSRC> reader,
             final WritableResource<RSRC, RESPONSE> writer) {
-        return new MergerImpl<>(reader, FluentWritableResource.from(writer).toFunction());
+        return new MergerImpl<>(reader, TransformedWritableResource.from(writer).toFunction());
     }
 
     /**
@@ -68,8 +68,8 @@ public static <RRSRC, WRSRC, RESPONSE> ResourceMerger<RESPONSE> mapToWriter(
             final Func1<? super Observable<RRSRC>, ? extends Observable<WRSRC>> mapper,
             final WritableResource<WRSRC, RESPONSE> writer) {
         return new MergerImpl<>(
-                FluentReadableResource.from(reader).mapValue(mapper),
-                FluentWritableResource.from(writer).toFunction());
+                TransformedReadableResource.from(reader).mapValue(mapper),
+                TransformedWritableResource.from(writer).toFunction());
     }
 
     /**
@@ -106,7 +106,7 @@ private ResourceMerger() {
      * reflected in the public API.
      */
     private static final class MergerImpl<RSRC, RESPONSE> extends ResourceMerger<RESPONSE> {
-        private final FluentReadableResource<RESPONSE> merger;
+        private final TransformedReadableResource<RESPONSE> merger;
         /**
          * Kept around just for {@link #toString()}, {@link #equals(Object)},
          * and {@link #hashCode()}. The results of the former and latter could
@@ -121,7 +121,7 @@ private static final class MergerImpl<RSRC, RESPONSE> extends ResourceMerger<RES
         public MergerImpl(
                 final ReadableResource<RSRC> reader,
                 final Func1<RSRC, ? extends Observable<? extends RESPONSE>> writer) {
-            this.merger = FluentReadableResource.from(reader).mapValue(new Func1<Observable<RSRC>, Observable<RESPONSE>>() {
+            this.merger = TransformedReadableResource.from(reader).mapValue(new Func1<Observable<RSRC>, Observable<RESPONSE>>() {
                 @Override
                 public Observable<RESPONSE> call(final Observable<RSRC> resource) {
                     return resource.flatMap(writer);

src/main/java/crud/transform/FluentReadableResource.java renamed to src/main/java/crud/transform/TransformedReadableResource.java

@@ -24,17 +24,17 @@
 
 
 /**
- * A set of fluent transformations on {@link ReadableResource}s.
+ * A set of transformations on {@link ReadableResource}s.
  */
-public abstract class FluentReadableResource<RSRC> implements ReadableResource<RSRC> {
+public abstract class TransformedReadableResource<RSRC> implements ReadableResource<RSRC> {
 
     /**
-     * If the given resource is a {@code FluentReadableResource}, return it.
+     * If the given resource is a {@code TransformedReadableResource}, return it.
      * Otherwise, wrap it in a new instance.
      */
-    public static <RSRC> FluentReadableResource<RSRC> from(final ReadableResource<RSRC> resource) {
-        if (resource instanceof FluentReadableResource<?>) {
-            return (FluentReadableResource<RSRC>) resource;
+    public static <RSRC> TransformedReadableResource<RSRC> from(final ReadableResource<RSRC> resource) {
+        if (resource instanceof TransformedReadableResource<?>) {
+            return (TransformedReadableResource<RSRC>) resource;
         } else {
             return new DelegatingReadableResource<>(resource);
         }
@@ -44,13 +44,13 @@ public static <RSRC> FluentReadableResource<RSRC> from(final ReadableResource<RS
      * Create and return a new resource that will transform the state of
      * this resource.
      *
-     * If this method is called on two equal {@code FluentReadableResource}s,
+     * If this method is called on two equal {@code TransformedReadableResource}s,
      * the results will be equal if the functions are equal. If equality
      * behavior it important to you (for example, if you intend to keep
      * resources in a {@code HashSet}), consider it in your function
      * implementation.
      */
-    public <TO> FluentReadableResource<TO> mapValue(
+    public <TO> TransformedReadableResource<TO> mapValue(
             final Func1<? super Observable<RSRC>, ? extends Observable<TO>> mapper) {
         return new MappingReadableResource<>(this, mapper);
     }
@@ -79,7 +79,7 @@ private DelegateObjectMethods.Callable<Observable<RSRC>> toResourceCallable() {
         return new DelegateObjectMethods.Callable<Observable<RSRC>>(this) {
             @Override
             public Observable<RSRC> call() {
-                return FluentReadableResource.this.read();
+                return TransformedReadableResource.this.read();
             }
         };
     }
@@ -90,14 +90,14 @@ public Observable<RSRC> call() {
      * combined with its parent class, because it needs additional type
      * parameters that should not be public.
      */
-    private static abstract class AbstractFluentReadableResource<FROM, TO, T>
-    extends FluentReadableResource<TO> {
-        protected final FluentResourceStateMixin<ReadableResource<FROM>, T> state;
+    private static abstract class AbstractTransformedReadableResource<FROM, TO, T>
+    extends TransformedReadableResource<TO> {
+        protected final TransformedResourceStateMixin<ReadableResource<FROM>, T> state;
 
-        protected AbstractFluentReadableResource(
+        protected AbstractTransformedReadableResource(
                 final ReadableResource<FROM> delegate,
                 final T auxiliary) {
-            this.state = new FluentResourceStateMixin<>(delegate, auxiliary);
+            this.state = new TransformedResourceStateMixin<>(delegate, auxiliary);
         }
 
         @Override
@@ -111,7 +111,7 @@ public boolean equals(final Object obj) {
             if (getClass() != obj.getClass()) {
                 return false;
             }
-            final AbstractFluentReadableResource<?, ?, ?> other = (AbstractFluentReadableResource<?, ?, ?>) obj;
+            final AbstractTransformedReadableResource<?, ?, ?> other = (AbstractTransformedReadableResource<?, ?, ?>) obj;
             return this.state.equals(other.state);
         }
 
@@ -124,11 +124,11 @@ public int hashCode() {
 
     /**
      * It may seem that the business of this class could be accomplished by
-     * FluentReadableResource itself. However, that would require an
+     * TransformedReadableResource itself. However, that would require an
      * additional layer of equals() and hashCode overrides and an unsafe cast.
      */
     private static final class DelegatingReadableResource<RSRC>
-    extends AbstractFluentReadableResource<RSRC, RSRC, Void> {
+    extends AbstractTransformedReadableResource<RSRC, RSRC, Void> {
         public DelegatingReadableResource(final ReadableResource<RSRC> delegate) {
             super(delegate, null);
         }
@@ -143,7 +143,7 @@ public Observable<RSRC> read() {
 
 
     private static final class MappingReadableResource<FROM, TO>
-    extends AbstractFluentReadableResource<FROM, TO, Func1<? super Observable<FROM>, ? extends Observable<TO>>> {
+    extends AbstractTransformedReadableResource<FROM, TO, Func1<? super Observable<FROM>, ? extends Observable<TO>>> {
         public MappingReadableResource(
                 final ReadableResource<FROM> delegate,
                 final Func1<? super Observable<FROM>, ? extends Observable<TO>> mapper) {

src/main/java/crud/transform/FluentReadableResourceSet.java renamed to src/main/java/crud/transform/TransformedReadableResourceSet.java

@@ -21,29 +21,29 @@
 import rx.functions.Func1;
 
 
-public abstract class FluentReadableResourceSet<KEY, RSRC>
+public abstract class TransformedReadableResourceSet<KEY, RSRC>
 implements ReadableResourceSet<KEY, RSRC> {
 
-    public static <KEY, RSRC> FluentReadableResourceSet<KEY, RSRC> from(
+    public static <KEY, RSRC> TransformedReadableResourceSet<KEY, RSRC> from(
             final ReadableResourceSet<KEY, RSRC> rsrcSet) {
-        if (rsrcSet instanceof FluentReadableResourceSet<?, ?>) {
-            return (FluentReadableResourceSet<KEY, RSRC>) rsrcSet;
+        if (rsrcSet instanceof TransformedReadableResourceSet<?, ?>) {
+            return (TransformedReadableResourceSet<KEY, RSRC>) rsrcSet;
         } else {
-            return new FluentReadableResourceSet<KEY, RSRC>() {
+            return new TransformedReadableResourceSet<KEY, RSRC>() {
                 @Override
-                public FluentReadableResource<RSRC> get(final KEY key) {
-                    return FluentReadableResource.from(rsrcSet.get(key));
+                public TransformedReadableResource<RSRC> get(final KEY key) {
+                    return TransformedReadableResource.from(rsrcSet.get(key));
                 }
             };
         }
     }
 
-    public <R> FluentReadableResourceSet<KEY, R> mapValue(
+    public <R> TransformedReadableResourceSet<KEY, R> mapValue(
             final Func1<? super Observable<? super RSRC>, ? extends Observable<R>> mapper) {
         Objects.requireNonNull(mapper, "null function");
-        final FluentReadableResourceSet<KEY, R> result = new FluentReadableResourceSet<KEY, R>() {
+        final TransformedReadableResourceSet<KEY, R> result = new TransformedReadableResourceSet<KEY, R>() {
             @Override
-            public FluentReadableResource<R> get(final KEY key) {
+            public TransformedReadableResource<R> get(final KEY key) {
                 return outerResourceSet()
                         .get(key)
                         .mapValue(mapper);
@@ -52,12 +52,12 @@ public FluentReadableResource<R> get(final KEY key) {
         return result;
     }
 
-    public <K> FluentReadableResourceSet<K, RSRC> adaptKey(
+    public <K> TransformedReadableResourceSet<K, RSRC> adaptKey(
             final Func1<? super K, ? extends KEY> adapter) {
         Objects.requireNonNull(adapter, "null function");
-        final FluentReadableResourceSet<K, RSRC> result = new FluentReadableResourceSet<K, RSRC>() {
+        final TransformedReadableResourceSet<K, RSRC> result = new TransformedReadableResourceSet<K, RSRC>() {
             @Override
-            public FluentReadableResource<RSRC> get(final K key) {
+            public TransformedReadableResource<RSRC> get(final K key) {
                 Objects.requireNonNull(key, "null key");
                 final KEY transformedKey = adapter.call(key);
                 return outerResourceSet().get(transformedKey);
@@ -66,19 +66,19 @@ public FluentReadableResource<RSRC> get(final K key) {
         return result;
     }
 
-    public Func1<KEY, FluentReadableResource<RSRC>> toFunction() {
-        return new DelegateObjectMethods.Function<KEY, FluentReadableResource<RSRC>>(this) {
+    public Func1<KEY, TransformedReadableResource<RSRC>> toFunction() {
+        return new DelegateObjectMethods.Function<KEY, TransformedReadableResource<RSRC>>(this) {
             @Override
-            public FluentReadableResource<RSRC> call(final KEY key) {
+            public TransformedReadableResource<RSRC> call(final KEY key) {
                 return get(key);
             }
         };
     }
 
     @Override
-    public abstract FluentReadableResource<RSRC> get(KEY key);
+    public abstract TransformedReadableResource<RSRC> get(KEY key);
 
-    private FluentReadableResourceSet<KEY, RSRC> outerResourceSet() {
+    private TransformedReadableResourceSet<KEY, RSRC> outerResourceSet() {
         return this;
     }
 

src/main/java/crud/transform/FluentResourceStateMixin.java renamed to src/main/java/crud/transform/TransformedResourceStateMixin.java

@@ -17,15 +17,14 @@
 import java.util.Objects;
 
 import crud.core.Resource;
-
 import rx.functions.Func1;
 
 
 /**
- * Maintains state on behalf of the {@code Fluent*Resource} classes in this
+ * Maintains state on behalf of the {@code Transformed*Resource} classes in this
  * package, in order to minimize repeated boilerplate code.
  */
-/*package*/ final class FluentResourceStateMixin<R extends Resource, T> {
+/*package*/ final class TransformedResourceStateMixin<R extends Resource, T> {
 
     private final R delegate;
     private final T auxiliaryState;
@@ -39,7 +38,7 @@
      *                  {@link Func1} -- specific to the concrete type of the
      *                  wrapping {@code Resource}. It may be null.
      */
-    public FluentResourceStateMixin(final R delegate, final T auxiliary) {
+    public TransformedResourceStateMixin(final R delegate, final T auxiliary) {
         this.delegate = Objects.requireNonNull(delegate);
         this.auxiliaryState = auxiliary;    // may be null
     }
@@ -63,7 +62,7 @@ public boolean equals(final Object obj) {
         if (getClass() != obj.getClass()) {
             return false;
         }
-        final FluentResourceStateMixin<?, ?> other = (FluentResourceStateMixin<?, ?>) obj;
+        final TransformedResourceStateMixin<?, ?> other = (TransformedResourceStateMixin<?, ?>) obj;
         if (!this.delegate.equals(other.delegate)) {
             return false;
         }

src/main/java/crud/transform/FluentWritableResource.java renamed to src/main/java/crud/transform/TransformedWritableResource.java

@@ -22,18 +22,18 @@
 
 
 /**
- * A set of fluent transformations on {@link WritableResource}s.
+ * A set of transformations on {@link WritableResource}s.
  */
-public abstract class FluentWritableResource<RSRC, RESPONSE> implements WritableResource<RSRC, RESPONSE> {
+public abstract class TransformedWritableResource<RSRC, RESPONSE> implements WritableResource<RSRC, RESPONSE> {
 
     /**
-     * If the given resource is a {@code FluentWritableResource}, return it.
+     * If the given resource is a {@code TransformedWritableResource}, return it.
      * Otherwise, wrap it in a new instance.
      */
-    public static <RSRC, RESPONSE> FluentWritableResource<RSRC, RESPONSE> from(
+    public static <RSRC, RESPONSE> TransformedWritableResource<RSRC, RESPONSE> from(
             final WritableResource<RSRC, RESPONSE> resource) {
-        if (resource instanceof FluentWritableResource<?, ?>) {
-            return (FluentWritableResource<RSRC, RESPONSE>) resource;
+        if (resource instanceof TransformedWritableResource<?, ?>) {
+            return (TransformedWritableResource<RSRC, RESPONSE>) resource;
         } else {
             return new DelegatingWritableResource<>(resource);
         }
@@ -43,13 +43,13 @@ public static <RSRC, RESPONSE> FluentWritableResource<RSRC, RESPONSE> from(
      * Create and return a new resource that will transform the responses from
      * this resource.
      *
-     * If this method is called on two equal {@code FluentWritableResource}s,
+     * If this method is called on two equal {@code TransformedWritableResource}s,
      * the results will be equal if the functions are equal. If equality
      * behavior it important to you (for example, if you intend to keep
      * resources in a {@code HashSet}), consider it in your function
      * implementation.
      */
-    public <TO> FluentWritableResource<RSRC, TO> mapResponse(
+    public <TO> TransformedWritableResource<RSRC, TO> mapResponse(
             final Func1<? super Observable<RESPONSE>, ? extends Observable<TO>> mapper) {
         return new MappingWritableResource<>(this, mapper);
     }
@@ -58,13 +58,13 @@ public <TO> FluentWritableResource<RSRC, TO> mapResponse(
      * Create and return a new resource that will transform the input resource
      * states before passing them to this resource.
      *
-     * If this method is called on two equal {@code FluentWritableResource}s,
+     * If this method is called on two equal {@code TransformedWritableResource}s,
      * the results will be equal if the functions are equal. If equality
      * behavior it important to you (for example, if you intend to keep
      * resources in a {@code HashSet}), consider it in your function
      * implementation.
      */
-    public <TO> FluentWritableResource<TO, RESPONSE> adaptNewValue(
+    public <TO> TransformedWritableResource<TO, RESPONSE> adaptNewValue(
             final Func1<? super TO, ? extends RSRC> adapter) {
         return new AdaptingWritableResource<>(this, adapter);
     }
@@ -79,7 +79,7 @@ public Func1<RSRC, Observable<RESPONSE>> toFunction() {
         return new DelegateObjectMethods.Function<RSRC, Observable<RESPONSE>>(this) {
             @Override
             public Observable<RESPONSE> call(final RSRC newValue) {
-                return FluentWritableResource.this.write(newValue);
+                return TransformedWritableResource.this.write(newValue);
             }
         };
     }
@@ -90,14 +90,14 @@ public Observable<RESPONSE> call(final RSRC newValue) {
      * combined with its parent class, because it needs additional type
      * parameters that should not be public.
      */
-    private static abstract class AbstractFluentWritableResource<FROMRS, TORS, FROMRP, TORP, T>
-    extends FluentWritableResource<TORS, TORP> {
-        protected final FluentResourceStateMixin<WritableResource<FROMRS, FROMRP>, T> state;
+    private static abstract class AbstractTransformedWritableResource<FROMRS, TORS, FROMRP, TORP, T>
+    extends TransformedWritableResource<TORS, TORP> {
+        protected final TransformedResourceStateMixin<WritableResource<FROMRS, FROMRP>, T> state;
 
-        protected AbstractFluentWritableResource(
+        protected AbstractTransformedWritableResource(
                 final WritableResource<FROMRS, FROMRP> delegate,
                 final T auxiliary) {
-            this.state = new FluentResourceStateMixin<>(delegate, auxiliary);
+            this.state = new TransformedResourceStateMixin<>(delegate, auxiliary);
         }
 
         @Override
@@ -111,7 +111,7 @@ public boolean equals(final Object obj) {
             if (getClass() != obj.getClass()) {
                 return false;
             }
-            final AbstractFluentWritableResource<?, ?, ?, ?, ?> other = (AbstractFluentWritableResource<?, ?, ?, ?, ?>) obj;
+            final AbstractTransformedWritableResource<?, ?, ?, ?, ?> other = (AbstractTransformedWritableResource<?, ?, ?, ?, ?>) obj;
             return this.state.equals(other.state);
         }
 
@@ -123,7 +123,7 @@ public int hashCode() {
 
 
     private static final class DelegatingWritableResource<RSRC, RESPONSE>
-    extends AbstractFluentWritableResource<RSRC, RSRC, RESPONSE, RESPONSE, Void> {
+    extends AbstractTransformedWritableResource<RSRC, RSRC, RESPONSE, RESPONSE, Void> {
         public DelegatingWritableResource(final WritableResource<RSRC, RESPONSE> delegate) {
             super(delegate, null);
         }
@@ -138,7 +138,7 @@ public Observable<RESPONSE> write(final RSRC newValue) {
 
 
     private static final class MappingWritableResource<RSRC, FROM, TO>
-    extends AbstractFluentWritableResource<RSRC, RSRC, FROM, TO, Func1<? super Observable<FROM>, ? extends Observable<TO>>> {
+    extends AbstractTransformedWritableResource<RSRC, RSRC, FROM, TO, Func1<? super Observable<FROM>, ? extends Observable<TO>>> {
         public MappingWritableResource(
                 final WritableResource<RSRC, FROM> delegate,
                 final Func1<? super Observable<FROM>, ? extends Observable<TO>> mapper) {
@@ -156,7 +156,7 @@ public Observable<TO> write(final RSRC value) {
 
 
     private static final class AdaptingWritableResource<FROM, TO, RESPONSE>
-    extends AbstractFluentWritableResource<FROM, TO, RESPONSE, RESPONSE, Func1<? super TO, ? extends FROM>> {
+    extends AbstractTransformedWritableResource<FROM, TO, RESPONSE, RESPONSE, Func1<? super TO, ? extends FROM>> {
         private AdaptingWritableResource(
                 final WritableResource<FROM, RESPONSE> delegate,
                 final Func1<? super TO, ? extends FROM> adapter) {