Package de.aristaflow.adept2.model.worklistmodel

Class CachingIncWorklistUpdate

    • Field Detail

      • wrappedUpdate

        protected IncrementalWorklistUpdate wrappedUpdate
        The wrapped incremental worklist update of which all item updates will be cached. Note that the current cursor need not correspond to the current cursor of the underlying incremental worklist update. This will be null when the incremental worklist update has been dropped.

      • lastCached

        protected int lastCached
        The index of the last item update that is in the cache. This corresponds to the current index of the wrapped incremental worklist update.

      • last

        protected int last
        The index of last item update in case it has been reached in the result set, -1 otherwise.

      • current

        protected int current
        The reference to the current item update which is to be retrieved next.

      • worklistId

        protected UUID worklistId
        The ID the worklist of the incremental worklist update. This will be null until first retrieved from the wrapped incremental worklist update.

      • sourceRevision

        protected WorklistRevision sourceRevision
        The source revision of the worklist update. This will be null until first retrieved from the wrapped incremental worklist update.

      • targetRevision

        protected Long targetRevision
        The target revision of the worklist update. This will be null until first retrieved from the wrapped incremental worklist update.

      • maxPriority

        protected Integer maxPriority
        The maximum priority of the worklist update. This will be null until first retrieved from the wrapped incremental worklist update.

    • Constructor Detail

      • CachingIncWorklistUpdate

        public CachingIncWorklistUpdate​(IncrementalWorklistUpdate wrappedUpdate)
        Creates a new caching incremental worklist update for the designated incremental worklist update.
        Parameters:
        wrappedUpdate - The incremental worklist update of which the item updates should be cached as soon as they are iterated (with getNext(int)).

    • Method Detail

      • getNext

        public List<WorklistItemUpdate<ClientWorklistItem>> getNext​(int count)
        Description copied from interface: IncrementalWorklistUpdate
        Gets the next specified amount of worklist item updates of this incremental worklist update.
        Be sure to call this method afterwards to release occupied memory and resources.
        Specified by:
        getNext in interface IncrementalWorklistUpdate
        Parameters:
        count - The amount of worklist item updates to retrieve. This has to be > 0.
        Returns:
        The next n worklist item updates of this incremental worklist update, where n is the specified count. In case of an insufficient amount of next elements remaining only the available elements will be returned. If there are no more next elements, null will be returned.

      • getNext

        public List<WorklistItemUpdate<ClientWorklistItem>> getNext​(int count,
                                                            int start)
        Gets the next specified amount of item updates of this incremental worklist update starting at the designated index (0-based). The returned data will be consistent within the returned list (but not necessarily with respect to previous or later retrievals) due to the usage of synchronisation.
        Afterwards the cursor to the current item update will be set to the index start + count, that is, getNext(n) will be the same as calling getNext(n, start + count).
        Parameters:
        count - The amount of item updates to retrieve in forward direction. This has to be > 0.
        start - The index of the item update from which to retrieve the next count item updates. 0 is the index of the first item update . This has to be >= 0 and it must not be bigger than the amounts of item updates in this incremental worklist update.
        Returns:
        The next n item updates of this incremental worklist update, where n is the specified count. In case of an insufficient amount of next item updates remaining only the available item updates will be returned. If there are no more next item updates, null will be returned.
        Throws:
        IllegalArgumentException - If count is non-positive (<= 0) or start is negative (< 0) or it refers to an index that is bigger than the amount of item updates of this incremental worklist update, an IllegalArgumentException will be thrown. The incremental worklist update will be reset to the first item update.
        IllegalStateException - If this incremental worklist update has been dropped (explicitly or implicitly), an IllegalStateException will be thrown on server side.

      • getPrevious

        public List<WorklistItemUpdate<ClientWorklistItem>> getPrevious​(int count)
        Gets the previous specified amount of item updates of this incremental worklist update. The returned data will be consistent within the returned list (but not necessarily with respect to previous or later retrievals) due to the usage of synchronisation.
        Parameters:
        count - The amount of item updates to retrieve in backward direction. This has to be > 0.
        Returns:
        The previous n item updates of this incremental worklist update, where n is the specified count. The order corresponds to the one in the underlying data structure, that is previous item updates in the returned list are also previous item updates in the data structure. In case of an insufficient amount of previous item updates remaining only the available item updates will be returned. If there are no more previous item updates, null will be returned.
        Throws:
        IllegalArgumentException - If this incremental worklist update does not have any previous item updates or count is non-positive (<= 0), an IllegalArgumentException will be thrown.
        IllegalStateException - If this iterator has been dropped (explicitly or implicitly), an IllegalStateException will be thrown on server side.
        de.aristaflow.adept2.model.communication.ServiceConnectionException - If this incremental worklist update has been dropped (explicitly or implicitly), a ServiceConnectionException will be thrown on client side.

      • getAll

        public List<WorklistItemUpdate<ClientWorklistItem>> getAll()
        Description copied from interface: IncrementalWorklistUpdate
        Returns all updates, i.e. the differences from the source revision up to (and including) the target revision. The map contains all worklist items including the ones which are deleted since the source revision.

        The returned collection is unmodifiable.

        When compiling the individual recorded updates into a worklist update, the case when there are multiple recorded updates for the same worklist item (i.e. same ID, not necessarily same state) needs special attention. In this case the recorded updates need to be compressed, since a worklist update may only contain one update per worklist item. It is assumed, that every revision only contains one added, removed or changed worklist item. To compress these individual updates, only the first (since the source revision) and the last recorded update of a certain worklist item need to be considered: The state of the client worklist item (which is the key of the map), is the state at the time of its last update.
        The WorklistConstants.WorklistItemUpdateType (which is the value in the map) is determined by looking at the type of the first and the last recorded update for that item. The following shows the relevant combinations and their results.

        How different worklist item update types aggregate.
        type of first recorded update type of last recorded update resulting update type
        ADDEDCHANGEDADDED
        ADDEDREMOVEDomit (NOTHING)
        ADDEDADDED_OR_CHANGEDADDED
        ADDEDREMOVED_OR_NOTHINGomit (NOTHING)
        CHANGEDCHANGEDCHANGED
        CHANGEDREMOVEDREMOVED
        CHANGEDADDED_OR_CHANGEDCHANGED
        CHANGEDREMOVED_OR_NOTHINGREMOVED
        REMOVEDADDEDCHANGED
        REMOVEDADDED_OR_CHANGEDCHANGED
        REMOVEDREMOVED_OR_NOTHINGREMOVED
        ADDED_OR_CHANGEDCHANGEDADDED_OR_CHANGED
        ADDED_OR_CHANGEDREMOVEDREMOVED_OR_NOTHING
        ADDED_OR_CHANGEDADDED_OR_CHANGEDADDED_OR_CHANGED
        ADDED_OR_CHANGEDREMOVED_OR_NOTHINGREMOVED_OR_NOTHING
        REMOVED_OR_NOTHINGADDEDADDED_OR_CHANGED
        REMOVED_OR_NOTHINGADDED_OR_CHANGEDADDED_OR_CHANGED
        REMOVED_OR_NOTHINGREMOVED_OR_NOTHINGREMOVED_OR_NOTHING
        Other combinations don't make any sense and therefore shouldn't occur. If there's only one recorded update for an item use that update's type. After calling this method once, this incremental worklist update will be dropped. You will not be able to use it again, that is, every method will throw an IllegalStateException.
        Specified by:
        getAll in interface IncrementalWorklistUpdate
        Specified by:
        getAll in interface WorklistUpdate
        Returns:
        The updates / differences between source and target revision.

      • drop

        public void drop()
        Description copied from interface: IncrementalWorklistUpdate
        Explicitly drops this worklist update which allows to release occupied memory and resources. Dropping will be done implicitly after the worklist update has been retrieved completely by calling IncrementalWorklistUpdate.getAll() once. When retrieving incrementally, be sure to call this method afterwards to release occupied memory and resources.
        This method may be called several times. Implementors have to take care of this.
        Specified by:
        drop in interface IncrementalWorklistUpdate

      • dropWrapped

        protected void dropWrapped​(boolean dropThis)
        Drops the wrapped incremental worklist update either since it is explicitly dropped or the cache contains all items and the wrapped incremental worklist update is no longer required.
        Parameters:
        dropThis - Whether to drop this caching incremental worklist update or only the wrapped incremental worklist update. This affects whether the cached fields will be set or not.