Java BuildRootDescriptor类代码示例

import org.jetbrains.jps.builders.BuildRootDescriptor; //导入依赖的package包/类
public void save(DataOutput out) throws IOException {
  lockData();
  try {
    out.writeInt(myDeletedPaths.size());
    for (String path : myDeletedPaths) {
      IOUtil.writeString(path, out);
    }
    out.writeInt(myFilesToRecompile.size());
    for (Map.Entry<BuildRootDescriptor, Set<File>> entry : myFilesToRecompile.entrySet()) {
      IOUtil.writeString(entry.getKey().getRootId(), out);
      final Set<File> files = entry.getValue();
      out.writeInt(files.size());
      for (File file : files) {
        IOUtil.writeString(FileUtil.toSystemIndependentName(file.getPath()), out);
      }
    }
  }
  finally {
    unlockData();
  }
}
 

import org.jetbrains.jps.builders.BuildRootDescriptor; //导入依赖的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.BuildRootDescriptor; //导入依赖的package包/类
@Override
public void filesGenerated(Collection<Pair<String, String>> paths) {
  BuildFSState fsState = myContext.getProjectDescriptor().fsState;
  BuildRootIndex rootsIndex = myContext.getProjectDescriptor().getBuildRootIndex();
  for (Pair<String, String> pair : paths) {
    String relativePath = pair.getSecond();
    File file = relativePath.equals(".") ? new File(pair.getFirst()) : new File(pair.getFirst(), relativePath);
    Collection<BuildRootDescriptor> descriptors = rootsIndex.findAllParentDescriptors(file, null, myContext);
    for (BuildRootDescriptor descriptor : descriptors) {
      try {
        fsState.markDirty(myContext, file, descriptor, myContext.getProjectDescriptor().timestamps.getStorage(), false);
      }
      catch (IOException ignored) {
      }
    }
  }
}
 

import org.jetbrains.jps.builders.BuildRootDescriptor; //导入依赖的package包/类
@Override
protected void buildTarget(@NotNull AndroidResourcePackagingBuildTarget target,
                           @NotNull DirtyFilesHolder<BuildRootDescriptor, AndroidResourcePackagingBuildTarget> holder,
                           @NotNull BuildOutputConsumer outputConsumer,
                           @NotNull CompileContext context) throws ProjectBuildException, IOException {
  final boolean releaseBuild = AndroidJpsUtil.isReleaseBuild(context);
  final AndroidPackagingStateStorage packagingStateStorage =
    context.getProjectDescriptor().dataManager.getStorage(target, AndroidPackagingStateStorage.Provider.INSTANCE);

  if (!holder.hasDirtyFiles() && !holder.hasRemovedFiles()) {
    final AndroidPackagingStateStorage.MyState savedState = packagingStateStorage.read();

    if (savedState != null && savedState.isRelease() == releaseBuild) {
      return;
    }
  }
  assert !AndroidJpsUtil.isLightBuild(context);

  if (!packageResources(target, context, outputConsumer, releaseBuild)) {
    throw new StopBuildException();
  }
  packagingStateStorage.saveState(new AndroidPackagingStateStorage.MyState(releaseBuild));
}
 

import org.jetbrains.jps.builders.BuildRootDescriptor; //导入依赖的package包/类
@NotNull
@Override
protected List<BuildRootDescriptor> doComputeRootDescriptors(JpsModel model,
                                                             ModuleExcludeIndex index,
                                                             IgnoredFileIndex ignoredFileIndex,
                                                             BuildDataPaths dataPaths) {
  final File moduleOutputDir = ProjectPaths.getModuleOutputDir(myModule, false);

  if (moduleOutputDir != null) {
    return Collections.<BuildRootDescriptor>singletonList(
      new AndroidClassesDirBuildRootDescriptor(this, moduleOutputDir));
  }
  else {
    return Collections.emptyList();
  }
}
 

import org.jetbrains.jps.builders.BuildRootDescriptor; //导入依赖的package包/类
@NotNull
@Override
protected List<BuildRootDescriptor> doComputeRootDescriptors(JpsModel model,
                                                             ModuleExcludeIndex index,
                                                             IgnoredFileIndex ignoredFileIndex,
                                                             BuildDataPaths dataPaths) {
  final Set<JpsLibrary> libraries = JpsJavaExtensionService.getInstance().enumerateDependencies(
    Collections.singleton(myModule)).runtimeOnly().productionOnly().getLibraries();
  final List<BuildRootDescriptor> result = new ArrayList<BuildRootDescriptor>();

  for (JpsLibrary library : libraries) {
    final Pair<File, List<File>> pair = AndroidJpsUtil.getResDirAndJarsIfAar(library);
    final List<File> jars = pair != null ? pair.getSecond() : null;

    if (jars != null) {
      for (File jar : jars) {
        result.add(new BuildRootDescriptorImpl(this, jar));
      }
    }
  }
  return result;
}
 

import org.jetbrains.jps.builders.BuildRootDescriptor; //导入依赖的package包/类
public void save(DataOutput out) throws IOException {
  out.writeInt(myDeletedPaths.size());
  synchronized (myDeletedPaths) {
    for (String path : myDeletedPaths) {
      IOUtil.writeString(path, out);
    }
  }
  synchronized (myFilesToRecompile) {
    out.writeInt(myFilesToRecompile.size());
    for (Map.Entry<BuildRootDescriptor, Set<File>> entry : myFilesToRecompile.entrySet()) {
      IOUtil.writeString(entry.getKey().getRootId(), out);
      final Set<File> files = entry.getValue();
      out.writeInt(files.size());
      for (File file : files) {
        IOUtil.writeString(FileUtil.toSystemIndependentName(file.getPath()), out);
      }
    }
  }
}
 

import org.jetbrains.jps.builders.BuildRootDescriptor; //导入依赖的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.BuildRootDescriptor; //导入依赖的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.BuildRootDescriptor; //导入依赖的package包/类
private void addAll(FilesDelta other) {
  other.lockData();
  try {
    myDeletedPaths.addAll(other.myDeletedPaths);
    for (Map.Entry<BuildRootDescriptor, Set<File>> entry : other.myFilesToRecompile.entrySet()) {
      _addToRecompiled(entry.getKey(), entry.getValue());
    }
  }
  finally {
    other.unlockData();
  }
}
 

import org.jetbrains.jps.builders.BuildRootDescriptor; //导入依赖的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.BuildRootDescriptor; //导入依赖的package包/类
public boolean markRecompile(BuildRootDescriptor root, File file) {
  lockData();
  try {
    final boolean added = _addToRecompiled(root, file);
    if (added) {
      if (!myDeletedPaths.isEmpty()) { // optimization
        myDeletedPaths.remove(FileUtil.toCanonicalPath(file.getPath()));
      }
    }
    return added;
  }
  finally {
    unlockData();
  }
}
 

import org.jetbrains.jps.builders.BuildRootDescriptor; //导入依赖的package包/类
public boolean markRecompileIfNotDeleted(BuildRootDescriptor root, File file) {
  lockData();
  try {
    final boolean isMarkedDeleted = !myDeletedPaths.isEmpty() && myDeletedPaths.contains(FileUtil.toCanonicalPath(file.getPath()));
    if (!isMarkedDeleted) {
      _addToRecompiled(root, file);
      return true;
    }
    return false;
  }
  finally {
    unlockData();
  }
}
 

import org.jetbrains.jps.builders.BuildRootDescriptor; //导入依赖的package包/类
private boolean _addToRecompiled(BuildRootDescriptor root, Collection<File> filesToAdd) {
  Set<File> files = myFilesToRecompile.get(root);
  if (files == null) {
    files = new THashSet<File>(FileUtil.FILE_HASHING_STRATEGY);
    myFilesToRecompile.put(root, files);
  }
  return files.addAll(filesToAdd);
}
 

import org.jetbrains.jps.builders.BuildRootDescriptor; //导入依赖的package包/类
public boolean isMarkedRecompile(BuildRootDescriptor rd, File file) {
  lockData();
  try {
    final Set<File> files = myFilesToRecompile.get(rd);
    return files != null && files.contains(file);
  }
  finally {
    unlockData();
  }
}