Class List
Here are the classes, structs, unions and interfaces with brief descriptions:

log4cxx |
config |
PropertySetter | General purpose Object property setter
db |
SQLException |
ODBCAppender |
filter |
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
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
helpers |
SimpleDateFormatImpl |
AbsoluteTimeDateFormat | Formats a date in the format HH:mm:ss,SSS for example, "15:49:37,459"
AppenderAttachableImpl |
APRInitializer |
BufferedOutputStream | Abstract class for writing to character streams
BufferedWriter | Writes text to a character-output stream buffering requests to increase efficiency
ByteArrayInputStream | InputStream implemented on top of a byte array
ByteArrayOutputStream | OutputStream implemented on top of std::vector
ByteBuffer | A byte buffer
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
Class |
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
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
DateLayout | This abstract layout takes care of all the date related options and formatting work

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"

Exception

    The class Exception and its subclasses indicate conditions that a

reasonable application might want to catch

RuntimeException

    RuntimeException is the parent class of those exceptions that can be

thrown during the normal operation of the process

NullPointerException

    Thrown when an application attempts to use null in a case where an

object is required

IllegalArgumentException

    Thrown to indicate that a method has been passed

an illegal or inappropriate argument

IOException | Signals that an I/O exception of some sort has occurred
MissingResourceException |
PoolException |
MutexException |
InterruptedException |
ThreadException |
TranscoderException |
IllegalMonitorStateException |
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
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
NoSuchElementException |
IllegalStateException |

SocketException

    Thrown to indicate that there is an error in the underlying

protocol, such as a TCP error

ConnectException

    Signals that an error occurred while attempting to connect a socket

to a remote address and port

ClosedChannelException |

BindException

    Signals that an error occurred while attempting to bind a socket to

a local address and port

InterruptedIOException | Signals that an I/O operation has been interrupted
SocketTimeoutException | Signals that an I/O operation has been interrupted
FileInputStream | InputStream implemented on top of APR file IO
FileOutputStream | OutputStream implemented on top of APR file IO
FileWatchdog | Check every now and then that a certain file has not changed
UnknownHostException |
InetAddress |
InputStream | Abstract class for reading from character streams
InputStreamReader | Class for reading from character streams
Integer |
ISO8601DateFormat | Formats a date in the format yyyy-MM-dd HH:mm:ss,SSS for example "1999-11-27 15:49:37,459"
Loader |
Locale |
LogLog | This class used to output log statements from within the log4cxx package
CharMessageBuffer | This class is used by the LOG4CXX_INFO and similar macros to support insertion operators in the message parameter
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
MessageBuffer | This class is used by the LOG4CXX_INFO and similar macros to support insertion operators in the message parameter
Mutex |
Object | Base class for java-like objects
ClazzObject |
ObjectImpl | Implementation class for Object
ObjectOutputStream | Emulates java serialization
ObjectPtrBase |
ObjectPtrT | Smart pointer to a Object descendant
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
OptionConverter | A convenience class to convert property values to specific types
OutputStream | Abstract class for writing to character streams
OutputStreamWriter | Abstract class for writing to character streams
Pool |
Properties |
PropertyResourceBundle | PropertyResourceBundle is a concrete subclass of ResourceBundle that manages resources for a locale using a set of static strings from a property file
Reader | Abstract class for reading from character streams
RelativeTimeDateFormat | Formats a date by printing the number of seconds elapsed since the start of the application
ResourceBundle | Resource bundles contain locale-specific objects
ServerSocket |
SimpleDateFormat | Concrete class for formatting and parsing dates in a locale-sensitive manner
Socket |
SocketOutputStream |
StrftimeDateFormat | Concrete class for formatting and parsing dates in a locale-sensitive manner
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
SystemErrWriter | Abstract class for writing to character streams
SystemOutWriter | Abstract class for writing to character streams
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
TimeZone |
Transcoder | Simple transcoder for converting between external char and wchar_t strings and internal strings
Transform | Utility class for transforming strings
Writer | Abstract class for writing to character streams
DOMException |
XMLDOMNode | The XMLDOMNode interface is the primary datatype for the entire Document Object Model
XMLDOMElement | The XMLDOMElement interface represents an element in an XML document
XMLDOMDocument | The XMLDOMDocument interface represents an entire XML document
XMLDOMNodeList | The XMLDOMNodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented
net |
SMTPAppender | Send an e-mail when a specific logging event occurs, typically on errors or fatal errors
SocketAppender | Sends LoggingEvent objects to a remote a log server, usually Apache Chainsaw
SocketAppenderSkeleton | Abstract base class for SocketAppender and XMLSocketAppender
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 |
XMLSocketAppender | Sends LoggingEvent objects in XML format to a remote a log server, usually a XMLSocketNode
nt |
NTEventLogAppender | Appends log events to NT EventLog
OutputDebugStringAppender |
pattern |
CachedDateFormat |
ClassNamePatternConverter | Formats the class name of the site of the logging request
DatePatternConverter | Convert and format the event's date in a StringBuffer
FileDatePatternConverter | Formats an date by delegating to DatePatternConverter
FileLocationPatternConverter | Return the event's line location information in a StringBuffer
FormattingInfo | Modifies the output of a pattern converter for a specified minimum and maximum width and alignment
FullLocationPatternConverter | Format the event's line location information
IntegerPatternConverter | Formats an integer
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
LoggerPatternConverter | Formats a logger name
LoggingEventPatternConverter | LoggingEventPatternConverter is a base class for pattern converters that can format information from instances of LoggingEvent
MessagePatternConverter | Formats the message of an logging event
MethodLocationPatternConverter | Return the event's line location information in a StringBuffer
NameAbbreviator | NameAbbreviator generates abbreviated logger and class names
NamePatternConverter | Base class for other pattern converters which can return only parts of their name
NDCPatternConverter | Return the event's NDC in a StringBuffer
PatternConverter |
PatternParser | Most of the work of the PatternLayout class is delegated to the PatternParser class
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
rolling |
Action | A file system action performed as part of a rollover event
FileRenameAction |
FilterBasedTriggeringPolicy | FilterBasedTriggeringPolicy determines if rolling should be triggered by evaluating the current message against a set of filters
FixedWindowRollingPolicy | When rolling over, `FixedWindowRollingPolicy` renames files according to a fixed window algorithm as described below
GZCompressAction |
ManualTriggeringPolicy | ManualTriggeringPolicy only rolls over on explicit calls to RollingFileAppender.rollover()
RollingFileAppender | `RollingFileAppender` extends log4cxx::FileAppender to backup the log files depending on RollingPolicy and TriggeringPolicy
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)
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
RolloverDescription |
SizeBasedTriggeringPolicy | SizeBasedTriggeringPolicy looks at size of the file being currently written to
TimeBasedRollingPolicy | `TimeBasedRollingPolicy` is both easy to configure and quite powerful
TriggeringPolicy | A `TriggeringPolicy` controls the conditions under which rollover occurs
ZipCompressAction |
rule |
spi |
AppenderAttachable | This Interface is for attaching Appenders to objects
Configurator | Implemented by classes capable of configuring log4j using a URL
DefaultRepositorySelector |
ErrorCode |
ErrorHandler | Appenders may delegate their error handling to `ErrorHandlers`
Filter | Users should extend this class to implement customized logging event filtering
HierarchyEventListener | Listen to events occuring within a Hierarchy
LocationInfo | This class represents the location of a logging statement
LoggerFactory | Implement this interface to create new instances of Logger or a sub-class of Logger
LoggerRepository | A `LoggerRepository` is used to create and retrieve `Loggers`
LoggingEvent | The internal representation of logging events
OptionHandler | A string based interface to configure package components
RepositorySelector | The `LogManager` uses one (and only one) `RepositorySelector` implementation to select the LoggerRepository for a particular application context
RootLogger | RootLogger sits at the top of the logger hierachy
TriggeringEventEvaluator | Implementions of this interface allow certain appenders to decide when to perform an appender specific action
varia |
FallbackErrorHandler | The `FallbackErrorHandler` implements the ErrorHandler interface such that a secondary appender may be specified
xml |
DOMConfigurator | Use this class to initialize the log4cxx environment using a DOM tree
XMLLayout | The output of the XMLLayout consists of a series of log4j:event elements
Appender | Implement this interface for your own strategies for outputting log statements
AppenderSkeleton | Implementation base class for all appenders
AsyncAppender | The AsyncAppender lets users log events asynchronously
BasicConfigurator | Use this class to quickly configure the package
ConsoleAppender | ConsoleAppender appends log events to `stdout` or `stderr` using a layout specified by the user
DailyRollingFileAppender | DailyRollingFileAppender extends FileAppender so that the underlying file is rolled over at a user chosen frequency
DefaultConfigurator | Configures the repository from environmental settings and files
DefaultLoggerFactory |
File | An abstract representation of file and directory path names
FileAppender | FileAppender appends log events to a file
Hierarchy | This class is specialized in retrieving loggers by name and also maintaining the logger hierarchy
HTMLLayout | This layout outputs events in a HTML table
Layout | Extend this abstract class to create your own log layout format
Level | Defines the minimum set of levels recognized by the system, that is `OFF`, `FATAL`, `ERROR`, `WARN`, `INFO`, `DEBUG` and `ALL`
LevelClass |
Logger | This is the central class in the log4cxx package
LogManager | Use the `LogManager` class to retreive Logger instances or to operate on the current LoggerRepository
MDC | Similar to the NDC class except that it is based on a map instead of a stack
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
PatternLayout | A flexible layout configurable with pattern string
PropertyConfigurator | Allows the configuration of log4cxx from an external file
RollingFileAppender | RollingFileAppender extends FileAppender to backup the log files when they reach a certain size
SimpleLayout | SimpleLayout consists of the level of the log statement, followed by " - " and then the log message itself
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
wlogstream | An STL-like stream API for log4cxx using wchar_t as the character type
ulogstream | An STL-like stream API for log4cxx using UniChar as the character type
TTCCLayout | TTCC layout format consists of time, thread, logger name and nested diagnostic context information, hence the name
WriterAppender | WriterAppender appends log events to a standard output stream
std |