Package com.vaadin.data.util

Class AbstractInMemoryContainer<ITEMIDTYPE,​PROPERTYIDCLASS,​ITEMCLASS extends Item>

    • Constructor Detail

      • AbstractInMemoryContainer

        protected AbstractInMemoryContainer()
        Constructor for an abstract in-memory container.

    • Method Detail

      • getItem

        public ITEMCLASS getItem​(Object itemId)
        Description copied from interface: Container
        Gets the Item with the given Item ID from the Container. If the Container does not contain the requested Item, null is returned.

        Containers should not return Items that are filtered out.

        Specified by:
        getItem in interface Container
        Parameters:
        itemId - ID of the Item to retrieve
        Returns:
        the Item with the given ID or null if the Item is not found in the Container

      • getUnfilteredItem

        protected abstract ITEMCLASS getUnfilteredItem​(Object itemId)
        Get an item even if filtered out. For internal use only.
        Parameters:
        itemId -
        Returns:

      • size

        public int size()
        Description copied from interface: Container
        Gets the number of visible Items in the Container.

        Filtering can hide items so that they will not be visible through the container API.

        Specified by:
        size in interface Container
        Returns:
        number of Items in the Container

      • containsId

        public boolean containsId​(Object itemId)
        Description copied from interface: Container
        Tests if the Container contains the specified Item.

        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.

        Specified by:
        containsId in interface Container
        Parameters:
        itemId - ID the of Item to be tested
        Returns:
        boolean indicating if the Container holds the specified Item

      • getItemIds

        public List<?> getItemIds()
        Description copied from interface: Container
        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.

        If the container is Container.Ordered, the collection returned by this method should follow that order. If the container is Container.Sortable, the items should be in the sorted order.

        Calling this method for large lazy containers can be an expensive operation and should be avoided when practical.

        Specified by:
        getItemIds in interface Container
        Returns:
        unmodifiable collection of Item IDs

      • nextItemId

        public ITEMIDTYPE nextItemId​(Object itemId)
        Description copied from interface: Container.Ordered
        Gets the ID of the Item following the Item that corresponds to itemId. If the given Item is the last or not found in the Container, null is returned.
        Specified by:
        nextItemId in interface Container.Ordered
        Parameters:
        itemId - ID of a visible Item in the Container
        Returns:
        ID of the next visible Item or null

      • prevItemId

        public ITEMIDTYPE prevItemId​(Object itemId)
        Description copied from interface: Container.Ordered
        Gets the ID of the Item preceding the Item that corresponds to itemId. If the given Item is the first or not found in the Container, null is returned.
        Specified by:
        prevItemId in interface Container.Ordered
        Parameters:
        itemId - ID of a visible Item in the Container
        Returns:
        ID of the previous visible Item or null

      • isFirstId

        public boolean isFirstId​(Object itemId)
        Description copied from interface: Container.Ordered
        Tests if the Item corresponding to the given Item ID is the first Item in the Container.
        Specified by:
        isFirstId in interface Container.Ordered
        Parameters:
        itemId - ID of an Item in the Container
        Returns:
        true if the Item is first visible item in the Container, false if not

      • isLastId

        public boolean isLastId​(Object itemId)
        Description copied from interface: Container.Ordered
        Tests if the Item corresponding to the given Item ID is the last Item in the Container.
        Specified by:
        isLastId in interface Container.Ordered
        Returns:
        true if the Item is last visible item in the Container, false if not

      • getIdByIndex

        public ITEMIDTYPE getIdByIndex​(int index)
        Description copied from interface: Container.Indexed
        Get the item id for the item at the position given by index.

        Specified by:
        getIdByIndex in interface Container.Indexed
        Parameters:
        index - the index of the requested item id
        Returns:
        the item id of the item at the given index

      • getItemIds

        public List<ITEMIDTYPE> getItemIds​(int startIndex,
                                   int numberOfIds)
        Description copied from interface: Container.Indexed
        Get numberOfItems consecutive item ids from the container, starting with the item id at startIndex.

        Implementations should return at most numberOfItems 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:

        startIndex to max(startIndex + (numberOfItems-1), container.size()-1).

        For quick migration to new API see: ContainerHelpers.getItemIdsUsingGetIdByIndex(int, int, Indexed)

        Specified by:
        getItemIds in interface Container.Indexed
        Parameters:
        startIndex - the index for the first item which id to include
        numberOfIds - the number of consecutive item ids to get from the given start index, must be >= 0
        Returns:
        List containing the requested item ids or empty list if numberOfItems == 0; not null

      • indexOfId

        public int indexOfId​(Object itemId)
        Description copied from interface: Container.Indexed
        Gets the index of the Item corresponding to the itemId. The following is true for the returned index: 0 <= index < size(), or index = -1 if there is no visible item with that id in the container.
        Specified by:
        indexOfId in interface Container.Indexed
        Parameters:
        itemId - ID of an Item in the Container
        Returns:
        index of the Item, or -1 if (the filtered and sorted view of) the Container does not include the Item

      • addItemAt

        public Object addItemAt​(int index)
                 throws UnsupportedOperationException
        Description copied from interface: Container.Indexed
        Adds a new item at given index (in the filtered view).

        The indices of the item currently in the given position and all the following items are incremented.

        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 Container.Indexed, Container.Ordered, Container.Filterable and Container.Sortable for more information.

        Specified by:
        addItemAt in interface Container.Indexed
        Parameters:
        index - Index (in the filtered and sorted view) to add the new item.
        Returns:
        item id of the created item or null if the operation fails.
        Throws:
        UnsupportedOperationException - if the operation is not supported by the container

      • addItemAt

        public Item addItemAt​(int index,
                      Object newItemId)
               throws UnsupportedOperationException
        Description copied from interface: Container.Indexed
        Adds a new item at given index (in the filtered view).

        The indexes of the item currently in the given position and all the following items are incremented.

        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 Container.Indexed, Container.Filterable and Container.Sortable for more information.

        Specified by:
        addItemAt in interface Container.Indexed
        Parameters:
        index - Index (in the filtered and sorted view) at which to add the new item.
        newItemId - Id of the new item to be added.
        Returns:
        new Item or null if the operation fails.
        Throws:
        UnsupportedOperationException - if the operation is not supported by the container

      • addItem

        public Item addItem​(Object itemId)
             throws UnsupportedOperationException
        Description copied from interface: Container
        Creates a new Item with the given ID in the Container.

        The new Item is returned, and it is ready to have its Properties modified. Returns null if the operation fails or the Container already contains a Item with the given ID.

        This functionality is optional.

        Specified by:
        addItem in interface Container
        Parameters:
        itemId - ID of the Item to be created
        Returns:
        Created new Item, or null in case of a failure
        Throws:
        UnsupportedOperationException - if adding an item with an explicit item ID is not supported by the container

      • addItem

        public Object addItem()
               throws UnsupportedOperationException
        Description copied from interface: Container
        Creates a new Item into the Container, and assign it an automatic ID.

        The new ID is returned, or null if the operation fails. After a successful call you can use the getItemmethod to fetch the Item.

        This functionality is optional.

        Specified by:
        addItem in interface Container
        Returns:
        ID of the newly created Item, or null in case of a failure
        Throws:
        UnsupportedOperationException - if adding an item without an explicit item ID is not supported by the container

      • removeItem

        public boolean removeItem​(Object itemId)
                   throws UnsupportedOperationException
        Description copied from interface: Container
        Removes the Item identified by ItemId from the Container.

        Containers that support filtering should also allow removing an item that is currently filtered out.

        This functionality is optional.

        Specified by:
        removeItem in interface Container
        Parameters:
        itemId - ID of the Item to remove
        Returns:
        true if the operation succeeded, false if not
        Throws:
        UnsupportedOperationException - if the container does not support removing individual items

      • removeAllItems

        public boolean removeAllItems()
                       throws UnsupportedOperationException
        Description copied from interface: Container
        Removes all Items from the Container.

        Note that Property ID and type information is preserved. This functionality is optional.

        Specified by:
        removeAllItems in interface Container
        Returns:
        true if the operation succeeded, false if not
        Throws:
        UnsupportedOperationException - if the container does not support removing all items

      • addContainerProperty

        public boolean addContainerProperty​(Object propertyId,
                                    Class<?> type,
                                    Object defaultValue)
                             throws UnsupportedOperationException
        Description copied from interface: Container
        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.

        This functionality is optional.

        Specified by:
        addContainerProperty in interface Container
        Parameters:
        propertyId - ID of the Property
        type - Data type of the new Property
        defaultValue - The value all created Properties are initialized to
        Returns:
        true if the operation succeeded, false if not
        Throws:
        UnsupportedOperationException - if the container does not support explicitly adding container properties

      • removeContainerProperty

        public boolean removeContainerProperty​(Object propertyId)
                                throws UnsupportedOperationException
        Description copied from interface: Container
        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.

        This functionality is optional.

        Specified by:
        removeContainerProperty in interface Container
        Parameters:
        propertyId - ID of the Property to remove
        Returns:
        true if the operation succeeded, false if not
        Throws:
        UnsupportedOperationException - if the container does not support removing container properties

      • filterAll

        protected void filterAll()
        Filter the view to recreate the visible item list from the unfiltered items, and send a notification if the set of visible items changed in any way.

      • doFilterContainer

        protected boolean doFilterContainer​(boolean hasFilters)
        Filters the data in the container and updates internal data structures. This method should reset any internal data structures and then repopulate them so getItemIds() and other methods only return the filtered items.
        Parameters:
        hasFilters - true if filters has been set for the container, false otherwise
        Returns:
        true if the item set has changed as a result of the filtering

      • passesFilters

        protected boolean passesFilters​(Object itemId)
        Checks if the given itemId passes the filters set for the container. The caller should make sure the itemId exists in the container. For non-existing itemIds the behavior is undefined.
        Parameters:
        itemId - An itemId that exists in the container.
        Returns:
        true if the itemId passes all filters or no filters are set, false otherwise.

      • hasContainerFilters

        protected boolean hasContainerFilters()
        Returns true if any filters have been applied to the container.
        Returns:
        true if the container has filters applied, false otherwise
        Since:
        7.1

      • isPropertyFiltered

        protected boolean isPropertyFiltered​(Object propertyId)
        Checks if there is a filter that applies to a given property.
        Parameters:
        propertyId -
        Returns:
        true if there is an active filter for the property

      • removeFilters

        protected Collection<Container.Filter> removeFilters​(Object propertyId)
        Remove all container filters for a given property identifier and re-filter the view. This also removes filters applying to multiple properties including the one identified by propertyId. This can be used to implement Filterable#removeContainerFilters(Object).
        Parameters:
        propertyId -
        Returns:
        Collection removed filters

      • getItemSorter

        protected ItemSorter getItemSorter()
        Returns the ItemSorter used for comparing items in a sort. See setItemSorter(ItemSorter) for more information.
        Returns:
        The ItemSorter used for comparing two items in a sort.

      • setItemSorter

        protected void setItemSorter​(ItemSorter itemSorter)
        Sets the ItemSorter used for comparing items in a sort. The ItemSorter.compare(Object, Object) method is called with item ids to perform the sorting. A default ItemSorter is used if this is not explicitly set.
        Parameters:
        itemSorter - The ItemSorter used for comparing two items in a sort (not null).

      • doSort

        protected void doSort()
        Perform the sorting of the data structures in the container. This is invoked when the itemSorter has been prepared for the sort operation. Typically this method calls Collections.sort(aCollection, getItemSorter()) on all arrays (containing item ids) that need to be sorted.

      • internalRemoveAllItems

        protected void internalRemoveAllItems()
        Removes all items from the internal data structures of this class. This can be used to implement removeAllItems() in subclasses. No notification is sent, the caller has to fire a suitable item set change notification.

      • internalRemoveItem

        protected boolean internalRemoveItem​(Object itemId)
        Removes a single item from the internal data structures of this class. This can be used to implement removeItem(Object) in subclasses. No notification is sent, the caller has to fire a suitable item set change notification.
        Parameters:
        itemId - the identifier of the item to remove
        Returns:
        true if an item was successfully removed, false if failed to remove or no such item

      • internalAddItemAtEnd

        protected ITEMCLASS internalAddItemAtEnd​(ITEMIDTYPE newItemId,
                                         ITEMCLASS item,
                                         boolean filter)
        Add an item at the end of the container, and perform filtering if necessary. An event is fired if the filtered view changes.
        Parameters:
        newItemId -
        item - new item to add
        filter - true to perform filtering and send event after adding the item, false to skip these operations for batch inserts - if false, caller needs to make sure these operations are performed at the end of the batch
        Returns:
        item added or null if no item was added

      • internalAddItemAfter

        protected ITEMCLASS internalAddItemAfter​(ITEMIDTYPE previousItemId,
                                         ITEMIDTYPE newItemId,
                                         ITEMCLASS item,
                                         boolean filter)
        Add an item after a given (visible) item, and perform filtering. An event is fired if the filtered view changes. The new item is added at the beginning if previousItemId is null.
        Parameters:
        previousItemId - item id of a visible item after which to add the new item, or null to add at the beginning
        newItemId -
        item - new item to add
        filter - true to perform filtering and send event after adding the item, false to skip these operations for batch inserts - if false, caller needs to make sure these operations are performed at the end of the batch
        Returns:
        item added or null if no item was added

      • internalAddItemAt

        protected ITEMCLASS internalAddItemAt​(int index,
                                      ITEMIDTYPE newItemId,
                                      ITEMCLASS item,
                                      boolean filter)
        Add an item at a given (visible after filtering) item index, and perform filtering. An event is fired if the filtered view changes.
        Parameters:
        index - position where to add the item (visible/view index)
        newItemId -
        item - new item to add
        filter - true to perform filtering and send event after adding the item, false to skip these operations for batch inserts - if false, caller needs to make sure these operations are performed at the end of the batch
        Returns:
        item added or null if no item was added

      • registerNewItem

        protected void registerNewItem​(int position,
                               ITEMIDTYPE itemId,
                               ITEMCLASS item)
        Registers a new item as having been added to the container. This can involve storing the item or any relevant information about it in internal container-specific collections if necessary, as well as registering listeners etc. The full identifier list in AbstractInMemoryContainer has already been updated to reflect the new item when this method is called.
        Parameters:
        position -
        itemId -
        item -

      • fireItemAdded

        protected void fireItemAdded​(int position,
                             ITEMIDTYPE itemId,
                             ITEMCLASS item)
        Notify item set change listeners that an item has been added to the container.
        Parameters:
        position - position of the added item in the view
        itemId - id of the added item
        item - the added item
        Since:
        7.4

      • fireItemsAdded

        protected void fireItemsAdded​(int firstPosition,
                              ITEMIDTYPE firstItemId,
                              int numberOfItems)
        Notify item set change listeners that items has been added to the container.
        Parameters:
        firstPosition - position of the first visible added item in the view
        firstItemId - id of the first visible added item
        numberOfItems - the number of visible added items

      • fireItemRemoved

        protected void fireItemRemoved​(int position,
                               Object itemId)
        Notify item set change listeners that an item has been removed from the container.
        Parameters:
        position - position of the removed item in the view prior to removal (if was visible)
        itemId - id of the removed item, of type Object to satisfy Container.removeItem(Object) API
        Since:
        7.4

      • fireItemsRemoved

        protected void fireItemsRemoved​(int firstPosition,
                                Object firstItemId,
                                int numberOfItems)
        Notify item set change listeners that items has been removed from the container.
        Parameters:
        firstPosition - position of the first visible removed item in the view prior to removal
        firstItemId - id of the first visible removed item, of type Object to satisfy Container.removeItem(Object) API
        numberOfItems - the number of removed visible items

      • getVisibleItemIds

        protected List<ITEMIDTYPE> getVisibleItemIds()
        Returns the internal list of visible item identifiers after filtering. For internal use only.

      • getFirstVisibleItem

        protected ITEMIDTYPE getFirstVisibleItem()
        Returns the item id of the first visible item after filtering. 'Null' is returned if there is no visible items.

        For internal use only.

        Returns:
        item id of the first visible item
        Since:
        7.4

      • isFiltered

        protected boolean isFiltered()
        Returns true is the container has active filters.
        Returns:
        true if the container is currently filtered

      • setFilteredItemIds

        @Deprecated
protected void setFilteredItemIds​(List<ITEMIDTYPE> filteredItemIds)
        Deprecated.
        Internal helper method to set the internal list of filtered item identifiers. Should not be used outside this class except for implementing clone(), may disappear from future versions.
        Parameters:
        filteredItemIds -

      • getFilteredItemIds

        protected List<ITEMIDTYPE> getFilteredItemIds()
        Internal helper method to get the internal list of filtered item identifiers. Should not be used outside this class except for implementing clone(), may disappear from future versions - use getVisibleItemIds() in other contexts.
        Returns:
        List

      • setAllItemIds

        @Deprecated
protected void setAllItemIds​(List<ITEMIDTYPE> allItemIds)
        Deprecated.
        Internal helper method to set the internal list of all item identifiers. Should not be used outside this class except for implementing clone(), may disappear from future versions.
        Parameters:
        allItemIds -

      • getAllItemIds

        protected List<ITEMIDTYPE> getAllItemIds()
        Internal helper method to get the internal list of all item identifiers. Avoid using this method outside this class, may disappear in future versions.
        Returns:
        List

      • setFilters

        protected void setFilters​(Set<Container.Filter> filters)
        Set the internal collection of filters without performing filtering. This method is mostly for internal use, use addFilter(Container.Filter) and remove*Filter* (which also re-filter the container) instead when possible.
        Parameters:
        filters -

      • getFilters

        protected Set<Container.Filter> getFilters()
        Returns the internal collection of filters. The returned collection should not be modified by callers outside this class.
        Returns:
        Set