Move Container to compatibility package

Change-Id: I32bbf4891d6aca9dc9ee8f1b7ae733bc28b4cd30

19 files changed, 0 insertions, 3911 deletions

diff --git a/server/src/main/java/com/vaadin/event/DataBoundTransferable.java b/server/src/main/java/com/vaadin/event/DataBoundTransferable.java
deleted file mode 100644
index d4b4a5ba6b..0000000000
--- a/server/src/main/java/com/vaadin/event/DataBoundTransferable.java
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright 2000-2016 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.event;
-
-import java.util.Map;
-
-import com.vaadin.ui.Component;
-import com.vaadin.v7.data.Container;
-
-/**
- * Parent class for {@link Transferable} implementations that have a Vaadin
- * container as a data source. The transfer is associated with an item
- * (identified by its Id) and optionally also a property identifier (e.g. a
- * table column identifier when transferring a single table cell).
- *
- * The component must implement the interface
- * {@link com.vaadin.v7.data.Container.Viewer}.
- *
- * In most cases, receivers of data transfers should depend on this class
- * instead of its concrete subclasses.
- *
- * @since 6.3
- */
-public abstract class DataBoundTransferable extends TransferableImpl {
-
-    public DataBoundTransferable(Component sourceComponent,
-            Map<String, Object> rawVariables) {
-        super(sourceComponent, rawVariables);
-    }
-
-    /**
-     * Returns the identifier of the item being transferred.
-     *
-     * @return item identifier
-     */
-    public abstract Object getItemId();
-
-    /**
-     * Returns the optional property identifier that the transfer concerns.
-     *
-     * This can be e.g. the table column from which a drag operation originated.
-     *
-     * @return property identifier
-     */
-    public abstract Object getPropertyId();
-
-    /**
-     * Returns the container data source from which the transfer occurs.
-     *
-     * {@link com.vaadin.v7.data.Container.Viewer#getContainerDataSource()} is used
-     * to obtain the underlying container of the source component.
-     *
-     * @return Container
-     */
-    public Container getSourceContainer() {
-        Component sourceComponent = getSourceComponent();
-        if (sourceComponent instanceof Container.Viewer) {
-            return ((Container.Viewer) sourceComponent)
-                    .getContainerDataSource();
-        } else {
-            // this should not happen
-            return null;
-        }
-    }
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/Collapsible.java b/server/src/main/java/com/vaadin/v7/data/Collapsible.java
deleted file mode 100644
index a5d63c5a50..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/Collapsible.java
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data;
-
-import com.vaadin.v7.data.Container.Hierarchical;
-import com.vaadin.v7.data.Container.Ordered;
-
-/**
- * Container needed by large lazy loading hierarchies displayed e.g. in
- * TreeTable.
- * <p>
- * Container of this type gets notified when a subtree is opened/closed in a
- * component displaying its content. This allows container to lazy load subtrees
- * and release memory when a sub-tree is no longer displayed.
- * <p>
- * Methods from {@link Container.Ordered} (and from {@linkContainer.Indexed} if
- * implemented) are expected to work as in "preorder" of the currently visible
- * hierarchy. This means for example that the return value of size method
- * changes when subtree is collapsed/expanded. In other words items in collapsed
- * sub trees should be "ignored" by container when the container is accessed
- * with methods introduced in {@link Container.Ordered} or
- * {@linkContainer.Indexed}. From the accessors point of view, items in
- * collapsed subtrees don't exist.
- * <p>
- *
- */
-public interface Collapsible extends Hierarchical, Ordered {
-
-    /**
-     * <p>
-     * Collapsing the {@link Item} indicated by <code>itemId</code> hides all
-     * children, and their respective children, from the {@link Container}.
-     * </p>
-     *
-     * <p>
-     * If called on a leaf {@link Item}, this method does nothing.
-     * </p>
-     *
-     * @param itemId
-     *            the identifier of the collapsed {@link Item}
-     * @param collapsed
-     *            <code>true</code> if you want to collapse the children below
-     *            this {@link Item}. <code>false</code> if you want to
-     *            uncollapse the children.
-     */
-    public void setCollapsed(Object itemId, boolean collapsed);
-
-    /**
-     * <p>
-     * Checks whether the {@link Item}, identified by <code>itemId</code> is
-     * collapsed or not.
-     * </p>
-     *
-     * <p>
-     * If an {@link Item} is "collapsed" its children are not included in
-     * methods used to list Items in this container.
-     * </p>
-     *
-     * @param itemId
-     *            The {@link Item}'s identifier that is to be checked.
-     * @return <code>true</code> iff the {@link Item} identified by
-     *         <code>itemId</code> is currently collapsed, otherwise
-     *         <code>false</code>.
-     */
-    public boolean isCollapsed(Object itemId);
-
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/Container.java b/server/src/main/java/com/vaadin/v7/data/Container.java
deleted file mode 100644
index c280525dcd..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/Container.java
+++ /dev/null
@@ -1,1255 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data;
-
-import java.io.Serializable;
-import java.util.Collection;
-import java.util.List;
-
-import com.vaadin.v7.data.util.filter.SimpleStringFilter;
-import com.vaadin.v7.data.util.filter.UnsupportedFilterException;
-
-/**
- * <p>
- * A specialized set of identified Items. Basically the Container is a set of
- * {@link Item}s, but it imposes certain constraints on its contents. These
- * constraints state the following:
- * </p>
- *
- * <ul>
- * <li>All Items in the Container must have the same number of Properties.
- * <li>All Items in the Container must have the same Property ID's (see
- * {@link Item#getItemPropertyIds()}).
- * <li>All Properties in the Items corresponding to the same Property ID must
- * have the same data type.
- * <li>All Items within a container are uniquely identified by their non-null
- * IDs.
- * </ul>
- *
- * <p>
- * The Container can be visualized as a representation of a relational database
- * table. Each Item in the Container represents a row in the table, and all
- * cells in a column (identified by a Property ID) have the same data type. Note
- * that as with the cells in a database table, no Property in a Container may be
- * empty, though they may contain <code>null</code> values.
- * </p>
- *
- * <p>
- * Note that though uniquely identified, the Items in a Container are not
- * necessarily {@link Container.Ordered ordered} or {@link Container.Indexed
- * indexed}.
- * </p>
- *
- * <p>
- * Containers can derive Item ID's from the item properties or use other,
- * container specific or user specified identifiers.
- * </p>
- *
- * <p>
- * If a container is {@link Filterable filtered} or {@link Sortable sorted},
- * most of the the methods of the container interface and its subinterfaces
- * (container size, {@link #containsId(Object)}, iteration and indices etc.)
- * relate to the filtered and sorted view, not to the full container contents.
- * See individual method javadoc for exceptions to this (adding and removing
- * items).
- * </p>
- *
- * <p>
- * <img src=doc-files/Container_full.gif>
- * </p>
- *
- * <p>
- * The Container interface is split to several subinterfaces so that a class can
- * implement only the ones it needs.
- * </p>
- *
- * @author Vaadin Ltd
- * @since 3.0
- */
-public interface Container extends Serializable {
-
-    /**
-     * Gets the {@link Item} with the given Item ID from the Container. If the
-     * Container does not contain the requested Item, <code>null</code> is
-     * returned.
-     * <p>
-     * Containers should not return Items that are filtered out.
-     *
-     * @param itemId
-     *            ID of the {@link Item} to retrieve
-     * @return the {@link Item} with the given ID or <code>null</code> if the
-     *         Item is not found in the Container
-     */
-    public Item getItem(Object itemId);
-
-    /**
-     * Gets the ID's of all Properties stored in the Container. The ID's cannot
-     * be modified through the returned collection.
-     *
-     * @return unmodifiable collection of Property IDs
-     */
-    public Collection<?> getContainerPropertyIds();
-
-    /**
-     * Gets the ID's of all visible (after filtering and sorting) Items stored
-     * in the Container. The ID's cannot be modified through the returned
-     * collection.
-     * <p>
-     * If the container is {@link Ordered}, the collection returned by this
-     * method should follow that order. If the container is {@link Sortable},
-     * the items should be in the sorted order.
-     * <p>
-     * Calling this method for large lazy containers can be an expensive
-     * operation and should be avoided when practical.
-     *
-     * @return unmodifiable collection of Item IDs
-     */
-    public Collection<?> getItemIds();
-
-    /**
-     * Gets the Property identified by the given itemId and propertyId from the
-     * Container. If the Container does not contain the item or it is filtered
-     * out, or the Container does not have the Property, <code>null</code> is
-     * returned.
-     *
-     * @param itemId
-     *            ID of the visible Item which contains the Property
-     * @param propertyId
-     *            ID of the Property to retrieve
-     * @return Property with the given ID or <code>null</code>
-     */
-    public Property getContainerProperty(Object itemId, Object propertyId);
-
-    /**
-     * Gets the data type of all Properties identified by the given Property ID.
-     *
-     * @param propertyId
-     *            ID identifying the Properties
-     * @return data type of the Properties
-     */
-    public Class<?> getType(Object propertyId);
-
-    /**
-     * Gets the number of visible Items in the Container.
-     * <p>
-     * Filtering can hide items so that they will not be visible through the
-     * container API.
-     *
-     * @return number of Items in the Container
-     */
-    public int size();
-
-    /**
-     * Tests if the Container contains the specified Item.
-     * <p>
-     * Filtering can hide items so that they will not be visible through the
-     * container API, and this method should respect visibility of items (i.e.
-     * only indicate visible items as being in the container) if feasible for
-     * the container.
-     *
-     * @param itemId
-     *            ID the of Item to be tested
-     * @return boolean indicating if the Container holds the specified Item
-     */
-    public boolean containsId(Object itemId);
-
-    /**
-     * Creates a new Item with the given ID in the Container.
-     *
-     * <p>
-     * The new Item is returned, and it is ready to have its Properties
-     * modified. Returns <code>null</code> if the operation fails or the
-     * Container already contains a Item with the given ID.
-     * </p>
-     *
-     * <p>
-     * This functionality is optional.
-     * </p>
-     *
-     * @param itemId
-     *            ID of the Item to be created
-     * @return Created new Item, or <code>null</code> in case of a failure
-     * @throws UnsupportedOperationException
-     *             if adding an item with an explicit item ID is not supported
-     *             by the container
-     */
-    public Item addItem(Object itemId) throws UnsupportedOperationException;
-
-    /**
-     * Creates a new Item into the Container, and assign it an automatic ID.
-     *
-     * <p>
-     * The new ID is returned, or <code>null</code> if the operation fails.
-     * After a successful call you can use the {@link #getItem(Object ItemId)
-     * <code>getItem</code>}method to fetch the Item.
-     * </p>
-     *
-     * <p>
-     * This functionality is optional.
-     * </p>
-     *
-     * @return ID of the newly created Item, or <code>null</code> in case of a
-     *         failure
-     * @throws UnsupportedOperationException
-     *             if adding an item without an explicit item ID is not
-     *             supported by the container
-     */
-    public Object addItem() throws UnsupportedOperationException;
-
-    /**
-     * Removes the Item identified by <code>ItemId</code> from the Container.
-     *
-     * <p>
-     * Containers that support filtering should also allow removing an item that
-     * is currently filtered out.
-     * </p>
-     *
-     * <p>
-     * This functionality is optional.
-     * </p>
-     *
-     * @param itemId
-     *            ID of the Item to remove
-     * @return <code>true</code> if the operation succeeded, <code>false</code>
-     *         if not
-     * @throws UnsupportedOperationException
-     *             if the container does not support removing individual items
-     */
-    public boolean removeItem(Object itemId)
-            throws UnsupportedOperationException;
-
-    /**
-     * Adds a new Property to all Items in the Container. The Property ID, data
-     * type and default value of the new Property are given as parameters.
-     * <p>
-     * This functionality is optional.
-     *
-     * @param propertyId
-     *            ID of the Property
-     * @param type
-     *            Data type of the new Property
-     * @param defaultValue
-     *            The value all created Properties are initialized to
-     * @return <code>true</code> if the operation succeeded, <code>false</code>
-     *         if not
-     * @throws UnsupportedOperationException
-     *             if the container does not support explicitly adding container
-     *             properties
-     */
-    public boolean addContainerProperty(Object propertyId, Class<?> type,
-            Object defaultValue) throws UnsupportedOperationException;
-
-    /**
-     * Removes a Property specified by the given Property ID from the Container.
-     * Note that the Property will be removed from all Items in the Container.
-     * <p>
-     * This functionality is optional.
-     *
-     * @param propertyId
-     *            ID of the Property to remove
-     * @return <code>true</code> if the operation succeeded, <code>false</code>
-     *         if not
-     * @throws UnsupportedOperationException
-     *             if the container does not support removing container
-     *             properties
-     */
-    public boolean removeContainerProperty(Object propertyId)
-            throws UnsupportedOperationException;
-
-    /**
-     * Removes all Items from the Container.
-     *
-     * <p>
-     * Note that Property ID and type information is preserved. This
-     * functionality is optional.
-     * </p>
-     *
-     * @return <code>true</code> if the operation succeeded, <code>false</code>
-     *         if not
-     * @throws UnsupportedOperationException
-     *             if the container does not support removing all items
-     */
-    public boolean removeAllItems() throws UnsupportedOperationException;
-
-    /**
-     * Interface for Container classes whose {@link Item}s can be traversed in
-     * order.
-     *
-     * <p>
-     * If the container is filtered or sorted, the traversal applies to the
-     * filtered and sorted view.
-     * </p>
-     * <p>
-     * The <code>addItemAfter()</code> methods should apply filters to the added
-     * item after inserting it, possibly hiding it immediately. If the container
-     * is being sorted, they may add items at the correct sorted position
-     * instead of the given position. See also {@link Filterable} and
-     * {@link Sortable} for more information.
-     * </p>
-     */
-    public interface Ordered extends Container {
-
-        /**
-         * Gets the ID of the Item following the Item that corresponds to
-         * <code>itemId</code>. If the given Item is the last or not found in
-         * the Container, <code>null</code> is returned.
-         *
-         * @param itemId
-         *            ID of a visible Item in the Container
-         * @return ID of the next visible Item or <code>null</code>
-         */
-        public Object nextItemId(Object itemId);
-
-        /**
-         * Gets the ID of the Item preceding the Item that corresponds to
-         * <code>itemId</code>. If the given Item is the first or not found in
-         * the Container, <code>null</code> is returned.
-         *
-         * @param itemId
-         *            ID of a visible Item in the Container
-         * @return ID of the previous visible Item or <code>null</code>
-         */
-        public Object prevItemId(Object itemId);
-
-        /**
-         * Gets the ID of the first Item in the Container.
-         *
-         * @return ID of the first visible Item in the Container
-         */
-        public Object firstItemId();
-
-        /**
-         * Gets the ID of the last Item in the Container..
-         *
-         * @return ID of the last visible Item in the Container
-         */
-        public Object lastItemId();
-
-        /**
-         * Tests if the Item corresponding to the given Item ID is the first
-         * Item in the Container.
-         *
-         * @param itemId
-         *            ID of an Item in the Container
-         * @return <code>true</code> if the Item is first visible item in the
-         *         Container, <code>false</code> if not
-         */
-        public boolean isFirstId(Object itemId);
-
-        /**
-         * Tests if the Item corresponding to the given Item ID is the last Item
-         * in the Container.
-         *
-         * @return <code>true</code> if the Item is last visible item in the
-         *         Container, <code>false</code> if not
-         */
-        public boolean isLastId(Object itemId);
-
-        /**
-         * Adds a new item after the given item.
-         * <p>
-         * Adding an item after null item adds the item as first item of the
-         * ordered container.
-         * </p>
-         *
-         * @see Ordered Ordered: adding items in filtered or sorted containers
-         *
-         * @param previousItemId
-         *            Id of the visible item in ordered container after which to
-         *            insert the new item.
-         * @return item id the the created new item or null if the operation
-         *         fails.
-         * @throws UnsupportedOperationException
-         *             if the operation is not supported by the container
-         */
-        public Object addItemAfter(Object previousItemId)
-                throws UnsupportedOperationException;
-
-        /**
-         * Adds a new item after the given item.
-         * <p>
-         * Adding an item after null item adds the item as first item of the
-         * ordered container.
-         * </p>
-         *
-         * @see Ordered Ordered: adding items in filtered or sorted containers
-         *
-         * @param previousItemId
-         *            Id of the visible item in ordered container after which to
-         *            insert the new item.
-         * @param newItemId
-         *            Id of the new item to be added.
-         * @return new item or null if the operation fails.
-         * @throws UnsupportedOperationException
-         *             if the operation is not supported by the container
-         */
-        public Item addItemAfter(Object previousItemId, Object newItemId)
-                throws UnsupportedOperationException;
-
-    }
-
-    /**
-     * Interface for Container classes whose {@link Item}s can be sorted.
-     * <p>
-     * When an {@link Ordered} or {@link Indexed} container is sorted, all
-     * relevant operations of these interfaces should only use the filtered and
-     * sorted contents and the filtered indices to the container. Indices or
-     * item identifiers in the public API refer to the visible view unless
-     * otherwise stated. However, the <code>addItem*()</code> methods may add
-     * items that will be filtered out after addition or moved to another
-     * position based on sorting.
-     * </p>
-     * <p>
-     * How sorting is performed when a {@link Hierarchical} container implements
-     * {@link Sortable} is implementation specific and should be documented in
-     * the implementing class. However, the recommended approach is sorting the
-     * roots and the sets of children of each item separately.
-     * </p>
-     * <p>
-     * Depending on the container type, sorting a container may permanently
-     * change the internal order of items in the container.
-     * </p>
-     */
-    public interface Sortable extends Ordered {
-
-        /**
-         * Sorts the container items.
-         * <p>
-         * Sorting a container can irreversibly change the order of its items or
-         * only change the order temporarily, depending on the container.
-         *
-         * @param propertyId
-         *            Array of container property IDs, whose values are used to
-         *            sort the items in container as primary, secondary, ...
-         *            sorting criterion. All of the item IDs must be in the
-         *            collection returned by
-         *            {@link #getSortableContainerPropertyIds()}
-         * @param ascending
-         *            Array of sorting order flags corresponding to each
-         *            property ID used in sorting. If this array is shorter than
-         *            propertyId array, ascending order is assumed for items
-         *            where the order is not specified. Use <code>true</code> to
-         *            sort in ascending order, <code>false</code> to use
-         *            descending order.
-         */
-        void sort(Object[] propertyId, boolean[] ascending);
-
-        /**
-         * Gets the container property IDs which can be used to sort the items.
-         *
-         * @return the IDs of the properties that can be used for sorting the
-         *         container
-         */
-        Collection<?> getSortableContainerPropertyIds();
-
-    }
-
-    /**
-     * Interface for Container classes whose {@link Item}s can be accessed by
-     * their position in the container.
-     * <p>
-     * If the container is filtered or sorted, all indices refer to the filtered
-     * and sorted view. However, the <code>addItemAt()</code> methods may add
-     * items that will be filtered out after addition or moved to another
-     * position based on sorting.
-     * </p>
-     */
-    public interface Indexed extends Ordered {
-
-        /**
-         * Gets the index of the Item corresponding to the itemId. The following
-         * is <code>true</code> for the returned index: 0 <= index < size(), or
-         * index = -1 if there is no visible item with that id in the container.
-         *
-         * @param itemId
-         *            ID of an Item in the Container
-         * @return index of the Item, or -1 if (the filtered and sorted view of)
-         *         the Container does not include the Item
-         */
-        public int indexOfId(Object itemId);
-
-        /**
-         * Get the item id for the item at the position given by
-         * <code>index</code>.
-         * <p>
-         *
-         * @param index
-         *            the index of the requested item id
-         * @return the item id of the item at the given index
-         * @throws IndexOutOfBoundsException
-         *             if <code>index</code> is outside the range of the
-         *             container. (i.e.
-         *             <code>index &lt; 0 || container.size()-1 &lt; index</code>
-         *             )
-         */
-        public Object getIdByIndex(int index);
-
-        /**
-         * Get <code>numberOfItems</code> consecutive item ids from the
-         * container, starting with the item id at <code>startIndex</code>.
-         * <p>
-         * Implementations should return at most <code>numberOfItems</code> item
-         * ids, but can contain less if the container has less items than
-         * required to fulfill the request. The returned list must hence contain
-         * all of the item ids from the range:
-         * <p>
-         * <code>startIndex</code> to
-         * <code>max(startIndex + (numberOfItems-1), container.size()-1)</code>.
-         * <p>
-         * For quick migration to new API see:
-         * {@link ContainerHelpers#getItemIdsUsingGetIdByIndex(int, int, Indexed)}
-         *
-         * @param startIndex
-         *            the index for the first item which id to include
-         * @param numberOfItems
-         *            the number of consecutive item ids to get from the given
-         *            start index, must be >= 0
-         * @return List containing the requested item ids or empty list if
-         *         <code>numberOfItems</code> == 0; not null
-         *
-         * @throws IllegalArgumentException
-         *             if <code>numberOfItems</code> is < 0
-         * @throws IndexOutOfBoundsException
-         *             if <code>startIndex</code> is outside the range of the
-         *             container. (i.e.
-         *             <code>startIndex &lt; 0 || container.size()-1 &lt; startIndex</code>
-         *             )
-         *
-         * @since 7.0
-         */
-        public List<?> getItemIds(int startIndex, int numberOfItems);
-
-        /**
-         * Adds a new item at given index (in the filtered view).
-         * <p>
-         * The indices of the item currently in the given position and all the
-         * following items are incremented.
-         * </p>
-         * <p>
-         * This method should apply filters to the added item after inserting
-         * it, possibly hiding it immediately. If the container is being sorted,
-         * the item may be added at the correct sorted position instead of the
-         * given position. See {@link Indexed}, {@link Ordered},
-         * {@link Filterable} and {@link Sortable} for more information.
-         * </p>
-         *
-         * @param index
-         *            Index (in the filtered and sorted view) to add the new
-         *            item.
-         * @return item id of the created item or null if the operation fails.
-         * @throws UnsupportedOperationException
-         *             if the operation is not supported by the container
-         */
-        public Object addItemAt(int index) throws UnsupportedOperationException;
-
-        /**
-         * Adds a new item at given index (in the filtered view).
-         * <p>
-         * The indexes of the item currently in the given position and all the
-         * following items are incremented.
-         * </p>
-         * <p>
-         * This method should apply filters to the added item after inserting
-         * it, possibly hiding it immediately. If the container is being sorted,
-         * the item may be added at the correct sorted position instead of the
-         * given position. See {@link Indexed}, {@link Filterable} and
-         * {@link Sortable} for more information.
-         * </p>
-         *
-         * @param index
-         *            Index (in the filtered and sorted view) at which to add
-         *            the new item.
-         * @param newItemId
-         *            Id of the new item to be added.
-         * @return new {@link Item} or null if the operation fails.
-         * @throws UnsupportedOperationException
-         *             if the operation is not supported by the container
-         */
-        public Item addItemAt(int index, Object newItemId)
-                throws UnsupportedOperationException;
-
-        /**
-         * An <code>Event</code> object specifying information about the added
-         * items.
-         *
-         * @since 7.4
-         */
-        public interface ItemAddEvent extends ItemSetChangeEvent {
-
-            /**
-             * Gets the item id of the first added item.
-             *
-             * @return item id of the first added item
-             */
-            public Object getFirstItemId();
-
-            /**
-             * Gets the index of the first added item.
-             *
-             * @return index of the first added item
-             */
-            public int getFirstIndex();
-
-            /**
-             * Gets the number of the added items.
-             *
-             * @return the number of added items.
-             */
-            public int getAddedItemsCount();
-        }
-
-        /**
-         * An <code>Event</code> object specifying information about the removed
-         * items.
-         *
-         * @since 7.4
-         */
-        public interface ItemRemoveEvent extends ItemSetChangeEvent {
-            /**
-             * Gets the item id of the first removed item.
-             *
-             * @return item id of the first removed item
-             */
-            public Object getFirstItemId();
-
-            /**
-             * Gets the index of the first removed item.
-             *
-             * @return index of the first removed item
-             */
-            public int getFirstIndex();
-
-            /**
-             * Gets the number of the removed items.
-             *
-             * @return the number of removed items
-             */
-            public int getRemovedItemsCount();
-        }
-    }
-
-    /**
-     * <p>
-     * Interface for <code>Container</code> classes whose Items can be arranged
-     * hierarchically. This means that the Items in the container belong in a
-     * tree-like structure, with the following quirks:
-     * </p>
-     *
-     * <ul>
-     * <li>The Item structure may have more than one root elements
-     * <li>The Items in the hierarchy can be declared explicitly to be able or
-     * unable to have children.
-     * </ul>
-     */
-    public interface Hierarchical extends Container {
-
-        /**
-         * Gets the IDs of all Items that are children of the specified Item.
-         * The returned collection is unmodifiable.
-         *
-         * @param itemId
-         *            ID of the Item whose children the caller is interested in
-         * @return An unmodifiable {@link java.util.Collection collection}
-         *         containing the IDs of all other Items that are children in
-         *         the container hierarchy
-         */
-        public Collection<?> getChildren(Object itemId);
-
-        /**
-         * Gets the ID of the parent Item of the specified Item.
-         *
-         * @param itemId
-         *            ID of the Item whose parent the caller wishes to find out.
-         * @return the ID of the parent Item. Will be <code>null</code> if the
-         *         specified Item is a root element.
-         */
-        public Object getParent(Object itemId);
-
-        /**
-         * Gets the IDs of all Items in the container that don't have a parent.
-         * Such items are called <code>root</code> Items. The returned
-         * collection is unmodifiable.
-         *
-         * @return An unmodifiable {@link java.util.Collection collection}
-         *         containing IDs of all root elements of the container
-         */
-        public Collection<?> rootItemIds();
-
-        /**
-         * <p>
-         * Sets the parent of an Item. The new parent item must exist and be
-         * able to have children. (
-         * <code>{@link #areChildrenAllowed(Object)} == true</code> ). It is
-         * also possible to detach a node from the hierarchy (and thus make it
-         * root) by setting the parent <code>null</code>.
-         * </p>
-         *
-         * <p>
-         * This operation is optional.
-         * </p>
-         *
-         * @param itemId
-         *            ID of the item to be set as the child of the Item
-         *            identified with <code>newParentId</code>
-         * @param newParentId
-         *            ID of the Item that's to be the new parent of the Item
-         *            identified with <code>itemId</code>
-         * @return <code>true</code> if the operation succeeded,
-         *         <code>false</code> if not
-         */
-        public boolean setParent(Object itemId, Object newParentId)
-                throws UnsupportedOperationException;
-
-        /**
-         * Tests if the Item with given ID can have children.
-         *
-         * @param itemId
-         *            ID of the Item in the container whose child capability is
-         *            to be tested
-         * @return <code>true</code> if the specified Item exists in the
-         *         Container and it can have children, <code>false</code> if
-         *         it's not found from the container or it can't have children.
-         */
-        public boolean areChildrenAllowed(Object itemId);
-
-        /**
-         * <p>
-         * Sets the given Item's capability to have children. If the Item
-         * identified with <code>itemId</code> already has children and
-         * <code>{@link #areChildrenAllowed(Object)}</code> is false this method
-         * fails and <code>false</code> is returned.
-         * </p>
-         * <p>
-         * The children must be first explicitly removed with
-         * {@link #setParent(Object itemId, Object newParentId)}or
-         * {@link com.vaadin.v7.data.Container#removeItem(Object itemId)}.
-         * </p>
-         *
-         * <p>
-         * This operation is optional. If it is not implemented, the method
-         * always returns <code>false</code>.
-         * </p>
-         *
-         * @param itemId
-         *            ID of the Item in the container whose child capability is
-         *            to be set
-         * @param areChildrenAllowed
-         *            boolean value specifying if the Item can have children or
-         *            not
-         * @return <code>true</code> if the operation succeeded,
-         *         <code>false</code> if not
-         */
-        public boolean setChildrenAllowed(Object itemId,
-                boolean areChildrenAllowed)
-                throws UnsupportedOperationException;
-
-        /**
-         * Tests if the Item specified with <code>itemId</code> is a root Item.
-         * The hierarchical container can have more than one root and must have
-         * at least one unless it is empty. The
-         * {@link #getParent(Object itemId)} method always returns
-         * <code>null</code> for root Items.
-         *
-         * @param itemId
-         *            ID of the Item whose root status is to be tested
-         * @return <code>true</code> if the specified Item is a root,
-         *         <code>false</code> if not
-         */
-        public boolean isRoot(Object itemId);
-
-        /**
-         * <p>
-         * Tests if the Item specified with <code>itemId</code> has child Items
-         * or if it is a leaf. The {@link #getChildren(Object itemId)} method
-         * always returns <code>null</code> for leaf Items.
-         * </p>
-         *
-         * <p>
-         * Note that being a leaf does not imply whether or not an Item is
-         * allowed to have children.
-         * </p>
-         *
-         * @param itemId
-         *            ID of the Item to be tested
-         * @return <code>true</code> if the specified Item has children,
-         *         <code>false</code> if not (is a leaf)
-         */
-        public boolean hasChildren(Object itemId);
-
-        /**
-         * <p>
-         * Removes the Item identified by <code>ItemId</code> from the
-         * Container.
-         * </p>
-         *
-         * <p>
-         * Note that this does not remove any children the item might have.
-         * </p>
-         *
-         * @param itemId
-         *            ID of the Item to remove
-         * @return <code>true</code> if the operation succeeded,
-         *         <code>false</code> if not
-         */
-        @Override
-        public boolean removeItem(Object itemId)
-                throws UnsupportedOperationException;
-    }
-
-    /**
-     * Interface that is implemented by containers which allow reducing their
-     * visible contents based on a set of filters. This interface has been
-     * renamed from {@link Filterable}, and implementing the new
-     * {@link Filterable} instead of or in addition to {@link SimpleFilterable}
-     * is recommended. This interface might be removed in future Vaadin
-     * versions.
-     * <p>
-     * When a set of filters are set, only items that match all the filters are
-     * included in the visible contents of the container. Still new items that
-     * do not match filters can be added to the container. Multiple filters can
-     * be added and the container remembers the state of the filters. When
-     * multiple filters are added, all filters must match for an item to be
-     * visible in the container.
-     * </p>
-     * <p>
-     * When an {@link Ordered} or {@link Indexed} container is filtered, all
-     * operations of these interfaces should only use the filtered contents and
-     * the filtered indices to the container.
-     * </p>
-     * <p>
-     * How filtering is performed when a {@link Hierarchical} container
-     * implements {@link SimpleFilterable} is implementation specific and should
-     * be documented in the implementing class.
-     * </p>
-     * <p>
-     * Adding items (if supported) to a filtered {@link Ordered} or
-     * {@link Indexed} container should insert them immediately after the
-     * indicated visible item. The unfiltered position of items added at index
-     * 0, at index {@link com.vaadin.v7.data.Container#size()} or at an undefined
-     * position is up to the implementation.
-     * </p>
-     * <p>
-     * The functionality of SimpleFilterable can be implemented using the
-     * {@link Filterable} API and {@link SimpleStringFilter}.
-     * </p>
-     *
-     * @since 5.0 (renamed from Filterable to SimpleFilterable in 6.6)
-     */
-    public interface SimpleFilterable extends Container, Serializable {
-
-        /**
-         * Add a filter for given property.
-         * <p>
-         * The API {@link Filterable#addContainerFilter(Filter)} is recommended
-         * instead of this method. A {@link SimpleStringFilter} can be used with
-         * the new API to implement the old string filtering functionality.
-         * <p>
-         * The filter accepts items for which toString() of the value of the
-         * given property contains or starts with given filterString. Other
-         * items are not visible in the container when filtered.
-         * <p>
-         * If a container has multiple filters, only items accepted by all
-         * filters are visible.
-         *
-         * @param propertyId
-         *            Property for which the filter is applied to.
-         * @param filterString
-         *            String that must match the value of the property
-         * @param ignoreCase
-         *            Determine if the casing can be ignored when comparing
-         *            strings.
-         * @param onlyMatchPrefix
-         *            Only match prefixes; no other matches are included.
-         */
-        public void addContainerFilter(Object propertyId, String filterString,
-                boolean ignoreCase, boolean onlyMatchPrefix);
-
-        /**
-         * Remove all filters from all properties.
-         */
-        public void removeAllContainerFilters();
-
-        /**
-         * Remove all filters from the given property.
-         *
-         * @param propertyId
-         *            for which to remove filters
-         */
-        public void removeContainerFilters(Object propertyId);
-    }
-
-    /**
-     * Filter interface for container filtering.
-     * <p>
-     * If a filter does not support in-memory filtering,
-     * {@link #passesFilter(Item)} should throw
-     * {@link UnsupportedOperationException}.
-     * <p>
-     * Lazy containers must be able to map filters to their internal
-     * representation (e.g. SQL or JPA 2.0 Criteria).
-     * <p>
-     * An {@link UnsupportedFilterException} can be thrown by the container if a
-     * particular filter is not supported by the container.
-     * <p>
-     * An {@link Filter} should implement {@link #equals(Object)} and
-     * {@link #hashCode()} correctly to avoid duplicate filter registrations
-     * etc.
-     *
-     * @see Filterable
-     *
-     * @since 6.6
-     */
-    public interface Filter extends Serializable {
-
-        /**
-         * Check if an item passes the filter (in-memory filtering).
-         *
-         * @param itemId
-         *            identifier of the item being filtered; may be null when
-         *            the item is being added to the container
-         * @param item
-         *            the item being filtered
-         * @return true if the item is accepted by this filter
-         * @throws UnsupportedOperationException
-         *             if the filter cannot be used for in-memory filtering
-         */
-        public boolean passesFilter(Object itemId, Item item)
-                throws UnsupportedOperationException;
-
-        /**
-         * Check if a change in the value of a property can affect the filtering
-         * result. May always return true, at the cost of performance.
-         *
-         * If the filter cannot determine whether it may depend on the property
-         * or not, should return true.
-         *
-         * @param propertyId
-         * @return true if the filtering result may/does change based on changes
-         *         to the property identified by propertyId
-         */
-        public boolean appliesToProperty(Object propertyId);
-
-    }
-
-    /**
-     * Interface that is implemented by containers which allow reducing their
-     * visible contents based on a set of filters.
-     * <p>
-     * When a set of filters are set, only items that match all the filters are
-     * included in the visible contents of the container. Still new items that
-     * do not match filters can be added to the container. Multiple filters can
-     * be added and the container remembers the state of the filters. When
-     * multiple filters are added, all filters must match for an item to be
-     * visible in the container.
-     * </p>
-     * <p>
-     * When an {@link Ordered} or {@link Indexed} container is filtered, all
-     * operations of these interfaces should only use the filtered and sorted
-     * contents and the filtered indices to the container. Indices or item
-     * identifiers in the public API refer to the visible view unless otherwise
-     * stated. However, the <code>addItem*()</code> methods may add items that
-     * will be filtered out after addition or moved to another position based on
-     * sorting.
-     * </p>
-     * <p>
-     * How filtering is performed when a {@link Hierarchical} container
-     * implements {@link Filterable} is implementation specific and should be
-     * documented in the implementing class.
-     * </p>
-     * <p>
-     * Adding items (if supported) to a filtered {@link Ordered} or
-     * {@link Indexed} container should insert them immediately after the
-     * indicated visible item. However, the unfiltered position of items added
-     * at index 0, at index {@link com.vaadin.v7.data.Container#size()} or at an
-     * undefined position is up to the implementation.
-     * </p>
-     *
-     * <p>
-     * This API replaces the old Filterable interface, renamed to
-     * {@link SimpleFilterable} in Vaadin 6.6.
-     * </p>
-     *
-     * @since 6.6
-     */
-    public interface Filterable extends Container, Serializable {
-        /**
-         * Adds a filter for the container.
-         * <p>
-         * If a container has multiple filters, only items accepted by all
-         * filters are visible.
-         *
-         * @throws UnsupportedFilterException
-         *             if the filter is not supported by the container
-         */
-        public void addContainerFilter(Filter filter)
-                throws UnsupportedFilterException;
-
-        /**
-         * Removes a filter from the container.
-         * <p>
-         * This requires that the equals() method considers the filters as
-         * equivalent (same instance or properly implemented equals() method).
-         */
-        public void removeContainerFilter(Filter filter);
-
-        /**
-         * Remove all active filters from the container.
-         */
-        public void removeAllContainerFilters();
-
-        /**
-         * Returns the filters which have been applied to the container
-         *
-         * @return A collection of filters which have been applied to the
-         *         container. An empty collection if no filters have been
-         *         applied.
-         * @since 7.1
-         */
-        public Collection<Filter> getContainerFilters();
-    }
-
-    /**
-     * Interface implemented by viewer classes capable of using a Container as a
-     * data source.
-     */
-    public interface Viewer extends Serializable {
-
-        /**
-         * Sets the Container that serves as the data source of the viewer.
-         *
-         * @param newDataSource
-         *            The new data source Item
-         */
-        public void setContainerDataSource(Container newDataSource);
-
-        /**
-         * Gets the Container serving as the data source of the viewer.
-         *
-         * @return data source Container
-         */
-        public Container getContainerDataSource();
-
-    }
-
-    /**
-     * <p>
-     * Interface implemented by the editor classes supporting editing the
-     * Container. Implementing this interface means that the Container serving
-     * as the data source of the editor can be modified through it.
-     * </p>
-     * <p>
-     * Note that not implementing the <code>Container.Editor</code> interface
-     * does not restrict the class from editing the Container contents
-     * internally.
-     * </p>
-     */
-    public interface Editor extends Container.Viewer, Serializable {
-
-    }
-
-    /* Contents change event */
-
-    /**
-     * An <code>Event</code> object specifying the Container whose Item set has
-     * changed (items added, removed or reordered).
-     *
-     * A simple property value change is not an item set change.
-     */
-    public interface ItemSetChangeEvent extends Serializable {
-
-        /**
-         * Gets the Property where the event occurred.
-         *
-         * @return source of the event
-         */
-        public Container getContainer();
-    }
-
-    /**
-     * Container Item set change listener interface.
-     * <p>
-     * An item set change refers to addition, removal or reordering of items in
-     * the container. A simple property value change is not an item set change.
-     */
-    public interface ItemSetChangeListener extends Serializable {
-
-        /**
-         * Lets the listener know a Containers visible (filtered and/or sorted,
-         * if applicable) Item set has changed.
-         *
-         * @param event
-         *            change event text
-         */
-        public void containerItemSetChange(Container.ItemSetChangeEvent event);
-    }
-
-    /**
-     * The interface for adding and removing <code>ItemSetChangeEvent</code>
-     * listeners. By implementing this interface a class explicitly announces
-     * that it will generate a <code>ItemSetChangeEvent</code> when its contents
-     * are modified.
-     * <p>
-     * An item set change refers to addition, removal or reordering of items in
-     * the container. A simple property value change is not an item set change.
-     *
-     * <p>
-     * Note: The general Java convention is not to explicitly declare that a
-     * class generates events, but to directly define the
-     * <code>addListener</code> and <code>removeListener</code> methods. That
-     * way the caller of these methods has no real way of finding out if the
-     * class really will send the events, or if it just defines the methods to
-     * be able to implement an interface.
-     * </p>
-     */
-    public interface ItemSetChangeNotifier extends Serializable {
-
-        /**
-         * Adds an Item set change listener for the object.
-         *
-         * @param listener
-         *            listener to be added
-         */
-        public void addItemSetChangeListener(
-                Container.ItemSetChangeListener listener);
-
-        /**
-         * @deprecated As of 7.0, replaced by
-         *             {@link #addItemSetChangeListener(ItemSetChangeListener)}
-         **/
-        @Deprecated
-        public void addListener(Container.ItemSetChangeListener listener);
-
-        /**
-         * Removes the Item set change listener from the object.
-         *
-         * @param listener
-         *            listener to be removed
-         */
-        public void removeItemSetChangeListener(
-                Container.ItemSetChangeListener listener);
-
-        /**
-         * @deprecated As of 7.0, replaced by
-         *             {@link #removeItemSetChangeListener(ItemSetChangeListener)}
-         **/
-        @Deprecated
-        public void removeListener(Container.ItemSetChangeListener listener);
-    }
-
-    /* Property set change event */
-
-    /**
-     * An <code>Event</code> object specifying the Container whose Property set
-     * has changed.
-     * <p>
-     * A property set change means the addition, removal or other structural
-     * changes to the properties of a container. Changes concerning the set of
-     * items in the container and their property values are not property set
-     * changes.
-     */
-    public interface PropertySetChangeEvent extends Serializable {
-
-        /**
-         * Retrieves the Container whose contents have been modified.
-         *
-         * @return Source Container of the event.
-         */
-        public Container getContainer();
-    }
-
-    /**
-     * The listener interface for receiving <code>PropertySetChangeEvent</code>
-     * objects.
-     * <p>
-     * A property set change means the addition, removal or other structural
-     * change of the properties (supported property IDs) of a container. Changes
-     * concerning the set of items in the container and their property values
-     * are not property set changes.
-     */
-    public interface PropertySetChangeListener extends Serializable {
-
-        /**
-         * Notifies this listener that the set of property IDs supported by the
-         * Container has changed.
-         *
-         * @param event
-         *            Change event.
-         */
-        public void containerPropertySetChange(
-                Container.PropertySetChangeEvent event);
-    }
-
-    /**
-     * <p>
-     * The interface for adding and removing <code>PropertySetChangeEvent</code>
-     * listeners. By implementing this interface a class explicitly announces
-     * that it will generate a <code>PropertySetChangeEvent</code> when the set
-     * of property IDs supported by the container is modified.
-     * </p>
-     *
-     * <p>
-     * A property set change means the addition, removal or other structural
-     * changes to the properties of a container. Changes concerning the set of
-     * items in the container and their property values are not property set
-     * changes.
-     * </p>
-     *
-     * <p>
-     * Note that the general Java convention is not to explicitly declare that a
-     * class generates events, but to directly define the
-     * <code>addListener</code> and <code>removeListener</code> methods. That
-     * way the caller of these methods has no real way of finding out if the
-     * class really will send the events, or if it just defines the methods to
-     * be able to implement an interface.
-     * </p>
-     */
-    public interface PropertySetChangeNotifier extends Serializable {
-
-        /**
-         * Registers a new Property set change listener for this Container.
-         *
-         * @param listener
-         *            The new Listener to be registered
-         */
-        public void addPropertySetChangeListener(
-                Container.PropertySetChangeListener listener);
-
-        /**
-         * @deprecated As of 7.0, replaced by
-         *             {@link #addPropertySetChangeListener(PropertySetChangeListener)}
-         **/
-        @Deprecated
-        public void addListener(Container.PropertySetChangeListener listener);
-
-        /**
-         * Removes a previously registered Property set change listener.
-         *
-         * @param listener
-         *            Listener to be removed
-         */
-        public void removePropertySetChangeListener(
-                Container.PropertySetChangeListener listener);
-
-        /**
-         * @deprecated As of 7.0, replaced by
-         *             {@link #removePropertySetChangeListener(PropertySetChangeListener)}
-         **/
-        @Deprecated
-        public void removeListener(
-                Container.PropertySetChangeListener listener);
-    }
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/ContainerHelpers.java b/server/src/main/java/com/vaadin/v7/data/ContainerHelpers.java
deleted file mode 100644
index c782f33133..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/ContainerHelpers.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import com.vaadin.v7.data.Container.Indexed;
-
-/**
- * Contains helper methods for containers that can be used to ease development
- * of containers in Vaadin.
- *
- * @since 7.0
- */
-public class ContainerHelpers implements Serializable {
-
-    /**
-     * Get a range of item ids from the container using
-     * {@link Indexed#getIdByIndex(int)}. This is just a helper method to aid
-     * developers to quickly add the required functionality to a Container
-     * during development. This should not be used in a "finished product"
-     * unless fetching an id for an index is very inexpensive because a separate
-     * request will be performed for each index in the range.
-     *
-     * @param startIndex
-     *            index of the first item id to get
-     * @param numberOfIds
-     *            the number of consecutive items whose ids should be returned
-     * @param container
-     *            the container from which the items should be fetched
-     * @return A list of item ids in the range specified
-     */
-    public static List<?> getItemIdsUsingGetIdByIndex(int startIndex,
-            int numberOfIds, Container.Indexed container) {
-
-        if (container == null) {
-            throw new IllegalArgumentException(
-                    "The given container cannot be null!");
-        }
-
-        if (startIndex < 0) {
-            throw new IndexOutOfBoundsException(
-                    "Start index cannot be negative! startIndex=" + startIndex);
-        }
-
-        if (startIndex > container.size()) {
-            throw new IndexOutOfBoundsException(
-                    "Start index exceeds container size! startIndex="
-                            + startIndex + " containerLastItemIndex="
-                            + (container.size() - 1));
-        }
-
-        if (numberOfIds < 1) {
-            if (numberOfIds == 0) {
-                return Collections.emptyList();
-            }
-
-            throw new IllegalArgumentException(
-                    "Cannot get negative amount of items! numberOfItems="
-                            + numberOfIds);
-        }
-
-        // not included in the range
-        int endIndex = startIndex + numberOfIds;
-
-        if (endIndex > container.size()) {
-            endIndex = container.size();
-        }
-
-        ArrayList<Object> rangeOfIds = new ArrayList<Object>();
-        for (int i = startIndex; i < endIndex; i++) {
-            Object idByIndex = container.getIdByIndex(i);
-            if (idByIndex == null) {
-                throw new RuntimeException(
-                        "Unable to get item id for index: " + i
-                                + " from container using Container.Indexed#getIdByIndex() "
-                                + "even though container.size() > endIndex. "
-                                + "Returned item id was null. "
-                                + "Check your container implementation!");
-            }
-            rangeOfIds.add(idByIndex);
-        }
-
-        return Collections.unmodifiableList(rangeOfIds);
-    }
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/ContainerOrderedWrapper.java b/server/src/main/java/com/vaadin/v7/data/util/ContainerOrderedWrapper.java
deleted file mode 100644
index 9ac8038f03..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/ContainerOrderedWrapper.java
+++ /dev/null
@@ -1,728 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Hashtable;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-
-import com.vaadin.v7.data.Container;
-import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Property;
-
-/**
- * <p>
- * A wrapper class for adding external ordering to containers not implementing
- * the {@link com.vaadin.v7.data.Container.Ordered} interface.
- * </p>
- *
- * <p>
- * If the wrapped container is changed directly (that is, not through the
- * wrapper), and does not implement Container.ItemSetChangeNotifier and/or
- * Container.PropertySetChangeNotifier the hierarchy information must be updated
- * with the {@link #updateOrderWrapper()} method.
- * </p>
- *
- * @author Vaadin Ltd.
- * @since 3.0
- */
-@SuppressWarnings("serial")
-public class ContainerOrderedWrapper implements Container.Ordered,
-        Container.ItemSetChangeNotifier, Container.PropertySetChangeNotifier {
-
-    /**
-     * The wrapped container
-     */
-    private final Container container;
-
-    /**
-     * Ordering information, ie. the mapping from Item ID to the next item ID.
-     * The last item id should not be present
-     */
-    private Hashtable<Object, Object> next;
-
-    /**
-     * Reverse ordering information for convenience and performance reasons. The
-     * first item id should not be present
-     */
-    private Hashtable<Object, Object> prev;
-
-    /**
-     * ID of the first Item in the container.
-     */
-    private Object first;
-
-    /**
-     * ID of the last Item in the container.
-     */
-    private Object last;
-
-    /**
-     * Is the wrapped container ordered by itself, ie. does it implement the
-     * Container.Ordered interface by itself? If it does, this class will use
-     * the methods of the underlying container directly.
-     */
-    private boolean ordered = false;
-
-    /**
-     * The last known size of the wrapped container. Used to check whether items
-     * have been added or removed to the wrapped container, when the wrapped
-     * container does not send ItemSetChangeEvents.
-     */
-    private int lastKnownSize = -1;
-
-    /**
-     * Constructs a new ordered wrapper for an existing Container. Works even if
-     * the to-be-wrapped container already implements the Container.Ordered
-     * interface.
-     *
-     * @param toBeWrapped
-     *            the container whose contents need to be ordered.
-     */
-    public ContainerOrderedWrapper(Container toBeWrapped) {
-
-        container = toBeWrapped;
-        ordered = container instanceof Container.Ordered;
-
-        // Checks arguments
-        if (container == null) {
-            throw new NullPointerException("Null can not be wrapped");
-        }
-
-        // Creates initial order if needed
-        updateOrderWrapper();
-    }
-
-    /**
-     * Removes the specified Item from the wrapper's internal hierarchy
-     * structure.
-     * <p>
-     * Note : The Item is not removed from the underlying Container.
-     * </p>
-     *
-     * @param id
-     *            the ID of the Item to be removed from the ordering.
-     */
-    private void removeFromOrderWrapper(Object id) {
-        if (id != null) {
-            final Object pid = prev.get(id);
-            final Object nid = next.get(id);
-            if (first.equals(id)) {
-                first = nid;
-            }
-            if (last.equals(id)) {
-                last = pid;
-            }
-            if (nid != null) {
-                if (pid == null) {
-                    prev.remove(nid);
-                } else {
-                    prev.put(nid, pid);
-                }
-            }
-            if (pid != null) {
-                if (nid == null) {
-                    next.remove(pid);
-                } else {
-                    next.put(pid, nid);
-                }
-            }
-            next.remove(id);
-            prev.remove(id);
-        }
-    }
-
-    /**
-     * Registers the specified Item to the last position in the wrapper's
-     * internal ordering. The underlying container is not modified.
-     *
-     * @param id
-     *            the ID of the Item to be added to the ordering.
-     */
-    private void addToOrderWrapper(Object id) {
-
-        // Adds the if to tail
-        if (last != null) {
-            next.put(last, id);
-            prev.put(id, last);
-            last = id;
-        } else {
-            first = last = id;
-        }
-    }
-
-    /**
-     * Registers the specified Item after the specified itemId in the wrapper's
-     * internal ordering. The underlying container is not modified. Given item
-     * id must be in the container, or must be null.
-     *
-     * @param id
-     *            the ID of the Item to be added to the ordering.
-     * @param previousItemId
-     *            the Id of the previous item.
-     */
-    private void addToOrderWrapper(Object id, Object previousItemId) {
-
-        if (last == previousItemId || last == null) {
-            addToOrderWrapper(id);
-        } else {
-            if (previousItemId == null) {
-                next.put(id, first);
-                prev.put(first, id);
-                first = id;
-            } else {
-                prev.put(id, previousItemId);
-                next.put(id, next.get(previousItemId));
-                prev.put(next.get(previousItemId), id);
-                next.put(previousItemId, id);
-            }
-        }
-    }
-
-    /**
-     * Updates the wrapper's internal ordering information to include all Items
-     * in the underlying container.
-     * <p>
-     * Note : If the contents of the wrapped container change without the
-     * wrapper's knowledge, this method needs to be called to update the
-     * ordering information of the Items.
-     * </p>
-     */
-    public void updateOrderWrapper() {
-
-        if (!ordered) {
-
-            final Collection<?> ids = container.getItemIds();
-
-            // Recreates ordering if some parts of it are missing
-            if (next == null || first == null || last == null || prev == null) {
-                first = null;
-                last = null;
-                next = new Hashtable<Object, Object>();
-                prev = new Hashtable<Object, Object>();
-            }
-
-            // Filter out all the missing items
-            final LinkedList<?> l = new LinkedList<Object>(next.keySet());
-            for (final Iterator<?> i = l.iterator(); i.hasNext();) {
-                final Object id = i.next();
-                if (!container.containsId(id)) {
-                    removeFromOrderWrapper(id);
-                }
-            }
-
-            // Adds missing items
-            for (final Iterator<?> i = ids.iterator(); i.hasNext();) {
-                final Object id = i.next();
-                if (!next.containsKey(id) && last != id) {
-                    addToOrderWrapper(id);
-                }
-            }
-        }
-    }
-
-    /*
-     * Gets the first item stored in the ordered container Don't add a JavaDoc
-     * comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public Object firstItemId() {
-        if (ordered) {
-            return ((Container.Ordered) container).firstItemId();
-        }
-        return first;
-    }
-
-    /*
-     * Tests if the given item is the first item in the container Don't add a
-     * JavaDoc comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public boolean isFirstId(Object itemId) {
-        if (ordered) {
-            return ((Container.Ordered) container).isFirstId(itemId);
-        }
-        return first != null && first.equals(itemId);
-    }
-
-    /*
-     * Tests if the given item is the last item in the container Don't add a
-     * JavaDoc comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public boolean isLastId(Object itemId) {
-        if (ordered) {
-            return ((Container.Ordered) container).isLastId(itemId);
-        }
-        return last != null && last.equals(itemId);
-    }
-
-    /*
-     * Gets the last item stored in the ordered container Don't add a JavaDoc
-     * comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public Object lastItemId() {
-        if (ordered) {
-            return ((Container.Ordered) container).lastItemId();
-        }
-        return last;
-    }
-
-    /*
-     * Gets the item that is next from the specified item. Don't add a JavaDoc
-     * comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public Object nextItemId(Object itemId) {
-        if (ordered) {
-            return ((Container.Ordered) container).nextItemId(itemId);
-        }
-        if (itemId == null) {
-            return null;
-        }
-        return next.get(itemId);
-    }
-
-    /*
-     * Gets the item that is previous from the specified item. Don't add a
-     * JavaDoc comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public Object prevItemId(Object itemId) {
-        if (ordered) {
-            return ((Container.Ordered) container).prevItemId(itemId);
-        }
-        if (itemId == null) {
-            return null;
-        }
-        return prev.get(itemId);
-    }
-
-    /**
-     * Registers a new Property to all Items in the Container.
-     *
-     * @param propertyId
-     *            the ID of the new Property.
-     * @param type
-     *            the Data type of the new Property.
-     * @param defaultValue
-     *            the value all created Properties are initialized to.
-     * @return <code>true</code> if the operation succeeded, <code>false</code>
-     *         if not
-     */
-    @Override
-    public boolean addContainerProperty(Object propertyId, Class<?> type,
-            Object defaultValue) throws UnsupportedOperationException {
-
-        return container.addContainerProperty(propertyId, type, defaultValue);
-    }
-
-    /**
-     * Creates a new Item into the Container, assigns it an automatic ID, and
-     * adds it to the ordering.
-     *
-     * @return the autogenerated ID of the new Item or <code>null</code> if the
-     *         operation failed
-     * @throws UnsupportedOperationException
-     *             if the addItem is not supported.
-     */
-    @Override
-    public Object addItem() throws UnsupportedOperationException {
-
-        final Object id = container.addItem();
-        if (!ordered && id != null) {
-            addToOrderWrapper(id);
-        }
-        return id;
-    }
-
-    /**
-     * Registers a new Item by its ID to the underlying container and to the
-     * ordering.
-     *
-     * @param itemId
-     *            the ID of the Item to be created.
-     * @return the added Item or <code>null</code> if the operation failed
-     * @throws UnsupportedOperationException
-     *             if the addItem is not supported.
-     */
-    @Override
-    public Item addItem(Object itemId) throws UnsupportedOperationException {
-        final Item item = container.addItem(itemId);
-        if (!ordered && item != null) {
-            addToOrderWrapper(itemId);
-        }
-        return item;
-    }
-
-    /**
-     * Removes all items from the underlying container and from the ordering.
-     *
-     * @return <code>true</code> if the operation succeeded, otherwise
-     *         <code>false</code>
-     * @throws UnsupportedOperationException
-     *             if the removeAllItems is not supported.
-     */
-    @Override
-    public boolean removeAllItems() throws UnsupportedOperationException {
-        final boolean success = container.removeAllItems();
-        if (!ordered && success) {
-            first = last = null;
-            next.clear();
-            prev.clear();
-        }
-        return success;
-    }
-
-    /**
-     * Removes an Item specified by the itemId from the underlying container and
-     * from the ordering.
-     *
-     * @param itemId
-     *            the ID of the Item to be removed.
-     * @return <code>true</code> if the operation succeeded, <code>false</code>
-     *         if not
-     * @throws UnsupportedOperationException
-     *             if the removeItem is not supported.
-     */
-    @Override
-    public boolean removeItem(Object itemId)
-            throws UnsupportedOperationException {
-
-        final boolean success = container.removeItem(itemId);
-        if (!ordered && success) {
-            removeFromOrderWrapper(itemId);
-        }
-        return success;
-    }
-
-    /**
-     * Removes the specified Property from the underlying container and from the
-     * ordering.
-     * <p>
-     * Note : The Property will be removed from all the Items in the Container.
-     * </p>
-     *
-     * @param propertyId
-     *            the ID of the Property to remove.
-     * @return <code>true</code> if the operation succeeded, <code>false</code>
-     *         if not
-     * @throws UnsupportedOperationException
-     *             if the removeContainerProperty is not supported.
-     */
-    @Override
-    public boolean removeContainerProperty(Object propertyId)
-            throws UnsupportedOperationException {
-        return container.removeContainerProperty(propertyId);
-    }
-
-    /*
-     * Does the container contain the specified Item? Don't add a JavaDoc
-     * comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public boolean containsId(Object itemId) {
-        return container.containsId(itemId);
-    }
-
-    /*
-     * Gets the specified Item from the container. Don't add a JavaDoc comment
-     * here, we use the default documentation from implemented interface.
-     */
-    @Override
-    public Item getItem(Object itemId) {
-        return container.getItem(itemId);
-    }
-
-    /*
-     * Gets the ID's of all Items stored in the Container Don't add a JavaDoc
-     * comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public Collection<?> getItemIds() {
-        if (ordered) {
-            return ((Container.Ordered) container).getItemIds();
-        } else if (first == null) {
-            return new ArrayList<Object>();
-        } else {
-            List<Object> itemIds = new ArrayList<Object>();
-            itemIds.add(first);
-            Object current = first;
-            while (next.containsKey(current)) {
-                current = next.get(current);
-                itemIds.add(current);
-            }
-            return itemIds;
-        }
-
-    }
-
-    /*
-     * Gets the Property identified by the given itemId and propertyId from the
-     * Container Don't add a JavaDoc comment here, we use the default
-     * documentation from implemented interface.
-     */
-    @Override
-    public Property getContainerProperty(Object itemId, Object propertyId) {
-        return container.getContainerProperty(itemId, propertyId);
-    }
-
-    /*
-     * Gets the ID's of all Properties stored in the Container Don't add a
-     * JavaDoc comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public Collection<?> getContainerPropertyIds() {
-        return container.getContainerPropertyIds();
-    }
-
-    /*
-     * Gets the data type of all Properties identified by the given Property ID.
-     * Don't add a JavaDoc comment here, we use the default documentation from
-     * implemented interface.
-     */
-    @Override
-    public Class<?> getType(Object propertyId) {
-        return container.getType(propertyId);
-    }
-
-    /*
-     * Gets the number of Items in the Container. Don't add a JavaDoc comment
-     * here, we use the default documentation from implemented interface.
-     */
-    @Override
-    public int size() {
-        int newSize = container.size();
-        assert newSize >= 0;
-        if (lastKnownSize != -1 && newSize != lastKnownSize
-                && !(container instanceof Container.ItemSetChangeNotifier)) {
-            // Update the internal cache when the size of the container changes
-            // and the container is incapable of sending ItemSetChangeEvents
-            updateOrderWrapper();
-        }
-        lastKnownSize = newSize;
-        return newSize;
-    }
-
-    /*
-     * Registers a new Item set change listener for this Container. Don't add a
-     * JavaDoc comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public void addItemSetChangeListener(
-            Container.ItemSetChangeListener listener) {
-        if (container instanceof Container.ItemSetChangeNotifier) {
-            ((Container.ItemSetChangeNotifier) container)
-                    .addItemSetChangeListener(new PiggybackListener(listener));
-        }
-    }
-
-    /**
-     * @deprecated As of 7.0, replaced by
-     *             {@link #addItemSetChangeListener(com.vaadin.v7.data.Container.ItemSetChangeListener)}
-     **/
-    @Override
-    @Deprecated
-    public void addListener(Container.ItemSetChangeListener listener) {
-        addItemSetChangeListener(listener);
-    }
-
-    /*
-     * Removes a Item set change listener from the object. Don't add a JavaDoc
-     * comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public void removeItemSetChangeListener(
-            Container.ItemSetChangeListener listener) {
-        if (container instanceof Container.ItemSetChangeNotifier) {
-            ((Container.ItemSetChangeNotifier) container)
-                    .removeItemSetChangeListener(
-                            new PiggybackListener(listener));
-        }
-    }
-
-    /**
-     * @deprecated As of 7.0, replaced by
-     *             {@link #removeItemSetChangeListener(com.vaadin.v7.data.Container.ItemSetChangeListener)}
-     **/
-    @Override
-    @Deprecated
-    public void removeListener(Container.ItemSetChangeListener listener) {
-        removeItemSetChangeListener(listener);
-    }
-
-    /*
-     * Registers a new Property set change listener for this Container. Don't
-     * add a JavaDoc comment here, we use the default documentation from
-     * implemented interface.
-     */
-    @Override
-    public void addPropertySetChangeListener(
-            Container.PropertySetChangeListener listener) {
-        if (container instanceof Container.PropertySetChangeNotifier) {
-            ((Container.PropertySetChangeNotifier) container)
-                    .addPropertySetChangeListener(
-                            new PiggybackListener(listener));
-        }
-    }
-
-    /**
-     * @deprecated As of 7.0, replaced by
-     *             {@link #addPropertySetChangeListener(com.vaadin.v7.data.Container.PropertySetChangeListener)}
-     **/
-    @Override
-    @Deprecated
-    public void addListener(Container.PropertySetChangeListener listener) {
-        addPropertySetChangeListener(listener);
-    }
-
-    /*
-     * Removes a Property set change listener from the object. Don't add a
-     * JavaDoc comment here, we use the default documentation from implemented
-     * interface.
-     */
-    @Override
-    public void removePropertySetChangeListener(
-            Container.PropertySetChangeListener listener) {
-        if (container instanceof Container.PropertySetChangeNotifier) {
-            ((Container.PropertySetChangeNotifier) container)
-                    .removePropertySetChangeListener(
-                            new PiggybackListener(listener));
-        }
-    }
-
-    /**
-     * @deprecated As of 7.0, replaced by
-     *             {@link #removePropertySetChangeListener(com.vaadin.v7.data.Container.PropertySetChangeListener)}
-     **/
-    @Override
-    @Deprecated
-    public void removeListener(Container.PropertySetChangeListener listener) {
-        removePropertySetChangeListener(listener);
-    }
-
-    /*
-     * (non-Javadoc)
-     *
-     * @see com.vaadin.data.Container.Ordered#addItemAfter(java.lang.Object,
-     * java.lang.Object)
-     */
-    @Override
-    public Item addItemAfter(Object previousItemId, Object newItemId)
-            throws UnsupportedOperationException {
-
-        // If the previous item is not in the container, fail
-        if (previousItemId != null && !containsId(previousItemId)) {
-            return null;
-        }
-
-        // Adds the item to container
-        final Item item = container.addItem(newItemId);
-
-        // Puts the new item to its correct place
-        if (!ordered && item != null) {
-            addToOrderWrapper(newItemId, previousItemId);
-        }
-
-        return item;
-    }
-
-    /*
-     * (non-Javadoc)
-     *
-     * @see com.vaadin.data.Container.Ordered#addItemAfter(java.lang.Object)
-     */
-    @Override
-    public Object addItemAfter(Object previousItemId)
-            throws UnsupportedOperationException {
-
-        // If the previous item is not in the container, fail
-        if (previousItemId != null && !containsId(previousItemId)) {
-            return null;
-        }
-
-        // Adds the item to container
-        final Object id = container.addItem();
-
-        // Puts the new item to its correct place
-        if (!ordered && id != null) {
-            addToOrderWrapper(id, previousItemId);
-        }
-
-        return id;
-    }
-
-    /**
-     * This listener 'piggybacks' on the real listener in order to update the
-     * wrapper when needed. It proxies equals() and hashCode() to the real
-     * listener so that the correct listener gets removed.
-     *
-     */
-    private class PiggybackListener
-            implements Container.PropertySetChangeListener,
-            Container.ItemSetChangeListener {
-
-        Object listener;
-
-        public PiggybackListener(Object realListener) {
-            listener = realListener;
-        }
-
-        @Override
-        public void containerItemSetChange(ItemSetChangeEvent event) {
-            updateOrderWrapper();
-            ((Container.ItemSetChangeListener) listener)
-                    .containerItemSetChange(event);
-
-        }
-
-        @Override
-        public void containerPropertySetChange(PropertySetChangeEvent event) {
-            updateOrderWrapper();
-            ((Container.PropertySetChangeListener) listener)
-                    .containerPropertySetChange(event);
-
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-            return obj == listener || (obj != null && obj.equals(listener));
-        }
-
-        @Override
-        public int hashCode() {
-            return listener.hashCode();
-        }
-
-    }
-
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/DefaultItemSorter.java b/server/src/main/java/com/vaadin/v7/data/util/DefaultItemSorter.java
deleted file mode 100644
index 345d50614f..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/DefaultItemSorter.java
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Comparator;
-import java.util.List;
-
-import com.vaadin.v7.data.Container;
-import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Property;
-import com.vaadin.v7.data.Container.Sortable;
-
-/**
- * Provides a default implementation of an ItemSorter. The
- * <code>DefaultItemSorter</code> adheres to the
- * {@link Sortable#sort(Object[], boolean[])} rules and sorts the container
- * according to the properties given using
- * {@link #setSortProperties(Sortable, Object[], boolean[])}.
- * <p>
- * A Comparator is used for comparing the individual <code>Property</code>
- * values. The comparator can be set using the constructor. If no comparator is
- * provided a default comparator is used.
- *
- */
-public class DefaultItemSorter implements ItemSorter {
-
-    private java.lang.Object[] sortPropertyIds;
-    private boolean[] sortDirections;
-    private Container container;
-    private Comparator<Object> propertyValueComparator;
-
-    /**
-     * Constructs a DefaultItemSorter using the default <code>Comparator</code>
-     * for comparing <code>Property</code>values.
-     *
-     */
-    public DefaultItemSorter() {
-        this(new DefaultPropertyValueComparator());
-    }
-
-    /**
-     * Constructs a DefaultItemSorter which uses the <code>Comparator</code>
-     * indicated by the <code>propertyValueComparator</code> parameter for
-     * comparing <code>Property</code>values.
-     *
-     * @param propertyValueComparator
-     *            The comparator to use when comparing individual
-     *            <code>Property</code> values
-     */
-    public DefaultItemSorter(Comparator<Object> propertyValueComparator) {
-        this.propertyValueComparator = propertyValueComparator;
-    }
-
-    /*
-     * (non-Javadoc)
-     *
-     * @see com.vaadin.data.util.ItemSorter#compare(java.lang.Object,
-     * java.lang.Object)
-     */
-    @Override
-    public int compare(Object o1, Object o2) {
-        Item item1 = container.getItem(o1);
-        Item item2 = container.getItem(o2);
-
-        /*
-         * Items can be null if the container is filtered. Null is considered
-         * "less" than not-null.
-         */
-        if (item1 == null) {
-            if (item2 == null) {
-                return 0;
-            } else {
-                return 1;
-            }
-        } else if (item2 == null) {
-            return -1;
-        }
-
-        for (int i = 0; i < sortPropertyIds.length; i++) {
-
-            int result = compareProperty(sortPropertyIds[i], sortDirections[i],
-                    item1, item2);
-
-            // If order can be decided
-            if (result != 0) {
-                return result;
-            }
-
-        }
-
-        return 0;
-    }
-
-    /**
-     * Compares the property indicated by <code>propertyId</code> in the items
-     * indicated by <code>item1</code> and <code>item2</code> for order. Returns
-     * a negative integer, zero, or a positive integer as the property value in
-     * the first item is less than, equal to, or greater than the property value
-     * in the second item. If the <code>sortDirection</code> is false the
-     * returned value is negated.
-     * <p>
-     * The comparator set for this <code>DefaultItemSorter</code> is used for
-     * comparing the two property values.
-     *
-     * @param propertyId
-     *            The property id for the property that is used for comparison.
-     * @param sortDirection
-     *            The direction of the sort. A false value negates the result.
-     * @param item1
-     *            The first item to compare.
-     * @param item2
-     *            The second item to compare.
-     * @return a negative, zero, or positive integer if the property value in
-     *         the first item is less than, equal to, or greater than the
-     *         property value in the second item. Negated if
-     *         {@code sortDirection} is false.
-     */
-    protected int compareProperty(Object propertyId, boolean sortDirection,
-            Item item1, Item item2) {
-
-        // Get the properties to compare
-        final Property<?> property1 = item1.getItemProperty(propertyId);
-        final Property<?> property2 = item2.getItemProperty(propertyId);
-
-        // Get the values to compare
-        final Object value1 = (property1 == null) ? null : property1.getValue();
-        final Object value2 = (property2 == null) ? null : property2.getValue();
-
-        // Result of the comparison
-        int r = 0;
-        if (sortDirection) {
-            r = propertyValueComparator.compare(value1, value2);
-        } else {
-            r = propertyValueComparator.compare(value2, value1);
-        }
-
-        return r;
-    }
-
-    /*
-     * (non-Javadoc)
-     *
-     * @see com.vaadin.data.util.ItemSorter#setSortProperties(com.vaadin.data.
-     * Container .Sortable, java.lang.Object[], boolean[])
-     */
-    @Override
-    public void setSortProperties(Container.Sortable container,
-            Object[] propertyId, boolean[] ascending) {
-        this.container = container;
-
-        // Removes any non-sortable property ids
-        final List<Object> ids = new ArrayList<Object>();
-        final List<Boolean> orders = new ArrayList<Boolean>();
-        final Collection<?> sortable = container
-                .getSortableContainerPropertyIds();
-        for (int i = 0; i < propertyId.length; i++) {
-            if (sortable.contains(propertyId[i])) {
-                ids.add(propertyId[i]);
-                orders.add(Boolean
-                        .valueOf(i < ascending.length ? ascending[i] : true));
-            }
-        }
-
-        sortPropertyIds = ids.toArray();
-        sortDirections = new boolean[orders.size()];
-        for (int i = 0; i < sortDirections.length; i++) {
-            sortDirections[i] = (orders.get(i)).booleanValue();
-        }
-
-    }
-
-    /**
-     * Provides a default comparator used for comparing {@link Property} values.
-     * The <code>DefaultPropertyValueComparator</code> assumes all objects it
-     * compares can be cast to Comparable.
-     *
-     */
-    public static class DefaultPropertyValueComparator
-            implements Comparator<Object>, Serializable {
-
-        @Override
-        @SuppressWarnings("unchecked")
-        public int compare(Object o1, Object o2) {
-            int r = 0;
-            // Normal non-null comparison
-            if (o1 != null && o2 != null) {
-                // Assume the objects can be cast to Comparable, throw
-                // ClassCastException otherwise.
-                r = ((Comparable<Object>) o1).compareTo(o2);
-            } else if (o1 == o2) {
-                // Objects are equal if both are null
-                r = 0;
-            } else {
-                if (o1 == null) {
-                    r = -1; // null is less than non-null
-                } else {
-                    r = 1; // non-null is greater than null
-                }
-            }
-
-            return r;
-        }
-    }
-
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/HierarchicalContainerOrderedWrapper.java b/server/src/main/java/com/vaadin/v7/data/util/HierarchicalContainerOrderedWrapper.java
deleted file mode 100644
index f25842aec9..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/HierarchicalContainerOrderedWrapper.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util;
-
-import java.util.Collection;
-
-import com.vaadin.v7.data.Container.Hierarchical;
-
-/**
- * A wrapper class for adding external ordering to containers not implementing
- * the {@link com.vaadin.v7.data.Container.Ordered} interface while retaining
- * {@link Hierarchical} features.
- *
- * @see ContainerOrderedWrapper
- */
-@SuppressWarnings({ "serial" })
-public class HierarchicalContainerOrderedWrapper extends ContainerOrderedWrapper
-        implements Hierarchical {
-
-    private Hierarchical hierarchical;
-
-    public HierarchicalContainerOrderedWrapper(Hierarchical toBeWrapped) {
-        super(toBeWrapped);
-        hierarchical = toBeWrapped;
-    }
-
-    @Override
-    public boolean areChildrenAllowed(Object itemId) {
-        return hierarchical.areChildrenAllowed(itemId);
-    }
-
-    @Override
-    public Collection<?> getChildren(Object itemId) {
-        return hierarchical.getChildren(itemId);
-    }
-
-    @Override
-    public Object getParent(Object itemId) {
-        return hierarchical.getParent(itemId);
-    }
-
-    @Override
-    public boolean hasChildren(Object itemId) {
-        return hierarchical.hasChildren(itemId);
-    }
-
-    @Override
-    public boolean isRoot(Object itemId) {
-        return hierarchical.isRoot(itemId);
-    }
-
-    @Override
-    public Collection<?> rootItemIds() {
-        return hierarchical.rootItemIds();
-    }
-
-    @Override
-    public boolean setChildrenAllowed(Object itemId, boolean areChildrenAllowed)
-            throws UnsupportedOperationException {
-        return hierarchical.setChildrenAllowed(itemId, areChildrenAllowed);
-    }
-
-    @Override
-    public boolean setParent(Object itemId, Object newParentId)
-            throws UnsupportedOperationException {
-        return hierarchical.setParent(itemId, newParentId);
-    }
-
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/ItemSorter.java b/server/src/main/java/com/vaadin/v7/data/util/ItemSorter.java
deleted file mode 100644
index 9ca21ca137..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/ItemSorter.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util;
-
-import java.io.Serializable;
-import java.util.Comparator;
-
-import com.vaadin.v7.data.Container;
-import com.vaadin.v7.data.Container.Sortable;
-
-/**
- * An item comparator which is compatible with the {@link Sortable} interface.
- * The <code>ItemSorter</code> interface can be used in <code>Sortable</code>
- * implementations to provide a custom sorting method.
- */
-public interface ItemSorter
-        extends Comparator<Object>, Cloneable, Serializable {
-
-    /**
-     * Sets the parameters for an upcoming sort operation. The parameters
-     * determine what container to sort and how the <code>ItemSorter</code>
-     * sorts the container.
-     *
-     * @param container
-     *            The container that will be sorted. The container must contain
-     *            the propertyIds given in the <code>propertyId</code>
-     *            parameter.
-     * @param propertyId
-     *            The property ids used for sorting. The property ids must exist
-     *            in the container and should only be used if they are also
-     *            sortable, i.e include in the collection returned by
-     *            <code>container.getSortableContainerPropertyIds()</code>. See
-     *            {@link Sortable#sort(Object[], boolean[])} for more
-     *            information.
-     * @param ascending
-     *            Sorting order flags for each property id. See
-     *            {@link Sortable#sort(Object[], boolean[])} for more
-     *            information.
-     */
-    void setSortProperties(Container.Sortable container, Object[] propertyId,
-            boolean[] ascending);
-
-    /**
-     * Compares its two arguments for order. Returns a negative integer, zero,
-     * or a positive integer as the first argument is less than, equal to, or
-     * greater than the second.
-     * <p>
-     * The parameters for the <code>ItemSorter</code> <code>compare()</code>
-     * method must always be item ids which exist in the container set using
-     * {@link #setSortProperties(Sortable, Object[], boolean[])}.
-     *
-     * @see Comparator#compare(Object, Object)
-     */
-    @Override
-    int compare(Object itemId1, Object itemId2);
-
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/PropertyValueGenerator.java b/server/src/main/java/com/vaadin/v7/data/util/PropertyValueGenerator.java
deleted file mode 100644
index 8cc4e7ac10..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/PropertyValueGenerator.java
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util;
-
-import java.io.Serializable;
-
-import com.vaadin.data.sort.SortOrder;
-import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Property;
-import com.vaadin.v7.data.Container.Filter;
-import com.vaadin.v7.data.util.filter.UnsupportedFilterException;
-
-/**
- * PropertyValueGenerator for GeneratedPropertyContainer.
- *
- * @param <T>
- *            Property data type
- * @since 7.4
- * @author Vaadin Ltd
- */
-public abstract class PropertyValueGenerator<T> implements Serializable {
-
-    /**
-     * Returns value for given Item. Used by GeneratedPropertyContainer when
-     * generating new properties.
-     *
-     * @param item
-     *            currently handled item
-     * @param itemId
-     *            item id for currently handled item
-     * @param propertyId
-     *            id for this property
-     * @return generated value
-     */
-    public abstract T getValue(Item item, Object itemId, Object propertyId);
-
-    /**
-     * Return Property type for this generator. This function is called when
-     * {@link Property#getType()} is called for generated property.
-     *
-     * @return type of generated property
-     */
-    public abstract Class<T> getType();
-
-    /**
-     * Translates sorting of the generated property in a specific direction to a
-     * set of property ids and directions in the underlying container.
-     * <p>
-     * SortOrder is similar to (or the same as) the SortOrder already defined
-     * for Grid.
-     * <p>
-     * The default implementation of this method returns an empty array, which
-     * means that the property will not be included in
-     * getSortableContainerPropertyIds(). Attempting to sort by that column
-     * throws UnsupportedOperationException.
-     *
-     * Returning null is not allowed.
-     *
-     * @param order
-     *            a sort order for this property
-     * @return an array of sort orders describing how this property is sorted
-     */
-    public SortOrder[] getSortProperties(SortOrder order) {
-        return new SortOrder[] {};
-    }
-
-    /**
-     * Return an updated filter that should be compatible with the underlying
-     * container.
-     * <p>
-     * This function is called when setting a filter for this generated
-     * property. Returning null from this function causes
-     * GeneratedPropertyContainer to discard the filter and not use it.
-     * <p>
-     * By default this function throws UnsupportedFilterException.
-     *
-     * @param filter
-     *            original filter for this property
-     * @return modified filter that is compatible with the underlying container
-     * @throws UnsupportedFilterException
-     *             if the implementation doesn't support modifying the provided
-     *             filter
-     */
-    public Filter modifyFilter(Filter filter)
-            throws UnsupportedFilterException {
-        throw new UnsupportedFilterException(
-                "Filter" + filter + " is not supported");
-    }
-
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/filter/AbstractJunctionFilter.java b/server/src/main/java/com/vaadin/v7/data/util/filter/AbstractJunctionFilter.java
deleted file mode 100644
index 17b708a22c..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/filter/AbstractJunctionFilter.java
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util.filter;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-
-import com.vaadin.v7.data.Container.Filter;
-
-/**
- * Abstract base class for filters that are composed of multiple sub-filters.
- *
- * The method {@link #appliesToProperty(Object)} is provided to help
- * implementing {@link Filter} for in-memory filters.
- *
- * @since 6.6
- */
-public abstract class AbstractJunctionFilter implements Filter {
-
-    protected final Collection<Filter> filters;
-
-    public AbstractJunctionFilter(Filter... filters) {
-        this.filters = Collections
-                .unmodifiableCollection(Arrays.asList(filters));
-    }
-
-    /**
-     * Returns an unmodifiable collection of the sub-filters of this composite
-     * filter.
-     *
-     * @return
-     */
-    public Collection<Filter> getFilters() {
-        return filters;
-    }
-
-    /**
-     * Returns true if a change in the named property may affect the filtering
-     * result. If some of the sub-filters are not in-memory filters, true is
-     * returned.
-     *
-     * By default, all sub-filters are iterated to check if any of them applies.
-     * If there are no sub-filters, false is returned - override in subclasses
-     * to change this behavior.
-     */
-    @Override
-    public boolean appliesToProperty(Object propertyId) {
-        for (Filter filter : getFilters()) {
-            if (filter.appliesToProperty(propertyId)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == null || !getClass().equals(obj.getClass())) {
-            return false;
-        }
-        AbstractJunctionFilter other = (AbstractJunctionFilter) obj;
-        // contents comparison with equals()
-        return Arrays.equals(filters.toArray(), other.filters.toArray());
-    }
-
-    @Override
-    public int hashCode() {
-        int hash = getFilters().size();
-        for (Filter filter : filters) {
-            hash = (hash << 1) ^ filter.hashCode();
-        }
-        return hash;
-    }
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/filter/And.java b/server/src/main/java/com/vaadin/v7/data/util/filter/And.java
deleted file mode 100644
index b7b5a18f3d..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/filter/And.java
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util.filter;
-
-import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Container.Filter;
-
-/**
- * A compound {@link Filter} that accepts an item if all of its filters accept
- * the item.
- *
- * If no filters are given, the filter should accept all items.
- *
- * This filter also directly supports in-memory filtering when all sub-filters
- * do so.
- *
- * @see Or
- *
- * @since 6.6
- */
-public final class And extends AbstractJunctionFilter {
-
-    /**
-     *
-     * @param filters
-     *            filters of which the And filter will be composed
-     */
-    public And(Filter... filters) {
-        super(filters);
-    }
-
-    @Override
-    public boolean passesFilter(Object itemId, Item item)
-            throws UnsupportedFilterException {
-        for (Filter filter : getFilters()) {
-            if (!filter.passesFilter(itemId, item)) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/filter/Between.java b/server/src/main/java/com/vaadin/v7/data/util/filter/Between.java
deleted file mode 100644
index ec0e468554..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/filter/Between.java
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util.filter;
-
-import java.util.Arrays;
-
-import com.vaadin.shared.util.SharedUtil;
-import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Container.Filter;
-
-public class Between implements Filter {
-
-    private final Object propertyId;
-    private final Comparable<?> startValue;
-    private final Comparable<?> endValue;
-
-    public Between(Object propertyId, Comparable<?> startValue,
-            Comparable<?> endValue) {
-        this.propertyId = propertyId;
-        this.startValue = startValue;
-        this.endValue = endValue;
-    }
-
-    public Object getPropertyId() {
-        return propertyId;
-    }
-
-    public Comparable<?> getStartValue() {
-        return startValue;
-    }
-
-    public Comparable<?> getEndValue() {
-        return endValue;
-    }
-
-    @Override
-    public boolean passesFilter(Object itemId, Item item)
-            throws UnsupportedOperationException {
-        Object value = item.getItemProperty(getPropertyId()).getValue();
-        if (value instanceof Comparable) {
-            Comparable comparable = (Comparable) value;
-            return isAfterStartValue(comparable)
-                    && isBeforeEndValue(comparable);
-        } else if (value == null) {
-            return getStartValue() == null && getEndValue() == null;
-        }
-        return false;
-    }
-
-    @Override
-    public boolean appliesToProperty(Object propertyId) {
-        return getPropertyId() != null && getPropertyId().equals(propertyId);
-    }
-
-    @Override
-    public int hashCode() {
-        return Arrays.hashCode(new Object[] { getPropertyId(), getStartValue(),
-                getEndValue() });
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == null) {
-            return false;
-        }
-
-        // Only objects of the same class can be equal
-        if (!getClass().equals(obj.getClass())) {
-            return false;
-        }
-        final Between o = (Between) obj;
-
-        // Checks the properties one by one
-        boolean propertyIdEqual = SharedUtil.equals(getPropertyId(),
-                o.getPropertyId());
-        boolean startValueEqual = SharedUtil.equals(getStartValue(),
-                o.getStartValue());
-        boolean endValueEqual = SharedUtil.equals(getEndValue(),
-                o.getEndValue());
-        return propertyIdEqual && startValueEqual && endValueEqual;
-
-    }
-
-    private boolean isAfterStartValue(Comparable comparable) {
-        return getStartValue() == null
-                || comparable.compareTo(getStartValue()) >= 0;
-    }
-
-    private boolean isBeforeEndValue(Comparable comparable) {
-        return getEndValue() == null
-                || comparable.compareTo(getEndValue()) <= 0;
-    }
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/filter/Compare.java b/server/src/main/java/com/vaadin/v7/data/util/filter/Compare.java
deleted file mode 100644
index 5b945ff411..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/filter/Compare.java
+++ /dev/null
@@ -1,370 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util.filter;
-
-import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Property;
-import com.vaadin.v7.data.Container.Filter;
-
-/**
- * Simple container filter comparing an item property value against a given
- * constant value. Use the nested classes {@link Equal}, {@link Greater},
- * {@link Less}, {@link GreaterOrEqual} and {@link LessOrEqual} instead of this
- * class directly.
- *
- * This filter also directly supports in-memory filtering.
- *
- * The reference and actual values must implement {@link Comparable} and the
- * class of the actual property value must be assignable from the class of the
- * reference value.
- *
- * @since 6.6
- */
-public abstract class Compare implements Filter {
-
-    public enum Operation {
-        EQUAL, GREATER, LESS, GREATER_OR_EQUAL, LESS_OR_EQUAL
-    }
-
-    private final Object propertyId;
-    private final Operation operation;
-    private final Object value;
-
-    /**
-     * A {@link Compare} filter that accepts items for which the identified
-     * property value is equal to <code>value</code>.
-     *
-     * For in-memory filters, {@link Comparable#compareTo(Object)} or, if not
-     * Comparable, {@link #equals(Object)} is used for the comparison. For other
-     * containers, the comparison implementation is container dependent and may
-     * use e.g. database comparison operations.
-     *
-     * @since 6.6
-     */
-    public static final class Equal extends Compare {
-        /**
-         * Construct a filter that accepts items for which the identified
-         * property value is equal to <code>value</code>.
-         *
-         * For in-memory filters, equals() is used for the comparison. For other
-         * containers, the comparison implementation is container dependent and
-         * may use e.g. database comparison operations.
-         *
-         * @param propertyId
-         *            the identifier of the property whose value to compare
-         *            against value, not null
-         * @param value
-         *            the value to compare against - null values may or may not
-         *            be supported depending on the container
-         */
-        public Equal(Object propertyId, Object value) {
-            super(propertyId, value, Operation.EQUAL);
-        }
-    }
-
-    /**
-     * A {@link Compare} filter that accepts items for which the identified
-     * property value is greater than <code>value</code>.
-     *
-     * For in-memory filters, the values must implement {@link Comparable} and
-     * {@link Comparable#compareTo(Object)} is used for the comparison. For
-     * other containers, the comparison implementation is container dependent
-     * and may use e.g. database comparison operations.
-     *
-     * @since 6.6
-     */
-    public static final class Greater extends Compare {
-        /**
-         * Construct a filter that accepts items for which the identified
-         * property value is greater than <code>value</code>.
-         *
-         * For in-memory filters, the values must implement {@link Comparable}
-         * and {@link Comparable#compareTo(Object)} is used for the comparison.
-         * For other containers, the comparison implementation is container
-         * dependent and may use e.g. database comparison operations.
-         *
-         * @param propertyId
-         *            the identifier of the property whose value to compare
-         *            against value, not null
-         * @param value
-         *            the value to compare against - null values may or may not
-         *            be supported depending on the container
-         */
-        public Greater(Object propertyId, Object value) {
-            super(propertyId, value, Operation.GREATER);
-        }
-    }
-
-    /**
-     * A {@link Compare} filter that accepts items for which the identified
-     * property value is less than <code>value</code>.
-     *
-     * For in-memory filters, the values must implement {@link Comparable} and
-     * {@link Comparable#compareTo(Object)} is used for the comparison. For
-     * other containers, the comparison implementation is container dependent
-     * and may use e.g. database comparison operations.
-     *
-     * @since 6.6
-     */
-    public static final class Less extends Compare {
-        /**
-         * Construct a filter that accepts items for which the identified
-         * property value is less than <code>value</code>.
-         *
-         * For in-memory filters, the values must implement {@link Comparable}
-         * and {@link Comparable#compareTo(Object)} is used for the comparison.
-         * For other containers, the comparison implementation is container
-         * dependent and may use e.g. database comparison operations.
-         *
-         * @param propertyId
-         *            the identifier of the property whose value to compare
-         *            against value, not null
-         * @param value
-         *            the value to compare against - null values may or may not
-         *            be supported depending on the container
-         */
-        public Less(Object propertyId, Object value) {
-            super(propertyId, value, Operation.LESS);
-        }
-    }
-
-    /**
-     * A {@link Compare} filter that accepts items for which the identified
-     * property value is greater than or equal to <code>value</code>.
-     *
-     * For in-memory filters, the values must implement {@link Comparable} and
-     * {@link Comparable#compareTo(Object)} is used for the comparison. For
-     * other containers, the comparison implementation is container dependent
-     * and may use e.g. database comparison operations.
-     *
-     * @since 6.6
-     */
-    public static final class GreaterOrEqual extends Compare {
-        /**
-         * Construct a filter that accepts items for which the identified
-         * property value is greater than or equal to <code>value</code>.
-         *
-         * For in-memory filters, the values must implement {@link Comparable}
-         * and {@link Comparable#compareTo(Object)} is used for the comparison.
-         * For other containers, the comparison implementation is container
-         * dependent and may use e.g. database comparison operations.
-         *
-         * @param propertyId
-         *            the identifier of the property whose value to compare
-         *            against value, not null
-         * @param value
-         *            the value to compare against - null values may or may not
-         *            be supported depending on the container
-         */
-        public GreaterOrEqual(Object propertyId, Object value) {
-            super(propertyId, value, Operation.GREATER_OR_EQUAL);
-        }
-    }
-
-    /**
-     * A {@link Compare} filter that accepts items for which the identified
-     * property value is less than or equal to <code>value</code>.
-     *
-     * For in-memory filters, the values must implement {@link Comparable} and
-     * {@link Comparable#compareTo(Object)} is used for the comparison. For
-     * other containers, the comparison implementation is container dependent
-     * and may use e.g. database comparison operations.
-     *
-     * @since 6.6
-     */
-    public static final class LessOrEqual extends Compare {
-        /**
-         * Construct a filter that accepts items for which the identified
-         * property value is less than or equal to <code>value</code>.
-         *
-         * For in-memory filters, the values must implement {@link Comparable}
-         * and {@link Comparable#compareTo(Object)} is used for the comparison.
-         * For other containers, the comparison implementation is container
-         * dependent and may use e.g. database comparison operations.
-         *
-         * @param propertyId
-         *            the identifier of the property whose value to compare
-         *            against value, not null
-         * @param value
-         *            the value to compare against - null values may or may not
-         *            be supported depending on the container
-         */
-        public LessOrEqual(Object propertyId, Object value) {
-            super(propertyId, value, Operation.LESS_OR_EQUAL);
-        }
-    }
-
-    /**
-     * Constructor for a {@link Compare} filter that compares the value of an
-     * item property with the given constant <code>value</code>.
-     *
-     * This constructor is intended to be used by the nested static classes only
-     * ({@link Equal}, {@link Greater}, {@link Less}, {@link GreaterOrEqual},
-     * {@link LessOrEqual}).
-     *
-     * For in-memory filtering, comparisons except EQUAL require that the values
-     * implement {@link Comparable} and {@link Comparable#compareTo(Object)} is
-     * used for the comparison. The equality comparison is performed using
-     * {@link Object#equals(Object)}.
-     *
-     * For other containers, the comparison implementation is container
-     * dependent and may use e.g. database comparison operations. Therefore, the
-     * behavior of comparisons might differ in some cases between in-memory and
-     * other containers.
-     *
-     * @param propertyId
-     *            the identifier of the property whose value to compare against
-     *            value, not null
-     * @param value
-     *            the value to compare against - null values may or may not be
-     *            supported depending on the container
-     * @param operation
-     *            the comparison {@link Operation} to use
-     */
-    Compare(Object propertyId, Object value, Operation operation) {
-        this.propertyId = propertyId;
-        this.value = value;
-        this.operation = operation;
-    }
-
-    @Override
-    public boolean passesFilter(Object itemId, Item item) {
-        final Property<?> p = item.getItemProperty(getPropertyId());
-        if (null == p) {
-            return false;
-        }
-        Object value = p.getValue();
-        switch (getOperation()) {
-        case EQUAL:
-            return compareEquals(value);
-        case GREATER:
-            return compareValue(value) > 0;
-        case LESS:
-            return compareValue(value) < 0;
-        case GREATER_OR_EQUAL:
-            return compareValue(value) >= 0;
-        case LESS_OR_EQUAL:
-            return compareValue(value) <= 0;
-        }
-        // all cases should have been processed above
-        return false;
-    }
-
-    /**
-     * Checks if the this value equals the given value. Favors Comparable over
-     * equals to better support e.g. BigDecimal where equals is stricter than
-     * compareTo.
-     *
-     * @param otherValue
-     *            The value to compare to
-     * @return true if the values are equal, false otherwise
-     */
-    private boolean compareEquals(Object otherValue) {
-        if (value == null || otherValue == null) {
-            return (otherValue == value);
-        } else if (value == otherValue) {
-            return true;
-        } else if (value instanceof Comparable && otherValue.getClass()
-                .isAssignableFrom(getValue().getClass())) {
-            return ((Comparable) value).compareTo(otherValue) == 0;
-        } else {
-            return value.equals(otherValue);
-        }
-    }
-
-    @SuppressWarnings({ "unchecked", "rawtypes" })
-    protected int compareValue(Object value1) {
-        if (null == value) {
-            return null == value1 ? 0 : -1;
-        } else if (null == value1) {
-            return 1;
-        } else if (getValue() instanceof Comparable) {
-            if (value1.getClass().isInstance(getValue())) {
-                return -((Comparable) getValue()).compareTo(value1);
-            } else if (getValue().getClass().isInstance(value1)) {
-                // isInstance returns true if value1 is a sub-type of
-                // getValue(), i.e. value1 must here be Comparable
-                return ((Comparable) value1).compareTo(getValue());
-            }
-
-        }
-        throw new IllegalArgumentException("Could not compare the arguments: "
-                + value1 + ", " + getValue());
-    }
-
-    @Override
-    public boolean appliesToProperty(Object propertyId) {
-        return getPropertyId().equals(propertyId);
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == null) {
-            return false;
-        }
-
-        // Only objects of the same class can be equal
-        if (!getClass().equals(obj.getClass())) {
-            return false;
-        }
-        final Compare o = (Compare) obj;
-
-        // Checks the properties one by one
-        if (getPropertyId() != o.getPropertyId() && null != o.getPropertyId()
-                && !o.getPropertyId().equals(getPropertyId())) {
-            return false;
-        }
-        if (getOperation() != o.getOperation()) {
-            return false;
-        }
-        return (null == getValue()) ? null == o.getValue()
-                : getValue().equals(o.getValue());
-    }
-
-    @Override
-    public int hashCode() {
-        return (null != getPropertyId() ? getPropertyId().hashCode() : 0)
-                ^ (null != getValue() ? getValue().hashCode() : 0);
-    }
-
-    /**
-     * Returns the property id of the property to compare against the fixed
-     * value.
-     *
-     * @return property id (not null)
-     */
-    public Object getPropertyId() {
-        return propertyId;
-    }
-
-    /**
-     * Returns the comparison operation.
-     *
-     * @return {@link Operation}
-     */
-    public Operation getOperation() {
-        return operation;
-    }
-
-    /**
-     * Returns the value to compare the property against.
-     *
-     * @return comparison reference value
-     */
-    public Object getValue() {
-        return value;
-    }
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/filter/IsNull.java b/server/src/main/java/com/vaadin/v7/data/util/filter/IsNull.java
deleted file mode 100644
index 0a7e115255..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/filter/IsNull.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util.filter;
-
-import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Property;
-import com.vaadin.v7.data.Container.Filter;
-
-/**
- * Simple container filter checking whether an item property value is null.
- *
- * This filter also directly supports in-memory filtering.
- *
- * @since 6.6
- */
-public final class IsNull implements Filter {
-
-    private final Object propertyId;
-
-    /**
-     * Constructor for a filter that compares the value of an item property with
-     * null.
-     *
-     * For in-memory filtering, a simple == check is performed. For other
-     * containers, the comparison implementation is container dependent but
-     * should correspond to the in-memory null check.
-     *
-     * @param propertyId
-     *            the identifier (not null) of the property whose value to check
-     */
-    public IsNull(Object propertyId) {
-        this.propertyId = propertyId;
-    }
-
-    @Override
-    public boolean passesFilter(Object itemId, Item item)
-            throws UnsupportedOperationException {
-        final Property<?> p = item.getItemProperty(getPropertyId());
-        if (null == p) {
-            return false;
-        }
-        return null == p.getValue();
-    }
-
-    @Override
-    public boolean appliesToProperty(Object propertyId) {
-        return getPropertyId().equals(propertyId);
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == null) {
-            return false;
-        }
-
-        // Only objects of the same class can be equal
-        if (!getClass().equals(obj.getClass())) {
-            return false;
-        }
-        final IsNull o = (IsNull) obj;
-
-        // Checks the properties one by one
-        return (null != getPropertyId())
-                ? getPropertyId().equals(o.getPropertyId())
-                : null == o.getPropertyId();
-    }
-
-    @Override
-    public int hashCode() {
-        return (null != getPropertyId() ? getPropertyId().hashCode() : 0);
-    }
-
-    /**
-     * Returns the property id of the property tested by the filter, not null
-     * for valid filters.
-     *
-     * @return property id (not null)
-     */
-    public Object getPropertyId() {
-        return propertyId;
-    }
-
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/filter/Like.java b/server/src/main/java/com/vaadin/v7/data/util/filter/Like.java
deleted file mode 100644
index 5d92271afe..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/filter/Like.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util.filter;
-
-import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Container.Filter;
-
-public class Like implements Filter {
-    private final Object propertyId;
-    private final String value;
-    private boolean caseSensitive;
-
-    public Like(Object propertyId, String value) {
-        this(propertyId, value, true);
-    }
-
-    public Like(Object propertyId, String value, boolean caseSensitive) {
-        this.propertyId = propertyId;
-        this.value = value;
-        setCaseSensitive(caseSensitive);
-    }
-
-    public Object getPropertyId() {
-        return propertyId;
-    }
-
-    public String getValue() {
-        return value;
-    }
-
-    public void setCaseSensitive(boolean caseSensitive) {
-        this.caseSensitive = caseSensitive;
-    }
-
-    public boolean isCaseSensitive() {
-        return caseSensitive;
-    }
-
-    @Override
-    public boolean passesFilter(Object itemId, Item item)
-            throws UnsupportedOperationException {
-        if (!item.getItemProperty(getPropertyId()).getType()
-                .isAssignableFrom(String.class)) {
-            // We can only handle strings
-            return false;
-        }
-        String colValue = (String) item.getItemProperty(getPropertyId())
-                .getValue();
-
-        // Fix issue #10167 - avoid NPE and drop null property values
-        if (colValue == null) {
-            return false;
-        }
-
-        String pattern = getValue().replace("%", ".*");
-        if (isCaseSensitive()) {
-            return colValue.matches(pattern);
-        }
-        return colValue.toUpperCase().matches(pattern.toUpperCase());
-    }
-
-    @Override
-    public boolean appliesToProperty(Object propertyId) {
-        return getPropertyId() != null && getPropertyId().equals(propertyId);
-    }
-
-    @Override
-    public int hashCode() {
-        return getPropertyId().hashCode() + getValue().hashCode();
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == null) {
-            return false;
-        }
-
-        // Only objects of the same class can be equal
-        if (!getClass().equals(obj.getClass())) {
-            return false;
-        }
-        final Like o = (Like) obj;
-
-        // Checks the properties one by one
-        boolean propertyIdEqual = (null != getPropertyId())
-                ? getPropertyId().equals(o.getPropertyId())
-                : null == o.getPropertyId();
-        boolean valueEqual = (null != getValue())
-                ? getValue().equals(o.getValue()) : null == o.getValue();
-        return propertyIdEqual && valueEqual;
-    }
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/filter/Not.java b/server/src/main/java/com/vaadin/v7/data/util/filter/Not.java
deleted file mode 100644
index d0680eb481..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/filter/Not.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util.filter;
-
-import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Container.Filter;
-
-/**
- * Negating filter that accepts the items rejected by another filter.
- *
- * This filter directly supports in-memory filtering when the negated filter
- * does so.
- *
- * @since 6.6
- */
-public final class Not implements Filter {
-    private final Filter filter;
-
-    /**
-     * Constructs a filter that negates a filter.
-     *
-     * @param filter
-     *            {@link Filter} to negate, not-null
-     */
-    public Not(Filter filter) {
-        this.filter = filter;
-    }
-
-    /**
-     * Returns the negated filter.
-     *
-     * @return Filter
-     */
-    public Filter getFilter() {
-        return filter;
-    }
-
-    @Override
-    public boolean passesFilter(Object itemId, Item item)
-            throws UnsupportedOperationException {
-        return !filter.passesFilter(itemId, item);
-    }
-
-    /**
-     * Returns true if a change in the named property may affect the filtering
-     * result. Return value is the same as {@link #appliesToProperty(Object)}
-     * for the negated filter.
-     *
-     * @return boolean
-     */
-    @Override
-    public boolean appliesToProperty(Object propertyId) {
-        return filter.appliesToProperty(propertyId);
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == null || !getClass().equals(obj.getClass())) {
-            return false;
-        }
-        return filter.equals(((Not) obj).getFilter());
-    }
-
-    @Override
-    public int hashCode() {
-        return filter.hashCode();
-    }
-
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/filter/Or.java b/server/src/main/java/com/vaadin/v7/data/util/filter/Or.java
deleted file mode 100644
index 5062e6d987..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/filter/Or.java
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util.filter;
-
-import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Container.Filter;
-
-/**
- * A compound {@link Filter} that accepts an item if any of its filters accept
- * the item.
- *
- * If no filters are given, the filter should reject all items.
- *
- * This filter also directly supports in-memory filtering when all sub-filters
- * do so.
- *
- * @see And
- *
- * @since 6.6
- */
-public final class Or extends AbstractJunctionFilter {
-
-    /**
-     *
-     * @param filters
-     *            filters of which the Or filter will be composed
-     */
-    public Or(Filter... filters) {
-        super(filters);
-    }
-
-    @Override
-    public boolean passesFilter(Object itemId, Item item)
-            throws UnsupportedFilterException {
-        for (Filter filter : getFilters()) {
-            if (filter.passesFilter(itemId, item)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Returns true if a change in the named property may affect the filtering
-     * result. If some of the sub-filters are not in-memory filters, true is
-     * returned.
-     *
-     * By default, all sub-filters are iterated to check if any of them applies.
-     * If there are no sub-filters, true is returned as an empty Or rejects all
-     * items.
-     */
-    @Override
-    public boolean appliesToProperty(Object propertyId) {
-        if (getFilters().isEmpty()) {
-            // empty Or filters out everything
-            return true;
-        } else {
-            return super.appliesToProperty(propertyId);
-        }
-    }
-
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/filter/SimpleStringFilter.java b/server/src/main/java/com/vaadin/v7/data/util/filter/SimpleStringFilter.java
deleted file mode 100644
index b3f7d032e1..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/filter/SimpleStringFilter.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util.filter;
-
-import com.vaadin.v7.data.Item;
-import com.vaadin.v7.data.Property;
-import com.vaadin.v7.data.Container.Filter;
-
-/**
- * Simple string filter for matching items that start with or contain a
- * specified string. The matching can be case-sensitive or case-insensitive.
- *
- * This filter also directly supports in-memory filtering. When performing
- * in-memory filtering, values of other types are converted using toString(),
- * but other (lazy container) implementations do not need to perform such
- * conversions and might not support values of different types.
- *
- * Note that this filter is modeled after the pre-6.6 filtering mechanisms, and
- * might not be very efficient e.g. for database filtering.
- *
- * TODO this might still change
- *
- * @since 6.6
- */
-public final class SimpleStringFilter implements Filter {
-
-    final Object propertyId;
-    final String filterString;
-    final boolean ignoreCase;
-    final boolean onlyMatchPrefix;
-
-    public SimpleStringFilter(Object propertyId, String filterString,
-            boolean ignoreCase, boolean onlyMatchPrefix) {
-        this.propertyId = propertyId;
-        this.filterString = ignoreCase ? filterString.toLowerCase()
-                : filterString;
-        this.ignoreCase = ignoreCase;
-        this.onlyMatchPrefix = onlyMatchPrefix;
-    }
-
-    @Override
-    public boolean passesFilter(Object itemId, Item item) {
-        final Property<?> p = item.getItemProperty(propertyId);
-        if (p == null) {
-            return false;
-        }
-        Object propertyValue = p.getValue();
-        if (propertyValue == null) {
-            return false;
-        }
-        final String value = ignoreCase ? propertyValue.toString().toLowerCase()
-                : propertyValue.toString();
-        if (onlyMatchPrefix) {
-            if (!value.startsWith(filterString)) {
-                return false;
-            }
-        } else {
-            if (!value.contains(filterString)) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    @Override
-    public boolean appliesToProperty(Object propertyId) {
-        return this.propertyId.equals(propertyId);
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == null) {
-            return false;
-        }
-
-        // Only ones of the objects of the same class can be equal
-        if (!(obj instanceof SimpleStringFilter)) {
-            return false;
-        }
-        final SimpleStringFilter o = (SimpleStringFilter) obj;
-
-        // Checks the properties one by one
-        if (propertyId != o.propertyId && o.propertyId != null
-                && !o.propertyId.equals(propertyId)) {
-            return false;
-        }
-        if (filterString != o.filterString && o.filterString != null
-                && !o.filterString.equals(filterString)) {
-            return false;
-        }
-        if (ignoreCase != o.ignoreCase) {
-            return false;
-        }
-        if (onlyMatchPrefix != o.onlyMatchPrefix) {
-            return false;
-        }
-
-        return true;
-    }
-
-    @Override
-    public int hashCode() {
-        return (propertyId != null ? propertyId.hashCode() : 0)
-                ^ (filterString != null ? filterString.hashCode() : 0);
-    }
-
-    /**
-     * Returns the property identifier to which this filter applies.
-     *
-     * @return property id
-     */
-    public Object getPropertyId() {
-        return propertyId;
-    }
-
-    /**
-     * Returns the filter string.
-     *
-     * Note: this method is intended only for implementations of lazy string
-     * filters and may change in the future.
-     *
-     * @return filter string given to the constructor
-     */
-    public String getFilterString() {
-        return filterString;
-    }
-
-    /**
-     * Returns whether the filter is case-insensitive or case-sensitive.
-     *
-     * Note: this method is intended only for implementations of lazy string
-     * filters and may change in the future.
-     *
-     * @return true if performing case-insensitive filtering, false for
-     *         case-sensitive
-     */
-    public boolean isIgnoreCase() {
-        return ignoreCase;
-    }
-
-    /**
-     * Returns true if the filter only applies to the beginning of the value
-     * string, false for any location in the value.
-     *
-     * Note: this method is intended only for implementations of lazy string
-     * filters and may change in the future.
-     *
-     * @return true if checking for matches at the beginning of the value only,
-     *         false if matching any part of value
-     */
-    public boolean isOnlyMatchPrefix() {
-        return onlyMatchPrefix;
-    }
-}
diff --git a/server/src/main/java/com/vaadin/v7/data/util/filter/UnsupportedFilterException.java b/server/src/main/java/com/vaadin/v7/data/util/filter/UnsupportedFilterException.java
deleted file mode 100644
index 68e18da32a..0000000000
--- a/server/src/main/java/com/vaadin/v7/data/util/filter/UnsupportedFilterException.java
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright 2000-2016 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.v7.data.util.filter;
-
-import java.io.Serializable;
-
-/**
- * Exception for cases where a container does not support a specific type of
- * filters.
- *
- * If possible, this should be thrown already when adding a filter to a
- * container. If a problem is not detected at that point, an
- * {@link UnsupportedOperationException} can be throws when attempting to
- * perform filtering.
- *
- * @since 6.6
- */
-public class UnsupportedFilterException extends RuntimeException
-        implements Serializable {
-    public UnsupportedFilterException() {
-    }
-
-    public UnsupportedFilterException(String message) {
-        super(message);
-    }
-
-    public UnsupportedFilterException(Exception cause) {
-        super(cause);
-    }
-
-    public UnsupportedFilterException(String message, Exception cause) {
-        super(message, cause);
-    }
-}