A few minor changes to the experimental parts of the domain layer support

dddsample/src/main/java/se/citerus/dddsample/domain/shared/experimental/Entity.java

@@ -14,6 +14,11 @@ public interface Entity<T,ID> {
    */
   boolean sameIdentityAs(T other);
 
+  /**
+   * Entities have an identity.
+   *
+   * @return The identity of this entity.
+   */
   ID identity();
 
 }

dddsample/src/main/java/se/citerus/dddsample/domain/shared/experimental/EntitySupport.java

@@ -3,7 +3,7 @@ package se.citerus.dddsample.domain.shared.experimental;
 import java.lang.reflect.Field;
 
 /**
- *
+ * Base class for entities.
  *
  */
 public abstract class EntitySupport<T extends Entity, ID> implements Entity<T, ID> {

dddsample/src/main/java/se/citerus/dddsample/domain/shared/experimental/Identity.java

@@ -12,4 +12,4 @@ import java.lang.annotation.Target;
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.FIELD)
 public @interface Identity {
-}
+}

dddsample/src/main/java/se/citerus/dddsample/domain/shared/experimental/ValueObject.java

@@ -1,12 +1,10 @@
 package se.citerus.dddsample.domain.shared.experimental;
 
-import java.io.Serializable;
-
 /**
  * A value object.
  *
  */
-public interface ValueObject<T> extends Serializable {
+public interface ValueObject<T> {
 
   /**
    * Value objects compare by the values of their attributes, they don't have an identity.
@@ -16,8 +14,11 @@ public interface ValueObject<T> extends Serializable {
    */
   boolean sameValueAs(T other);
 
-
-  // Value objects can be safely copied:
-  // T copy();
+  /**
+   * Value objects can be freely copied.
+   *
+   * @return A safe, deep copy of this value object.
+   */
+  T copy();
 
 }

dddsample/src/main/java/se/citerus/dddsample/domain/shared/experimental/ValueObjectSupport.java

@@ -2,41 +2,59 @@ package se.citerus.dddsample.domain.shared.experimental;
 
 import org.apache.commons.lang.builder.EqualsBuilder;
 import org.apache.commons.lang.builder.HashCodeBuilder;
-import se.citerus.dddsample.domain.model.ValueObject;
-
-public class ValueObjectSupport<T extends ValueObject> implements ValueObject<T> {
-
-    private transient int cachedHashCode = 0;
-
-    @Override
-    public final boolean sameValueAs(final T other) {
-        return other != null && EqualsBuilder.reflectionEquals(this, other, false);
+import se.citerus.dddsample.domain.shared.ValueObject;
+
+/**
+ * Base class for value objects.
+ *
+ * @param <T>
+ */
+public abstract class ValueObjectSupport<T extends ValueObject> implements ValueObject<T> {
+
+  private transient int cachedHashCode = 0;
+
+  /**
+   * @param other The other value object.
+   * @return True if all non-transient fields are equal.
+   */
+  @Override
+  public final boolean sameValueAs(final T other) {
+    return other != null && EqualsBuilder.reflectionEquals(this, other, false);
+  }
+
+  /**
+   * @return Hash code built from all non-transient fields.
+   */
+  @Override
+  public final int hashCode() {
+    // Using a local variable to ensure that we only do a single read
+    // of the cachedHashCode field, to avoid race conditions.
+    // It doesn't matter if several threads compute the hash code and overwrite
+    // each other, but it's important that we never return 0, which could happen
+    // with multiple reads of the cachedHashCode field.
+    //
+    // See java.lang.String.hashCode()
+    int h = cachedHashCode;
+    if (h == 0) {
+      // Lazy initialization of hash code.
+      // Value objects are immutable, so the hash code never changes.
+      h = HashCodeBuilder.reflectionHashCode(this, false);
+      cachedHashCode = h;
     }
 
-    @Override
-    public final int hashCode() {
-        // Using a local variable to ensure that we only do a single read
-        // of the cachedHashCode field, to avoid race conditions.
-        // It doesn't matter if several threads compute the hash code and overwrite
-        // each other, but it's important that we never return 0, which could happen
-        // with multiple field reads.
-        int h = cachedHashCode;
-        if (h == 0) {
-            // Lazy initialization of hash code.
-            // Value objects are immutable, so the hash code never changes.
-            h = HashCodeBuilder.reflectionHashCode(this, false);
-            cachedHashCode = h;
-        }
-
-        return h;
-    }
+    return h;
+  }
 
-    @Override
-    public final boolean equals(final Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+  /**
+   * @param o other object
+   * @return True if other object has the same value as this value object.
+   */
+  @Override
+  public final boolean equals(final Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
 
-        return sameValueAs((T) o);
-    }
+    return sameValueAs((T) o);
+  }
 
-}
+}