Package nl.tue.astar.impl.memefficient

Class MemoryEfficientStorageHandler<H extends Head,T extends Tail>

java.lang.Object

nl.tue.astar.impl.memefficient.MemoryEfficientStorageHandler<H,T>

All Implemented Interfaces:

AbstractAStarThread.StorageHandler<H,T>

public class MemoryEfficientStorageHandler<H extends Head,T extends Tail>
extends java.lang.Object
implements AbstractAStarThread.StorageHandler<H,T>

Field Summary

Fields

Modifier and Type	Field	Description
protected MemoryEfficientAStarAlgorithm<H,T>	algorithm
protected StorageAwareDelegate<H,T>	delegate
protected java.util.concurrent.locks.ReentrantReadWriteLock	lock
protected CompressedHashSet<State<H,T>>	statespace
protected CompressedStore<State<H,T>>	store

Constructor Summary

Constructors

Constructor	Description
MemoryEfficientStorageHandler(MemoryEfficientAStarAlgorithm<H,T> algorithm)

Method Summary

Modifier and Type	Method	Description
int	getEstimate(H head, long index)	return the estimate of the tail for the given head.
long	getIndexOf(H head)
State<H,T>	getStoredState(Record rec)
<TT extends FastLowerBoundTail> void	reComputeFastLowerboundTail(Record rec, TT tail, H head, int storedEstimate)	implementations may assume that TT == T
void	storeStateForRecord(State<H,T> state, Record newRec)

Methods inherited from class java.lang.Object

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

Field Detail

algorithm

protected final MemoryEfficientAStarAlgorithm<H extends Head,T extends Tail> algorithm

store

protected final CompressedStore<State<H extends Head,T extends Tail>> store

statespace

protected final CompressedHashSet<State<H extends Head,T extends Tail>> statespace

delegate

protected final StorageAwareDelegate<H extends Head,T extends Tail> delegate

lock

protected final java.util.concurrent.locks.ReentrantReadWriteLock lock

Constructor Detail

MemoryEfficientStorageHandler

public MemoryEfficientStorageHandler(MemoryEfficientAStarAlgorithm<H,T> algorithm)

Method Detail

storeStateForRecord

public void storeStateForRecord(State<H,T> state,
                                Record newRec)
                         throws AStarException

Specified by:

storeStateForRecord in interface AbstractAStarThread.StorageHandler<H extends Head,T extends Tail>

Throws:

AStarException

getIndexOf

public long getIndexOf(H head)
                throws AStarException

Specified by:

getIndexOf in interface AbstractAStarThread.StorageHandler<H extends Head,T extends Tail>

Throws:

AStarException

getStoredState

public State<H,T> getStoredState(Record rec)
                                throws AStarException

Specified by:

getStoredState in interface AbstractAStarThread.StorageHandler<H extends Head,T extends Tail>

Throws:

AStarException

getEstimate

public int getEstimate(H head,
                       long index)
                throws AStarException

Description copied from interface: AbstractAStarThread.StorageHandler

return the estimate of the tail for the given head. The head is stored at the given index.

Specified by:

getEstimate in interface AbstractAStarThread.StorageHandler<H extends Head,T extends Tail>

Returns:

Throws:

AStarException

reComputeFastLowerboundTail

public <TT extends FastLowerBoundTail> void reComputeFastLowerboundTail(Record rec,
                                                                        TT tail,
                                                                        H head,
                                                                        int storedEstimate)
                                                                 throws AStarException

Description copied from interface: AbstractAStarThread.StorageHandler

implementations may assume that TT == T

Specified by:

reComputeFastLowerboundTail in interface AbstractAStarThread.StorageHandler<H extends Head,T extends Tail>

Throws:

AStarException