File	Doc	Category	Size	Date	Package
MemoryHandler.java	API Doc	Android 1.5 API	10608	Wed May 06 22:41:04 BST 2009	java.util.logging

MemoryHandler

• java.lang.Object
  • java.util.logging.Handler

Fields Summary
private static final int	DEFAULT_SIZE
private Handler	target
private int	size
private Level	push
private final LogManager	manager
private LogRecord[]	buffer
private int	cursor

Constructors Summary
public MemoryHandler() Default constructor, construct and init a {@code MemoryHandler} using {@code LogManager} properties or default values. throws RuntimeException if property value are invalid and no default value could be used. super(); String className = this.getClass().getName(); //init target final String targetName = manager.getProperty(className+".target"); //$NON-NLS-1$ try { Class<?> targetClass = AccessController.doPrivileged(new PrivilegedExceptionAction<Class<?>>(){ public Class<?> run() throws Exception{ ClassLoader loader = Thread.currentThread().getContextClassLoader(); if(loader == null){ loader = ClassLoader.getSystemClassLoader(); } return loader.loadClass(targetName); } }); target = (Handler) targetClass.newInstance(); } catch (Exception e) { // logging.10=Cannot load target handler:{0} throw new RuntimeException(Messages.getString("logging.10", //$NON-NLS-1$ targetName)); } //init size String sizeString = manager.getProperty(className+".size"); //$NON-NLS-1$ if (null != sizeString) { try { size = Integer.parseInt(sizeString); if(size <= 0){ size = DEFAULT_SIZE; } } catch (Exception e) { printInvalidPropMessage(className+".size", sizeString, e); //$NON-NLS-1$ } } //init push level String pushName = manager.getProperty(className+".push"); //$NON-NLS-1$ if (null != pushName) { try { push = Level.parse(pushName); } catch (Exception e) { printInvalidPropMessage(className+".push", pushName, e); //$NON-NLS-1$ } } //init other properties which are common for all Handler initProperties("ALL", null, "java.util.logging.SimpleFormatter", null); //$NON-NLS-1$//$NON-NLS-2$ buffer = new LogRecord[size];
public MemoryHandler(Handler target, int size, Level pushLevel) 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. if (size <= 0) { // logging.11=Size must be positive. throw new IllegalArgumentException(Messages.getString("logging.11")); //$NON-NLS-1$ } target.getLevel(); pushLevel.intValue(); this.target = target; this.size = size; this.push = pushLevel; initProperties("ALL", null, "java.util.logging.SimpleFormatter", null); //$NON-NLS-1$//$NON-NLS-2$ buffer = new LogRecord[size];

Methods Summary
public void	close() Close this handler and target handler, free all associated resources. throws SecurityException if security manager exists and it determines that caller does not have the required permissions to control this handler. manager.checkAccess(); target.close(); setLevel(Level.OFF);
public void	flush() Call target handler to flush any buffered output. Note that this doesn't cause this {@code MemoryHandler} to push. target.flush();
public java.util.logging.Level	getPushLevel() Return the push level. return the push level return push;
public boolean	isLoggable(java.util.logging.LogRecord record) Check if given {@code LogRecord} would be put into this {@code MemoryHandler}'s internal buffer. The given {@code LogRecord} is loggable if and only if it has appropriate level and it pass any associated filter's check. Note that the push level is not used for this check. param record the given {@code LogRecord} return the given {@code LogRecord} if it should be logged, {@code false} if {@code LogRecord} is {@code null}. return super.isLoggable(record);
public synchronized void	publish(java.util.logging.LogRecord record) 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 if (!isLoggable(record)) { return; } if (cursor >= size) { cursor = 0; } buffer[cursor++] = record; if (record.getLevel().intValue() >= push.intValue()) { push(); } return;
public void	push() Triggers a push action to output all buffered records to the target handler, and the target handler will publish them. Then the buffer is cleared. for (int i = cursor; i < size; i++) { if(null != buffer[i]) { target.publish(buffer[i]); } buffer[i] = null; } for (int i = 0; i < cursor; i++) { if(null != buffer[i]) { target.publish(buffer[i]); } buffer[i] = null; } cursor = 0;
public void	setPushLevel(java.util.logging.Level newLevel) 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. manager.checkAccess(); newLevel.intValue(); this.push = newLevel;