HBDataCacheQueue (Alfresco Heartbeat Data Sender 1.0.12 API)

java.lang.Object
- org.alfresco.heartbeat.datasender.internal.HBDataCacheQueue<T>

Type Parameters:

T -
```
public class HBDataCacheQueue<T>
extends Object
```
Heartbeat cache implementation - data is consumed in batches and after that evicted from the cache.

Author:

Ancuta Morarasu

Nested Class Summary

Nested Classes
Modifier and Type Class Description

class HBDataCacheQueue.HBCacheEvictOperation
Functional consumer that removes a batch of entries from the cache

Field Summary

Fields
Modifier and Type Field Description

protected Queue<T> cache

Constructor Summary

Constructors
Constructor Description

HBDataCacheQueue()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`add(T data)`
`void`	`addAll(List<T> data)`
`void`	`clear()`
`void`	`loadCache()`
`void`	`persistCache()`
`void`	`process(int batchSize, Consumer<List<T>> consumer)`	Data is consumed in batches; if the processing is successful, the batch is removed from the cache.
`void`	`removeAll(List<T> data)`
`void`	`setMaxEntries(long maxEntries)`
`int`	`size()`

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

Field Detail
- cache
```
protected final Queue<T> cache
```

Constructor Detail
- HBDataCacheQueue
```
public HBDataCacheQueue()
```

Method Detail

add
```
public void add(T data)
```

addAll
```
public void addAll(List<T> data)
```

removeAll

public void removeAll(List<T> data)

clear
```
public void clear()
```

persistCache
```
public void persistCache()
```

loadCache
```
public void loadCache()
```

size
```
public int size()
```

setMaxEntries

public void setMaxEntries(long maxEntries)

process
```
public void process(int batchSize,
                    Consumer<List<T>> consumer)
```
Data is consumed in batches; if the processing is successful, the batch is removed from the cache.

Parameters:

batchSize - the size of the batch to process

consumer - the batch processor