Cursor (JPC 0.0.1-alpha-SNAPSHOT API)

java.lang.Object
- org.jpc.query.Cursor<T>

Type Parameters:

T -

All Implemented Interfaces:

AutoCloseable, Iterator<T>

Direct Known Subclasses:

CursorAdapter, CursorFilter, Query
```
public abstract class Cursor<T>
extends Object
implements AutoCloseable, Iterator<T>
```
Note: The class hierarchy of class Cursor will be redesigned after the coming release of Java8 supporting virtual extension methods

Author:

sergioc

Constructor Summary

Constructors
Constructor and Description

Cursor()

Constructors
Constructor and Description
`Cursor()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`abort()` Aborts execution.
`<T2> Cursor<T2>`	`adapt(com.google.common.base.Function<T,T2> converter)`
`List<T>`	`allSolutions()`
`protected abstract void`	`basicAbort()`
`protected List<T>`	`basicAllSolutions()` The default implementation for obtaining all the solutions consists on just making use of the existing next() method However, children could override this in case many calls to next() are more expensive that obtaining all the results of the query at once (e.g., a findall/3 query in Prolog)
`protected abstract void`	`basicClose()`
`protected abstract T`	`basicNext()` Returns the next available element in the cursor.
`protected T`	`basicOneSolutionOrThrow()`
`protected List<T>`	`basicSolutionsRange(long from, long to)`
`protected T`	`cachedNext()`
`void`	`close()`
`Cursor<T>`	`filter(com.google.common.base.Predicate<T> predicate)`
`void`	`finalize()`
`CursorState`	`getState()`
`boolean`	`hasNext()` Answers if there are still rows in the cursor.
`boolean`	`hasSolution()`
`abstract boolean`	`isAbortable()`
`boolean`	`isExhausted()`
`boolean`	`isOpen()`
`boolean`	`isReady()`
`protected List<T>`	`iterativeAllSolutions()`
`T`	`next()` Answers the next solution.
`protected void`	`nonSynchronizedClose()`
`List<T>`	`nSolutions(long n)`
`long`	`numberOfSolutions()`
`com.google.common.base.Optional<T>`	`oneSolution()`
`T`	`oneSolutionOrThrow()`
`void`	`remove()`
`protected void`	`setState(CursorState state)`
`List<T>`	`solutionsRange(long from, long to)`

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.Iterator
forEachRemaining

- Constructor Detail
  - Cursor
```
public Cursor()
```
- Method Detail
  - getState
```
public CursorState getState()
```
  - setState
```
protected void setState(CursorState state)
```
  - numberOfSolutions
```
public long numberOfSolutions()
```
    Returns:
    
    the number of solutions.
    
    Throws:
    
    IllegalStateException - if the cursor state is not READY.
  - hasSolution
```
public boolean hasSolution()
```
    Returns:
    
    true if there is at least one solution, false otherwise.
    
    Throws:
    
    IllegalStateException - if the cursor state is not READY.
  - oneSolution
```
public com.google.common.base.Optional<T> oneSolution()
```
    Returns:
    
    an Optional value with the first solution. Empty means that there are no solutions.
    
    Throws:
    
    IllegalStateException - if the cursor state is not READY.
  - oneSolutionOrThrow
```
public T oneSolutionOrThrow()
```
    Returns:
    
    the first solution to the query.
    
    Throws:
    
    IllegalStateException - if the cursor state is not READY.
    
    NoSuchElementException - if there are no solutions to the query.
  - basicOneSolutionOrThrow
```
protected T basicOneSolutionOrThrow()
```
  - nSolutions
```
public List<T> nSolutions(long n)
```
    Parameters:
    
    n - the number of solutions the method should return or until exhaustion of the solutions (whatever happens first).
    
    Returns:
    
    the first n solutions
    
    Throws:
    
    IllegalStateException - if the cursor state is not READY.
  - solutionsRange
```
public List<T> solutionsRange(long from,
                              long to)
```
    Parameters:
    
    from - the (0-based) index (inclusive) of the first solution
    
    to - the (0-based) index (exclusive) of the last solution
    
    Returns:
    
    a list with the solutions starting from 'from' (inclusive) to 'to' (exclusive) or until exhaustion of the solutions (whatever happens first). If there are less than (from+1) solutions will return an empty List
    
    Throws:
    
    IllegalStateException - if the cursor state is not READY.
  - basicSolutionsRange
```
protected List<T> basicSolutionsRange(long from,
                                      long to)
```
  - allSolutions
```
public List<T> allSolutions()
```
    Returns:
    
    a list with all solutions.
    
    Throws:
    
    IllegalStateException - if the cursor state is not READY.
  - basicAllSolutions
```
protected List<T> basicAllSolutions()
```
    The default implementation for obtaining all the solutions consists on just making use of the existing next() method However, children could override this in case many calls to next() are more expensive that obtaining all the results of the query at once (e.g., a findall/3 query in Prolog)
    
    Returns:
    
    a list with all solutions.
  - iterativeAllSolutions
```
protected List<T> iterativeAllSolutions()
```
  - filter
```
public Cursor<T> filter(com.google.common.base.Predicate<T> predicate)
```
  - adapt
```
public <T2> Cursor<T2> adapt(com.google.common.base.Function<T,T2> converter)
```
  - isReady
```
public boolean isReady()
```
    Returns:
    
    true if the cursor is ready, otherwise false.
  - isOpen
```
public boolean isOpen()
```
    Returns:
    
    true if the cursor is open, otherwise false.
  - isExhausted
```
public boolean isExhausted()
```
  - abort
```
public void abort()
```
    Aborts execution. This method is not synchronized since it is supposed to be called from a thread different to the one currently executing a query.
    
    Throws:
    
    IllegalStateException - if the cursor is not open.
  - isAbortable
```
public abstract boolean isAbortable()
```
  - close
```
public void close()
```
    Specified by:
    
    close in interface AutoCloseable
  - nonSynchronizedClose
```
protected void nonSynchronizedClose()
```
  - hasNext
```
public boolean hasNext()
```
    Answers if there are still rows in the cursor. This method may have effects on the state of the cursor. If the cursor is in READY state, it will change it to OPEN. If there are no more elements, it will change the state of the cursor to EXHAUSTED.
    
    Specified by:
    
    hasNext in interface Iterator<T>
    
    Returns:
    
    true if there are more solutions, false otherwise.
  - next
```
public T next()
```
    Answers the next solution.
    
    Specified by:
    
    next in interface Iterator<T>
    
    Returns:
    
    the next solution
    
    Throws:
    
    NoSuchElementException - if there are no more elements in the cursor.
  - cachedNext
```
protected T cachedNext()
```
  - basicAbort
```
protected abstract void basicAbort()
```
  - basicClose
```
protected abstract void basicClose()
```
  - basicNext
```
protected abstract T basicNext()
```
    Returns the next available element in the cursor. If the cursor is exhausted it should throw a NoSuchElementException the first time it is invoked. Its behavior is undetermined if invoked more than once after the cursor has been exhausted.
    
    Returns:
  - finalize
```
public void finalize()
```
    Overrides:
    
    finalize in class Object
  - remove
```
public void remove()
```
    Specified by:
    
    remove in interface Iterator<T>

Class Cursor<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Iterator

Constructor Detail

Cursor

Method Detail

getState

setState

numberOfSolutions

hasSolution

oneSolution

oneSolutionOrThrow

basicOneSolutionOrThrow

nSolutions

solutionsRange

basicSolutionsRange

allSolutions

basicAllSolutions

iterativeAllSolutions

filter

adapt

isReady

isOpen

isExhausted

abort

isAbortable

close

nonSynchronizedClose

hasNext

next

cachedNext

basicAbort

basicClose

basicNext

finalize

remove