## Uses of Interface
ch.qos.logback.core.spi.LifeCycle

Packages that use LifeCycle
ch.qos.logback.access.filter
ch.qos.logback.access.jetty: This is logback access' implementation for Jetty 8.
ch.qos.logback.access.net
ch.qos.logback.access.pattern: Provides classes implementing format specifiers in conversion patterns.
ch.qos.logback.access.sift
ch.qos.logback.access.spi: Contains the core classes of logback access.
ch.qos.logback.access.tomcat: This is logback access' implementation for Tomcat.
ch.qos.logback.classic: Contains logback classic main classes.
ch.qos.logback.classic.boolex
ch.qos.logback.classic.db: The ch.qos.logback.classic.db package provides means to append logging events into various databases.
ch.qos.logback.classic.encoder
ch.qos.logback.classic.filter
ch.qos.logback.classic.html: Contains classes to format log output in HTML.
ch.qos.logback.classic.jul: Logback <-> java.util.logging (JUL) integration.
ch.qos.logback.classic.layout
ch.qos.logback.classic.log4j: Contains support for log4j output formats.
ch.qos.logback.classic.net: Contains classes used to log through a network
ch.qos.logback.classic.net.server: Provides a robust logging server
ch.qos.logback.classic.pattern: Provides classes implementing format specifiers in conversion patterns.
ch.qos.logback.classic.pattern.color
ch.qos.logback.classic.sift
ch.qos.logback.classic.turbo
ch.qos.logback.core: Contains the main classes of logback core.
ch.qos.logback.core.boolex: Contains the EventEvaluator interface and subclasses.
ch.qos.logback.core.db: The ch.qos.logback.core.db package provides bases classes to append objects into various databases.
ch.qos.logback.core.encoder
ch.qos.logback.core.filter: Contains base classes to the event filtering functionality of logback.
ch.qos.logback.core.helpers: Helpers package.
ch.qos.logback.core.html: Contains the base classes needed to format logging events to HTML.
ch.qos.logback.core.layout
ch.qos.logback.core.net: Contains the base classes used by logback to log to remote destinations.
ch.qos.logback.core.net.server: Contains the base classes used by logback to serve logging events to remote peers.
ch.qos.logback.core.pattern: Contains the base classes used by PatternLayout.
ch.qos.logback.core.pattern.color
ch.qos.logback.core.read
ch.qos.logback.core.rolling: Implements various file rolling policies.
ch.qos.logback.core.rolling.helper: Internal helper classes used by `ch.qos.logback.core.rolling` package.
ch.qos.logback.core.sift
ch.qos.logback.core.status: Contains logback's internal error reporting system.

### Uses of LifeCycle in ch.qos.logback.access.filter

Classes in ch.qos.logback.access.filter that implement LifeCycle
`class` `CountingFilter`
`class` `StatisticalViewImpl`

### Uses of LifeCycle in ch.qos.logback.access.jetty

Classes in ch.qos.logback.access.jetty that implement LifeCycle
`class` `RequestLogImpl` This class is logback's implementation of jetty's RequestLog interface.

### Uses of LifeCycle in ch.qos.logback.access.net

Classes in ch.qos.logback.access.net that implement LifeCycle
`class` `URLEvaluator`

### Uses of LifeCycle in ch.qos.logback.access.pattern

Classes in ch.qos.logback.access.pattern that implement LifeCycle
`class` `AccessConverter`
`class` `ContentLengthConverter`
`class` `ElapsedSecondsConverter`
`class` `ElapsedTimeConverter`
`class` `FullRequestConverter` This class is tied to the `fullRequest` conversion word.
`class` `FullResponseConverter`
`class` `LocalIPAddressConverter`
`class` `LocalPortConverter`
`class` `NAConverter` Always returns the NA (not available) string which is "-" in the case of access conversions.
`class` `QueryStringConverter`
`class` `RemoteHostConverter`
`class` `RemoteIPAddressConverter`
`class` `RemoteUserConverter`
`class` `RequestAttributeConverter`
`class` `RequestContentConverter` This class is tied to the `requestContent` conversion word.
`class` `RequestCookieConverter`
`class` `RequestHeaderConverter`
`class` `RequestMethodConverter`
`class` `RequestParameterConverter`
`class` `RequestProtocolConverter`
`class` `RequestURIConverter` The request URI.
`class` `RequestURLConverter` The first line of the request.
`class` `ResponseContentConverter` This class is tied to the `requestContent` conversion word.
`class` `ResponseHeaderConverter`
`class` `ServerNameConverter`
`class` `SessionIDConverter`
`class` `StatusCodeConverter`
`class` `ThreadNameConverter`

### Uses of LifeCycle in ch.qos.logback.access.sift

Classes in ch.qos.logback.access.sift that implement LifeCycle
`class` `AccessEventDiscriminator` AccessEventDiscriminator's job is to return the value of a designated field in an `IAccessEvent` instance.

### Uses of LifeCycle in ch.qos.logback.access.spi

Classes in ch.qos.logback.access.spi that implement LifeCycle
`class` `AccessContext` A minimal context implementation used by certain logback-access components, mainly SocketServer.

### Uses of LifeCycle in ch.qos.logback.access.tomcat

Methods in ch.qos.logback.access.tomcat with parameters of type LifeCycle
`void` LogbackValve.`register(LifeCycle component)`

### Uses of LifeCycle in ch.qos.logback.classic

Classes in ch.qos.logback.classic that implement LifeCycle
`class` `AsyncAppender` In order to optimize performance this appender deems events of level TRACE, DEBUG and INFO as discardable.
`class` `LoggerContext` LoggerContext glues many of the logback-classic components together.
`class` `PatternLayout` A flexible layout configurable with pattern string.

### Uses of LifeCycle in ch.qos.logback.classic.boolex

Classes in ch.qos.logback.classic.boolex that implement LifeCycle
`class` `GEventEvaluator`
`class` `JaninoEventEvaluator`
`class` `OnErrorEvaluator` Evaluates to true when the logging event passed as parameter has level ERROR or higher.
`class` `OnMarkerEvaluator` Evaluates to true when the logging event passed as parameter contains one of the user-specified markers.

### Uses of LifeCycle in ch.qos.logback.classic.db

Classes in ch.qos.logback.classic.db that implement LifeCycle
`class` `DBAppender` The DBAppender inserts logging events into three database tables in a format independent of the Java programming language.

### Uses of LifeCycle in ch.qos.logback.classic.encoder

Classes in ch.qos.logback.classic.encoder that implement LifeCycle
`class` `PatternLayoutEncoder`

### Uses of LifeCycle in ch.qos.logback.classic.filter

Classes in ch.qos.logback.classic.filter that implement LifeCycle
`class` `LevelFilter` A class that filters events by the level equality.
`class` `ThresholdFilter` Filters events below the threshold level.

### Uses of LifeCycle in ch.qos.logback.classic.html

Classes in ch.qos.logback.classic.html that implement LifeCycle
`class` `HTMLLayout` HTMLLayout outputs events in an HTML table.

### Uses of LifeCycle in ch.qos.logback.classic.jul

Classes in ch.qos.logback.classic.jul that implement LifeCycle
`class` `LevelChangePropagator` Propagate level changes made to a logback logger into the equivalent logger in j.u.l.

### Uses of LifeCycle in ch.qos.logback.classic.layout

Classes in ch.qos.logback.classic.layout that implement LifeCycle
`class` `TTLLLayout` A layout with a fixed format.

### Uses of LifeCycle in ch.qos.logback.classic.log4j

Classes in ch.qos.logback.classic.log4j that implement LifeCycle
`class` `XMLLayout` Generates log4j.dtd compliant XML documents.

### Uses of LifeCycle in ch.qos.logback.classic.net

Classes in ch.qos.logback.classic.net that implement LifeCycle
`class` `ReceiverBase` An abstract base for components that receive logging events from a remote peer and log according to local policy
`class` `SMTPAppender` Send an e-mail when a specific logging event occurs, typically on errors or fatal errors.
`class` `SocketAppender` Sends `ILoggingEvent` objects to a remote a log server, usually a `SocketNode`.
`class` `SocketReceiver` A component that receives serialized `ILoggingEvent` objects from a remote appender over a `Socket`.
`class` `SSLSocketAppender` A `SocketAppender` that supports SSL.
`class` `SSLSocketReceiver` A `SocketReceiver` that supports SSL.
`class` `SyslogAppender` This appender can be used to send messages to a remote syslog daemon.

### Uses of LifeCycle in ch.qos.logback.classic.net.server

Classes in ch.qos.logback.classic.net.server that implement LifeCycle
`class` `ServerSocketAppender` An appender that listens on a TCP port for connections from remote loggers.
`class` `ServerSocketReceiver` A logging socket server that is configurable using Joran.
`class` `SSLServerSocketAppender` A `ServerSocketAppender` that supports SSL.
`class` `SSLServerSocketReceiver` A `ServerSocketReceiver` that supports SSL.

### Uses of LifeCycle in ch.qos.logback.classic.pattern

Classes in ch.qos.logback.classic.pattern that implement LifeCycle
`class` `CallerDataConverter` This converter outputs caller data depending on depth or depth range and marker data.
`class` `ClassicConverter` This class serves the super-class of all converters in logback.
`class` `ClassOfCallerConverter`
`class` `ContextNameConverter` Converts an event to the logger context's name.
`class` `DateConverter`
`class` `ExtendedThrowableProxyConverter`
`class` `FileOfCallerConverter`
`class` `LevelConverter` Return the event's level.
`class` `LineOfCallerConverter`
`class` `LineSeparatorConverter`
`class` `LocalSequenceNumberConverter` A converters based on a a locally incremented sequence number.
`class` `LoggerConverter`
`class` `MarkerConverter` Return the event's marker value(s).
`class` `MDCConverter`
`class` `MessageConverter` Return the event's formatted message.
`class` `MethodOfCallerConverter`
`class` `NamedConverter`
`class` `NopThrowableInformationConverter` Always returns an empty string.
`class` `PropertyConverter`
`class` `RelativeTimeConverter`
`class` `RootCauseFirstThrowableProxyConverter`
`class` `SyslogStartConverter`
`class` `ThreadConverter` Return the events thread (usually the current thread).
`class` `ThrowableHandlingConverter` Converter which handle throwables should be derived from this class.
`class` `ThrowableProxyConverter` Add a stack trace in case the event contains a Throwable.

### Uses of LifeCycle in ch.qos.logback.classic.pattern.color

Classes in ch.qos.logback.classic.pattern.color that implement LifeCycle
`class` `HighlightingCompositeConverter` Highlights inner-text depending on the level, in bold red for events of level ERROR, in red for WARN, in BLUE for INFO, and in the default color for other levels.

### Uses of LifeCycle in ch.qos.logback.classic.sift

Classes in ch.qos.logback.classic.sift that implement LifeCycle
`class` `ContextBasedDiscriminator` This discriminator returns the value context to which this event is attached to.
`class` `JNDIBasedContextDiscriminator` This discriminator returns the value context as determined by JNDI.
`class` `MDCBasedDiscriminator` MDCBasedDiscriminator essentially returns the value mapped to an MDC key.
`class` `SiftingAppender` This appender can contains other appenders which it can build dynamically depending on MDC values.

### Uses of LifeCycle in ch.qos.logback.classic.turbo

Classes in ch.qos.logback.classic.turbo that implement LifeCycle
`class` `DuplicateMessageFilter` See `http://logback.qos.ch/manual/filters.html#DuplicateMessageFilter` for details.
`class` `DynamicThresholdFilter` This filter allows for efficient course grained filtering based on criteria such as product name or company name that would be associated with requests as they are processed.
`class` `MarkerFilter` Checks whether the marker in the event matches the marker specified by the user.
`class` `MatchingFilter` An abstract class containing support for `MatchingFilter.onMatch` on `MatchingFilter.onMismatch` attributes, shared by many but not all turbo filters.
`class` `MDCFilter` This class allows output for a given MDC value.
`class` `ReconfigureOnChangeFilter` Reconfigure a LoggerContext when the configuration file changes.
`class` `TurboFilter` TurboFilter is a specialized filter with a decide method that takes a bunch of parameters instead of a single event object.

### Uses of LifeCycle in ch.qos.logback.core

Subinterfaces of LifeCycle in ch.qos.logback.core
`interface` `Appender<E>`
`interface` `Layout<E>`

Classes in ch.qos.logback.core that implement LifeCycle
`class` `AppenderBase<E>` Sets a skeleton implementation for appenders.
`class` `AsyncAppenderBase<E>` This appender and derived classes, log events asynchronously.
`class` `ConsoleAppender<E>` ConsoleAppender appends log events to `System.out` or `System.err` using a layout specified by the user.
`class` `ContextBase`
`class` `FileAppender<E>` FileAppender appends log events to a file.
`class` `LayoutBase<E>`
`class` `OutputStreamAppender<E>` OutputStreamAppender appends events to a `OutputStream`.
`class` `UnsynchronizedAppenderBase<E>` Similar to AppenderBase except that derived appenders need to handle thread synchronization on their own.

Methods in ch.qos.logback.core with parameters of type LifeCycle
`void` Context.`register(LifeCycle component)` Register a component that participates in the context's life cycle.
`void` ContextBase.`register(LifeCycle component)`
`void` LifeCycleManager.`register(LifeCycle component)` Registers a component with this manager.

### Uses of LifeCycle in ch.qos.logback.core.boolex

Subinterfaces of LifeCycle in ch.qos.logback.core.boolex
`interface` `EventEvaluator<E>` Evaluates whether a given an event matches user-specified criteria.

Classes in ch.qos.logback.core.boolex that implement LifeCycle
`class` `EventEvaluatorBase<E>`
`class` `JaninoEventEvaluatorBase<E>` Abstract class which sets the groundwork for janino based evaluations.
`class` `Matcher`

### Uses of LifeCycle in ch.qos.logback.core.db

Subinterfaces of LifeCycle in ch.qos.logback.core.db
`interface` `ConnectionSource` The <id>ConnectionSource</id> interface provides a pluggable means of transparently obtaining JDBC `Connection`s for logback classes that require the use of a `Connection`.

Classes in ch.qos.logback.core.db that implement LifeCycle
`class` `ConnectionSourceBase`
`class` `DataSourceConnectionSource` The DataSourceConnectionSource is an implementation of `ConnectionSource` that obtains the Connection in the recommended JDBC manner based on a `DataSource`.
`class` `DBAppenderBase<E>`
`class` `DriverManagerConnectionSource` The DriverManagerConnectionSource is an implementation of `ConnectionSource` that obtains the Connection in the traditional JDBC manner based on the connection URL.
`class` `JNDIConnectionSource` The <id>JNDIConnectionSource</id> is an implementation of `ConnectionSource` that obtains a `DataSource` from a JNDI provider and uses it to obtain a `Connection`.

### Uses of LifeCycle in ch.qos.logback.core.encoder

Subinterfaces of LifeCycle in ch.qos.logback.core.encoder
`interface` `Encoder<E>` Encoders are responsible for transform an incoming event into a byte array

Classes in ch.qos.logback.core.encoder that implement LifeCycle
`class` `EchoEncoder<E>`
`class` `EncoderBase<E>`
`class` `LayoutWrappingEncoder<E>`

### Uses of LifeCycle in ch.qos.logback.core.filter

Classes in ch.qos.logback.core.filter that implement LifeCycle
`class` `AbstractMatcherFilter<E>`
`class` `EvaluatorFilter<E>` The value of the `AbstractMatcherFilter.onMatch` and `AbstractMatcherFilter.onMismatch` attributes is set to `FilterReply.NEUTRAL`, so that a badly configured evaluator filter does not disturb the functioning of the filter chain.
`class` `Filter<E>` Users should extend this class to implement customized event filtering.

### Uses of LifeCycle in ch.qos.logback.core.helpers

Classes in ch.qos.logback.core.helpers that implement LifeCycle
`class` `NOPAppender<E>`

### Uses of LifeCycle in ch.qos.logback.core.html

Classes in ch.qos.logback.core.html that implement LifeCycle
`class` `HTMLLayoutBase<E>` This class is a base class for HTMLLayout classes part of other logback modules such as logback-classic and logback-access.

### Uses of LifeCycle in ch.qos.logback.core.layout

Classes in ch.qos.logback.core.layout that implement LifeCycle
`class` `EchoLayout<E>` Echos the incoming object adding a line separator character(s) at the end.

### Uses of LifeCycle in ch.qos.logback.core.net

Classes in ch.qos.logback.core.net that implement LifeCycle
`class` `AbstractSocketAppender<E>` An abstract base for module specific `SocketAppender` implementations in other logback modules.
`class` `AbstractSSLSocketAppender<E>` An abstract base for module specific `SSLSocketAppender` implementations located in other logback modules.
`class` `SMTPAppenderBase<E>` An abstract class that provides support for sending events to an email address.
`class` `SyslogAppenderBase<E>` Base class for SyslogAppender.

### Uses of LifeCycle in ch.qos.logback.core.net.server

Classes in ch.qos.logback.core.net.server that implement LifeCycle
`class` `AbstractServerSocketAppender<E>` This is the super class for module specific ServerSocketAppender implementations can derive from.
`class` `SSLServerSocketAppenderBase<E>` This is the base class for module specific ServerSocketAppender implementations.

### Uses of LifeCycle in ch.qos.logback.core.pattern

Classes in ch.qos.logback.core.pattern that implement LifeCycle
`class` `CompositeConverter<E>`
`class` `DynamicConverter<E>`
`class` `IdentityCompositeConverter<E>`
`class` `PatternLayoutBase<E>`
`class` `PatternLayoutEncoderBase<E>`
`class` `ReplacingCompositeConverter<E>`

### Uses of LifeCycle in ch.qos.logback.core.pattern.color

Classes in ch.qos.logback.core.pattern.color that implement LifeCycle
`class` `BlackCompositeConverter<E>` Encloses a given set of converter output in black using the appropriate ANSI escape codes.
`class` `BlueCompositeConverter<E>` Encloses a given set of converter output in blue using the appropriate ANSI escape codes.
`class` `BoldBlueCompositeConverter<E>` Encloses a given set of converter output in bold blue using the appropriate ANSI escape codes.
`class` `BoldCyanCompositeConverter<E>` Encloses a given set of converter output in bold cyan using the appropriate ANSI escape codes.
`class` `BoldGreenCompositeConverter<E>` Encloses a given set of converter output in bold green using the appropriate ANSI escape codes.
`class` `BoldMagentaCompositeConverter<E>` Encloses a given set of converter output in bold magenta using the appropriate ANSI escape codes.
`class` `BoldRedCompositeConverter<E>` Encloses a given set of converter output in bold red using the appropriate ANSI escape codes.
`class` `BoldWhiteCompositeConverter<E>` Encloses a given set of converter output in bold white using the appropriate ANSI escape codes.
`class` `BoldYellowCompositeConverter<E>` Encloses a given set of converter output in bold yellow using the appropriate ANSI escape codes.
`class` `CyanCompositeConverter<E>` Encloses a given set of converter output in cyan using the appropriate ANSI escape codes.
`class` `ForegroundCompositeConverterBase<E>` Base class for all foreground color setting composite converters.
`class` `GrayCompositeConverter<E>` Encloses a given set of converter output in gray using the appropriate ANSI escape codes.
`class` `GreenCompositeConverter<E>` Encloses a given set of converter output in green using the appropriate ANSI escape codes.
`class` `MagentaCompositeConverter<E>` Encloses a given set of converter output in magenta using the appropriate ANSI escape codes.
`class` `RedCompositeConverter<E>` Encloses a given set of converter output in red using the appropriate ANSI escape codes.
`class` `WhiteCompositeConverter<E>` Encloses a given set of converter output in white using the appropriate ANSI escape codes.
`class` `YellowCompositeConverter<E>` Encloses a given set of converter output in yellow using the appropriate ANSI escape codes.

### Uses of LifeCycle in ch.qos.logback.core.read

Classes in ch.qos.logback.core.read that implement LifeCycle
`class` `CyclicBufferAppender<E>` CyclicBufferAppender stores events in a cyclic buffer of user-specified size.
`class` `ListAppender<E>`

### Uses of LifeCycle in ch.qos.logback.core.rolling

Subinterfaces of LifeCycle in ch.qos.logback.core.rolling
`interface` `RollingPolicy` A `RollingPolicy` is responsible for performing the rolling over of the active log file.
`interface` `TimeBasedFileNamingAndTriggeringPolicy<E>` This interface lists the set of methods that need to be implemented by triggering policies which are nested within a `TimeBasedRollingPolicy`.
`interface` `TriggeringPolicy<E>` A `TriggeringPolicy` controls the conditions under which roll-over occurs.

Classes in ch.qos.logback.core.rolling that implement LifeCycle
`class` `DefaultTimeBasedFileNamingAndTriggeringPolicy<E>`
`class` `FixedWindowRollingPolicy` When rolling over, `FixedWindowRollingPolicy` renames files according to a fixed window algorithm.
`class` `RollingFileAppender<E>` `RollingFileAppender` extends `FileAppender` to backup the log files depending on `RollingPolicy` and `TriggeringPolicy`.
`class` `RollingPolicyBase` Implements methods common to most, it not all, rolling policies.
`class` `SizeAndTimeBasedFNATP<E>`
`class` `SizeAndTimeBasedRollingPolicy<E>`
`class` `SizeBasedTriggeringPolicy<E>` SizeBasedTriggeringPolicy looks at size of the file being currently written to.
`class` `TimeBasedFileNamingAndTriggeringPolicyBase<E>`
`class` `TimeBasedRollingPolicy<E>` `TimeBasedRollingPolicy` is both easy to configure and quite powerful.
`class` `TriggeringPolicyBase<E>` SizeBasedTriggeringPolicy looks at size of the file being currently written to.

### Uses of LifeCycle in ch.qos.logback.core.rolling.helper

Classes in ch.qos.logback.core.rolling.helper that implement LifeCycle
`class` `DateTokenConverter<E>` Returns a date formatted by SimpleDateFormatter.
`class` `IntegerTokenConverter` When asked to convert an integer, `IntegerTokenConverter` the string value of that integer.

### Uses of LifeCycle in ch.qos.logback.core.sift

Subinterfaces of LifeCycle in ch.qos.logback.core.sift
`interface` `Discriminator<E>` Implement this interface in order to compute a discriminating value for a given event of type <E>.

Classes in ch.qos.logback.core.sift that implement LifeCycle
`class` `AbstractDiscriminator<E>` Base implementation of `Discriminator` that provides basic lifecycle management
`class` `DefaultDiscriminator<E>`
`class` `SiftingAppenderBase<E>` This appender serves as the base class for actual SiftingAppenders implemented by the logback-classic and logback-access modules.

### Uses of LifeCycle in ch.qos.logback.core.status

Classes in ch.qos.logback.core.status that implement LifeCycle
`class` `OnConsoleStatusListener` Print all new incoming status messages on the console (System.out).
`class` `OnErrorConsoleStatusListener` Print all new incoming status messages on the error console (System.err).
`class` `OnPrintStreamStatusListenerBase` Print all new incoming status messages on the on the designated PrintStream.