Java ProgressLogger类代码示例

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public ConsumerConnection create(Distribution distribution, ProgressLoggerFactory progressLoggerFactory, ConnectionParameters connectionParameters, BuildCancellationToken cancellationToken) {
    if (lock.tryLock()) {
        try {
            return delegate.create(distribution, progressLoggerFactory, connectionParameters, cancellationToken);
        } finally {
            lock.unlock();
        }
    }
    ProgressLogger logger = progressLoggerFactory.newOperation(SynchronizedToolingImplementationLoader.class);
    logger.setDescription("Wait for the other thread to finish acquiring the distribution");
    logger.started();
    lock.lock();
    try {
        return delegate.create(distribution, progressLoggerFactory, connectionParameters, cancellationToken);
    } finally {
        lock.unlock();
        logger.completed();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public <T> T run(ConsumerAction<T> action) throws UnsupportedOperationException, IllegalStateException {
    ConsumerOperationParameters parameters = action.getParameters();
    ProgressListenerAdapter listener = new ProgressListenerAdapter(parameters.getProgressListener());
    ListenerManager listenerManager = loggingProvider.getListenerManager();
    listenerManager.addListener(listener);
    try {
        ProgressLogger progressLogger = loggingProvider.getProgressLoggerFactory().newOperation(ProgressLoggingConsumerActionExecutor.class);
        progressLogger.setDescription("Build");
        progressLogger.started();
        try {
            return actionExecutor.run(action);
        } finally {
            progressLogger.completed();
        }
    } finally {
        listenerManager.removeListener(listener);
    }
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public ConsumerConnection create(Distribution distribution, ProgressLoggerFactory progressLoggerFactory, ConnectionParameters connectionParameters) {
    if (lock.tryLock()) {
        try {
            return delegate.create(distribution, progressLoggerFactory, connectionParameters);
        } finally {
            lock.unlock();
        }
    }
    ProgressLogger logger = progressLoggerFactory.newOperation(SynchronizedToolingImplementationLoader.class);
    logger.setDescription("Wait for the other thread to finish acquiring the distribution");
    logger.started();
    lock.lock();
    try {
        return delegate.create(distribution, progressLoggerFactory, connectionParameters);
    } finally {
        lock.unlock();
        logger.completed();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public void download(URI address, File destination) throws Exception {
  ProgressLogger progressLogger = progressLoggerFactory.newOperation(DistributionFactory.class);
  progressLogger.setDescription(String.format("Download %s", address));
  progressLogger.started();
  try {
    new Download(new Logger(false), "Gradle Tooling API", GradleVersion.current().getVersion()).download(address, destination);
  } finally {
    progressLogger.completed();
  }
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public ClassPath getToolingImplementationClasspath(ProgressLoggerFactory progressLoggerFactory,
                                                   File userHomeDir,
                                                   BuildCancellationToken cancellationToken) {
  ProgressLogger progressLogger = progressLoggerFactory.newOperation(DistributionFactory.class);
  progressLogger.setDescription("Validate distribution");
  progressLogger.started();
  try {
    return getToolingImpl();
  }
  finally {
    progressLogger.completed();
  }
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
private ProgressLogger startProgress(String description, Class loggingClass) {
    ProgressLogger progressLogger = progressLoggerFactory.newOperation(loggingClass != null ? loggingClass : getClass());
    progressLogger.setDescription(description);
    progressLogger.setLoggingHeader(description);
    progressLogger.started();
    return progressLogger;
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public void download(URI address, File destination) throws Exception {
    ProgressLogger progressLogger = progressLoggerFactory.newOperation(DistributionFactory.class);
    progressLogger.setDescription(String.format("Download %s", address));
    progressLogger.started();
    try {
        new Download("Gradle Tooling API", GradleVersion.current().getVersion()).download(address, destination);
    } finally {
        progressLogger.completed();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public ClassPath getToolingImplementationClasspath(ProgressLoggerFactory progressLoggerFactory, File userHomeDir, BuildCancellationToken cancellationToken) {
    ProgressLogger progressLogger = progressLoggerFactory.newOperation(DistributionFactory.class);
    progressLogger.setDescription("Validate distribution");
    progressLogger.started();
    try {
        return getToolingImpl();
    } finally {
        progressLogger.completed();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public GradleBuildComparison(
        ComparableGradleBuildExecuter sourceBuildExecuter,
        ComparableGradleBuildExecuter targetBuildExecuter,
        Logger logger,
        ProgressLogger progressLogger,
        Gradle gradle) {
    this.sourceBuildExecuter = sourceBuildExecuter;
    this.targetBuildExecuter = targetBuildExecuter;
    this.logger = logger;
    this.progressLogger = progressLogger;
    this.gradle = gradle;
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public void beforeResolve(ResolvableDependencies dependencies) {
    LinkedList<ProgressLogger> loggers = progressLoggers.get();
    progressLoggers.set(loggers);
    ProgressLogger logger = loggerFactory.newOperation(DependencyResolutionLogger.class);
    logger.start(String.format("Resolve %s", dependencies), String.format("Resolving %s", dependencies));
    loggers.add(logger);
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public void afterResolve(ResolvableDependencies dependencies) {
    LinkedList<ProgressLogger> loggers = progressLoggers.get();
    if (loggers.isEmpty()) {
        throw new IllegalStateException("Logging operation was not started or it has already completed.");
    }
    ProgressLogger logger = loggers.removeLast();
    logger.completed();
    if (loggers.isEmpty()) {
        progressLoggers.remove();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public void execute(PersistentCache cache) {
    ProgressLogger op = progressLoggerFactory.newOperation(FileCacheBackedScriptClassCompiler.class)
            .start("Compile script into cache", "Compiling script into cache");
    try {
        delegate.execute(cache);
    } finally {
        op.completed();
    }
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public OperationsHierarchy currentHierarchy(ProgressLogger parentHint) {
    LinkedList<Long> h = hierarchy.get();
    if (h == null) {
        h = new LinkedList<Long>();
        if (parentHint != null) {
            h.add(parentHint.currentOperationId());
        }
        hierarchy.set(h);
    }
    return new OperationsHierarchy(sharedCounter, h);
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public void buildFinished() {
    for (ProgressLogger l : projectConfigurationProgress.values()) {
        l.completed();
    }
    if (configurationProgress != null) {
        configurationProgress.completed();
    }
    buildProgress.completed();
    buildProgress = null;
    buildProgressFormatter = null;
    configurationProgress = null;
}
 

import org.gradle.logging.ProgressLogger; //导入依赖的package包/类
public void afterEvaluate(String projectPath) {
    if (configurationProgress != null) {
        ProgressLogger logger = projectConfigurationProgress.remove(projectPath);
        if (logger == null) {
            throw new IllegalStateException("Unexpected afterEvaluate event received without beforeEvaluate");
        }
        logger.completed();
        configurationProgress.progress(configurationProgressFormatter.incrementAndGetProgress());
    }
}