NoOpApolloStore (apollo-runtime 1.2.2 API)

java.lang.Object
- com.apollographql.apollo.internal.cache.normalized.NoOpApolloStore

All Implemented Interfaces:

ApolloStore, ReadableStore, WriteableStore
```
public final class NoOpApolloStore
extends java.lang.Object
implements ApolloStore, ReadableStore, WriteableStore
```
An alternative to RealApolloStore for when a no-operation cache is needed.

Nested Class Summary
- Nested classes/interfaces inherited from interface com.apollographql.apollo.cache.normalized.ApolloStore
  ApolloStore.RecordChangeSubscriber

Field Summary
- Fields inherited from interface com.apollographql.apollo.cache.normalized.ApolloStore
  NO_APOLLO_STORE

Constructor Summary

Constructors
Constructor and Description

NoOpApolloStore()

Constructors
Constructor and Description
`NoOpApolloStore()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`CacheKeyResolver`	`cacheKeyResolver()`
`ResponseNormalizer<Record>`	`cacheResponseNormalizer()`
`ApolloStoreOperation<java.lang.Boolean>`	`clearAll()` Clear all records from this `ApolloStore`.
`java.util.Set<java.lang.String>`	`merge(java.util.Collection<Record> recordCollection, CacheHeaders cacheHeaders)`
`java.util.Set<java.lang.String>`	`merge(Record record, CacheHeaders cacheHeaders)`
`ResponseNormalizer<java.util.Map<java.lang.String,java.lang.Object>>`	`networkResponseNormalizer()`
`NormalizedCache`	`normalizedCache()`
`void`	`publish(java.util.Set<java.lang.String> keys)`
`java.util.Collection<Record>`	`read(java.util.Collection<java.lang.String> keys, CacheHeaders cacheHeaders)`
`<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<T>`	`read(com.apollographql.apollo.api.Operation<D,T,V> operation)` Read GraphQL operation from store.
`<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<com.apollographql.apollo.api.Response<T>>`	`read(com.apollographql.apollo.api.Operation<D,T,V> operation, com.apollographql.apollo.api.ResponseFieldMapper<D> responseFieldMapper, ResponseNormalizer<Record> responseNormalizer, CacheHeaders cacheHeaders)` Read GraphQL operation response from store.
`<F extends com.apollographql.apollo.api.GraphqlFragment> ApolloStoreOperation<F>`	`read(com.apollographql.apollo.api.ResponseFieldMapper<F> fieldMapper, CacheKey cacheKey, com.apollographql.apollo.api.Operation.Variables variables)` Read GraphQL fragment from store.
`Record`	`read(java.lang.String key, CacheHeaders cacheHeaders)`
`<R> R`	`readTransaction(Transaction<ReadableStore,R> transaction)` Run a operation inside a read-lock.
`ApolloStoreOperation<java.lang.Boolean>`	`remove(CacheKey cacheKey)` Remove cache record by the key
`ApolloStoreOperation<java.lang.Boolean>`	`remove(CacheKey cacheKey, boolean cascade)` Remove cache record by the key
`ApolloStoreOperation<java.lang.Integer>`	`remove(java.util.List<CacheKey> cacheKeys)` Remove cache records by the list of keys
`ApolloStoreOperation<java.util.Set<java.lang.String>>`	`rollbackOptimisticUpdates(java.util.UUID mutationId)` Rollback operation data optimistic updates.
`ApolloStoreOperation<java.lang.Boolean>`	`rollbackOptimisticUpdatesAndPublish(java.util.UUID mutationId)` Rollback operation data optimistic updates and publish changes of `Record`s which have changed, that will notify any that depends on these `Record` to re-fetch.
`void`	`subscribe(ApolloStore.RecordChangeSubscriber subscriber)`
`void`	`unsubscribe(ApolloStore.RecordChangeSubscriber subscriber)`
`ApolloStoreOperation<java.util.Set<java.lang.String>>`	`write(com.apollographql.apollo.api.GraphqlFragment fragment, CacheKey cacheKey, com.apollographql.apollo.api.Operation.Variables variables)` Write fragment to the store.
`<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.util.Set<java.lang.String>>`	`write(com.apollographql.apollo.api.Operation<D,T,V> operation, D operationData)` Write operation to the store.
`ApolloStoreOperation<java.lang.Boolean>`	`writeAndPublish(com.apollographql.apollo.api.GraphqlFragment fragment, CacheKey cacheKey, com.apollographql.apollo.api.Operation.Variables variables)` Write fragment to the store and publish changes of `Record` which have changed, that will notify any `ApolloQueryWatcher` that depends on these `Record` to re-fetch.
`<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.lang.Boolean>`	`writeAndPublish(com.apollographql.apollo.api.Operation<D,T,V> operation, D operationData)` Write operation to the store and publish changes of `Record` which have changed, that will notify any `ApolloQueryWatcher` that depends on these `Record` to re-fetch.
`<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.util.Set<java.lang.String>>`	`writeOptimisticUpdates(com.apollographql.apollo.api.Operation<D,T,V> operation, D operationData, java.util.UUID mutationId)` Write operation data to the optimistic store.
`<D extends com.apollographql.apollo.api.Operation.Data,T,V extends com.apollographql.apollo.api.Operation.Variables> ApolloStoreOperation<java.lang.Boolean>`	`writeOptimisticUpdatesAndPublish(com.apollographql.apollo.api.Operation<D,T,V> operation, D operationData, java.util.UUID mutationId)` Write operation data to the optimistic store and publish changes of `Record`s which have changed, that will notify any that depends on these `Record` to re-fetch.
`<R> R`	`writeTransaction(Transaction<WriteableStore,R> transaction)` Run a operation inside a write-lock.

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

Constructor Detail
- NoOpApolloStore
```
public NoOpApolloStore()
```

Method Detail

merge

public java.util.Set<java.lang.String> merge(@NotNull
                                             java.util.Collection<Record> recordCollection,
                                             @NotNull
                                             CacheHeaders cacheHeaders)

Specified by:: merge in interface WriteableStore

merge

public java.util.Set<java.lang.String> merge(Record record,
                                             @NotNull
                                             CacheHeaders cacheHeaders)

Specified by:: merge in interface WriteableStore

read

@Nullable
public Record read(@NotNull
                             java.lang.String key,
                             @NotNull
                             CacheHeaders cacheHeaders)

Specified by:: read in interface ReadableStore

read

public java.util.Collection<Record> read(@NotNull
                                         java.util.Collection<java.lang.String> keys,
                                         @NotNull
                                         CacheHeaders cacheHeaders)

Specified by:: read in interface ReadableStore

public void subscribe(ApolloStore.RecordChangeSubscriber subscriber)

Specified by:: subscribe in interface ApolloStore

unsubscribe

public void unsubscribe(ApolloStore.RecordChangeSubscriber subscriber)

Specified by:: unsubscribe in interface ApolloStore

publish
```
public void publish(java.util.Set<java.lang.String> keys)
```
Specified by:

publish in interface ApolloStore

Parameters:

keys - A set of keys of Record which have changed.

clearAll
```
@NotNull
public ApolloStoreOperation<java.lang.Boolean> clearAll()
```
Description copied from interface: ApolloStore

Clear all records from this ApolloStore.

Specified by:

clearAll in interface ApolloStore

Returns:

to be performed, that will be resolved with true if all records was successfully removed, false otherwise

remove
```
@NotNull
public ApolloStoreOperation<java.lang.Boolean> remove(@NotNull
                                                               CacheKey cacheKey,
                                                               boolean cascade)
```
Description copied from interface: ApolloStore

Remove cache record by the key

Specified by:

remove in interface ApolloStore

Parameters:

cacheKey - of record to be removed

cascade - defines if remove operation is propagated to the referenced entities

Returns:

to be performed, that will be resolved with true if record with such key was successfully removed, false otherwise

remove
```
@NotNull
public ApolloStoreOperation<java.lang.Boolean> remove(@NotNull
                                                               CacheKey cacheKey)
```
Description copied from interface: ApolloStore

Remove cache record by the key

Specified by:

remove in interface ApolloStore

Parameters:

cacheKey - of record to be removed

Returns:

to be performed, that will be resolved with true if record with such key was successfully removed, false otherwise

remove
```
@NotNull
public ApolloStoreOperation<java.lang.Integer> remove(@NotNull
                                                               java.util.List<CacheKey> cacheKeys)
```
Description copied from interface: ApolloStore

Remove cache records by the list of keys

Specified by:

remove in interface ApolloStore

Parameters:

cacheKeys - keys of records to be removed

Returns:

to be performed, that will be resolved with the count of records been removed

networkResponseNormalizer
```
public ResponseNormalizer<java.util.Map<java.lang.String,java.lang.Object>> networkResponseNormalizer()
```
Specified by:

networkResponseNormalizer in interface ApolloStore

Returns:

The ResponseNormalizer used to generate normalized records from the network.

cacheResponseNormalizer
```
public ResponseNormalizer<Record> cacheResponseNormalizer()
```
Specified by:

cacheResponseNormalizer in interface ApolloStore

Returns:

The ResponseNormalizer used to generate normalized records from the cache.

readTransaction
```
public <R> R readTransaction(Transaction<ReadableStore,R> transaction)
```
Description copied from interface: ApolloStore

Run a operation inside a read-lock. Blocks until read-lock is acquired.

Specified by:

readTransaction in interface ApolloStore

Type Parameters:

R - The result type of this read operation.

Parameters:

transaction - A code block to run once the read lock is acquired.

Returns:

A result from the read operation.

writeTransaction
```
public <R> R writeTransaction(Transaction<WriteableStore,R> transaction)
```
Description copied from interface: ApolloStore

Run a operation inside a write-lock. Blocks until write-lock is acquired.

Specified by:

writeTransaction in interface ApolloStore

Type Parameters:

R - The result type of this write operation.

Parameters:

transaction - A code block to run once the write lock is acquired.

Returns:

A result from the write operation.

normalizedCache
```
public NormalizedCache normalizedCache()
```
Specified by:

normalizedCache in interface ApolloStore

Returns:

The NormalizedCache which backs this ApolloStore.

cacheKeyResolver
```
public CacheKeyResolver cacheKeyResolver()
```
Specified by:

cacheKeyResolver in interface ApolloStore

Returns:

the CacheKeyResolver used for resolving field cache keys