Included Patrik's specification pattern implementation

dddsample/src/main/java/se/citerus/dddsample/domain/model/Specification.java

@@ -1,7 +0,0 @@
-package se.citerus.dddsample.domain.model;
-
-public interface Specification<T> {
-
-  boolean isSatisfiedBy(T t);
-    
-}

dddsample/src/main/java/se/citerus/dddsample/domain/model/cargo/RouteSpecification.java

@@ -3,9 +3,9 @@ package se.citerus.dddsample.domain.model.cargo;
 import org.apache.commons.lang.Validate;
 import org.apache.commons.lang.builder.EqualsBuilder;
 import org.apache.commons.lang.builder.HashCodeBuilder;
-import se.citerus.dddsample.domain.model.Specification;
 import se.citerus.dddsample.domain.model.ValueObject;
 import se.citerus.dddsample.domain.model.location.Location;
+import se.citerus.dddsample.domain.shared.AbstractSpecification;
 
 import java.util.Date;
 
@@ -13,7 +13,7 @@ import java.util.Date;
  * Route specification.
  * 
  */
-public class RouteSpecification implements ValueObject<RouteSpecification>, Specification<Itinerary> {
+public class RouteSpecification extends AbstractSpecification<Itinerary> implements ValueObject<RouteSpecification> {
   private Location origin;
   private Location destination;
   private Date arrivalDeadline;
@@ -95,5 +95,5 @@ public class RouteSpecification implements ValueObject<RouteSpecification>, Spec
       append(this.arrivalDeadline).
       toHashCode();
   }
-  
+
 }

dddsample/src/main/java/se/citerus/dddsample/domain/shared/AbstractSpecification.java

@@ -0,0 +1,35 @@
+package se.citerus.dddsample.domain.shared;
+
+
+/**
+ * Abstract base implementation of composite {@link Specification} with default
+ * implementations for {@code and}, {@code or} and {@code not}.
+ */
+public abstract class AbstractSpecification<T> implements Specification<T> {
+
+  /**
+   * {@inheritDoc}
+   */
+  public abstract boolean isSatisfiedBy(T t);
+
+  /**
+   * {@inheritDoc}
+   */
+  public Specification<T> and(final Specification<T> specification) {
+    return new AndSpecification<T>(this, specification);
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public Specification<T> or(final Specification<T> specification) {
+    return new OrSpecification<T>(this, specification);
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public Specification<T> not(final Specification<T> specification) {
+    return new NotSpecification<T>(specification);
+  }
+}

dddsample/src/main/java/se/citerus/dddsample/domain/shared/AndSpecification.java

@@ -0,0 +1,28 @@
+package se.citerus.dddsample.domain.shared;
+
+/**
+ * AND specification, used to create a new specifcation that is the AND of two other specifications.
+ */
+public class AndSpecification<T> extends AbstractSpecification<T> {
+
+  private Specification<T> spec1;
+  private Specification<T> spec2;
+
+  /**
+   * Create a new AND specification based on two other spec.
+   *
+   * @param spec1 Specification one.
+   * @param spec2 Specification two.
+   */
+  public AndSpecification(final Specification<T> spec1, final Specification<T> spec2) {
+    this.spec1 = spec1;
+    this.spec2 = spec2;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public boolean isSatisfiedBy(final T t) {
+    return spec1.isSatisfiedBy(t) && spec2.isSatisfiedBy(t);
+  }
+}

dddsample/src/main/java/se/citerus/dddsample/domain/shared/NotSpecification.java

@@ -0,0 +1,25 @@
+package se.citerus.dddsample.domain.shared;
+
+/**
+ * NOT decorator, used to create a new specifcation that is the inverse (NOT) of the given spec.
+ */
+public class NotSpecification<T> extends AbstractSpecification<T> {
+
+  private Specification<T> spec1;
+
+  /**
+   * Create a new NOT specification based on another spec.
+   *
+   * @param spec1 Specification instance to not.
+   */
+  public NotSpecification(final Specification<T> spec1) {
+    this.spec1 = spec1;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public boolean isSatisfiedBy(final T t) {
+    return !spec1.isSatisfiedBy(t);
+  }
+}

dddsample/src/main/java/se/citerus/dddsample/domain/shared/OrSpecification.java

@@ -0,0 +1,28 @@
+package se.citerus.dddsample.domain.shared;
+
+/**
+ * OR specification, used to create a new specifcation that is the OR of two other specifications.
+ */
+public class OrSpecification<T> extends AbstractSpecification<T> {
+
+  private Specification<T> spec1;
+  private Specification<T> spec2;
+
+  /**
+   * Create a new OR specification based on two other spec.
+   *
+   * @param spec1 Specification one.
+   * @param spec2 Specification two.
+   */
+  public OrSpecification(final Specification<T> spec1, final Specification<T> spec2) {
+    this.spec1 = spec1;
+    this.spec2 = spec2;
+  }
+
+  /**
+   * {@inheritDoc}
+   */
+  public boolean isSatisfiedBy(final T t) {
+    return spec1.isSatisfiedBy(t) || spec2.isSatisfiedBy(t);
+  }
+}

dddsample/src/main/java/se/citerus/dddsample/domain/shared/Specification.java

@@ -0,0 +1,39 @@
+package se.citerus.dddsample.domain.shared;
+
+/**
+ * Specificaiton interface.
+ * <p/>
+ * Use {@link se.citerus.dddsample.domain.shared.AbstractSpecification} as base for creating specifications, and
+ * only the method {@link #isSatisfiedBy(Object)} must be implemented.
+ */
+public interface Specification<T> {
+
+  /**
+   * Check if {@code t} is satisfied by the specification.
+   *
+   * @param t Object to test.
+   * @return {@code true} if {@code t} satisfies the specification.
+   */
+  boolean isSatisfiedBy(T t);
+
+  /**
+   * Create a new specification that is the AND operation of {@code this} specification and another specification.
+   * @param specification Specification to AND.
+   * @return A new specification.
+   */
+  Specification<T> and(Specification<T> specification);
+
+  /**
+   * Create a new specification that is the OR operation of {@code this} specification and another specification.
+   * @param specification Specification to OR.
+   * @return A new specification.
+   */
+  Specification<T> or(Specification<T> specification);
+
+  /**
+   * Create a new specification that is the NOT operation of {@code this} specification.
+   * @param specification Specification to NOT.
+   * @return A new specification.
+   */
+  Specification<T> not(Specification<T> specification);
+}