Package ch.qos.logback.core.spi

# Class AbstractComponentTracker<C>

java.lang.Object
ch.qos.logback.core.spi.AbstractComponentTracker<C>

Type Parameters:
  `C` - component type

All Implemented Interfaces:
  `ComponentTracker<C>`

Direct Known Subclasses:
  `AppenderTracker`, `CyclicBufferTracker`

public abstract class AbstractComponentTracker<C> extends Object implements ComponentTracker<C>
An abstract implementation of the ComponentTracker interface. Derived classes must implement `buildComponent(String)`, `processPriorToRemoval(Object)`, and `isComponentStale(Object)` methods as appropriate for their component type.

Author:
  Tommy Becker, Ceki Gulcu, David Roussel

## Field Summary

Fields
Modifier and Type
Field
Description
`static final long`
`LINGERING_TIMEOUT`
`protected int`
`maxComponents`
`protected long`
`timeout`
`static final long`
`WAIT_BETWEEN_SUCCESSIVE_REMOVAL_ITERATIONS`
The minimum amount of time that has to elapse between successive removal iterations.

### Fields inherited from interface ch.qos.logback.core.spi.ComponentTracker

`DEFAULT_MAX_COMPONENTS, DEFAULT_TIMEOUT`

## Constructor Summary

Constructors
Constructor
Description
`AbstractComponentTracker()`

## Method Summary

Modifier and Type
Method
Description
`Collection<C>`
`allComponents()`
Returns the collection of all components tracked by this instance.
`Set<String>`
`allKeys()`
Set of all keys in this tracker in no particular order.
`protected abstract C`
`buildComponent(String key)`
Build a component based on the key.
`void`
`endOfLife(String key)`
Mark component identified by 'key' as having reached its end-of-life.
`C`
`find(String key)`
Find the component identified by 'key', without updating the timestamp.
`int`
`getComponentCount()`
Returns the number of components tracked.
`int`
`getMaxComponents()`
`C`
`getOrCreate(String key, long timestamp)`
Get the component identified by 'key', updating its timestamp in the process.
`long`
`getTimeout()`
`protected abstract boolean`
`isComponentStale(C c)`
Components can declare themselves stale.
`protected abstract void`
`processPriorToRemoval(C component)`
Stop or clean the component.
`void`
`removeStaleComponents(long now)`
Clear (and detach) components which are stale.
`void`
`setMaxComponents(int maxComponents)`
`void`
`setTimeout(long timeout)`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Field Details

### LINGERING_TIMEOUT

public static final long LINGERING_TIMEOUT

See Also:
  - Constant Field Values

### WAIT_BETWEEN_SUCCESSIVE_REMOVAL_ITERATIONS

public static final long WAIT_BETWEEN_SUCCESSIVE_REMOVAL_ITERATIONS
The minimum amount of time that has to elapse between successive removal iterations.

See Also:
  - Constant Field Values

### maxComponents

protected int maxComponents

### timeout

protected long timeout

## Constructor Details

### AbstractComponentTracker

public AbstractComponentTracker()

## Method Details

### processPriorToRemoval

protected abstract void processPriorToRemoval(C component)
Stop or clean the component.

Parameters:
  `component` -

### buildComponent

protected abstract C buildComponent(String key)
Build a component based on the key.

Parameters:
  `key` -
Returns:

### isComponentStale

protected abstract boolean isComponentStale(C c)
Components can declare themselves stale. Such components may be removed before they time out.

Parameters:
  `c` -
Returns:

### getComponentCount

public int getComponentCount()
Description copied from interface: `ComponentTracker`
Returns the number of components tracked.

Specified by:
  `getComponentCount` in interface `ComponentTracker<C>`
Returns:
  number of components

### find

public C find(String key)
Find the component identified by 'key', without updating the timestamp. Returns null if no corresponding component could be found.

Note that this method is synchronized.

Specified by:
  `find` in interface `ComponentTracker<C>`
Parameters:
  `key` -
Returns:
  corresponding component, may be null

### getOrCreate

public C getOrCreate(String key, long timestamp)
Get the component identified by 'key', updating its timestamp in the process. If the corresponding component could not be found, it is created.

Note that this method is atomic, i.e. synchronized.

Specified by:
  `getOrCreate` in interface `ComponentTracker<C>`
Parameters:
  `key` -
  `timestamp` -
Returns:

### endOfLife

public void endOfLife(String key)
Mark component identified by 'key' as having reached its end-of-life.

Specified by:
  `endOfLife` in interface `ComponentTracker<C>`
Parameters:
  `key` -

### removeStaleComponents

public void removeStaleComponents(long now)
Clear (and detach) components which are stale. Components which have not been accessed for more than a user-specified duration are deemed stale.

Specified by:
  `removeStaleComponents` in interface `ComponentTracker<C>`
Parameters:
  `now` -

### allKeys

public Set<String> allKeys()
Description copied from interface: `ComponentTracker`
Set of all keys in this tracker in no particular order.

Specified by:
  `allKeys` in interface `ComponentTracker<C>`
Returns:

### allComponents

public Collection<C> allComponents()
Description copied from interface: `ComponentTracker`
Returns the collection of all components tracked by this instance.

Specified by:
  `allComponents` in interface `ComponentTracker<C>`
Returns:
  collection of components

### getTimeout

public long getTimeout()

### setTimeout

public void setTimeout(long timeout)

### getMaxComponents

public int getMaxComponents()

### setMaxComponents

public void setMaxComponents(int maxComponents)