final class LoggerNode
extends java.lang.Object
Modifier and Type | Field and Description |
---|---|
private java.util.Map<Logger.AttachmentKey,java.lang.Object> |
attachments
The attachments map.
|
private static java.util.concurrent.atomic.AtomicReferenceFieldUpdater<LoggerNode,java.util.Map> |
attachmentsUpdater
The atomic updater for the
attachments field. |
private java.util.concurrent.ConcurrentMap<java.lang.String,LoggerNode> |
children
The map of names to child nodes.
|
private LogContext |
context
The log context.
|
private int |
effectiveLevel
The effective level.
|
private java.util.logging.Filter |
filter
The filter for this logger instance.
|
private java.lang.String |
fullName
The fully-qualified name of this logger.
|
private java.util.logging.Handler[] |
handlers
The handlers for this logger.
|
private static AtomicArray<LoggerNode,java.util.logging.Handler> |
handlersUpdater
The atomic updater for the
handlers field. |
private java.util.logging.Level |
level
The actual level.
|
private LoggerNode |
parent
The parent node, or
null if this is the root logger node. |
private boolean |
useParentFilter
Flag to specify whether parent filters are used.
|
private boolean |
useParentHandlers
Flag to specify whether parent handlers are used.
|
Modifier | Constructor and Description |
---|---|
(package private) |
LoggerNode(LogContext context)
Construct a new root instance.
|
private |
LoggerNode(LogContext context,
LoggerNode parent,
java.lang.String nodeName)
Construct a child instance.
|
Modifier and Type | Method and Description |
---|---|
(package private) void |
addHandler(java.util.logging.Handler handler) |
(package private) <V> V |
attach(Logger.AttachmentKey<V> key,
V value) |
(package private) <V> V |
attachIfAbsent(Logger.AttachmentKey<V> key,
V value) |
(package private) java.util.logging.Handler[] |
clearHandlers() |
(package private) boolean |
compareAndSetHandlers(java.util.logging.Handler[] oldHandlers,
java.util.logging.Handler[] newHandlers) |
(package private) Logger |
createLogger() |
(package private) void |
decrementRef()
Removes one from the reference count.
|
<V> V |
detach(Logger.AttachmentKey<V> key) |
protected void |
finalize()
Perform finalization actions.
|
(package private) <V> V |
getAttachment(Logger.AttachmentKey<V> key) |
(package private) java.util.Collection<LoggerNode> |
getChildren()
Get the children of this logger.
|
(package private) LogContext |
getContext()
Get the log context.
|
(package private) int |
getEffectiveLevel() |
(package private) java.util.logging.Filter |
getFilter() |
(package private) java.lang.String |
getFullName() |
(package private) java.util.logging.Handler[] |
getHandlers() |
(package private) LoggerNode |
getIfExists(java.lang.String name)
Get a relative logger, if it exists.
|
(package private) java.util.logging.Level |
getLevel() |
(package private) LoggerNode |
getOrCreate(java.lang.String name)
Get or create a relative logger node.
|
(package private) LoggerNode |
getParent() |
(package private) boolean |
getUseParentFilters() |
(package private) boolean |
getUseParentHandlers() |
(package private) boolean |
isLoggable(ExtLogRecord record)
Checks the filter to see if the record is loggable.
|
private static boolean |
isLoggable(LoggerNode loggerNode,
ExtLogRecord record) |
(package private) void |
publish(ExtLogRecord record) |
(package private) void |
removeHandler(java.util.logging.Handler handler) |
(package private) void |
setEffectiveLevel(int newLevel)
Update the effective level if it is inherited from a parent.
|
(package private) void |
setFilter(java.util.logging.Filter filter) |
(package private) java.util.logging.Handler[] |
setHandlers(java.util.logging.Handler[] handlers) |
(package private) void |
setLevel(java.util.logging.Level newLevel) |
(package private) void |
setUseParentFilters(boolean useParentFilter) |
(package private) void |
setUseParentHandlers(boolean useParentHandlers) |
private final LogContext context
private final LoggerNode parent
null
if this is the root logger node.private final java.lang.String fullName
private final java.util.concurrent.ConcurrentMap<java.lang.String,LoggerNode> children
private volatile java.util.logging.Handler[] handlers
handlersUpdater
atomic updater. The array
instance should not be modified (treat as immutable).private volatile boolean useParentHandlers
private volatile java.util.logging.Filter filter
private volatile boolean useParentFilter
private volatile java.util.Map<Logger.AttachmentKey,java.lang.Object> attachments
private static final AtomicArray<LoggerNode,java.util.logging.Handler> handlersUpdater
handlers
field.private static final java.util.concurrent.atomic.AtomicReferenceFieldUpdater<LoggerNode,java.util.Map> attachmentsUpdater
attachments
field.private volatile java.util.logging.Level level
private volatile int effectiveLevel
LoggerNode(LogContext context)
context
- the logmanagerprivate LoggerNode(LogContext context, LoggerNode parent, java.lang.String nodeName)
context
- the logmanagerparent
- the parent nodenodeName
- the name of this subnodeLoggerNode getOrCreate(java.lang.String name)
name
- the nameLoggerNode getIfExists(java.lang.String name)
name
- the nameLogger createLogger()
void decrementRef()
java.util.Collection<LoggerNode> getChildren()
LogContext getContext()
void setEffectiveLevel(int newLevel)
newLevel
- the new effective levelvoid setFilter(java.util.logging.Filter filter)
java.util.logging.Filter getFilter()
boolean getUseParentFilters()
void setUseParentFilters(boolean useParentFilter)
int getEffectiveLevel()
java.util.logging.Handler[] getHandlers()
java.util.logging.Handler[] clearHandlers()
void removeHandler(java.util.logging.Handler handler)
void addHandler(java.util.logging.Handler handler)
java.util.logging.Handler[] setHandlers(java.util.logging.Handler[] handlers)
boolean compareAndSetHandlers(java.util.logging.Handler[] oldHandlers, java.util.logging.Handler[] newHandlers)
boolean getUseParentHandlers()
void setUseParentHandlers(boolean useParentHandlers)
void publish(ExtLogRecord record)
void setLevel(java.util.logging.Level newLevel)
java.util.logging.Level getLevel()
<V> V getAttachment(Logger.AttachmentKey<V> key)
<V> V attach(Logger.AttachmentKey<V> key, V value)
<V> V attachIfAbsent(Logger.AttachmentKey<V> key, V value)
public <V> V detach(Logger.AttachmentKey<V> key)
java.lang.String getFullName()
LoggerNode getParent()
boolean isLoggable(ExtLogRecord record)
getUseParentFilters()
is set to true
the parent loggers are checked.record
- the log record to check against the filtertrue
if the record is loggable, otherwise false
private static boolean isLoggable(LoggerNode loggerNode, ExtLogRecord record)
protected void finalize() throws java.lang.Throwable
finalize
in class java.lang.Object
java.lang.Throwable