Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:

APRInitializer |
BasicConfigurator | Use this class to quickly configure the package
ByteBuffer | A byte buffer
CharMessageBuffer | This class is used by the LOG4CXX_INFO and similar macros to support insertion operators in the message parameter
Class |
Object::ClazzObject |
Level::LevelClass |
ClassRegistration |
Condition | This class provides a means for one thread to suspend exception until notified by another thread to resume
CyclicBuffer | CyclicBuffer is used by other appenders to hold instances of LoggingEvent for immediate or deferred display
DefaultConfigurator | Configures the repository from environmental settings and files
ErrorCode |
exception | STL class
Exception | The class Exception and its subclasses indicate conditions that a reasonable application might want to catch
SQLException |
ClassNotFoundException | Thrown when an application tries to load in a class through its string name but no definition for the class with the specified name could be found
IllegalMonitorStateException |
IllegalStateException |
InstantiationException | Thrown when an application tries to create an instance of a class using the newInstance method in class Class, but the specified class object cannot be instantiated because it is an interface or is an abstract class
InterruptedException |
IOException | Signals that an I/O exception of some sort has occurred
InterruptedIOException | Signals that an I/O operation has been interrupted
SocketTimeoutException | Signals that an I/O operation has been interrupted
SocketException | Thrown to indicate that there is an error in the underlying protocol, such as a TCP error
BindException | Signals that an error occurred while attempting to bind a socket to a local address and port
ClosedChannelException |
ConnectException | Signals that an error occurred while attempting to connect a socket to a remote address and port
MissingResourceException |
MutexException |
NoSuchElementException |
PoolException |
RuntimeException | RuntimeException is the parent class of those exceptions that can be thrown during the normal operation of the process
DOMException |
IllegalArgumentException | Thrown to indicate that a method has been passed an illegal or inappropriate argument
NullPointerException | Thrown when an application attempts to use null in a case where an object is required
ThreadException |
TranscoderException |
UnknownHostException |
File | An abstract representation of file and directory path names
FileDatePatternConverter | Formats an date by delegating to DatePatternConverter
FileWatchdog | Check every now and then that a certain file has not changed
Loader |
Locale |
LocationInfo | This class represents the location of a logging statement
LogLog | This class used to output log statements from within the log4cxx package
LogManager | Use the `LogManager` class to retreive Logger instances or to operate on the current LoggerRepository
logstream_base | Base class for the basic_logstream template which attempts to emulate std::basic_ostream but attempts to short-circuit unnecessary operations
logstream | An STL-like stream API for log4cxx using char as the character type
ulogstream | An STL-like stream API for log4cxx using UniChar as the character type
wlogstream | An STL-like stream API for log4cxx using wchar_t as the character type
MDC | Similar to the NDC class except that it is based on a map instead of a stack
MessageBuffer | This class is used by the LOG4CXX_INFO and similar macros to support insertion operators in the message parameter
Mutex |
NDC | Ndc class implements nested diagnostic contexts as defined by neil harrison in the article "patterns for logging diagnostic messages" part of the book "<i>pattern languages of program design 3</i>" edited by martin et al
Object | Base class for java-like objects
ObjectImpl | Implementation class for Object
AppenderSkeleton | Implementation base class for all appenders
AsyncAppender | The AsyncAppender lets users log events asynchronously
ODBCAppender |
SMTPAppender | Send an e-mail when a specific logging event occurs, typically on errors or fatal errors
SocketAppenderSkeleton | Abstract base class for SocketAppender and XMLSocketAppender
SocketAppender | Sends LoggingEvent objects to a remote a log server, usually Apache Chainsaw
XMLSocketAppender | Sends LoggingEvent objects in XML format to a remote a log server, usually a XMLSocketNode
SocketHubAppender | Sends LoggingEvent objects to a set of remote log servers, usually a SocketNode
SyslogAppender | Use SyslogAppender to send log messages to a remote syslog daemon
TelnetAppender |
NTEventLogAppender | Appends log events to NT EventLog
OutputDebugStringAppender |
WriterAppender | WriterAppender appends log events to a standard output stream
ConsoleAppender | ConsoleAppender appends log events to `stdout` or `stderr` using a layout specified by the user
FileAppender | FileAppender appends log events to a file
RollingFileAppenderSkeleton | Base class for log4cxx::rolling::RollingFileAppender and log4cxx::RollingFileAppender (analogues of org.apache.log4j.rolling.RFA from extras companion and org.apache.log4j.RFA from log4j 1.2, respectively)
DailyRollingFileAppender | DailyRollingFileAppender extends FileAppender so that the underlying file is rolled over at a user chosen frequency
RollingFileAppender | `RollingFileAppender` extends log4cxx::FileAppender to backup the log files depending on RollingPolicy and TriggeringPolicy
RollingFileAppender | RollingFileAppender extends FileAppender to backup the log files when they reach a certain size
DefaultLoggerFactory |
AppenderAttachableImpl |
CharsetDecoder | An abstract engine to transform a sequences of bytes in a specific charset into a LogString
CharsetEncoder | An engine to transform LogStrings into bytes for the specific character set
DatagramPacket | This class represents a datagram packet
DatagramSocket | This class represents a socket for sending and receiving datagram packets
Date | Simple transcoder for converting between external char and wchar_t strings and internal strings
DateFormat | DateFormat is an abstract class for date/time formatting patterned after java.text.DateFormat
RelativeTimeDateFormat | Formats a date by printing the number of seconds elapsed since the start of the application
SimpleDateFormat | Concrete class for formatting and parsing dates in a locale-sensitive manner
AbsoluteTimeDateFormat | Formats a date in the format HH:mm:ss,SSS for example, "15:49:37,459"

DateTimeDateFormat

     Formats a date in the format <b>dd MMM yyyy HH:mm:ss,SSS</b> for example,

"06 Nov 1994 15:49:37,459"

ISO8601DateFormat | Formats a date in the format yyyy-MM-dd HH:mm:ss,SSS for example "1999-11-27 15:49:37,459"
StrftimeDateFormat | Concrete class for formatting and parsing dates in a locale-sensitive manner
CachedDateFormat |
InetAddress |
InputStream | Abstract class for reading from character streams
ByteArrayInputStream | InputStream implemented on top of a byte array
FileInputStream | InputStream implemented on top of APR file IO
Integer |
ObjectOutputStream | Emulates java serialization
OnlyOnceErrorHandler | The `OnlyOnceErrorHandler` implements log4cxx's default error handling policy which consists of emitting a message for the first error in an appender and ignoring all following errors
OutputStream | Abstract class for writing to character streams
BufferedOutputStream | Abstract class for writing to character streams
ByteArrayOutputStream | OutputStream implemented on top of std::vector
FileOutputStream | OutputStream implemented on top of APR file IO
SocketOutputStream |
Reader | Abstract class for reading from character streams
InputStreamReader | Class for reading from character streams
ResourceBundle | Resource bundles contain locale-specific objects
PropertyResourceBundle | PropertyResourceBundle is a concrete subclass of ResourceBundle that manages resources for a locale using a set of static strings from a property file
Socket |
TimeZone |
Writer | Abstract class for writing to character streams
BufferedWriter | Writes text to a character-output stream buffering requests to increase efficiency
OutputStreamWriter | Abstract class for writing to character streams
SystemErrWriter | Abstract class for writing to character streams
SystemOutWriter | Abstract class for writing to character streams
Hierarchy | This class is specialized in retrieving loggers by name and also maintaining the logger hierarchy
Layout | Extend this abstract class to create your own log layout format
DateLayout | This abstract layout takes care of all the date related options and formatting work
TTCCLayout | TTCC layout format consists of time, thread, logger name and nested diagnostic context information, hence the name
HTMLLayout | This layout outputs events in a HTML table
PatternLayout | A flexible layout configurable with pattern string
SimpleLayout | SimpleLayout consists of the level of the log statement, followed by " - " and then the log message itself
XMLLayout | The output of the XMLLayout consists of a series of log4j:event elements
Level | Defines the minimum set of levels recognized by the system, that is `OFF`, `FATAL`, `ERROR`, `WARN`, `INFO`, `DEBUG` and `ALL`
Logger | This is the central class in the log4cxx package
RootLogger | RootLogger sits at the top of the logger hierachy
FormattingInfo | Modifies the output of a pattern converter for a specified minimum and maximum width and alignment
NameAbbreviator | NameAbbreviator generates abbreviated logger and class names
PatternConverter |
IntegerPatternConverter | Formats an integer
LoggingEventPatternConverter | LoggingEventPatternConverter is a base class for pattern converters that can format information from instances of LoggingEvent
DatePatternConverter | Convert and format the event's date in a StringBuffer
FileLocationPatternConverter | Return the event's line location information in a StringBuffer
FullLocationPatternConverter | Format the event's line location information
LevelPatternConverter | Return the event's level in a StringBuffer
LineLocationPatternConverter | Format the event's line location information
LineSeparatorPatternConverter | Formats a line separator
LiteralPatternConverter | Formats a string literal
MessagePatternConverter | Formats the message of an logging event
MethodLocationPatternConverter | Return the event's line location information in a StringBuffer
NamePatternConverter | Base class for other pattern converters which can return only parts of their name
ClassNamePatternConverter | Formats the class name of the site of the logging request
LoggerPatternConverter | Formats a logger name
NDCPatternConverter | Return the event's NDC in a StringBuffer
PropertiesPatternConverter | Able to handle the contents of the LoggingEvent's Property bundle and either output the entire contents of the properties in a similar format to the java.util.Hashtable.toString(), or to output the value of a specific key within the property bundle when this pattern converter has the option set
RelativeTimePatternConverter | Format the relative time in milliseconds
ThreadPatternConverter | Formats the event thread name
ThrowableInformationPatternConverter | Outputs the ThrowableInformation portion of the LoggingiEvent as a full stacktrace unless this converter's option is 'short', where it just outputs the first line of the trace
PropertyConfigurator | Allows the configuration of log4cxx from an external file
Action | A file system action performed as part of a rollover event
FileRenameAction |
GZCompressAction |
ZipCompressAction |
RollingPolicyBase | Implements methods common to most, it not all, rolling policies
FixedWindowRollingPolicy | When rolling over, `FixedWindowRollingPolicy` renames files according to a fixed window algorithm as described below
TimeBasedRollingPolicy | `TimeBasedRollingPolicy` is both easy to configure and quite powerful
RolloverDescription |
TriggeringPolicy | A `TriggeringPolicy` controls the conditions under which rollover occurs
FilterBasedTriggeringPolicy | FilterBasedTriggeringPolicy determines if rolling should be triggered by evaluating the current message against a set of filters
ManualTriggeringPolicy | ManualTriggeringPolicy only rolls over on explicit calls to RollingFileAppender.rollover()
SizeBasedTriggeringPolicy | SizeBasedTriggeringPolicy looks at size of the file being currently written to
TimeBasedRollingPolicy | `TimeBasedRollingPolicy` is both easy to configure and quite powerful
DefaultRepositorySelector |
Filter | Users should extend this class to implement customized logging event filtering
AndFilter | A filter that 'and's the results of any number of contained filters together
DenyAllFilter | This filter drops all logging events
ExpressionFilter | A filter supporting complex expressions - supports both infix and postfix expressions (infix expressions must first be converted to postfix prior to processing)
LevelMatchFilter | This is a very simple filter based on level matching
LevelRangeFilter | This is a very simple filter based on level matching, which can be used to reject messages with priorities outside a certain range
LocationInfoFilter | Location information is usually specified at the appender level - all events associated with an appender either create and parse stack traces or they do not
LoggerMatchFilter | This is a very simple filter based on logger name matching
MapFilter |
PropertyFilter | NOTE: This filter modifies logging events by adding properties to the event
StringMatchFilter | This is a very simple filter based on string matching
LoggingEvent | The internal representation of logging events
FallbackErrorHandler | The `FallbackErrorHandler` implements the ErrorHandler interface such that a secondary appender may be specified
DOMConfigurator | Use this class to initialize the log4cxx environment using a DOM tree
XMLDOMNode | The XMLDOMNode interface is the primary datatype for the entire Document Object Model
XMLDOMDocument | The XMLDOMDocument interface represents an entire XML document
XMLDOMElement | The XMLDOMElement interface represents an element in an XML document
XMLDOMNodeList | The XMLDOMNodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented
AppenderAttachable | This Interface is for attaching Appenders to objects
AsyncAppender | The AsyncAppender lets users log events asynchronously
AppenderAttachableImpl |
Logger | This is the central class in the log4cxx package
Configurator | Implemented by classes capable of configuring log4j using a URL
PropertyConfigurator | Allows the configuration of log4cxx from an external file
DOMConfigurator | Use this class to initialize the log4cxx environment using a DOM tree
HierarchyEventListener | Listen to events occuring within a Hierarchy
LoggerFactory | Implement this interface to create new instances of Logger or a sub-class of Logger
DefaultLoggerFactory |
LoggerRepository | A `LoggerRepository` is used to create and retrieve `Loggers`
Hierarchy | This class is specialized in retrieving loggers by name and also maintaining the logger hierarchy
OptionHandler | A string based interface to configure package components
Appender | Implement this interface for your own strategies for outputting log statements
AppenderSkeleton | Implementation base class for all appenders
Layout | Extend this abstract class to create your own log layout format
RollingPolicy | A `RollingPolicy` is responsible for performing the rolling over of the active log file
RollingPolicyBase | Implements methods common to most, it not all, rolling policies
TriggeringPolicy | A `TriggeringPolicy` controls the conditions under which rollover occurs
ErrorHandler | Appenders may delegate their error handling to `ErrorHandlers`
OnlyOnceErrorHandler | The `OnlyOnceErrorHandler` implements log4cxx's default error handling policy which consists of emitting a message for the first error in an appender and ignoring all following errors
FallbackErrorHandler | The `FallbackErrorHandler` implements the ErrorHandler interface such that a secondary appender may be specified
Filter | Users should extend this class to implement customized logging event filtering
RepositorySelector | The `LogManager` uses one (and only one) `RepositorySelector` implementation to select the LoggerRepository for a particular application context
DefaultRepositorySelector |
TriggeringEventEvaluator | Implementions of this interface allow certain appenders to decide when to perform an appender specific action
ObjectPtr |
ObjectPtrBase |
ObjectPtrT< T > | Smart pointer to a Object descendant
ObjectPtrT< Appender > |
ObjectPtrT< ErrorHandler > |
ObjectPtrT< Filter > |
ObjectPtrT< Layout > |
ObjectPtrT< Level > |
ObjectPtrT< Logger > |
ObjectPtrT< LoggerFactory > |
ObjectPtrT< LoggerRepository > |
ObjectPtrT< LoggingEvent > |
ObjectPtrT< Rule > |
ObjectPtrT< spi::LoggerFactory > |
OptionConverter | A convenience class to convert property values to specific types
PatternParser | Most of the work of the PatternLayout class is delegated to the PatternParser class
Pool |
Properties |
PropertySetter | General purpose Object property setter
ServerSocket |
StrictMath | The class StrictMath contains methods for performing basic numeric operations
StringHelper | String manipulation routines
StringTokenizer |
synchronized | Utility class for objects multi-thread synchronization
SyslogWriter | SyslogWriter is a wrapper around the DatagramSocket class it writes text to the specified host on the port 514 (UNIX syslog)
System | Several useful class fields and methods
Thread | This class implements an approximation of java.util.Thread
ThreadLocal | This class provides thread-local variables
ThreadSpecificData | This class contains all the thread-specific data in use by log4cxx
Transcoder | Simple transcoder for converting between external char and wchar_t strings and internal strings
Transform | Utility class for transforming strings
UniCharMessageBuffer | This class is designed to support insertion operations in the message argument to the LOG4CXX_INFO and similar macros and is not designed for general purpose use
WideMessageBuffer | This class is designed to support insertion operations in the message argument to the LOG4CXX_INFO and similar macros and is not designed for general purpose use