Java 类org.gradle.api.tasks.incremental.InputFileDetails 实例源码

public void processChange(final InputFileDetails input, final RecompilationSpec spec) {
    // Do not process
    if (input.isRemoved()) {
        return;
    }

    final ClassReader classReader;
    try {
        classReader = new Java9ClassReader(Files.toByteArray(input.getFile()));
    } catch (IOException e) {
        throw new IllegalArgumentException(String.format("Unable to read class file: '%s'", input.getFile()));
    }

    String className = classReader.getClassName().replaceAll("/", ".");
    DependentsSet actualDependents = previousCompilation.getDependents(className);
    if (actualDependents.isDependencyToAll()) {
        spec.setFullRebuildCause(actualDependents.getDescription(), input.getFile());
    } else {
        spec.getClassNames().addAll(actualDependents.getDependentClasses());
    }
}

public void execute(InputFileDetails inputFileDetails) {
    if (fullRebuildNeeded != null) {
        return;
    }
    File inputFile = inputFileDetails.getFile();
    String name = inputFile.getName();
    if (name.endsWith(".java")) {
        JavaSourceClass source = mapper.toJavaSourceClass(inputFile);
        compiler.addStaleClass(source);
        changedSourceOnly.include(source.getRelativePath());
        Set<String> actualDependents = dependencyInfo.getActualDependents(source.getClassName());
        if (actualDependents == null) {
            fullRebuildNeeded = "change to " + source.getClassName() + " requires full rebuild";
            return;
        }
        for (String d : actualDependents) {
            JavaSourceClass dSource = mapper.toJavaSourceClass(d);
            compiler.addStaleClass(dSource);
            changedSourceOnly.include(dSource.getRelativePath());
        }
    }
    if (name.endsWith(".jar")) {
        fullRebuildNeeded = "change to " + inputFile + " requires full rebuild";
        return;
    }
}

public RebuildInfo processJarChange(InputFileDetails jarChangeDetails, JarArchive jarArchive) {
    JarSnapshot existing = jarSnapshotFeeder.changedJar(jarChangeDetails.getFile());
    if (jarChangeDetails.isAdded()) {
        return DefaultRebuildInfo.NOTHING_TO_REBUILD;
    }

    if (jarChangeDetails.isRemoved()) {
        if (existing != null) {
            return new AllFromJarRebuildInfo(jarArchive);
        } else {
            return DefaultRebuildInfo.FULL_REBUILD;
        }
    }

    if (jarChangeDetails.isModified()) {
        if (existing != null) {
            JarSnapshot newSnapshot = jarSnapshotFeeder.createSnapshot(jarArchive);
            JarDelta jarDelta = existing.compareToSnapshot(newSnapshot);
            return new SpecificClassesRebuildInfo(jarDelta);
        } else {
            return new AllFromJarRebuildInfo(jarArchive);
        }
    }

    throw new IllegalArgumentException("Unknown input file details provided: " + jarChangeDetails);
}

private static InputFileDetails mockInputFileDetails(File file) {
    return new InputFileDetails() {
        @Override
        public boolean isAdded() {
            return false;
        }

        @Override
        public boolean isModified() {
            return false;
        }

        @Override
        public boolean isRemoved() {
            return false;
        }

        @Override
        public File getFile() {
            return file;
        }
    };
}

public void processChange(InputFileDetails input, RecompilationSpec spec) {
    JarArchive jarArchive = new JarArchive(input.getFile(), fileOperations.zipTree(input.getFile()), fileOperations.getFileResolver().getPatternSetFactory());
    JarChangeDependentsFinder dependentsFinder = new JarChangeDependentsFinder(jarClasspathSnapshot, previousCompilation);
    DependentsSet actualDependents = dependentsFinder.getActualDependents(input, jarArchive);
    if (actualDependents.isDependencyToAll()) {
        spec.setFullRebuildCause(actualDependents.getDescription(), input.getFile());
        return;
    }
    spec.getClassNames().addAll(actualDependents.getDependentClasses());
}

@Override
public void execute(InputFileDetails input) {
    if (spec.getFullRebuildCause() != null) {
        return;
    }
    if (hasExtension(input.getFile(), ".java")) {
        javaChangeProcessor.processChange(input, spec);
    } else if (hasExtension(input.getFile(), ".class")) {
        classChangeProcessor.processChange(input, spec);
    } else if (hasExtension(input.getFile(), ".jar")) {
        jarChangeProcessor.processChange(input, spec);
    }
}

public void processChange(InputFileDetails input, RecompilationSpec spec) {
    String className = sourceToNameConverter.getClassName(input.getFile());
    spec.getClassNames().add(className);
    DependentsSet actualDependents = previousCompilation.getDependents(className);
    if (actualDependents.isDependencyToAll()) {
        spec.setFullRebuildCause(actualDependents.getDescription(), input.getFile());
        return;
    }
    spec.getClassNames().addAll(actualDependents.getDependentClasses());
}

public void outOfDate(final Action<? super InputFileDetails> outOfDateAction) {
    if (outOfDateProcessed) {
        throw new IllegalStateException("Cannot process outOfDate files multiple times");
    }
    doOutOfDate(outOfDateAction);
    outOfDateProcessed = true;
}

public void removed(Action<? super InputFileDetails> removedAction) {
    if (!outOfDateProcessed) {
        throw new IllegalStateException("Must first process outOfDate files before processing removed files");
    }
    if (removedProcessed) {
        throw new IllegalStateException("Cannot process removed files multiple times");
    }
    doRemoved(removedAction);
    removedProcessed = true;
}

@Override
protected void doOutOfDate(final Action<? super InputFileDetails> outOfDateAction) {
    for (TaskStateChange change : inputFilesState) {
        InputFileDetails fileChange = (InputFileDetails) change;
        if (fileChange.isRemoved()) {
            removedFiles.add(fileChange);
        } else {
            outOfDateAction.execute(fileChange);
        }
    }
}

@TaskAction
void generateClasses(IncrementalTaskInputs inputs) {
  inputs.outOfDate(new Action<InputFileDetails>() {
    @Override
    public void execute(InputFileDetails inputFileDetails) {
      GraphQLCompiler.Arguments args = new GraphQLCompiler.Arguments(inputFileDetails.getFile(), outputDir,
          apolloExtension.getCustomTypeMapping(), nullableValueType, apolloExtension.isUseSemanticNaming(),
          apolloExtension.isGenerateModelBuilder(), apolloExtension.isUseJavaBeansSemanticNaming(), apolloExtension
          .getOutputPackageName());
      new GraphQLCompiler().write(args);
    }
  });
}

public void processChange(InputFileDetails input, RecompilationSpec spec) {
    JarArchive jarArchive = new JarArchive(input.getFile(), fileOperations.zipTree(input.getFile()));
    JarChangeDependentsFinder dependentsFinder = new JarChangeDependentsFinder(jarClasspathSnapshot, previousCompilation);
    DependentsSet actualDependents = dependentsFinder.getActualDependents(input, jarArchive);
    if (actualDependents.isDependencyToAll()) {
        spec.setFullRebuildCause(actualDependents.getDescription(), input.getFile());
        return;
    }
    spec.getClassNames().addAll(actualDependents.getDependentClasses());
}

public void execute(InputFileDetails input) {
    if (spec.getFullRebuildCause() != null) {
        return;
    }
    if (input.getFile().getName().endsWith(".java")) {
        javaChangeProcessor.processChange(input, spec);
    }
    if (input.getFile().getName().endsWith(".jar")) {
        jarChangeProcessor.processChange(input, spec);
    }
}

public void processChange(InputFileDetails input, RecompilationSpec spec) {
    String className = sourceToNameConverter.getClassName(input.getFile());
    spec.getClassNames().add(className);
    DependentsSet actualDependents = previousCompilation.getDependents(className);
    if (actualDependents.isDependencyToAll()) {
        spec.setFullRebuildCause(actualDependents.getDescription(), input.getFile());
        return;
    }
    spec.getClassNames().addAll(actualDependents.getDependentClasses());
}

public void outOfDate(final Action<? super InputFileDetails> outOfDateAction) {
    if (outOfDateProcessed) {
        throw new IllegalStateException("Cannot process outOfDate files multiple times");
    }
    doOutOfDate(outOfDateAction);
    outOfDateProcessed = true;
}

public void removed(Action<? super InputFileDetails> removedAction) {
    if (!outOfDateProcessed) {
        throw new IllegalStateException("Must first process outOfDate files before processing removed files");
    }
    if (removedProcessed) {
        throw new IllegalStateException("Cannot process removed files multiple times");
    }
    doRemoved(removedAction);
    removedProcessed = true;
}

@Override
protected void doOutOfDate(final Action<? super InputFileDetails> outOfDateAction) {
    for (TaskStateChange change : inputFilesState) {
        InputFileDetails fileChange = (InputFileDetails) change;
        if (fileChange.isRemoved()) {
            removedFiles.add(fileChange);
        } else {
            outOfDateAction.execute(fileChange);
        }
    }
}

public void outOfDate(final Action<? super InputFileDetails> outOfDateAction) {
    if (outOfDateProcessed) {
        throw new IllegalStateException("Cannot process outOfDate files multiple times");
    }
    doOutOfDate(outOfDateAction);
    outOfDateProcessed = true;
}

public void removed(Action<? super InputFileDetails> removedAction) {
    if (!outOfDateProcessed) {
        throw new IllegalStateException("Must first process outOfDate files before processing removed files");
    }
    if (removedProcessed) {
        throw new IllegalStateException("Cannot process removed files multiple times");
    }
    doRemoved(removedAction);
    removedProcessed = true;
}

@Override
protected void doOutOfDate(final Action<? super InputFileDetails> outOfDateAction) {
    for (TaskStateChange change : inputFilesState) {
        InputFileDetails fileChange = (InputFileDetails) change;
        if (fileChange.isRemoved()) {
            removedFiles.add(fileChange);
        } else {
            outOfDateAction.execute(fileChange);
        }
    }
}

@Override
public void generate(IncrementalTaskInputs inputs) {
    mResFilesChanged = !inputs.isIncremental();

    if (!mResFilesChanged) {
        Action<InputFileDetails> detectChangesAction = new Action<InputFileDetails>() {
            @Override
            public void execute(InputFileDetails inputFileDetails) {
                if (!mResFilesChanged) {
                    mResFilesChanged = mResFileIdentifier.isResFile(inputFileDetails.getFile(), true);
                }
            }
        };

        inputs.outOfDate(detectChangesAction);
        if (!mResFilesChanged) {
            inputs.removed(detectChangesAction);
        }
    }

    if (mResFilesChanged) {
        // If we detect any changes, will rebuild all CodeColor resources.
        // Incremental build is too complex for its eventual gain.
        // For every build, we would have to parse the existing resources, and update or remove their
        // individual files and default values, for every configuration.
        generateResources();
    }
}

public DependentsSet getActualDependents(InputFileDetails jarChangeDetails, JarArchive jarArchive) {
    if (jarChangeDetails.isAdded()) {
        if (jarClasspathSnapshot.isAnyClassDuplicated(jarArchive)) {
            //at least one of the classes from the new jar is already present in jar classpath
            //to avoid calculation which class gets on the classpath first, rebuild all
            return new DependencyToAll("at least one of the classes of '" + jarArchive.file.getName() + "' is already present in classpath");
        } else {
            //none of the new classes in the jar are duplicated on classpath, don't rebuild
            return new DefaultDependentsSet();
        }
    }
    JarSnapshot previous = previousCompilation.getJarSnapshot(jarChangeDetails.getFile());

    if (previous == null) {
        //we don't know what classes were dependents of the jar in the previous build
        //for example, a class (in jar) with a constant might have changed into a class without a constant - we need to rebuild everything
        return new DependencyToAll("missing jar snapshot of '" + jarArchive.file.getName()  + "' from previous build");
    }

    if (jarChangeDetails.isRemoved()) {
        DependentsSet allClasses = previous.getAllClasses();
        if (allClasses.isDependencyToAll()) {
            return new DependencyToAll("at least one of the classes of removed jar '" + jarArchive.file.getName() + "' requires it");
        }
        //recompile all dependents of all the classes from jar
        return previousCompilation.getDependents(allClasses.getDependentClasses());
    }

    if (jarChangeDetails.isModified()) {
        JarSnapshot currentSnapshot = jarClasspathSnapshot.getSnapshot(jarArchive);
        AffectedClasses affected = currentSnapshot.getAffectedClassesSince(previous);
        if (affected.getAltered().isDependencyToAll()) {
            //at least one of the classes changed in the jar is a 'dependency-to-all'
            return affected.getAltered();
        }

        if (jarClasspathSnapshot.isAnyClassDuplicated(affected.getAdded())) {
            //A new duplicate class on classpath. As we don't fancy-handle classpath order right now, we don't know which class is on classpath first.
            //For safe measure rebuild everything
            return new DependencyToAll("at least one of the classes of modified jar '" + jarArchive.file.getName() + "' is already present in the classpath");
        }

        //recompile all dependents of the classes changed in the jar
        return previousCompilation.getDependents(affected.getAltered().getDependentClasses());
    }

    throw new IllegalArgumentException("Unknown input file details provided: " + jarChangeDetails);
}

public void doOutOfDate(Action<? super InputFileDetails> outOfDateAction) {
    for (File file : task.getInputs().getFiles()) {
        outOfDateAction.execute(new RebuildInputFile(file));
    }
}

public void doRemoved(Action<? super InputFileDetails> removedAction) {
}

@Override
protected void doRemoved(Action<? super InputFileDetails> removedAction) {
    for (InputFileDetails removedFile : removedFiles) {
        removedAction.execute(removedFile);
    }
}

public DependentsSet getActualDependents(InputFileDetails jarChangeDetails, JarArchive jarArchive) {
    if (jarChangeDetails.isAdded()) {
        if (jarClasspathSnapshot.isAnyClassDuplicated(jarArchive)) {
            //at least one of the classes from the new jar is already present in jar classpath
            //to avoid calculation which class gets on the classpath first, rebuild all
            return new DependencyToAll("at least one of the classes of '" + jarArchive.file.getName() + "' is already present in classpath");
        } else {
            //none of the new classes in the jar are duplicated on classpath, don't rebuild
            return new DefaultDependentsSet();
        }
    }
    JarSnapshot previous = previousCompilation.getJarSnapshot(jarChangeDetails.getFile());

    if (previous == null) {
        //we don't know what classes were dependents of the jar in the previous build
        //for example, a class (in jar) with a constant might have changed into a class without a constant - we need to rebuild everything
        return new DependencyToAll("missing jar snapshot of '" + jarArchive.file.getName()  + "' from previous build");
    }

    if (jarChangeDetails.isRemoved()) {
        DependentsSet allClasses = previous.getAllClasses();
        if (allClasses.isDependencyToAll()) {
            return new DependencyToAll("at least one of the classes of removed jar '" + jarArchive.file.getName() + "' requires it");
        }
        //recompile all dependents of all the classes from jar
        return previousCompilation.getDependents(allClasses.getDependentClasses());
    }

    if (jarChangeDetails.isModified()) {
        JarSnapshot currentSnapshot = jarClasspathSnapshot.getSnapshot(jarArchive);
        AffectedClasses affected = currentSnapshot.getAffectedClassesSince(previous);
        if (affected.getAltered().isDependencyToAll()) {
            //at least one of the classes changed in the jar is a 'dependency-to-all'
            return affected.getAltered();
        }

        if (jarClasspathSnapshot.isAnyClassDuplicated(affected.getAdded())) {
            //A new duplicate class on classpath. As we don't fancy-handle classpath order right now, we don't know which class is on classpath first.
            //For safe measure rebuild everything
            return new DependencyToAll("at least one of the classes of modified jar '" + jarArchive.file.getName() + "' is already present in the classpath");
        }

        //recompile all dependents of the classes changed in the jar
        return previousCompilation.getDependents(affected.getAltered().getDependentClasses());
    }

    throw new IllegalArgumentException("Unknown input file details provided: " + jarChangeDetails);
}

public void doOutOfDate(Action<? super InputFileDetails> outOfDateAction) {
    for (File file : task.getInputs().getFiles()) {
        outOfDateAction.execute(new RebuildInputFile(file));
    }
}

public void doRemoved(Action<? super InputFileDetails> removedAction) {
}

@Override
protected void doRemoved(Action<? super InputFileDetails> removedAction) {
    for (InputFileDetails removedFile : removedFiles) {
        removedAction.execute(removedFile);
    }
}

public void doOutOfDate(Action<? super InputFileDetails> outOfDateAction) {
    for (File file : task.getInputs().getFiles()) {
        outOfDateAction.execute(new RebuildInputFile(file));
    }
}

public void doRemoved(Action<? super InputFileDetails> removedAction) {
}

@Override
protected void doRemoved(Action<? super InputFileDetails> removedAction) {
    for (InputFileDetails removedFile : removedFiles) {
        removedAction.execute(removedFile);
    }
}

@Override
public void outOfDate(Action<? super InputFileDetails> action) {
    mIncrementalTaskInputs.outOfDate(new IgnoreResFilesActionWrapper(action, mResFiles));
}

@Override
public void removed(Action<? super InputFileDetails> action) {
    mIncrementalTaskInputs.removed(new IgnoreResFilesActionWrapper(action, mResFiles));
}

public IgnoreResFilesActionWrapper(Action<? super InputFileDetails> action, Set<File> resFiles) {
    mAction = action;
    mResFiles = resFiles;
}

@Override
public void execute(InputFileDetails inputFileDetails) {
    if (!mResFiles.contains(inputFileDetails.getFile())) {
        mAction.execute(new IgnoreResFilesInputFileDetailsWrapper(inputFileDetails, mResFiles));
    }
}

public IgnoreResFilesInputFileDetailsWrapper(InputFileDetails inputFileDetails, Set<File> resFiles) {
    mInputFileDetails = inputFileDetails;
    mFile = new IgnoreResFileFile(inputFileDetails.getFile().getPath(), resFiles);
}

protected abstract void doOutOfDate(Action<? super InputFileDetails> outOfDateAction);

protected abstract void doRemoved(Action<? super InputFileDetails> removedAction);

protected abstract void doOutOfDate(Action<? super InputFileDetails> outOfDateAction);