DefaultAbstractTokenContainerService (stumps 1.0-SNAPSHOT API)

java.lang.Object
- com.neurosys.q.service.AbstractTokenChangeGenerator<T,TokenEvent<T>>
- - com.neurosys.q.service.DefaultAbstractTokenContainerService<T,C>

Type Parameters:

T - as Token

C - as Token Container like Batch or Shift

All Implemented Interfaces:

ChangeGenerator<TokenEvent<T>>, TokenContainerService<T,C>
```
public abstract class DefaultAbstractTokenContainerService<T extends Token<T>,C extends TokenContainer<T>>
extends AbstractTokenChangeGenerator<T,TokenEvent<T>>
implements TokenContainerService<T,C>
```
Common methods for any form of Token Container Service like TokenManager and BatchService

Since this implements ChangeGenerator; it will also generate Events of Type
- BasicTokenEvent
Author:

Arjun Dhar

See Also:

SynchronousTokenChangeListener

Field Summary

Fields
Modifier and Type Field and Description

protected static Long SKIP_MOVE

Fields
Modifier and Type	Field and Description
`protected static Long`	`SKIP_MOVE`

Constructor Summary

Constructors
Constructor and Description

DefaultAbstractTokenContainerService()

Constructors
Constructor and Description
`DefaultAbstractTokenContainerService()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected abstract Supplier<javax.persistence.Query>`	`createTokensStateQuery(C tokenContainer, T afterToken, T beforeToken, Collection states, PageInfo pageInfo)` REUSABLE \| use with `#getTokens(TokenContainer, Token, Collection, String)`
`Collection<? extends T>`	`filter(Collection<? extends T> tokens)` All client sent tokens should be validated/filtered internally.
`protected javax.persistence.EntityManager`	`getEntityManager()`
`T`	`getFirstToken(C tokenContainer, Collection states)` Get the first token for a group of status
`T`	`getLastToken(C tokenContainer, Collection states)` In Some situations a token may need to be put end of Q in a particular State(s).
`protected List<Object[]>`	`getMovesForInterLinkingTokens(List<T> tokens)` For `ReQueableToken`s lnk them.
`protected List<Object[]>`	`getMovesForLinkingTokensAfter(List<T> tokens, T tokenAfter)` Link the internal tokens in order after the "tokenAfter".
`protected List<Object[]>`	`getMovesForMovedTokens(List<T> tokens)` The positions from which the tokens move (create spaces), patch them.
`List<TokenPosition<T>>`	`getPositions(List<T> tokens, Collection states)` Get the `TokenPosition` of a `Token` within its container .
`List<T>`	`getReadyToBeProcessed(C tokenContainer, T lastToken)` REUSABLE
`abstract List<T>`	`getTokens(C tokenContainer)`
`protected abstract List<T>`	`getTokens(C tokenContainer, Collection c, String field)` For a given `Token` Field name, where each element in the `Collection` matches the `Token` field value; fetch `Token` Example: If we wish to get all tokens with GUIDs in a set.
`List<T>`	`getTokens(C tokenContainer, T afterToken, Collection states)` REUSABLE
`List<T>`	`getTokens(C tokenContainer, T afterToken, T beforeToken, Collection states, PageInfo pageInfo)` REUSABLE
`protected abstract Number`	`getTokenSequenceId(C container, T token)` A Raw sequence#/position for a `Token` in the order it was added.
`List<T>`	`getTokensFrom(C tokenContainer, T token, Collection states)` Get all `Tokens`s in sequence till (excluding) the token
`List<T>`	`getTokensTill(C tokenContainer, T token, Collection states)` Get all `Tokens`s in sequence till (excluding) the token
`void`	`linkTokens(C tokenContainer, List<T> tokens)` Re-Q / Move the tokens
`abstract List<T>`	`lookupById(C tokenContainer, Object identifier)` Lookup token(s) in a token container, using any of the following identifiers.
`protected List<T>`	`lookupById(C tokenContainer, Object identifier, Supplier<javax.persistence.Query> query)`
`void`	`lookupBySequence(C tokenContainer, Map<Number,T> indexMap)` For each Number in the indeces, provide a Token, if it exists.
`T`	`lookupBySequence(C tokenContainer, Number sequence)` Lookup a token in a Container by sequence number in tokens that are `#getReadyToBeProcessed(TokenContainer, Token)`.
`int`	`move(C tokenContainer, List<T> tokens, T tokenAfter)` Deprecated. See `TokenContainerService.move(TokenContainer, List, Token)` JavaDoc for reason
`protected void`	`notifyAllListeners(Supplier<Collection<T>> tokensSupplier, TokenEvent<T> tokenEvent)` Convenience default method that allows basic mandatory actions like fetching all the tokens and apply `AbstractTokenChangeGenerator.trackChange(Object)` with asynchronous considerations
`protected abstract void`	`persistMoves(C tokenContainer, List<Object[]> moves)` A Move[] is an array [ `Token.getId()`, `ReQueableToken.getPreviousRef()`, `ReQueableToken.getNextRef()` ]. A `List` of moves
`T`	`poll(C tokenContainer)` Poll then next token READY to be served.
`List<T>`	`poll(C tokenContainer, Integer size)` An optimized Poll with N number of Tokens in one go.
`List<T>`	`poll(C tokenContainer, Integer size, T lastToken)` Based on Last Token return next set of `Token`s (of size), in `Shift`. This is for fail safe to ensure if a Token is lost in network errors, then the server knows last point of rollback.
`T`	`poll(C tokenContainer, T lastToken)` Based on Last Token return next `Token` in `TokenContainer`. This is for fail safe to ensure if a Token is lost in network errors, then the server knows last point of rollback.
`void`	`setEntityManager(javax.persistence.EntityManager em)`
`protected <S extends FlowStatus> List<T>`	`updateStatus(C tokenContainer, Collection c, S status, Function<String,javax.persistence.Query> query, TokenEvent<T> tokenEvent)`
`protected <S extends FlowStatus> List<T>`	`updateStatus(Collection c, S status, Function<String,javax.persistence.Query> query, TokenEvent<T> tokenEvent)`
`protected abstract void`	`updateTokenStatusInProcess(T token)` Update token to IN PROGRESS type state.
`protected boolean`	`validateMove(Object[] m)`

Methods inherited from class com.neurosys.q.service.AbstractTokenChangeGenerator
addChangeListener, getListeners, getTrackChange, notifyAllListeners, setListeners, setTrackChange, trackChange, trackChange

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

Methods inherited from interface com.neurosys.q.service.TokenContainerService
add, getAssignedContainer, getMaxResultSize, getQStatesStrategy, getSequence, getType, hasNext, init, lookup, remove, save, size, update, updateStatus, updateStatus

- Field Detail
  - SKIP_MOVE
```
protected static final Long SKIP_MOVE
```
- Constructor Detail
  - DefaultAbstractTokenContainerService
```
public DefaultAbstractTokenContainerService()
```
- Method Detail
  - getEntityManager
```
protected javax.persistence.EntityManager getEntityManager()
```
  - lookupById
```
public abstract List<T> lookupById(C tokenContainer,
                                   Object identifier)
```
    Description copied from interface: TokenContainerService
    
    Lookup token(s) in a token container, using any of the following identifiers. The types of identifiers supported is implementation dependent.
    
    A lookup operation is idempotent. Also, since the identifier can be anything full or partial a return type as List is supported. For all practical purposes this will be a single result.
    
    Specified by:
    
    lookupById in interface TokenContainerService<T extends Token<T>,C extends TokenContainer<T>>
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    identifier - as name String, Id Long
    
    Returns:
    
    List of
  - lookupBySequence
```
public void lookupBySequence(C tokenContainer,
                             Map<Number,T> indexMap)
```
    For each Number in the indeces, provide a Token, if it exists.
    
    Specified by:
    
    lookupBySequence in interface TokenContainerService<T extends Token<T>,C extends TokenContainer<T>>
    
    Parameters:
    
    batch - as Batch
    
    indexMap - as modifiable Map of the sequence as input and its value (if not null) as Token corresponding to it.
  - lookupBySequence
```
public T lookupBySequence(C tokenContainer,
                          Number sequence)
```
    Description copied from interface: TokenContainerService
    
    Lookup a token in a Container by sequence number in tokens that are #getReadyToBeProcessed(TokenContainer, Token).
    
    Specified by:
    
    lookupBySequence in interface TokenContainerService<T extends Token<T>,C extends TokenContainer<T>>
    
    Parameters:
    
    tokenContainer - as container type
    
    sequence - as Number
    
    Returns:
  - updateTokenStatusInProcess
```
protected abstract void updateTokenStatusInProcess(T token)
```
    Update token to IN PROGRESS type state. An in memory abstract operation used to support common code. HACK FOR COMMON FUNCTIONALITY like Queue.remove()
    
    Parameters:
    
    tokenContainer - as
    
    token - as Token
  - poll
```
public T poll(C tokenContainer)
```
    Description copied from interface: TokenContainerService
    
    Poll then next token READY to be served. A State of READY is defined by QStatesStrategy.getReadyToBeProcessed()
    
    Specified by:
    
    poll in interface TokenContainerService<T extends Token<T>,C extends TokenContainer<T>>
    
    Parameters:
    
    tokenContainer - as container type
    
    Returns:
    
    next Token within the container. null if none
    
    See Also:
    
    #getReadyToBeProcessed(TokenContainer), QStatesStrategy
  - poll
```
public T poll(C tokenContainer,
              T lastToken)
```
    Description copied from interface: TokenContainerService
    
    Based on Last Token return next Token in TokenContainer.
    This is for fail safe to ensure if a Token is lost in network errors, then the server knows last point of rollback.
    
    Specified by:
    
    poll in interface TokenContainerService<T extends Token<T>,C extends TokenContainer<T>>
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    lastToken - as Token type
    
    Returns:
    
    Token type . null if none
  - poll
```
public List<T> poll(C tokenContainer,
                    Integer size)
```
    Description copied from interface: TokenContainerService
    
    An optimized Poll with N number of Tokens in one go.
    
    Specified by:
    
    poll in interface TokenContainerService<T extends Token<T>,C extends TokenContainer<T>>
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    Returns:
    
    List of Token of type . null if none
  - poll
```
public List<T> poll(C tokenContainer,
                    Integer size,
                    T lastToken)
```
    Description copied from interface: TokenContainerService
    
    Based on Last Token return next set of Tokens (of size), in Shift.
    This is for fail safe to ensure if a Token is lost in network errors, then the server knows last point of rollback.
    
    Specified by:
    
    poll in interface TokenContainerService<T extends Token<T>,C extends TokenContainer<T>>
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    Returns:
    
    List of Token of type . null if none
  - setEntityManager
```
public void setEntityManager(javax.persistence.EntityManager em)
```
    Parameters:
    
    em - the em to set
  - filter
```
public Collection<? extends T> filter(Collection<? extends T> tokens)
```
    All client sent tokens should be validated/filtered internally. Provide a consistent an API call for it.
    
    Parameters:
    
    tokens -
    
    Returns:
  - lookupById
```
protected List<T> lookupById(C tokenContainer,
                             Object identifier,
                             Supplier<javax.persistence.Query> query)
```
  - getReadyToBeProcessed
```
public List<T> getReadyToBeProcessed(C tokenContainer,
                                     T lastToken)
```
    REUSABLE
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    lastToken - as Token type
    
    query -
    
    Returns:
    
    List
    
    See Also:
    
    #createTokensStateQuery(TokenContainer, Token, String)
  - createTokensStateQuery
```
protected abstract Supplier<javax.persistence.Query> createTokensStateQuery(C tokenContainer,
                                                                            T afterToken,
                                                                            T beforeToken,
                                                                            Collection states,
                                                                            PageInfo pageInfo)
```
    REUSABLE | use with #getTokens(TokenContainer, Token, Collection, String)
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    afterToken - AFTER which tokens should be queried as Token type . @nullable true
    
    beforeTokem - BEFORE which tokens should be queried as Token type . @nullable true
    
    states - as Collection of Token States. Example TokenStatus
    
    pageInfo - as PageInfo. Can be null
    
    Returns:
    
    Supplier
    
    See Also:
    
    DefaultAbstractTokenContainerService#getTokens(TokenContainer, Token, Collection, String)
  - getTokens
```
public List<T> getTokens(C tokenContainer,
                         T afterToken,
                         T beforeToken,
                         Collection states,
                         PageInfo pageInfo)
```
    REUSABLE
    
    See Also:
    
    #createTokensStateQuery(TokenContainer, Token, String)
  - getTokens
```
public List<T> getTokens(C tokenContainer,
                         T afterToken,
                         Collection states)
```
    REUSABLE
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    afterToken - as Token type
    
    states - as Collection of Token States. Example TokenStatus
    
    Returns:
    
    List
    
    See Also:
    
    #createTokensStateQuery(TokenContainer, Token, String)
  - getTokens
```
protected abstract List<T> getTokens(C tokenContainer,
                                     Collection c,
                                     String field)
```
    For a given Token Field name, where each element in the Collection matches the Token field value; fetch Token
    Example: If we wish to get all tokens with GUIDs in a set. The set is collection and field is GUID.
    
    Parameters:
    
    tokenContainer - as TokenContainer we wish to fetch the Tokens only for. Null implies all.
    
    c - as Collection of Ids or values that represent the field
    
    field - as String. Blank means the type is Token, if not blank then the field should contain a prefix "."
    
    See Also:
    
    AbstractTokenChangeGenerator.notifyAllListeners(TokenEvent)
  - getPositions
```
public List<TokenPosition<T>> getPositions(List<T> tokens,
                                           Collection states)
```
    Get the TokenPosition of a Token within its container . Number index starts from 0
    
    This uses #getTokens(...); all getTokens are expected to be sorted based on Q-sorting algo already, so any prioritization etc would be assumed taken care of within any wsorting within getTokens(...)
    
    Specified by:
    
    getPositions in interface TokenContainerService<T extends Token<T>,C extends TokenContainer<T>>
    
    Parameters:
    
    tokens - as List of Token type
    
    states - as Token States
    
    Returns:
    
    Number. null if in a ready state
    
    See Also:
    
    Batch.getSequence(Token), TokenContainerService.getSequence(TokenContainer, Token)
  - getTokenSequenceId
```
protected abstract Number getTokenSequenceId(C container,
                                             T token)
```
    A Raw sequence#/position for a Token in the order it was added. This does NOT indicate its TokenContainerService.getSequence(TokenContainer, Token) or getPositions(List, Collection)
    
    Parameters:
    
    token - as Token
    
    Returns:
    
    Number
  - updateStatus
```
protected <S extends FlowStatus> List<T> updateStatus(Collection c,
                                                      S status,
                                                      Function<String,javax.persistence.Query> query,
                                                      TokenEvent<T> tokenEvent)
```
    Parameters:
    
    c - as Collection of Tokens
    
    status - as FlowStatus to update to
    
    query - as Function to convert Field name to Query
    
    tokenEvent - as TokenEvent
    
    Returns:
    
    number of records whose status was updated
    
    See Also:
    
    #notifyAllListeners(Supplier, TokenEventFlowStatus, TokenEvent)
  - updateStatus
```
protected <S extends FlowStatus> List<T> updateStatus(C tokenContainer,
                                                      Collection c,
                                                      S status,
                                                      Function<String,javax.persistence.Query> query,
                                                      TokenEvent<T> tokenEvent)
```
    Parameters:
    
    tokenContainer - as TokenContainer or null (for tokens across containers)
    
    c - as Collection of Tokens
    
    status - as FlowStatus to update to
    
    query - as Function to convert Field name to Query
    
    tokenEvent - as TokenEvent
    
    Returns:
    
    number of records whose status was updated
    
    See Also:
    
    #notifyAllListeners(Supplier, TokenEventFlowStatus, TokenEvent)
  - notifyAllListeners
```
protected void notifyAllListeners(Supplier<Collection<T>> tokensSupplier,
                                  TokenEvent<T> tokenEvent)
```
    Convenience default method that allows basic mandatory actions like fetching all the tokens and apply AbstractTokenChangeGenerator.trackChange(Object) with asynchronous considerations
    
    Parameters:
    
    tokens - Supplier of Tokens
    
    status - as TokenEvent.TokenEventFlowStatus
    
    tokenEvent - as TokenEvent
    
    See Also:
    
    SynchronousChange, TokenEvent, BasicTokenEvent, Feedback, SynchronousTokenChangeListener
  - getTokens
```
public abstract List<T> getTokens(C tokenContainer)
```
  - getLastToken
```
public T getLastToken(C tokenContainer,
                      Collection states)
```
    In Some situations a token may need to be put end of Q in a particular State(s). So find out last token and place it after it.
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    states - as Collection of status type objects (Optional. If not specified will search across all Status)
    
    Returns:
    
    Token
    
    Can be null:
    
    true
  - getFirstToken
```
public T getFirstToken(C tokenContainer,
                       Collection states)
```
    Get the first token for a group of status
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    states - as Collection of status type objects (Optional. If not specified will search across all Status)
    
    Returns:
    
    Token
    
    Can be null:
    
    true
  - getTokensTill
```
public List<T> getTokensTill(C tokenContainer,
                             T token,
                             Collection states)
```
    Get all Tokenss in sequence till (excluding) the token
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    token - as Token till
    
    states - as Collection of status type objects (Optional. If not specified will search across all Status)
    
    Returns:
    
    List of Tokens
  - getTokensFrom
```
public List<T> getTokensFrom(C tokenContainer,
                             T token,
                             Collection states)
```
    Get all Tokenss in sequence till (excluding) the token
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    token - as Token from (excluding)
    
    states - as Collection of status type objects (Optional. If not specified will search across all Status)
    
    Returns:
    
    List of Tokens
  - validateMove
```
protected boolean validateMove(Object[] m)
```
  - persistMoves
```
protected abstract void persistMoves(C tokenContainer,
                                     List<Object[]> moves)
```
    A Move[] is an array [ Token.getId(), ReQueableToken.getPreviousRef(), ReQueableToken.getNextRef() ].
    A List of moves
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    moves - as List of Move (Object[])
  - getMovesForInterLinkingTokens
```
protected List<Object[]> getMovesForInterLinkingTokens(List<T> tokens)
```
    For ReQueableTokens lnk them.
    
    Parameters:
    
    tokens - as List of Tokens
    
    tokenAfter - as optional token after which the tokens will be added/intelinked
    
    Returns:
    
    List of moves
  - linkTokens
```
public void linkTokens(C tokenContainer,
                       List<T> tokens)
```
    Re-Q / Move the tokens
    
    Specified by:
    
    linkTokens in interface TokenContainerService<T extends Token<T>,C extends TokenContainer<T>>
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    tokens - as List of Tokens
  - getMovesForLinkingTokensAfter
```
protected List<Object[]> getMovesForLinkingTokensAfter(List<T> tokens,
                                                       T tokenAfter)
```
    Link the internal tokens in order after the "tokenAfter".
    
    See Also:
    
    #persistMoves(List, T), move(TokenContainer, List, Token)
  - getMovesForMovedTokens
```
protected List<Object[]> getMovesForMovedTokens(List<T> tokens)
```
    The positions from which the tokens move (create spaces), patch them. This will CUT out the tokens
    
    See Also:
    
    #persistMoves(List, T), move(TokenContainer, List, Token)
  - move
```
@Deprecated
public int move(C tokenContainer,
                            List<T> tokens,
                            T tokenAfter)
```
    Deprecated. See TokenContainerService.move(TokenContainer, List, Token) JavaDoc for reason
    
    Re-Q / Move the tokens This implementation assumes Tokens are of ReQueableToken type.
    
    Specified by:
    
    move in interface TokenContainerService<T extends Token<T>,C extends TokenContainer<T>>
    
    Parameters:
    
    tokenContainer - as TokenContainer type
    
    tokens - as List of Tokens
    
    Returns:
    
    int as count of number of moves made (including repairs to positions from where the tokens was moved from)
    
    See Also:
    
    USAGE CAUTION

Class DefaultAbstractTokenContainerService<T extends Token<T>,C extends TokenContainer<T>>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class com.neurosys.q.service.AbstractTokenChangeGenerator

Methods inherited from class java.lang.Object

Methods inherited from interface com.neurosys.q.service.TokenContainerService

Field Detail

SKIP_MOVE

Constructor Detail

DefaultAbstractTokenContainerService

Method Detail

getEntityManager

lookupById

lookupBySequence

lookupBySequence

updateTokenStatusInProcess

poll

poll

poll

poll

setEntityManager

filter

lookupById

getReadyToBeProcessed

createTokensStateQuery

getTokens

getTokens

getTokens

getPositions

getTokenSequenceId

updateStatus

updateStatus

notifyAllListeners

getTokens

getLastToken

getFirstToken

getTokensTill

getTokensFrom

validateMove

persistMoves

getMovesForInterLinkingTokens

linkTokens

getMovesForLinkingTokensAfter

getMovesForMovedTokens

move