diff options
Diffstat (limited to 'src/java/com/jogamp/gluegen/Logging.java')
| -rw-r--r-- | src/java/com/jogamp/gluegen/Logging.java | 349 |
1 files changed, 322 insertions, 27 deletions
diff --git a/src/java/com/jogamp/gluegen/Logging.java b/src/java/com/jogamp/gluegen/Logging.java index 40eadcb..c057db4 100644 --- a/src/java/com/jogamp/gluegen/Logging.java +++ b/src/java/com/jogamp/gluegen/Logging.java @@ -31,57 +31,352 @@ */ package com.jogamp.gluegen; +import java.util.HashMap; +import java.util.Map; import java.util.logging.ConsoleHandler; import java.util.logging.Formatter; +import java.util.logging.Handler; import java.util.logging.Level; import java.util.logging.LogRecord; import java.util.logging.Logger; +import jogamp.common.Debug; + import com.jogamp.common.util.PropertyAccess; +import com.jogamp.gluegen.cgram.types.AliasedSymbol; +import com.jogamp.gluegen.cgram.types.Type; /** * - * @author Michael Bien + * @author Michael Bien, et.al. */ public class Logging { + public static final boolean DEBUG = Debug.debug("Logging"); + + /** + * An interface for {@link Logger}. + */ + public static interface LoggerIf { + /** + * See {@link Logger#info(String)} + */ + void info(final String msg); + /** + * See {@link Logger#info(String)} + */ + void info(final ASTLocusTag loc, final String msg); + + /** + * See {@link Logger#warning(String)} + */ + void warning(final String msg); + /** + * See {@link Logger#warning(String)} + */ + void warning(final ASTLocusTag loc, final String msg); + + /** + * Calls {@link #log(Level, String)} w/ {@link Level#FINE}. + */ + void debug(final String msg); + /** + * Calls {@link #log(Level, ASTLocusTag, String)} w/ {@link Level#FINE}. + */ + void debug(final ASTLocusTag loc, final String msg); + + /** + * See {@link Logger#log(Level, String)} + */ + void log(final Level level, final String msg); + /** + * See {@link Logger#log(Level, String, Object)} + */ + void log(final Level level, final String msg, final Object param); + /** + * See {@link Logger#log(Level, String, Object[])} + */ + void log(final Level level, final String msg, final Object ... params); + + /** + * See {@link Logger#log(Level, String)} + */ + void log(final Level level, final ASTLocusTag loc, final String msg); + /** + * See {@link Logger#log(Level, String, Object)} + */ + void log(final Level level, final ASTLocusTag loc, final String msg, final Object param); + /** + * See {@link Logger#log(Level, String, Object[])} + */ + void log(final Level level, final ASTLocusTag loc, final String msg, final Object ... params); + + /** + * See {@link Logger#setLevel(Level)} + */ + void setLevel(final Level newLevel) throws SecurityException; + /** + * See {@link Handler#setLevel(Level)} + */ + void setLevelOfAllHandler(final Level newLevel) throws SecurityException; + /** + * See {@link Logger#getLevel()} + */ + Level getLevel(); + /** + * See {@link Logger#isLoggable(Level)} + */ + boolean isLoggable(Level level); + /** + * See {@link Logger#getName()} + */ + String getName(); + /** + * See {@link Logger#getHandlers()} + */ + Handler[] getHandlers(); + /** + * See {@link LogRecord#getSourceClassName()} + */ + String getSourceClassName(); + } + /* pp */ static class FQNLogger implements LoggerIf { + public final Logger impl; + public final PlainLogConsoleHandler handler; + /* pp */ FQNLogger(final String fqnClassName, final String simpleClassName, final Level level) { + this.impl = Logger.getLogger(fqnClassName); + this.handler = new PlainLogConsoleHandler(new PlainLogFormatter(simpleClassName), Level.ALL); + this.impl.setUseParentHandlers(false); + this.impl.setLevel(level); + this.impl.addHandler(this.handler); + this.impl.log(Level.INFO, "Logging.new: "+impl.getName()+": level "+level+ + ": obj 0x"+Integer.toHexString(impl.hashCode())); + } + @Override + public void info(final String msg) { + impl.info(msg); + } + @Override + public void info(final ASTLocusTag loc, final String msg) { + handler.plf.setASTLocusTag(loc); + try { + impl.info(msg); + } finally { + handler.plf.setASTLocusTag(null); + } + } + + @Override + public void warning(final String msg) { + impl.warning(msg); + } + @Override + public void warning(final ASTLocusTag loc, final String msg) { + handler.plf.setASTLocusTag(loc); + try { + impl.warning(msg); + } finally { + handler.plf.setASTLocusTag(null); + } + } + + @Override + public void debug(final String msg) { + log(Level.FINE, msg); + } + @Override + public void debug(final ASTLocusTag loc, final String msg) { + log(Level.FINE, loc, msg); + } + + @Override + public void log(final Level level, final String msg) { + impl.log(level, msg); + } + @Override + public void log(final Level level, final String msg, final Object param) { + impl.log(level, msg, param); + } + @Override + public void log(final Level level, final String msg, final Object ... params) { + impl.log(level, msg, params); + } - static void init() { + @Override + public void log(final Level level, final ASTLocusTag loc, final String msg) { + handler.plf.setASTLocusTag(loc); + try { + impl.log(level, msg); + } finally { + handler.plf.setASTLocusTag(null); + } + } + @Override + public void log(final Level level, final ASTLocusTag loc, final String msg, final Object param) { + handler.plf.setASTLocusTag(loc); + try { + impl.log(level, msg, param); + } finally { + handler.plf.setASTLocusTag(null); + } + } + @Override + public void log(final Level level, final ASTLocusTag loc, final String msg, final Object ... params) { + handler.plf.setASTLocusTag(loc); + try { + impl.log(level, msg, params); + } finally { + handler.plf.setASTLocusTag(null); + } + } + + @Override + public void setLevel(final Level newLevel) throws SecurityException { + impl.setLevel(newLevel); + } + @Override + public void setLevelOfAllHandler(final Level newLevel) throws SecurityException { + final Handler[] hs = getHandlers(); + for(final Handler h:hs) { + h.setLevel(newLevel); + } + } + @Override + public Level getLevel() { + return impl.getLevel(); + } + @Override + public boolean isLoggable(final Level level) { + return impl.isLoggable(level); + } + @Override + public String getName() { + return impl.getName(); + } + @Override + public synchronized Handler[] getHandlers() { + return impl.getHandlers(); + } + @Override + public String getSourceClassName() { + return handler.plf.simpleClassName; + } + } + static class PlainLogConsoleHandler extends ConsoleHandler { + final PlainLogFormatter plf; + PlainLogConsoleHandler(final PlainLogFormatter plf, final Level level) { + this.plf = plf; + setFormatter(plf); + setLevel(level); + } + @Override + public java.util.logging.Formatter getFormatter() { + return plf; + } + } + static class PlainLogFormatter extends Formatter { + final String simpleClassName; + ASTLocusTag astLocus; + PlainLogFormatter(final String simpleClassName) { + this.simpleClassName = simpleClassName; + } + public void setASTLocusTag(final ASTLocusTag loc) { astLocus = loc; } + @Override + public String format(final LogRecord record) { + // Replace [Type, JavaType] -> its debug string! + final Object[] params = record.getParameters(); + if( null != params ) { + for(int i=params.length-1; 0<=i; i--) { + final Object o = params[i]; + if( o instanceof Type ) { + params[i] = ((Type)o).getDebugString(); + } else if( o instanceof JavaType ) { + params[i] = ((JavaType)o).getDebugString(); + } else if( o instanceof AliasedSymbol ) { + params[i] = ((AliasedSymbol)o).getAliasedString(); + } + } + } + final StringBuilder sb = new StringBuilder(256); + if( null != astLocus ) { + astLocus.toString(sb, getCanonicalName(record.getLevel()), GlueGen.debug()).append(": "); + } + if( GlueGen.debug() ) { + sb.append(simpleClassName).append(": "); + } + sb.append(formatMessage(record)).append("\n"); + return sb.toString(); + } + } + + private final static Map<String, LoggerIf> loggers; + private final static FQNLogger rootPackageLogger; + static { + loggers = new HashMap<String, LoggerIf>(); final String packageName = Logging.class.getPackage().getName(); final String property = PropertyAccess.getProperty(packageName+".level", true); Level level; if(property != null) { level = Level.parse(property); } else { - level = Level.WARNING; + if( DEBUG || GlueGen.debug() ) { + level = Level.ALL; + } else { + level = Level.WARNING; + } } + final String simpleClassName = Logging.class.getSimpleName(); + final String fqnClassName = packageName+"."+simpleClassName; + rootPackageLogger = new FQNLogger(fqnClassName, simpleClassName, level); + loggers.put(fqnClassName, rootPackageLogger); + } - final ConsoleHandler handler = new ConsoleHandler() { - @Override - public java.util.logging.Formatter getFormatter() { - return new PlainLogFormatter(); - } - }; - handler.setFormatter(new PlainLogFormatter()); - handler.setLevel(level); - - final Logger rootPackageLogger = Logger.getLogger(packageName); - rootPackageLogger.setUseParentHandlers(false); - rootPackageLogger.setLevel(level); - rootPackageLogger.addHandler(handler); + /** provokes static initialization */ + static void init() { } + + public static String getCanonicalName(final Level level) { + if( Level.CONFIG == level ) { + return "config"; + } else if( Level.FINER == level ) { + return "verbose"; + } else if( Level.FINE == level ) { + return "debug"; + } else if( Level.INFO == level ) { + return "info"; + } else if( Level.WARNING == level ) { + return "warning"; + } else if( Level.SEVERE == level ) { + return "error"; + } else { + return level.getName().toLowerCase(); + } } - /** - * This log formatter needs usually one line per log record. - * @author Michael Bien - */ - private static class PlainLogFormatter extends Formatter { + /** Returns the <i>root package logger</i>. */ + public static LoggerIf getLogger() { + return rootPackageLogger; + } + /** Returns the demanded logger, while aligning its log-level to the root logger's level. */ + public static synchronized LoggerIf getLogger(final Class<?> clazz) { + return getLogger(clazz.getPackage().getName(), clazz.getSimpleName()); + } - @Override - public String format(final LogRecord record) { - final StringBuilder sb = new StringBuilder(128); - sb.append("[").append(record.getLevel()).append(' ').append(record.getSourceClassName()).append("]: "); - sb.append(formatMessage(record)).append("\n"); - return sb.toString(); + /** Returns the demanded logger, while aligning its log-level to the root logger's level. */ + public static synchronized LoggerIf getLogger(final String packageName, final String simpleClassName) { + final String fqnClassName = packageName+"."+simpleClassName; + LoggerIf res = loggers.get(fqnClassName); + if( null == res ) { + res = new FQNLogger(fqnClassName, simpleClassName, rootPackageLogger.getLevel()); + loggers.put(fqnClassName, res); } + return res; + } + /** Align log-level of given logger to the root logger's level. */ + public static void alignLevel(final LoggerIf l) { + alignLevel(l, rootPackageLogger.getLevel()); + } + /** Align log-level of given logger and all its handlers to the given level. */ + public static void alignLevel(final LoggerIf l, final Level level) { + l.setLevel(level); + l.setLevelOfAllHandler(level); } } |