Move Sort related helpers and events to correct packages (#13334)

Change-Id: I3aa86364b61d42f971c4fca2b4c4895ddae870c4

4 files changed, 261 insertions, 2 deletions

diff --git a/server/src/com/vaadin/data/sort/Sort.java b/server/src/com/vaadin/data/sort/Sort.java
new file mode 100644
index 0000000000..914a92f249
--- /dev/null
+++ b/server/src/com/vaadin/data/sort/Sort.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright 2000-2014 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.data.sort;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.vaadin.shared.ui.grid.SortDirection;
+
+/**
+ * Fluid Sort API. Provides a convenient, human-readable way of specifying
+ * multi-column sort order.
+ * 
+ * @since 7.4
+ * @author Vaadin Ltd
+ */
+public class Sort implements Serializable {
+
+    private final Sort previous;
+    private final SortOrder order;
+
+    /**
+     * Initial constructor, called by the static by() methods.
+     * 
+     * @param propertyId
+     *            a property ID, corresponding to a property in the data source
+     * @param direction
+     *            a sort direction value
+     */
+    private Sort(Object propertyId, SortDirection direction) {
+        previous = null;
+        order = new SortOrder(propertyId, direction);
+    }
+
+    /**
+     * Chaining constructor, called by the non-static then() methods. This
+     * constructor links to the previous Sort object.
+     * 
+     * @param previous
+     *            the sort marker that comes before this one
+     * @param propertyId
+     *            a property ID, corresponding to a property in the data source
+     * @param direction
+     *            a sort direction value
+     */
+    private Sort(Sort previous, Object propertyId, SortDirection direction) {
+        this.previous = previous;
+        order = new SortOrder(propertyId, direction);
+
+        Sort s = previous;
+        while (s != null) {
+            if (s.order.getPropertyId() == propertyId) {
+                throw new IllegalStateException(
+                        "Can not sort along the same property (" + propertyId
+                                + ") twice!");
+            }
+            s = s.previous;
+        }
+
+    }
+
+    /**
+     * Start building a Sort order by sorting a provided column in ascending
+     * order.
+     * 
+     * @param propertyId
+     *            a property id, corresponding to a data source property
+     * @return a sort object
+     */
+    public static Sort by(Object propertyId) {
+        return by(propertyId, SortDirection.ASCENDING);
+    }
+
+    /**
+     * Start building a Sort order by sorting a provided column.
+     * 
+     * @param propertyId
+     *            a property id, corresponding to a data source property
+     * @param direction
+     *            a sort direction value
+     * @return a sort object
+     */
+    public static Sort by(Object propertyId, SortDirection direction) {
+        return new Sort(propertyId, direction);
+    }
+
+    /**
+     * Continue building a Sort order. The provided property is sorted in
+     * ascending order if the previously added properties have been evaluated as
+     * equals.
+     * 
+     * @param propertyId
+     *            a property id, corresponding to a data source property
+     * @return a sort object
+     */
+    public Sort then(Object propertyId) {
+        return then(propertyId, SortDirection.ASCENDING);
+    }
+
+    /**
+     * Continue building a Sort order. The provided property is sorted in
+     * specified order if the previously added properties have been evaluated as
+     * equals.
+     * 
+     * @param propertyId
+     *            a property id, corresponding to a data source property
+     * @param direction
+     *            a sort direction value
+     * @return a sort object
+     */
+    public Sort then(Object propertyId, SortDirection direction) {
+        return new Sort(this, propertyId, direction);
+    }
+
+    /**
+     * Build a sort order list, ready to be passed to Grid
+     * 
+     * @return a sort order list.
+     */
+    public List<SortOrder> build() {
+
+        int count = 1;
+        Sort s = this;
+        while (s.previous != null) {
+            s = s.previous;
+            ++count;
+        }
+
+        List<SortOrder> order = new ArrayList<SortOrder>(count);
+
+        s = this;
+        do {
+            order.add(0, s.order);
+            s = s.previous;
+        } while (s != null);
+
+        return order;
+    }
+}
diff --git a/server/src/com/vaadin/data/sort/SortOrder.java b/server/src/com/vaadin/data/sort/SortOrder.java
new file mode 100644
index 0000000000..55cae8c51d
--- /dev/null
+++ b/server/src/com/vaadin/data/sort/SortOrder.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2000-2014 Vaadin Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.vaadin.data.sort;
+
+import java.io.Serializable;
+
+import com.vaadin.shared.ui.grid.SortDirection;
+
+/**
+ * Sort order descriptor. Links together a {@link SortDirection} value and a
+ * Vaadin container property ID.
+ * 
+ * @since 7.4
+ * @author Vaadin Ltd
+ */
+public class SortOrder implements Serializable {
+
+    private final Object propertyId;
+    private final SortDirection direction;
+
+    /**
+     * Create a SortOrder object. Both arguments must be non-null.
+     * 
+     * @param propertyId
+     *            id of the data source property to sort by
+     * @param direction
+     *            value indicating whether the property id should be sorted in
+     *            ascending or descending order
+     */
+    public SortOrder(Object propertyId, SortDirection direction) {
+        if (propertyId == null) {
+            throw new IllegalArgumentException("Property ID can not be null!");
+        }
+        if (direction == null) {
+            throw new IllegalArgumentException(
+                    "Direction value can not be null!");
+        }
+        this.propertyId = propertyId;
+        this.direction = direction;
+    }
+
+    /**
+     * Returns the property ID.
+     * 
+     * @return a property ID
+     */
+    public Object getPropertyId() {
+        return propertyId;
+    }
+
+    /**
+     * Returns the {@link SortDirection} value.
+     * 
+     * @return a sort direction value
+     */
+    public SortDirection getDirection() {
+        return direction;
+    }
+
+    @Override
+    public String toString() {
+        return propertyId + " " + direction;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + direction.hashCode();
+        result = prime * result + propertyId.hashCode();
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        } else if (obj == null) {
+            return false;
+        } else if (getClass() != obj.getClass()) {
+            return false;
+        }
+
+        SortOrder other = (SortOrder) obj;
+        if (direction != other.direction) {
+            return false;
+        } else if (!propertyId.equals(other.propertyId)) {
+            return false;
+        }
+        return true;
+    }
+
+}
diff --git a/server/src/com/vaadin/data/util/GeneratedPropertyContainer.java b/server/src/com/vaadin/data/util/GeneratedPropertyContainer.java
index 91498eaeb1..17472807b5 100644
--- a/server/src/com/vaadin/data/util/GeneratedPropertyContainer.java
+++ b/server/src/com/vaadin/data/util/GeneratedPropertyContainer.java
@@ -31,9 +31,9 @@ import com.google.gwt.thirdparty.guava.common.collect.Sets;
 import com.vaadin.data.Container;
 import com.vaadin.data.Item;
 import com.vaadin.data.Property;
+import com.vaadin.data.sort.SortOrder;
 import com.vaadin.data.util.filter.UnsupportedFilterException;
 import com.vaadin.shared.ui.grid.SortDirection;
-import com.vaadin.ui.components.grid.sort.SortOrder;
 
 /**
  * Container wrapper that adds support for generated properties. This container
diff --git a/server/src/com/vaadin/data/util/PropertyValueGenerator.java b/server/src/com/vaadin/data/util/PropertyValueGenerator.java
index 88169b785b..c535803ee1 100644
--- a/server/src/com/vaadin/data/util/PropertyValueGenerator.java
+++ b/server/src/com/vaadin/data/util/PropertyValueGenerator.java
@@ -20,8 +20,8 @@ import java.io.Serializable;
 import com.vaadin.data.Container.Filter;
 import com.vaadin.data.Item;
 import com.vaadin.data.Property;
+import com.vaadin.data.sort.SortOrder;
 import com.vaadin.data.util.filter.UnsupportedFilterException;
-import com.vaadin.ui.components.grid.sort.SortOrder;
 
 /**
  * PropertyValueGenerator for GeneratedPropertyContainer.