Package com.semedy.reasoner.reasoning.processes

Class EmptyStore

java.lang.Object

com.semedy.reasoner.reasoning.processes.ProcessImp

com.semedy.reasoner.reasoning.processes.UnbufferedStore

com.semedy.reasoner.reasoning.processes.BufferedStore

com.semedy.reasoner.reasoning.processes.EmptyStore

All Implemented Interfaces:

Receiver, Process, Store

public class EmptyStore
extends BufferedStore

An empty store, i.E. all incoming tuples are thrown away

Author:

angele

Constructor Summary

Constructors

Constructor	Description
EmptyStore(int arity)

Method Summary

Modifier and Type	Method	Description
void	addNegatedNeighbour(And join)	add a negated rule body operator as next operator
void	addNeighbour(And join)	add a rule body operator as next operator
void	addNextReceiver(Receiver n)	attach a next receiver which receives input from this
void	addRelation(ReasoningRelation R)	add a whole relation at the beginning
void	clear()	free up ressources
void	dispose()	free ressources allocated by this process
void	evaluate()	evaluate a process during reasoning.
void	evaluationFinished(long querykey)	the whole evaluation is finished
List<ReasoningRelation>	getAllTuples()
ReasoningRelation	getAllTuplesInOne()	get all received tuples
int	getArity()	arity of the tuples
ReasoningRelation	getLastResults()	get the last stores results
List<And>	getNeighbours()	get all neighbours
int	getPriority()	get the priority of a process
int	getStratum()	get the stratum
TupleStore	getTupleStore()	get the basic tuple store
List<ReasoningRelation>	incrementalRelations()
boolean	isNotQueuedSetQueued()	If process is not queued for reasoning set it as queued for reasoning
boolean	isSubsumed()	Store is subsumed.
Receiver	nextReceiver()	get next process
void	operationFinished()	this process is finished
void	readAccessBegin(Set<Integer> tickets, boolean lock)	Reading of the store by an operator starts.
boolean	readAccessEnd(ProcessImp source, Set<Integer> tickets, boolean lock, boolean pushed)	Reading of a store ends.
boolean	receiveRelation(ReasoningRelation R)	receive a whole relation
boolean	receiveTuple(int tuple)	receive a single tuple
boolean	receiveTuple(long[] tuple)	receive a single tuple
boolean	receiveTuple(TupleBuffer tuple)	receive a single tuple
List<ReasoningRelation>	relations()
void	setDataFlowGraph(ProcessExecutor processExecutor)	set the executor for this process
void	setStratum(int s)	set the stratum of this process
long	size()
Receiver	startTuples(Receiver source, boolean check4Duplicates)	start delivering single tuples
void	triggerNeighbours(int ticket)	trigger neighbours for evaluation
void	tuplesFinished(boolean isBottomUp)	finish delivering single tuples
void	tuplesFinished(String annotation, ReasoningRelation R1, ReasoningRelation R2)	Finish delivering single tuples.

Methods inherited from class com.semedy.reasoner.reasoning.processes.BufferedStore

bufferedSize, reset1

Methods inherited from class com.semedy.reasoner.reasoning.processes.UnbufferedStore

incrementalSize, toString

Methods inherited from class com.semedy.reasoner.reasoning.processes.ProcessImp

evaluationFinished, isQueued, setQueued

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.semedy.reasoner.reasoning.processes.Process

isQueued, setQueued

Methods inherited from interface com.semedy.reasoner.reasoning.processes.Store

toString

Constructor Details

EmptyStore

public EmptyStore(int arity)

Parameters:

interruptFlag -

monitor -

arity -

predicate -

cepReasoning -

cepReasoningWithRetracts -

executor -

sorted -

Method Details

getPriority

public int getPriority()

Description copied from interface: Process

get the priority of a process

Specified by:

getPriority in interface Process

Overrides:

getPriority in class ProcessImp

Returns:

isNotQueuedSetQueued

public boolean isNotQueuedSetQueued()

Description copied from interface: Process

If process is not queued for reasoning set it as queued for reasoning

Specified by:

isNotQueuedSetQueued in interface Process

Overrides:

isNotQueuedSetQueued in class ProcessImp

Returns:

setDataFlowGraph

public void setDataFlowGraph(ProcessExecutor processExecutor)

Description copied from interface: Process

set the executor for this process

Specified by:

setDataFlowGraph in interface Process

Overrides:

setDataFlowGraph in class ProcessImp

operationFinished

public void operationFinished()
                       throws SemReasonerException

Description copied from interface: Process

this process is finished

Specified by:

operationFinished in interface Process

Overrides:

operationFinished in class ProcessImp

Throws:

SemReasonerException

addNextReceiver

public void addNextReceiver(Receiver n)

Description copied from interface: Process

attach a next receiver which receives input from this

Specified by:

addNextReceiver in interface Process

Overrides:

addNextReceiver in class ProcessImp

dispose

public void dispose()

Description copied from interface: Process

free ressources allocated by this process

Specified by:

dispose in interface Process

Overrides:

dispose in class ProcessImp

setStratum

public void setStratum(int s)

Description copied from interface: Process

set the stratum of this process

Specified by:

setStratum in interface Process

Overrides:

setStratum in class ProcessImp

getStratum

public int getStratum()

Description copied from interface: Process

get the stratum

Specified by:

getStratum in interface Process

Overrides:

getStratum in class ProcessImp

Returns:

nextReceiver

public Receiver nextReceiver()

Description copied from interface: Process

get next process

Specified by:

nextReceiver in interface Process

Overrides:

nextReceiver in class ProcessImp

Returns:

clear

public void clear()
           throws IOException

Description copied from class: ProcessImp

free up ressources

Specified by:

clear in interface Process

Overrides:

clear in class BufferedStore

Throws:

IOException

receiveTuple

public boolean receiveTuple(TupleBuffer tuple)
                     throws IOException,
SemReasonerException

Description copied from interface: Receiver

receive a single tuple

Specified by:

receiveTuple in interface Receiver

Overrides:

receiveTuple in class BufferedStore

Parameters:

tuple - the tuple to be received

Returns:

true if tuple has been used (tuple cannot be free'd up)

Throws:

IOException

ReasoningException

SemReasonerException

evaluationFinished

public void evaluationFinished(long querykey)
                        throws SemReasonerException

Description copied from interface: Process

the whole evaluation is finished

Specified by:

evaluationFinished in interface Process

Specified by:

evaluationFinished in interface Store

Overrides:

evaluationFinished in class BufferedStore

Throws:

ReasoningException

SemReasonerException

size

public long size()
          throws IOException,
EDBException

Specified by:

size in interface Store

Overrides:

size in class BufferedStore

Returns:

Throws:

IOException

EDBException - How many tuples are stored

getAllTuples

public List<ReasoningRelation> getAllTuples()
                                     throws IOException,
EDBException

Specified by:

getAllTuples in interface Store

Overrides:

getAllTuples in class BufferedStore

Returns:

Throws:

EDBException - get a list of all relations stored in store

IOException

getAllTuplesInOne

public ReasoningRelation getAllTuplesInOne()
                                    throws IOException

Description copied from interface: Store

get all received tuples

Specified by:

getAllTuplesInOne in interface Store

Overrides:

getAllTuplesInOne in class BufferedStore

Returns:

Throws:

IOException

addNegatedNeighbour

public void addNegatedNeighbour(And join)

Description copied from interface: Store

add a negated rule body operator as next operator

Specified by:

addNegatedNeighbour in interface Store

Overrides:

addNegatedNeighbour in class BufferedStore

addNeighbour

public void addNeighbour(And join)

Description copied from interface: Store

add a rule body operator as next operator

Specified by:

addNeighbour in interface Store

Overrides:

addNeighbour in class BufferedStore

readAccessBegin

public void readAccessBegin(Set<Integer> tickets,
 boolean lock)

Description copied from interface: Store

Reading of the store by an operator starts.
Every reading is uniquely identified by a ticket.
Lock indicates that ressources must be locked

Specified by:

readAccessBegin in interface Store

Overrides:

readAccessBegin in class BufferedStore

readAccessEnd

public boolean readAccessEnd(ProcessImp source,
 Set<Integer> tickets,
 boolean lock,
 boolean pushed)
                      throws IOException,
SemReasonerException

Description copied from interface: Store

Reading of a store ends.

Specified by:

readAccessEnd in interface Store

Overrides:

readAccessEnd in class BufferedStore

Parameters:

source - , the reader

tickets - , the ticket of the reading process

lock - , was a lock required at begin of the reading process

pushed - , have relations be pushed instead of joined

Returns:

Throws:

IOException

SemReasonerException

receiveRelation

public boolean receiveRelation(ReasoningRelation R)
                        throws SemReasonerException,
InterruptedException,
IOException

Description copied from interface: Receiver

receive a whole relation

Specified by:

receiveRelation in interface Receiver

Specified by:

receiveRelation in interface Store

Overrides:

receiveRelation in class BufferedStore

Parameters:

R - the whole relation to be received

Returns:

true, if relation is later on dissolved, false otherwise

Throws:

ReasoningException

InterruptedException

IOException

SemReasonerException

addRelation

public void addRelation(ReasoningRelation R)
                 throws IOException,
EDBException

Description copied from interface: Receiver

add a whole relation at the beginning

Specified by:

addRelation in interface Process

Specified by:

addRelation in interface Receiver

Specified by:

addRelation in interface Store

Overrides:

addRelation in class BufferedStore

Parameters:

R - the relation to be added

Throws:

IOException

EDBException

startTuples

public Receiver startTuples(Receiver source,
 boolean check4Duplicates)
                     throws EDBException,
IOException

Description copied from interface: Receiver

start delivering single tuples

Specified by:

startTuples in interface Receiver

Specified by:

startTuples in interface Store

Overrides:

startTuples in class UnbufferedStore

Parameters:

source - , the delivering process

check4Duplicates - , check for duplicates in the target store

Returns:

an object receiving the results

Throws:

EDBException

IOException

incrementalRelations

public List<ReasoningRelation> incrementalRelations()
                                             throws IOException,
EDBException

Specified by:

incrementalRelations in interface Store

Overrides:

incrementalRelations in class UnbufferedStore

Returns:

Throws:

IOException

EDBException - get a list of incremental relations

relations

public List<ReasoningRelation> relations()
                                  throws IOException,
EDBException

Specified by:

relations in interface Store

Overrides:

relations in class UnbufferedStore

Returns:

Throws:

IOException

EDBException - get a list of received relations

getArity

public int getArity()

Description copied from interface: Receiver

arity of the tuples

Specified by:

getArity in interface Process

Specified by:

getArity in interface Receiver

Specified by:

getArity in interface Store

Overrides:

getArity in class UnbufferedStore

Returns:

the arity of the receiver

isSubsumed

public boolean isSubsumed()

Description copied from interface: Store

Store is subsumed. This means that no additional tuples are stored.

Specified by:

isSubsumed in interface Store

Overrides:

isSubsumed in class BufferedStore

Returns:

receiveTuple

public boolean receiveTuple(long[] tuple)
                     throws SemReasonerException,
IOException

Description copied from interface: Receiver

receive a single tuple

Specified by:

receiveTuple in interface Receiver

Specified by:

receiveTuple in interface Store

Overrides:

receiveTuple in class BufferedStore

Parameters:

tuple - the tuple to be received

Returns:

true if tuple has been used (tuple cannot be free'd up)

Throws:

SemReasonerException

IOException

receiveTuple

public boolean receiveTuple(int tuple)
                     throws SemReasonerException,
IOException

Description copied from interface: Receiver

receive a single tuple

Specified by:

receiveTuple in interface Receiver

Specified by:

receiveTuple in interface Store

Overrides:

receiveTuple in class BufferedStore

Parameters:

tuple - the tuple to be received

Returns:

true if tuple has been used (tuple cannot be free'd up)

Throws:

SemReasonerException

IOException

getTupleStore

public TupleStore getTupleStore()

Description copied from interface: Receiver

get the basic tuple store

Specified by:

getTupleStore in interface Process

Specified by:

getTupleStore in interface Receiver

Specified by:

getTupleStore in interface Store

Overrides:

getTupleStore in class BufferedStore

Returns:

the tuple store

evaluate

public void evaluate()
              throws InterruptedException,
SemReasonerException,
IOException

Description copied from interface: Process

evaluate a process during reasoning.
Returns how the number of tuples sent away

Specified by:

evaluate in interface Process

Specified by:

evaluate in interface Store

Overrides:

evaluate in class BufferedStore

Throws:

InterruptedException

ReasoningException

IOException

SemReasonerException

tuplesFinished

public void tuplesFinished(String annotation,
 ReasoningRelation R1,
 ReasoningRelation R2)
                    throws IOException,
SemReasonerException,
InterruptedException

Description copied from interface: Receiver

Finish delivering single tuples.
Cache result and annotate result.

Specified by:

tuplesFinished in interface Receiver

Specified by:

tuplesFinished in interface Store

Overrides:

tuplesFinished in class BufferedStore

Parameters:

annotation - , an annotation used for caching

R1 - , the relations which have been combined

R2 - , the relations which have been combined

Throws:

IOException

ReasoningException

SemReasonerException

InterruptedException

tuplesFinished

public void tuplesFinished(boolean isBottomUp)
                    throws SemReasonerException,
InterruptedException,
IOException

Description copied from interface: Receiver

finish delivering single tuples

Specified by:

tuplesFinished in interface Receiver

Specified by:

tuplesFinished in interface Store

Overrides:

tuplesFinished in class BufferedStore

Parameters:

isBottomUp - TODO

Throws:

ReasoningException

SemReasonerException

InterruptedException

IOException

triggerNeighbours

public void triggerNeighbours(int ticket)
                       throws SemReasonerException,
IOException

Description copied from interface: Store

trigger neighbours for evaluation

Specified by:

triggerNeighbours in interface Store

Overrides:

triggerNeighbours in class BufferedStore

Throws:

ReasoningException

IOException

SemReasonerException

getNeighbours

public List<And> getNeighbours()

Description copied from interface: Store

get all neighbours

Specified by:

getNeighbours in interface Store

Overrides:

getNeighbours in class BufferedStore

Returns:

getLastResults

public ReasoningRelation getLastResults()

Description copied from interface: Store

get the last stores results

Specified by:

getLastResults in interface Store

Overrides:

getLastResults in class BufferedStore

Returns: