Strongly-typed columns in query/subscription client API

client/src/main/java/io/spine/client/CompositeEntityStateFilter.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2020, TeamDev. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.client;
+
+import io.spine.base.EntityState;
+import io.spine.client.CompositeFilter.CompositeOperator;
+
+import java.util.Collection;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Lists.asList;
+import static io.spine.client.CompositeFilter.CompositeOperator.ALL;
+import static io.spine.client.CompositeFilter.CompositeOperator.EITHER;
+
+/**
+ * A subscription filter which aggregates one or more {@link EntityState} filters.
+ */
+public final class CompositeEntityStateFilter extends TypedCompositeFilter<EntityState> {
+
+    private static final long serialVersionUID = 0L;
+
+    private CompositeEntityStateFilter(Collection<EntityStateFilter> filters,
+                                       CompositeOperator operator) {
+        super(filters, operator);
+    }
+
+    /**
+     * Creates a new conjunction composite filter.
+     *
+     * <p>A record is considered matching this filter if and only if it matches all of the
+     * passed filters.
+     */
+    public static CompositeEntityStateFilter
+    all(EntityStateFilter first, EntityStateFilter... rest) {
+        checkNotNull(first);
+        checkNotNull(rest);
+        return new CompositeEntityStateFilter(asList(first, rest), ALL);
+    }
+
+    /**
+     * Creates a new disjunction composite filter.
+     *
+     * <p>A record is considered matching this filter if it matches at least one of the passed
+     * filters.
+     */
+    public static CompositeEntityStateFilter
+    either(EntityStateFilter first, EntityStateFilter... rest) {
+        checkNotNull(first);
+        checkNotNull(rest);
+        return new CompositeEntityStateFilter(asList(first, rest), EITHER);
+    }
+
+}

client/src/main/java/io/spine/client/CompositeEventFilter.java

@@ -20,57 +20,53 @@
 
 package io.spine.client;
 
-import com.google.common.collect.ImmutableList;
+import io.spine.client.CompositeFilter.CompositeOperator;
 import io.spine.core.Event;
 
-import java.util.List;
+import java.util.Collection;
 
 import static com.google.common.base.Preconditions.checkNotNull;
-import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.collect.Lists.asList;
+import static io.spine.client.CompositeFilter.CompositeOperator.ALL;
+import static io.spine.client.CompositeFilter.CompositeOperator.EITHER;
 
 /**
- * Filters events by composite criteria which can test both event messages and their contexts.
+ * A composite subscription filter which can aggregate both event message and event context
+ * filters.
  */
-final class CompositeEventFilter implements CompositeMessageFilter<Event> {
+public final class CompositeEventFilter extends TypedCompositeFilter<Event> {
 
-    /** The filter data as composed when creating a topic. */
-    private final CompositeFilter filter;
-    /** Filters adopted to filter events basing on the passed filter data. */
-    private final ImmutableList<MessageFilter<Event>> filters;
+    private static final long serialVersionUID = 0L;
 
-    CompositeEventFilter(CompositeFilter filter) {
-        this.filter = checkNotNull(filter);
-        this.filters =
-                filter.getFilterList()
-                      .stream()
-                      .map(EventFilter::new)
-                      .collect(toImmutableList());
-    }
-
-    @Override
-    public List<MessageFilter<Event>> filters() {
-        return filters;
+    private CompositeEventFilter(Collection<EventFilter> filters, CompositeOperator operator) {
+        super(filters, operator);
     }
 
-    @Override
-    public CompositeFilter.CompositeOperator operator() {
-        return filter.operator();
+    CompositeEventFilter(CompositeFilter filter) {
+        super(checkNotNull(filter), EventFilter::new);
     }
 
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
-        if (o == null || getClass() != o.getClass()) {
-            return false;
-        }
-        CompositeEventFilter other = (CompositeEventFilter) o;
-        return filter.equals(other.filter);
+    /**
+     * Creates a new conjunction composite filter.
+     *
+     * <p>A record is considered matching this filter if and only if it matches all of the passed
+     * filters.
+     */
+    public static CompositeEventFilter all(EventFilter first, EventFilter... rest) {
+        checkNotNull(first);
+        checkNotNull(rest);
+        return new CompositeEventFilter(asList(first, rest), ALL);
     }
 
-    @Override
-    public int hashCode() {
-        return filter.hashCode();
+    /**
+     * Creates a new disjunction composite filter.
+     *
+     * <p>A record is considered matching this filter if it matches at least one of the passed
+     * filters.
+     */
+    public static CompositeEventFilter either(EventFilter first, EventFilter... rest) {
+        checkNotNull(first);
+        checkNotNull(rest);
+        return new CompositeEventFilter(asList(first, rest), EITHER);
     }
 }

client/src/main/java/io/spine/client/CompositeQueryFilter.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2020, TeamDev. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.client;
+
+import io.spine.base.EntityState;
+import io.spine.client.CompositeFilter.CompositeOperator;
+
+import java.util.Collection;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.collect.Lists.asList;
+import static io.spine.client.CompositeFilter.CompositeOperator.ALL;
+import static io.spine.client.CompositeFilter.CompositeOperator.EITHER;
+
+/**
+ * A composite query filter which targets one or more entity
+ * {@link io.spine.base.EntityColumn columns}.
+ */
+public final class CompositeQueryFilter extends TypedCompositeFilter<EntityState> {
+
+    private static final long serialVersionUID = 0L;
+
+    private CompositeQueryFilter(Collection<QueryFilter> filters, CompositeOperator operator) {
+        super(filters, operator);
+    }
+
+    /**
+     * Creates a new conjunction composite filter.
+     *
+     * <p>A record is considered matching this filter if and only if it matches all of the
+     * passed filters.
+     */
+    public static CompositeQueryFilter all(QueryFilter first, QueryFilter... rest) {
+        checkNotNull(first);
+        checkNotNull(rest);
+        return new CompositeQueryFilter(asList(first, rest), ALL);
+    }
+
+    /**
+     * Creates a new disjunction composite filter.
+     *
+     * <p>A record is considered matching this filter if it matches at least one of the passed
+     * filters.
+     */
+    public static CompositeQueryFilter either(QueryFilter first, QueryFilter... rest) {
+        checkNotNull(first);
+        checkNotNull(rest);
+        return new CompositeQueryFilter(asList(first, rest), EITHER);
+    }
+}

client/src/main/java/io/spine/client/EntityStateFilter.java

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2020, TeamDev. All rights reserved.
+ *
+ * Redistribution and use in source and/or binary forms, with or without
+ * modification, must retain the above copyright notice and the following
+ * disclaimer.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package io.spine.client;
+
+import io.spine.base.EntityState;
+import io.spine.base.EntityStateField;
+import io.spine.client.Filter.Operator;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static io.spine.client.Filter.Operator.EQUAL;
+import static io.spine.client.Filter.Operator.GREATER_OR_EQUAL;
+import static io.spine.client.Filter.Operator.GREATER_THAN;
+import static io.spine.client.Filter.Operator.LESS_OR_EQUAL;
+import static io.spine.client.Filter.Operator.LESS_THAN;
+import static io.spine.client.Filters.checkSupportedOrderingComparisonType;
+import static io.spine.client.Filters.createFilter;
+
+/**
+ * A subscription filter which targets an {@link EntityState}.
+ */
+public final class EntityStateFilter extends TypedFilter<EntityState> {
+
+    private static final long serialVersionUID = 0L;
+
+    private EntityStateFilter(EntityStateField field, Object expected, Operator operator) {
+        super(createFilter(field.getField(), expected, operator));
+    }
+
+    /**
+     * Creates a new equality filter.
+     *
+     * @param field
+     *         the message field from which the actual value is taken
+     * @param value
+     *         the expected value
+     */
+    public static EntityStateFilter eq(EntityStateField field, Object value) {
+        checkNotNull(field);
+        checkNotNull(value);
+        return new EntityStateFilter(field, value, EQUAL);
+    }
+
+    /**
+     * Creates a new "greater than" filter.
+     *
+     * <p>NOTE: not all value types are supported for ordering comparison. See {@link Filters} for
+     * details.
+     *
+     * @param field
+     *         the message field from which the actual value is taken
+     * @param value
+     *         the expected value
+     */
+    public static EntityStateFilter gt(EntityStateField field, Object value) {
+        checkNotNull(field);
+        checkNotNull(value);
+        checkSupportedOrderingComparisonType(value.getClass());
+        return new EntityStateFilter(field, value, GREATER_THAN);
+    }
+
+    /**
+     * Creates a new "less than" filter.
+     *
+     * <p>NOTE: not all value types are supported for ordering comparison. See {@link Filters} for
+     * details.
+     *
+     * @param field
+     *         the message field from which the actual value is taken
+     * @param value
+     *         the expected value
+     */
+    public static EntityStateFilter lt(EntityStateField field, Object value) {
+        checkNotNull(field);
+        checkNotNull(value);
+        checkSupportedOrderingComparisonType(value.getClass());
+        return new EntityStateFilter(field, value, LESS_THAN);
+    }
+
+    /**
+     * Creates a new "greater than or equals" filter.
+     *
+     * <p>NOTE: not all value types are supported for ordering comparison. See {@link Filters} for
+     * details.
+     *
+     * @param field
+     *         the message field from which the actual value is taken
+     * @param value
+     *         the expected value
+     */
+    public static EntityStateFilter ge(EntityStateField field, Object value) {
+        checkNotNull(field);
+        checkNotNull(value);
+        checkSupportedOrderingComparisonType(value.getClass());
+        return new EntityStateFilter(field, value, GREATER_OR_EQUAL);
+    }
+
+    /**
+     * Creates a new "less than or equals" filter.
+     *
+     * <p>NOTE: not all value types are supported for ordering comparison. See {@link Filters} for
+     * details.
+     *
+     * @param field
+     *         the message field from which the actual value is taken
+     * @param value
+     *         the expected value
+     */
+    public static EntityStateFilter le(EntityStateField field, Object value) {
+        checkNotNull(field);
+        checkNotNull(value);
+        checkSupportedOrderingComparisonType(value.getClass());
+        return new EntityStateFilter(field, value, LESS_OR_EQUAL);
+    }
+}