import org.metaborg.util.log.ILogger; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public final <I> void hear(
        final TypeLiteral<I> typeLiteral,
        final TypeEncounter<I> typeEncounter) {
    Preconditions.checkNotNull(typeLiteral);
    Preconditions.checkNotNull(typeEncounter);

    // Go through the class and its ancestors to find fields like this:
    //     @InjectLogger private Logger logger;

    Class<?> clazz = typeLiteral.getRawType();
    while (clazz != null) {
        for (final Field field : clazz.getDeclaredFields()) {
            if (field.getType() == ILogger.class &&
                    field.isAnnotationPresent(InjectLogger.class)) {
                typeEncounter.register(new MetaborgLoggerMembersInjector<>(field));
            }
        }
        clazz = clazz.getSuperclass();
    }
}
 

import org.metaborg.util.log.ILogger; //导入依赖的package包/类
/**
 * Injects the specified logger into the specified object.
 *
 * Fields with the @InjectLogger annotation will be injected.
 * If injection fails, the field is not injected.
 *
 * Use this function only when Guice is not available to inject the logger
 * (e.g. in unit tests).
 *
 * @param obj The object instance to inject into.
 * @param logger The logger to inject.
 * @return The object instance.
 */
public static <T> T injectLogger(final T obj, final ILogger logger) {
    @Nullable Class<?> clazz = obj.getClass();
    while (clazz != null) {
        for (final Field loggerField : getLoggerFields(clazz)) {
            try {
                loggerField.setAccessible(true);
                loggerField.set(obj, logger);
            } catch (final Exception ex) {
                // Ignore any exceptions.
            }
        }
        // Set the logger in the super class.
        clazz = clazz.getSuperclass();
    }
    return obj;
}
 

import org.metaborg.util.log.ILogger; //导入依赖的package包/类
public TypesmartTermFactory(ITermFactory baseFactory, ILogger logger, TypesmartContext context) {
    super(baseFactory.getDefaultStorageType(), baseFactory);
    assert baseFactory
        .getDefaultStorageType() == IStrategoTerm.MUTABLE : "Typesmart factory needs to have a factory with MUTABLE terms";
    this.baseFactory = baseFactory;
    this.logger = logger;
    this.context = context;
}
 

import org.metaborg.util.log.ILogger; //导入依赖的package包/类
public StreamMessagePrinter(ISourceTextService sourceTextService, boolean printHighlight, boolean printExceptions,
    ILogger logger) {
    this(sourceTextService, printHighlight, printExceptions, LoggerUtils.stream(logger, Level.Info),
        LoggerUtils.stream(logger, Level.Warn), LoggerUtils.stream(logger, Level.Error));
}
 

import org.metaborg.util.log.ILogger; //导入依赖的package包/类
@Override
public ILogger getLogger() {
    return logger;
}
 

import org.metaborg.util.log.ILogger; //导入依赖的package包/类
@Override
public ILogger getLogger() {
    return this.logger;
}
 

import org.metaborg.util.log.ILogger; //导入依赖的package包/类
/**
 * Logs the exception.
 *
 * @param logger The logger.
 * @param throwable The exception.
 */
private static <T extends Throwable> T logException(final ILogger logger, final T throwable) {

    logger.error(throwable.getMessage(), throwable);

    return throwable;
}
 

import org.metaborg.util.log.ILogger; //导入依赖的package包/类
/**
 * Creates an exception and logs it as an error.
 *
 * @param logger The logger to use.
 * @param exceptionClass The class of exception to create.
 * @param msg The exception message.
 * @param t The throwable that caused the exception.
 * @param <T> The type of exception.
 * @return The exception object.
 */
public static <T extends Throwable> T exception(final ILogger logger,
                                                final Class<T> exceptionClass,
                                                final String msg,
                                                @Nullable final Throwable t) {

    return logException(logger, ExceptionUtils.exception(exceptionClass, msg, t));
}
 

import org.metaborg.util.log.ILogger; //导入依赖的package包/类
/**
 * Creates the logger.
 *
 * @param clazz The class.
 * @return The created logger instance.
 */
private static ILogger createLogger(final Class<?> clazz) {
    return LoggerUtils.logger(clazz);
}
 

import org.metaborg.util.log.ILogger; //导入依赖的package包/类
/**
 * Gets a logger to which the test output may be logged.
 *
 * @return A logger.
 */
ILogger getLogger();