import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
static void markDirtyFiles(CompileContext context,
                           BuildTarget<?> target,
                           final CompilationRound round,
                           Timestamps timestamps,
                           boolean forceMarkDirty,
                           @Nullable THashSet<File> currentFiles,
                           @Nullable FileFilter filter) throws IOException {
  if (filter == null && forceMarkDirty) {
    addCompletelyMarkedDirtyTarget(context, target);
  }

  for (BuildRootDescriptor rd : context.getProjectDescriptor().getBuildRootIndex().getTargetRoots(target, context)) {
    if (!rd.getRootFile().exists() ||
        //temp roots are managed by compilers themselves
        (rd instanceof JavaSourceRootDescriptor && ((JavaSourceRootDescriptor)rd).isTemp)) {
      continue;
    }
    if (filter == null) {
      context.getProjectDescriptor().fsState.clearRecompile(rd);
    }
    final FSCache fsCache = rd.canUseFileCache() ? context.getProjectDescriptor().getFSCache() : FSCache.NO_CACHE;
    traverseRecursively(context, rd, round, rd.getRootFile(), timestamps, forceMarkDirty, currentFiles, filter, fsCache);
  }
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
public CompileScopeImpl(Collection<? extends BuildTargetType<?>> types,
                        Collection<? extends BuildTargetType<?>> typesToForceBuild,
                        Collection<BuildTarget<?>> targets,
                        @NotNull Map<BuildTarget<?>, Set<File>> files) {
  myTypes = types;
  myTypesToForceBuild = new HashSet<BuildTargetType<?>>();
  boolean forceBuildAllModuleBasedTargets = false;
  for (BuildTargetType<?> type : typesToForceBuild) {
    myTypesToForceBuild.add(type);
    forceBuildAllModuleBasedTargets |= type instanceof JavaModuleBuildTargetType;
  }
  if (forceBuildAllModuleBasedTargets) {
    for (BuildTargetType<?> targetType : TargetTypeRegistry.getInstance().getTargetTypes()) {
      if (targetType instanceof ModuleBasedBuildTargetType<?>) {
        myTypesToForceBuild.add(targetType);
      }
    }
  }
  myTargets = targets;
  myFiles = files;
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
public synchronized void save() {
  try {
    FileUtil.createParentDirs(myTargetsFile);
    DataOutputStream output = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(myTargetsFile)));
    try {
      output.writeInt(0);
      output.writeInt(myTargetIds.size());
      for (Map.Entry<BuildTarget<?>, Integer> entry : myTargetIds.entrySet()) {
        IOUtil.writeString(entry.getKey().getId(), output);
        output.writeInt(entry.getValue());
      }
    }
    finally {
      output.close();
    }
  }
  catch (IOException e) {
    LOG.info("Cannot save " + myTargetType.getTypeId() + " targets data: " + e.getMessage(), e);
  }
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
public void cleanTargetStorages(BuildTarget<?> target) throws IOException {
  try {
    AtomicNotNullLazyValue<BuildTargetStorages> storages = myTargetStorages.remove(target);
    if (storages != null) {
      storages.getValue().close();
    }
  }
  finally {
    // delete all data except src-out mapping which is cleaned in a special way
    final File[] targetData = myDataPaths.getTargetDataRoot(target).listFiles();
    if (targetData != null) {
      final File srcOutputMapRoot = getSourceToOutputMapRoot(target);
      for (File dataFile : targetData) {
        if (!FileUtil.filesEqual(dataFile, srcOutputMapRoot)) {
          FileUtil.delete(dataFile);
        }
      }
    }
  }
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
public void removeStamp(File file, BuildTarget<?> buildTarget) throws IOException {
  TimestampPerTarget[] state = getState(file);
  if (state != null) {
    int targetId = myTargetsState.getBuildTargetId(buildTarget);
    for (int i = 0; i < state.length; i++) {
      TimestampPerTarget timestampPerTarget = state[i];
      if (timestampPerTarget.targetId == targetId) {
        if (state.length == 1) {
          remove(file);
        }
        else {
          TimestampPerTarget[] newState = ArrayUtil.remove(state, i);
          update(file, newState);
          break;
        }
      }
    }
  }
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
@Override
public boolean accept(File file) {
  final JavaSourceRootDescriptor rd = myBuildRootIndex.findJavaRootDescriptor(myContext, file);
  if (rd == null) {
    return true;
  }
  final ModuleBuildTarget targetOfFile = rd.target;
  if (myChunkTargets.contains(targetOfFile)) {
    return true;
  }
  Set<BuildTarget<?>> targetOfFileWithDependencies = myCache.get(targetOfFile);
  if (targetOfFileWithDependencies == null) {
    targetOfFileWithDependencies = myBuildTargetIndex.getDependenciesRecursively(targetOfFile, myContext);
    myCache.put(targetOfFile, targetOfFileWithDependencies);
  }
  return ContainerUtil.intersects(targetOfFileWithDependencies, myChunkTargets);
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
@Override
public Collection<BuildTarget<?>> getTargetsByOutputFile(@NotNull File file) {
  File current = file;
  Collection<BuildTarget<?>> result = null;
  while (current != null) {
    List<BuildTarget<?>> targets = myOutputToTargets.get(current);
    if (targets != null) {
      if (result == null) {
        result = targets;
      }
      else {
        result = new ArrayList<BuildTarget<?>>(result);
        result.addAll(targets);
      }
    }
    current = FileUtilRt.getParentFile(current);
  }
  return result != null ? result : Collections.<BuildTarget<?>>emptyList();
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
public BuildTargetRegistryImpl(JpsModel model) {
  myTargets = new THashMap<BuildTargetType<?>, List<? extends BuildTarget<?>>>();
  myModuleBasedTargets = new THashMap<JpsModule, List<ModuleBasedTarget>>();
  List<List<? extends BuildTarget<?>>> targetsByType = new ArrayList<List<? extends BuildTarget<?>>>();
  for (BuildTargetType<?> type : TargetTypeRegistry.getInstance().getTargetTypes()) {
    List<? extends BuildTarget<?>> targets = type.computeAllTargets(model);
    myTargets.put(type, targets);
    targetsByType.add(targets);
    for (BuildTarget<?> target : targets) {
      if (target instanceof ModuleBasedTarget) {
        final ModuleBasedTarget t = (ModuleBasedTarget)target;
        final JpsModule module = t.getModule();
        List<ModuleBasedTarget> list = myModuleBasedTargets.get(module);
        if (list == null) {
          list = new ArrayList<ModuleBasedTarget>();
          myModuleBasedTargets.put(module, list);
        }
        list.add(t);
      }
    }
  }
  myAllTargets = Collections.unmodifiableList(ContainerUtil.concat(targetsByType));
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
@NotNull
@Override
public List<JavaSourceRootDescriptor> getAdditionalRoots(@NotNull BuildTarget<JavaSourceRootDescriptor> target, BuildDataPaths dataPaths) {
  ModuleBuildTarget buildTarget = (ModuleBuildTarget)target;
  final File generatedSourcesRoot = AndroidJpsUtil.getGeneratedSourcesStorage(buildTarget.getModule(), dataPaths);
  final List<JavaSourceRootDescriptor> result = new ArrayList<JavaSourceRootDescriptor>();

  addRoot(result, buildTarget, new File(generatedSourcesRoot, AndroidJpsUtil.AAPT_GENERATED_SOURCE_ROOT_NAME));
  addRoot(result, buildTarget, new File(generatedSourcesRoot, AndroidJpsUtil.AIDL_GENERATED_SOURCE_ROOT_NAME));
  addRoot(result, buildTarget, new File(generatedSourcesRoot, AndroidJpsUtil.RENDERSCRIPT_GENERATED_SOURCE_ROOT_NAME));
  addRoot(result, buildTarget, new File(generatedSourcesRoot, AndroidJpsUtil.BUILD_CONFIG_GENERATED_SOURCE_ROOT_NAME));

  addRoot(result, buildTarget, AndroidJpsUtil.getCopiedSourcesStorage(buildTarget.getModule(), dataPaths));

  return result;
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
public <R extends BuildRootDescriptor, T extends BuildTarget<R>> boolean processFilesToRecompile(CompileContext context, final T target, final FileProcessor<R, T> processor) throws IOException {
  final Map<BuildRootDescriptor, Set<File>> data = getSourcesToRecompile(context, target);
  final CompileScope scope = context.getScope();
  synchronized (data) {
    for (Map.Entry<BuildRootDescriptor, Set<File>> entry : data.entrySet()) {
      //noinspection unchecked
      R root = (R)entry.getKey();
      for (File file : entry.getValue()) {
        if (!scope.isAffected(target, file)) {
          continue;
        }
        if (!processor.apply(target, file, root)) {
          return false;
        }
      }
    }
  }
  return true;
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
static void markDirtyFiles(CompileContext context,
                           BuildTarget<?> target,
                           Timestamps timestamps,
                           boolean forceMarkDirty,
                           @Nullable THashSet<File> currentFiles,
                           @Nullable FileFilter filter) throws IOException {
  for (BuildRootDescriptor rd : context.getProjectDescriptor().getBuildRootIndex().getTargetRoots(target, context)) {
    if (!rd.getRootFile().exists() ||
        //temp roots are managed by compilers themselves
        (rd instanceof JavaSourceRootDescriptor && ((JavaSourceRootDescriptor)rd).isTemp)) {
      continue;
    }
    if (filter == null) {
      context.getProjectDescriptor().fsState.clearRecompile(rd);
    }
    final FSCache fsCache = rd.canUseFileCache() ? context.getProjectDescriptor().getFSCache() : FSCache.NO_CACHE;
    traverseRecursively(context, rd, rd.getRootFile(), timestamps, forceMarkDirty, currentFiles, filter, fsCache);
  }
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
@NotNull
@Override
public BuildTargetLoader createLoader(@NotNull JpsModel model) {
    return new BuildTargetLoader() {
        @Nullable
        @Override
        public BuildTarget<?> createTarget(@NotNull String targetId) {
            return null;
        }
    };
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
@Override
public Collection<CompiledClass> getTargetCompiledClasses(BuildTarget<?> target) {
  final Collection<CompiledClass> classes = myTargetToClassesMap.get(target);
  if (classes != null) {
    return Collections.unmodifiableCollection(classes);
  }
  return Collections.emptyList();
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
@Override
public void registerCompiledClass(BuildTarget<?> target, CompiledClass compiled) throws IOException {
  if (compiled.getClassName() != null) {
    myClasses.put(compiled.getClassName(), compiled);
    Collection<CompiledClass> classes = myTargetToClassesMap.get(target);
    if (classes == null) {
      classes = new ArrayList<CompiledClass>();
      myTargetToClassesMap.put(target, classes);
    }
    classes.add(compiled);
  }
  registerOutputFile(target, compiled.getOutputFile(), Collections.<String>singleton(compiled.getSourceFile().getPath()));
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
@Override
public void registerOutputFile(BuildTarget<?> target, File outputFile, Collection<String> sourcePaths) throws IOException {
  BuildOutputConsumerImpl consumer = myTarget2Consumer.get(target);
  if (consumer == null) {
    consumer = new BuildOutputConsumerImpl(target, myContext);
    myTarget2Consumer.put(target, consumer);
  }
  consumer.registerOutputFile(outputFile, sourcePaths);
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
public void setCompilationStartStamp(Collection<BuildTarget<?>> targets, long stamp) {
  synchronized (myCompilationStartStamp) {
    for (BuildTarget<?> target : targets) {
      myCompilationStartStamp.put(target, stamp);
    }
  }
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
public void load(DataInput in, @NotNull BuildTarget<?> target, BuildRootIndex buildRootIndex) throws IOException {
  lockData();
  try {
    myDeletedPaths.clear();
    int deletedCount = in.readInt();
    while (deletedCount-- > 0) {
      myDeletedPaths.add(IOUtil.readString(in));
    }
    myFilesToRecompile.clear();
    int recompileCount = in.readInt();
    while (recompileCount-- > 0) {
      String rootId = IOUtil.readString(in);
      BuildRootDescriptor descriptor = target.findRootDescriptor(rootId, buildRootIndex);
      Set<File> files;
      if (descriptor != null) {
        files = myFilesToRecompile.get(descriptor);
        if (files == null) {
          files = new THashSet<File>(FileUtil.FILE_HASHING_STRATEGY);
          myFilesToRecompile.put(descriptor, files);
        }
      }
      else {
        LOG.debug("Cannot find root by " + rootId + ", delta will be skipped");
        files = new THashSet<File>(FileUtil.FILE_HASHING_STRATEGY);
      }
      int filesCount = in.readInt();
      while (filesCount-- > 0) {
        final File file = new File(IOUtil.readString(in));
        if (Utils.IS_TEST_MODE) {
          LOG.info("Loaded " + file.getPath());
        }
        files.add(file);
      }
    }
  }
  finally {
    unlockData();
  }
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
private static String composeMessageText(Collection<? extends BuildTarget<?>> targets, Event event) {
  String targetsString = StringUtil.join(targets, new NotNullFunction<BuildTarget<?>, String>() {
    @NotNull
    @Override
    public String fun(BuildTarget<?> dom) {
      return dom.getPresentableName();
    }
  }, ", ");
  return (event == Event.STARTED ? "Started" : "Finished") + " building " + targetsString;
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
public Collection<BuildTarget<?>> getDependencies(JpsPackagingElement element, TargetOutputIndex outputIndex) {
  LayoutElementBuilderService builder = getElementBuilder(element);
  if (builder != null) {
    //noinspection unchecked
    return builder.getDependencies(element, outputIndex);
  }
  return Collections.emptyList();
}
 

import org.jetbrains.jps.builders.BuildTarget; //导入依赖的package包/类
public static void pruneEmptyDirs(CompileContext context, @Nullable final Set<File> dirsToDelete) {
  if (dirsToDelete == null || dirsToDelete.isEmpty()) return;

  Set<File> doNotDelete = ALL_OUTPUTS_KEY.get(context);
  if (doNotDelete == null) {
    doNotDelete = new THashSet<File>(FileUtil.FILE_HASHING_STRATEGY);
    for (BuildTarget<?> target : context.getProjectDescriptor().getBuildTargetIndex().getAllTargets()) {
      doNotDelete.addAll(target.getOutputRoots(context));
    }
    ALL_OUTPUTS_KEY.set(context, doNotDelete);
  }

  Set<File> additionalDirs = null;
  Set<File> toDelete = dirsToDelete;
  while (toDelete != null) {
    for (File file : toDelete) {
      // important: do not force deletion if the directory is not empty!
      final boolean deleted = !doNotDelete.contains(file) && file.delete();
      if (deleted) {
        final File parentFile = file.getParentFile();
        if (parentFile != null) {
          if (additionalDirs == null) {
            additionalDirs = new THashSet<File>(FileUtil.FILE_HASHING_STRATEGY);
          }
          additionalDirs.add(parentFile);
        }
      }
    }
    toDelete = additionalDirs;
    additionalDirs = null;
  }
}