# Class IncrementalFaultList<E>

java.lang.Object
org.apache.cayenne.access.IncrementalFaultList<E>

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

public class IncrementalFaultList<E> extends Object implements List<E>, Serializable
A synchronized list that serves as a container of Persistent objects. 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 Persistent objects. 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 Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected final DataContext`
  `dataContext`
  `protected final List`
  `elements`
  `protected final int`
  `idWidth`
  Stores a hint allowing to distinguish data rows from unfetched ids when the query fetches data rows.
  `protected int`
  `maxFetchSize`
  Defines the upper limit on the size of fetches.
  `protected final QueryMetadata`
  `metadata`
  `protected final int`
  `pageSize`
  `protected final ObjEntity`
  `rootEntity`
  `protected int`
  `unfetchedObjects`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `add(int index, Object element)`
  `boolean`
  `add(Object o)`
  `boolean`
  `addAll(int index, Collection<? extends E> c)`
  `boolean`
  `addAll(Collection<? extends E> c)`
  `void`
  `clear()`
  `boolean`
  `contains(Object o)`
  `boolean`
  `containsAll(Collection<?> c)`
  `void`
  `fillIn(List<?> elementsList)`
  Sets initial data (i.e. list of ObjectIds) for this FaultList
  `protected void`
  `fillIn(Query query, List<Object> elementsList)`
  Deprecated, for removal: This API element is subject to removal in a future version.
  does nothing
  `E`
  `get(int index)`
  `DataContext`
  `getDataContext()`
  Returns the dataContext.
  `int`
  `getMaxFetchSize()`
  Get the upper bound on the number of records to resolve in one round trip to the database.
  `int`
  `getPageSize()`
  Returns the pageSize.
  `int`
  `getUnfetchedObjects()`
  Returns a total number of objects that are not resolved yet.
  `int`
  `indexOf(Object o)`
  `boolean`
  `isEmpty()`
  `Iterator<E>`
  `iterator()`
  Return an iterator for this list.
  `int`
  `lastIndexOf(Object o)`
  `ListIterator<E>`
  `listIterator()`
  Returns a list iterator for this list.
  `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.
  `int`
  `pageIndex(int elementIndex)`
  Returns zero-based index of the virtual "page" for a given array element index.
  `E`
  `remove(int index)`
  `boolean`
  `remove(Object o)`
  `boolean`
  `removeAll(Collection<?> c)`
  `void`
  `resolveAll()`
  Will resolve all unread objects.
  `protected void`
  `resolveInterval(int fromIndex, int toIndex)`
  Resolves a sublist of objects starting at `fromIndex` up to but not including `toIndex`.
  `boolean`
  `retainAll(Collection<?> c)`
  `E`
  `set(int index, Object element)`
  `void`
  `setMaxFetchSize(int fetchSize)`
  `int`
  `size()`
  `List<E>`
  `subList(int fromIndex, int toIndex)`
  `Object[]`
  `toArray()`
  `<T> T[]`
  `toArray(T[] a)`

  ### Methods inherited from class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

  ### Methods inherited from interface Collection

  `parallelStream, removeIf, stream, toArray`

  ### Methods inherited from interface Iterable

  `forEach`

  ### Methods inherited from interface List

  `addFirst, addLast, equals, getFirst, getLast, hashCode, removeFirst, removeLast, replaceAll, reversed, sort, spliterator`

- ## Field Details

  - ### pageSize

    protected final int pageSize

  - ### elements

    protected final List elements

  - ### dataContext

    protected final DataContext dataContext

  - ### rootEntity

    protected final ObjEntity rootEntity

  - ### unfetchedObjects

    protected volatile int unfetchedObjects

  - ### idWidth

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

  - ### metadata

    protected final QueryMetadata metadata

  - ### maxFetchSize

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

- ## Method Details

  - ### fillIn

    @Deprecated(since="5.0", forRemoval=true) protected void fillIn(Query query, List<Object> elementsList)
    Deprecated, for removal: This API element is subject to removal in a future version.
    does nothing
    Performs initialization of the list of objects. Only the first page is fully resolved. For the rest of the list, only ObjectIds are read.
    Since:
      3.0

  - ### fillIn

    public void fillIn(List<?> elementsList)
    Sets initial data (i.e. list of ObjectIds) for this FaultList
    Parameters:
      `elementsList` - initial data to fill this list with
    Since:
      5.0

  - ### 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.
    Returns:
      DataContext

  - ### getPageSize

    public int getPageSize()
    Returns the pageSize.
    Returns:
      int

  - ### listIterator

    public ListIterator<E> listIterator()
    Returns a list iterator for this list. Persistent objects 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. Persistent objects 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. Persistent objects 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>`

  - ### add

    public void add(int index, Object element)
    Specified by:
      `add` in interface `List<E>`
    See Also:
      - `List.add(int, Object)`

  - ### add

    public boolean add(Object o)
    Specified by:
      `add` in interface `Collection<E>`
    Specified by:
      `add` in interface `List<E>`
    See Also:
      - `Collection.add(Object)`

  - ### addAll

    public boolean addAll(Collection<? extends E> c)
    Specified by:
      `addAll` in interface `Collection<E>`
    Specified by:
      `addAll` in interface `List<E>`
    See Also:
      - `Collection.addAll(Collection)`

  - ### addAll

    public boolean addAll(int index, Collection<? extends E> c)
    Specified by:
      `addAll` in interface `List<E>`
    See Also:
      - `List.addAll(int, Collection)`

  - ### clear

    public void clear()
    Specified by:
      `clear` in interface `Collection<E>`
    Specified by:
      `clear` in interface `List<E>`
    See Also:
      - `Collection.clear()`

  - ### contains

    public boolean contains(Object o)
    Specified by:
      `contains` in interface `Collection<E>`
    Specified by:
      `contains` in interface `List<E>`
    See Also:
      - `Collection.contains(Object)`

  - ### containsAll

    public boolean containsAll(Collection<?> c)
    Specified by:
      `containsAll` in interface `Collection<E>`
    Specified by:
      `containsAll` in interface `List<E>`
    See Also:
      - `Collection.containsAll(Collection)`

  - ### get

    public E get(int index)
    Specified by:
      `get` in interface `List<E>`

  - ### indexOf

    public int indexOf(Object o)
    Specified by:
      `indexOf` in interface `List<E>`
    See Also:
      - `List.indexOf(Object)`

  - ### isEmpty

    public boolean isEmpty()
    Specified by:
      `isEmpty` in interface `Collection<E>`
    Specified by:
      `isEmpty` in interface `List<E>`
    See Also:
      - `Collection.isEmpty()`

  - ### lastIndexOf

    public int lastIndexOf(Object o)
    Specified by:
      `lastIndexOf` in interface `List<E>`

  - ### remove

    public E remove(int index)
    Specified by:
      `remove` in interface `List<E>`

  - ### remove

    public boolean remove(Object o)
    Specified by:
      `remove` in interface `Collection<E>`
    Specified by:
      `remove` in interface `List<E>`

  - ### removeAll

    public boolean removeAll(Collection<?> c)
    Specified by:
      `removeAll` in interface `Collection<E>`
    Specified by:
      `removeAll` in interface `List<E>`

  - ### retainAll

    public boolean retainAll(Collection<?> c)
    Specified by:
      `retainAll` in interface `Collection<E>`
    Specified by:
      `retainAll` in interface `List<E>`

  - ### set

    public E set(int index, Object element)
    Specified by:
      `set` in interface `List<E>`
    See Also:
      - `List.set(int, Object)`

  - ### size

    public int size()
    Specified by:
      `size` in interface `Collection<E>`
    Specified by:
      `size` in interface `List<E>`
    See Also:
      - `Collection.size()`

  - ### subList

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

  - ### toArray

    public Object[] toArray()
    Specified by:
      `toArray` in interface `Collection<E>`
    Specified by:
      `toArray` in interface `List<E>`

  - ### toArray

    public <T> T[] toArray(T[] a)
    Specified by:
      `toArray` in interface `Collection<E>`
    Specified by:
      `toArray` in interface `List<E>`

  - ### getUnfetchedObjects

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