Class IncrementalFaultList<E>

  • All Implemented Interfaces:
    Serializable, Iterable<E>, Collection<E>, List<E>

    public class IncrementalFaultList<E>
    extends Object
    implements List<E>, Serializable
    A synchronized list that serves as a container of DataObjects. It is returned when a paged query is performed by DataContext. On creation, only the first "page" is fully resolved, for the rest of the objects only their ObjectIds are read. Pages following the first page are resolved on demand only. On access to an element, the list would ensure that this element as well as all its siblings on the same page are fully resolved.

    The list can hold DataRows or DataObjects. Attempts to add any other object types will result in an exception.

    Performance note: certain operations like toArray would trigger full list fetch.

    See Also:
    Serialized Form
    • Field Detail

      • pageSize

        protected int pageSize
      • elements

        protected final List elements
      • unfetchedObjects

        protected int unfetchedObjects
      • idWidth

        protected int idWidth
        Stores a hint allowing to distinguish data rows from unfetched ids when the query fetches data rows.
      • maxFetchSize

        protected int maxFetchSize
        Defines the upper limit on the size of fetches. This is needed to avoid where clause size limitations.
    • Constructor Detail

      • IncrementalFaultList

        public IncrementalFaultList​(DataContext dataContext,
                                    Query query,
                                    int maxFetchSize)
        Creates a new IncrementalFaultList using a given DataContext and query.
        dataContext - DataContext used by IncrementalFaultList to fill itself with objects.
        query - Main query used to retrieve data. Must have "pageSize" property set to a value greater than zero.
        maxFetchSize - maximum number of fetches in one query
    • Method Detail

      • fillIn

        protected void fillIn​(Query query,
                              List<Object> elementsList)
        Performs initialization of the list of objects. Only the first page is fully resolved. For the rest of the list, only ObjectIds are read.
      • resolveAll

        public void resolveAll()
        Will resolve all unread objects.
      • resolveInterval

        protected void resolveInterval​(int fromIndex,
                                       int toIndex)
        Resolves a sublist of objects starting at fromIndex up to but not including toIndex. Internally performs bound checking and trims indexes accordingly.
      • pageIndex

        public int pageIndex​(int elementIndex)
        Returns zero-based index of the virtual "page" for a given array element index.
      • getMaxFetchSize

        public int getMaxFetchSize()
        Get the upper bound on the number of records to resolve in one round trip to the database. This setting governs the size/complexity of the where clause generated to retrieve the next page of records. If the fetch size is less than the page size, then multiple fetches will be made to resolve a page.
      • setMaxFetchSize

        public void setMaxFetchSize​(int fetchSize)
      • getDataContext

        public DataContext getDataContext()
        Returns the dataContext.
      • getPageSize

        public int getPageSize()
        Returns the pageSize.
      • listIterator

        public ListIterator<E> listIterator()
        Returns a list iterator for this list. DataObjects are resolved a page (according to getPageSize()) at a time as necessary - when retrieved with next() or previous().
        Specified by:
        listIterator in interface List<E>
      • listIterator

        public ListIterator<E> listIterator​(int index)
        Returns a list iterator of the elements in this list (in proper sequence), starting at the specified position in this list. The specified index indicates the first element that would be returned by an initial call to the next method. An initial call to the previous method would return the element with the specified index minus one. DataObjects are resolved a page at a time (according to getPageSize()) as necessary - when retrieved with next() or previous().
        Specified by:
        listIterator in interface List<E>
      • iterator

        public Iterator<E> iterator()
        Return an iterator for this list. DataObjects are resolved a page (according to getPageSize()) at a time as necessary - when retrieved with next().
        Specified by:
        iterator in interface Collection<E>
        Specified by:
        iterator in interface Iterable<E>
        Specified by:
        iterator in interface List<E>
      • get

        public E get​(int index)
        Specified by:
        get in interface List<E>
      • remove

        public E remove​(int index)
        Specified by:
        remove in interface List<E>
      • subList

        public List<E> subList​(int fromIndex,
                               int toIndex)
        Specified by:
        subList in interface List<E>
      • getUnfetchedObjects

        public int getUnfetchedObjects()
        Returns a total number of objects that are not resolved yet.