QueryPublisher

java.lang.Object
- io.objectbox.query.QueryPublisher<T>

All Implemented Interfaces:

DataPublisher<java.util.List<T>>, java.lang.Runnable
```
@Internal
class QueryPublisher<T>
extends java.lang.Object
implements DataPublisher<java.util.List<T>>, java.lang.Runnable
```
A DataPublisher that subscribes to an ObjectClassPublisher if there is at least one observer. Publishing is requested if the ObjectClassPublisher reports changes, a subscription is observed or Query.publish() is called. For publishing the query is re-run and the result delivered to the current observers. Results are published on a single thread, one at a time, in the order publishing was requested.

Nested Class Summary

Nested Classes
Modifier and Type Class Description

private static class QueryPublisher.SubscribedObservers<T>

Field Summary

Fields
Modifier and Type	Field	Description
`private Box<T>`	`box`
`private DataObserver<java.lang.Class<T>>`	`objectClassObserver`
`private DataSubscription`	`objectClassSubscription`
`private java.util.Set<DataObserver<java.util.List<T>>>`	`observers`
`private boolean`	`publisherRunning`
`private java.util.Deque<DataObserver<java.util.List<T>>>`	`publishQueue`
`private Query<T>`	`query`
`private QueryPublisher.SubscribedObservers<T>`	`SUBSCRIBED_OBSERVERS`	Placeholder observer to use if all subscribed observers should be notified.

Constructor Summary

Constructors
Constructor Description

QueryPublisher(Query<T> query, Box<T> box)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`(package private) void`	`publish()`
`void`	`publishSingle(DataObserver<java.util.List<T>> observer, java.lang.Object param)`
`private void`	`queueObserverAndScheduleRun(DataObserver<java.util.List<T>> observer)`	Non-blocking: will just enqueue the changes for a separate thread.
`void`	`run()`	Processes publish requests for this query on a single thread to prevent older query results getting delivered after newer query results.
`void`	`subscribe(DataObserver<java.util.List<T>> observer, java.lang.Object param)`
`void`	`unsubscribe(DataObserver<java.util.List<T>> observer, java.lang.Object param)`

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

Field Detail

query
```
private final Query<T> query
```

box
```
private final Box<T> box
```

observers

private final java.util.Set<DataObserver<java.util.List<T>>> observers

publishQueue

private final java.util.Deque<DataObserver<java.util.List<T>>> publishQueue

publisherRunning

private volatile boolean publisherRunning

SUBSCRIBED_OBSERVERS
```
private final QueryPublisher.SubscribedObservers<T> SUBSCRIBED_OBSERVERS
```
Placeholder observer to use if all subscribed observers should be notified.

objectClassObserver

private DataObserver<java.lang.Class<T>> objectClassObserver

objectClassSubscription

private DataSubscription objectClassSubscription

Constructor Detail

QueryPublisher

QueryPublisher(Query<T> query,
               Box<T> box)

Method Detail
- subscribe
```
public void subscribe(DataObserver<java.util.List<T>> observer,
                      @Nullable
                      java.lang.Object param)
```
  Specified by:
  
  subscribe in interface DataPublisher<T>
- publishSingle
```
public void publishSingle(DataObserver<java.util.List<T>> observer,
                          @Nullable
                          java.lang.Object param)
```
  Specified by:
  
  publishSingle in interface DataPublisher<T>
- publish
```
void publish()
```
- queueObserverAndScheduleRun
```
private void queueObserverAndScheduleRun(DataObserver<java.util.List<T>> observer)
```
  Non-blocking: will just enqueue the changes for a separate thread.
- run
```
public void run()
```
  Processes publish requests for this query on a single thread to prevent older query results getting delivered after newer query results. To speed up processing each loop publishes to all queued observers instead of just the next in line. This reduces time spent querying and waiting for DataObserver.onData() and their potential DataTransformers.
  
  Specified by:
  
  run in interface java.lang.Runnable
- unsubscribe
```
public void unsubscribe(DataObserver<java.util.List<T>> observer,
                        @Nullable
                        java.lang.Object param)
```
  Specified by:
  
  unsubscribe in interface DataPublisher<T>