/*
* Sets the level on {@code logger} to {@code newLevel}. Any child loggers
* currently inheriting their level from {@code logger} will be updated
* recursively.
*
* @param newLevel the new minimum logging threshold. If null, the logger's
* parent level will be used; or {@code Level.INFO} for loggers with no
* parent.
*/
internal void setLevelRecursively(Logger logger, Level newLevel)
{
lock (this)
{
int previous = logger.levelIntVal;
logger.levelObjVal = newLevel;
if (newLevel == null)
{
logger.levelIntVal = logger.parent != null
? logger.parent.levelIntVal
: Level.INFO.intValue();
}
else
{
logger.levelIntVal = newLevel.intValue();
}
if (previous != logger.levelIntVal)
{
foreach (Logger child in logger.children)
{
if (child.levelObjVal == null)
{
setLevelRecursively(child, null);
}
}
}
}
}
/**
* This method is for compatibility. Tests written to the reference
* implementation API imply that the isLoggable() method is not called
* directly. This behavior is important because subclass may override
* isLoggable() method, so that affect the result of log methods.
*/
private bool internalIsLoggable(Level l)
{
int effectiveLevel = levelIntVal;
if (effectiveLevel == Level.OFF.intValue())
{
// always return false if the effective level is off
return(false);
}
return(l.intValue() >= effectiveLevel);
}
/*
* Construct and init a {@code MemoryHandler} using given target, size and
* push level, other properties using {@code LogManager} properties or
* default values.
*
* @param target
* the given {@code Handler} to output
* @param size
* the maximum number of buffered {@code LogRecord}, greater than
* zero
* @param pushLevel
* the push level
* @throws IllegalArgumentException
* if {@code size <= 0}
* @throws RuntimeException
* if property value are invalid and no default value could be
* used.
*/
public MemoryHandler(Handler target, int size, Level pushLevel)
{
if (size <= 0)
{
// logging.11=Size must be positive.
throw new java.lang.IllegalArgumentException("Size must be positive."); //$NON-NLS-1$
}
target.getLevel();
pushLevel.intValue();
this.target = target;
this.size = size;
this.pushJ = pushLevel;
initProperties("ALL", null, "java.util.logging.SimpleFormatter", null); //$NON-NLS-1$//$NON-NLS-2$
buffer = new LogRecord[size];
}
/*
* Put a given {@code LogRecord} into internal buffer. If given record is
* not loggable, just return. Otherwise it is stored in the buffer.
* Furthermore if the record's level is not less than the push level, the
* push action is triggered to output all the buffered records to the target
* handler, and the target handler will publish them.
*
* @param record
* the log record
*/
public override void publish(LogRecord record)
{
lock (this) {
if (!isLoggable(record))
{
return;
}
if (cursor >= size)
{
cursor = 0;
}
buffer[cursor++] = record;
if (record.getLevel().intValue() >= pushJ.intValue())
{
push();
}
return;
}
}
/*
* Set the push level. The push level is used to check the push action
* triggering. When a new {@code LogRecord} is put into the internal
* buffer and its level is not less than the push level, the push action
* will be triggered. Note that set new push level won't trigger push action.
*
* @param newLevel
* the new level to set.
* @throws SecurityException
* if security manager exists and it determines that caller
* does not have the required permissions to control this handler.
*/
public void setPushLevel(Level newLevel)
{
manager.checkAccess();
newLevel.intValue();
this.pushJ = newLevel;
}
/**
* Sets the level on {@code logger} to {@code newLevel}. Any child loggers
* currently inheriting their level from {@code logger} will be updated
* recursively.
*
* @param newLevel the new minimum logging threshold. If null, the logger's
* parent level will be used; or {@code Level.INFO} for loggers with no
* parent.
*/
internal void setLevelRecursively(Logger logger, Level newLevel)
{
lock (this)
{
int previous = logger.levelIntVal;
logger.levelObjVal = newLevel;
if (newLevel == null)
{
logger.levelIntVal = logger.parent != null
? logger.parent.levelIntVal
: Level.INFO.intValue();
}
else
{
logger.levelIntVal = newLevel.intValue();
}
if (previous != logger.levelIntVal)
{
foreach (Logger child in logger.children)
{
if (child.levelObjVal == null)
{
setLevelRecursively(child, null);
}
}
}
}
}
/**
* Set the push level. The push level is used to check the push action
* triggering. When a new {@code LogRecord} is put into the internal
* buffer and its level is not less than the push level, the push action
* will be triggered. Note that set new push level won't trigger push action.
*
* @param newLevel
* the new level to set.
* @throws SecurityException
* if security manager exists and it determines that caller
* does not have the required permissions to control this handler.
*/
public void setPushLevel(Level newLevel)
{
manager.checkAccess();
newLevel.intValue();
this.pushJ = newLevel;
}
/**
* Construct and init a {@code MemoryHandler} using given target, size and
* push level, other properties using {@code LogManager} properties or
* default values.
*
* @param target
* the given {@code Handler} to output
* @param size
* the maximum number of buffered {@code LogRecord}, greater than
* zero
* @param pushLevel
* the push level
* @throws IllegalArgumentException
* if {@code size <= 0}
* @throws RuntimeException
* if property value are invalid and no default value could be
* used.
*/
public MemoryHandler(Handler target, int size, Level pushLevel)
{
if (size <= 0) {
// logging.11=Size must be positive.
throw new java.lang.IllegalArgumentException("Size must be positive."); //$NON-NLS-1$
}
target.getLevel();
pushLevel.intValue();
this.target = target;
this.size = size;
this.pushJ = pushLevel;
initProperties("ALL", null, "java.util.logging.SimpleFormatter", null); //$NON-NLS-1$//$NON-NLS-2$
buffer = new LogRecord[size];
}
/**
* This method is for compatibility. Tests written to the reference
* implementation API imply that the isLoggable() method is not called
* directly. This behavior is important because subclass may override
* isLoggable() method, so that affect the result of log methods.
*/
private bool internalIsLoggable(Level l)
{
int effectiveLevel = levelIntVal;
if (effectiveLevel == Level.OFF.intValue())
{
// always return false if the effective level is off
return false;
}
return l.intValue() >= effectiveLevel;
}