Cache (grakn-graql 0.17.1 API)

java.lang.Object
- ai.grakn.graql.internal.reasoner.cache.Cache<Q,T>

Type Parameters:

Q - the type of query that is being cached

T - the type of answer being cached

Direct Known Subclasses:

LazyQueryCache, QueryCache
```
public abstract class Cache<Q extends ReasonerQueryImpl,T extends Iterable<Answer>>
extends Object
```
Generic container class for storing performed query resolutions.

Author:

Kasper Piskorski

Constructor Summary

Constructors
Constructor and Description

Cache()

Constructors
Constructor and Description
`Cache()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(Cache<Q,T> c2)` Perform cache union
`abstract long`	`answerSize(Set<Q> queries)`
`void`	`clear()` Clear the cache
`boolean`	`contains(Q query)` Query cache containment check
`Collection<Pair<Q,T>>`	`entries()`
`Pair<Q,T>`	`get(Q query)`
`abstract LazyIterator<Answer>`	`getAnswerIterator(Q query)`
`abstract T`	`getAnswers(Q query)` retrieve cached answers for provided query
`abstract java.util.stream.Stream<Answer>`	`getAnswerStream(Q query)`
`abstract Pair<java.util.stream.Stream<Answer>,MultiUnifier>`	`getAnswerStreamWithUnifier(Q query)`
`abstract Pair<T,MultiUnifier>`	`getAnswersWithUnifier(Q query)`
`Map<Pair<Var,Concept>,Set<Answer>>`	`getInverseAnswerMap(Q query)` returns an inverse answer map with all query variables
`Map<Pair<Var,Concept>,Set<Answer>>`	`getInverseAnswerMap(Q query, Set<Var> vars)` return an inverse answer map which is more suitable for operations involving concept comparison (joins, filtering, etc.) NB: consumes the underlying stream for the specified query
`Set<Q>`	`getQueries()`
`Pair<Q,T>`	`put(Q query, T answers)` Associates the specified answers with the specified query in this cache adding an (query) -> (answers) entry
`void`	`putAll(Map<Q,Pair<Q,T>> map)` Copies all of the mappings from the specified map to this cache
`abstract java.util.stream.Stream<Answer>`	`record(Q query, java.util.stream.Stream<Answer> answers)` record answer stream for a specific query and retrieve the updated stream
`abstract T`	`record(Q query, T answers)` record answer iterable for a specific query and retrieve the updated answers
`abstract LazyIterator<Answer>`	`recordRetrieveLazy(Q query, java.util.stream.Stream<Answer> answers)` record answer stream for a specific query and retrieve the updated stream in a lazy iterator
`void`	`remove(Cache<Q,T> c2)` Perform cache difference
`abstract void`	`remove(Cache<Q,T> c2, Set<Q> queries)` cache subtraction of specified queries

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

- Constructor Detail
  - Cache
```
public Cache()
```
- Method Detail
  - get
```
public Pair<Q,T> get(Q query)
```
    Parameters:
    
    query - for which the entry is to be retrieved
    
    Returns:
    
    corresponding cache entry if any or null
  - put
```
public Pair<Q,T> put(Q query,
                     T answers)
```
    Associates the specified answers with the specified query in this cache adding an (query) -> (answers) entry
    
    Parameters:
    
    query - of the association
    
    answers - of the association
    
    Returns:
    
    previous value if any or null
  - putAll
```
public void putAll(Map<Q,Pair<Q,T>> map)
```
    Copies all of the mappings from the specified map to this cache
    
    Parameters:
    
    map - with mappings to be copied
  - add
```
public void add(Cache<Q,T> c2)
```
    Perform cache union
    
    Parameters:
    
    c2 - union right operand
  - contains
```
public boolean contains(Q query)
```
    Query cache containment check
    
    Parameters:
    
    query - to be checked for containment
    
    Returns:
    
    true if cache contains the query
  - getQueries
```
public Set<Q> getQueries()
```
    Returns:
    
    all queries constituting this cache
  - entries
```
public Collection<Pair<Q,T>> entries()
```
    Returns:
    
    all (query) -> (answers) mappings
  - remove
```
public void remove(Cache<Q,T> c2)
```
    Perform cache difference
    
    Parameters:
    
    c2 - cache which mappings should be removed from this cache
  - clear
```
public void clear()
```
    Clear the cache
  - record
```
public abstract T record(Q query,
                         T answers)
```
    record answer iterable for a specific query and retrieve the updated answers
    
    Parameters:
    
    query - to be recorded
    
    answers - to this query
    
    Returns:
    
    updated answer iterable
  - record
```
public abstract java.util.stream.Stream<Answer> record(Q query,
                                                       java.util.stream.Stream<Answer> answers)
```
    record answer stream for a specific query and retrieve the updated stream
    
    Parameters:
    
    query - to be recorded
    
    answers - answer stream of the query
    
    Returns:
    
    updated answer stream
  - recordRetrieveLazy
```
public abstract LazyIterator<Answer> recordRetrieveLazy(Q query,
                                                        java.util.stream.Stream<Answer> answers)
```
    record answer stream for a specific query and retrieve the updated stream in a lazy iterator
    
    Parameters:
    
    query - to be recorded
    
    answers - answer stream of the query
    
    Returns:
    
    lazy iterator of updated answers
  - getAnswers
```
public abstract T getAnswers(Q query)
```
    retrieve cached answers for provided query
    
    Parameters:
    
    query - for which to retrieve answers
    
    Returns:
    
    unified cached answers
  - getAnswersWithUnifier
```
public abstract Pair<T,MultiUnifier> getAnswersWithUnifier(Q query)
```
  - getAnswerStream
```
public abstract java.util.stream.Stream<Answer> getAnswerStream(Q query)
```
  - getAnswerStreamWithUnifier
```
public abstract Pair<java.util.stream.Stream<Answer>,MultiUnifier> getAnswerStreamWithUnifier(Q query)
```
  - getAnswerIterator
```
public abstract LazyIterator<Answer> getAnswerIterator(Q query)
```
  - getInverseAnswerMap
```
public Map<Pair<Var,Concept>,Set<Answer>> getInverseAnswerMap(Q query,
                                                              Set<Var> vars)
```
    return an inverse answer map which is more suitable for operations involving concept comparison (joins, filtering, etc.) NB: consumes the underlying stream for the specified query
    
    Parameters:
    
    query - for answer are to be retrieved
    
    vars - variable names of interest
    
    Returns:
    
    inverse answer map for specified query
  - getInverseAnswerMap
```
public Map<Pair<Var,Concept>,Set<Answer>> getInverseAnswerMap(Q query)
```
    returns an inverse answer map with all query variables
    
    Parameters:
    
    query - for answer are to be retrieved
    
    Returns:
    
    inverse answer map for specified query
  - remove
```
public abstract void remove(Cache<Q,T> c2,
                            Set<Q> queries)
```
    cache subtraction of specified queries
    
    Parameters:
    
    c2 - subtraction right operand
    
    queries - to which answers shall be subtracted
  - answerSize
```
public abstract long answerSize(Set<Q> queries)
```
    Parameters:
    
    queries - to be checked
    
    Returns:
    
    number of answers for the specified query set

Class Cache<Q extends ReasonerQueryImpl,T extends Iterable<Answer>>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Cache

Method Detail

get

put

putAll

add

contains

getQueries

entries

remove

clear

record

record

recordRetrieveLazy

getAnswers

getAnswersWithUnifier

getAnswerStream

getAnswerStreamWithUnifier

getAnswerIterator

getInverseAnswerMap

getInverseAnswerMap

remove

answerSize