Java ModifiableFacetModel.commit方法代码示例

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
@NotNull
public static AndroidFacet addAndroidFacet(final Module module, @NotNull VirtualFile contentRoot,
                                           boolean library) {
  final FacetManager facetManager = FacetManager.getInstance(module);
  ModifiableFacetModel model = facetManager.createModifiableModel();
  AndroidFacet facet = model.getFacetByType(AndroidFacet.ID);

  if (facet == null) {
    facet = facetManager.createFacet(AndroidFacet.getFacetType(), "Android", null);
    AndroidFacetConfiguration configuration = facet.getConfiguration();
    configuration.init(module, contentRoot);
    if (library) {
      configuration.getState().LIBRARY_PROJECT = true;
    }
    model.addFacet(facet);
  }
  model.commit();

  return facet;
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
private static void cleanUpAndroidModuleWithoutVariants(@NotNull Module module) {
  // Remove Android facet, otherwise the IDE will try to build the module, and fail. The facet may have been added in a previous
  // successful commit.
  AndroidFacet facet = AndroidFacet.getInstance(module);
  if (facet != null) {
    ModifiableFacetModel facetModel = FacetManager.getInstance(module).createModifiableModel();
    facetModel.removeFacet(facet);
    facetModel.commit();
  }

  // Clear all source and exclude folders.
  ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module);
  ModifiableRootModel rootModel = moduleRootManager.getModifiableModel();
  for (ContentEntry contentEntry : rootModel.getContentEntries()) {
    contentEntry.clearSourceFolders();
    contentEntry.clearExcludeFolders();
  }

  rootModel.commit();
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
private void setUpLibModule() {
  FacetManager facetManager = FacetManager.getInstance(myLibModule);
  ModifiableFacetModel facetModel = facetManager.createModifiableModel();
  try {
    AndroidFacet androidFacet = createFacet(facetManager, true);
    androidFacet.setIdeaAndroidProject(myLib);
    facetModel.addFacet(androidFacet);

    AndroidGradleFacet gradleFacet = facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null);
    gradleFacet.getConfiguration().GRADLE_PROJECT_PATH = myLibGradlePath;
    facetModel.addFacet(gradleFacet);
  }
  finally {
    facetModel.commit();
  }
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
public void testRemoveAllFacetsWithAndroidGradleFacets() throws Exception {
  FacetManager facetManager = FacetManager.getInstance(myModule);
  ModifiableFacetModel model = facetManager.createModifiableModel();
  try {
    AndroidGradleFacet facet = facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null);
    model.addFacet(facet);
  }
  finally {
    model.commit();
  }

  assertEquals(1, facetManager.getFacetsByType(AndroidGradleFacet.TYPE_ID).size());

  Facets.removeAllFacetsOfType(myModule, AndroidGradleFacet.TYPE_ID);

  assertEquals(0, facetManager.getFacetsByType(AndroidGradleFacet.TYPE_ID).size());
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
public void setMuleFacet(Module module) {
    MuleFacetType type = (MuleFacetType)FacetTypeRegistry.getInstance().findFacetType(MuleFacet.ID);
    MuleFacetConfiguration configuration = type.createDefaultConfiguration();
    configuration.setPathToSdk(MuleSdkManager.getInstance().findFromVersion(muleVersion).getMuleHome());
    Facet facet = type.createFacet(module, type.getPresentableName(), configuration, null);
    ModifiableFacetModel model = FacetManager.getInstance(module).createModifiableModel();
    model.addFacet(facet);
    model.commit();
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
public void addSupport(@NotNull Module module, @NotNull ModifiableRootModel model, @Nullable Library library) {
  final FacetManager facetManager = FacetManager.getInstance(module);
  ModifiableFacetModel facetModel = facetManager.createModifiableModel();
  LuaFacet facet = facetManager.createFacet(LuaFacetType.getInstance(), "Lua", null);
  facet.getConfiguration().setSdk(mySdkComboBox.getSelectedSdk());
  facetModel.addFacet(facet);
  facetModel.commit();
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
@Override
public void commitFacetModifiableModel(Module module, ModifiableFacetModel model) {
  final ModulesConfigurator configurator = getModulesConfigurator(module.getProject());
  if (configurator == null || !(configurator.getFacetsConfigurator().getFacetModel(module) instanceof ModifiableFacetModel)) {
    model.commit();
  }
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
public void addSupport(@NotNull Module module, @NotNull ModifiableRootModel model, @Nullable Library library) {
  final FacetManager facetManager = FacetManager.getInstance(module);
  ModifiableFacetModel facetModel = facetManager.createModifiableModel();
  PythonFacet facet = facetManager.createFacet(PythonFacetType.getInstance(), "Python", null);
  facet.getConfiguration().setSdk(mySdkComboBox.getSelectedSdk());
  facetModel.addFacet(facet);
  facetModel.commit();
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
public static void removeAndroidFacet(Module module) {
  AndroidFacet facet = AndroidFacet.getInstance(module);
  if (facet != null) {
    ModifiableFacetModel facetModel = FacetManager.getInstance(module).createModifiableModel();
    facetModel.removeFacet(facet);
    facetModel.commit();
  }
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
public static <T extends Facet> void removeAllFacetsOfType(@NotNull Module module, @NotNull FacetTypeId<T> typeId) {
  FacetManager facetManager = FacetManager.getInstance(module);
  Collection<T> facets = facetManager.getFacetsByType(typeId);
  if (!facets.isEmpty()) {
    ModifiableFacetModel model = facetManager.createModifiableModel();
    try {
      for (T facet : facets) {
        model.removeFacet(facet);
      }
    }
    finally {
      model.commit();
    }
  }
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
public void testIsCacheMissingModelsWhenCacheHasAndroidModel() {
  FacetManager facetManager = FacetManager.getInstance(myModule);
  ModifiableFacetModel model = facetManager.createModifiableModel();
  try {
    model.addFacet(facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null));
    model.addFacet(facetManager.createFacet(AndroidFacet.getFacetType(), AndroidFacet.NAME, null));
  } finally {
    model.commit();
  }

  myCachedModule.createChild(IDE_GRADLE_PROJECT, createMock(IdeaGradleProject.class));
  myCachedModule.createChild(IDE_ANDROID_PROJECT, createMock(IdeaAndroidProject.class));
  assertFalse(GradleProjectImporter.isCacheMissingModels(myCachedProject, myProject));
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
public void testGetGradleBuildFileFromModuleWithGradleFacet() {
  GradleProject project = createMock(GradleProject.class);
  expect(project.getPath()).andReturn(myModule.getName());

  //noinspection unchecked
  DomainObjectSet<? extends GradleTask> tasks = createMock(DomainObjectSet.class);
  project.getTasks();
  expectLastCall().andReturn(tasks);

  expect(tasks.isEmpty()).andReturn(true);
  replay(project, tasks);

  IdeaGradleProject gradleProject = IdeaGradleProject.newIdeaGradleProject(myModule.getName(), project, myBuildFile, "2.2.1");

  FacetManager facetManager = FacetManager.getInstance(myModule);
  ModifiableFacetModel model = facetManager.createModifiableModel();
  try {
    AndroidGradleFacet facet = facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null);
    model.addFacet(facet);
    facet.setGradleProject(gradleProject);
  }
  finally {
    model.commit();
  }

  VirtualFile buildFile = GradleUtil.getGradleBuildFile(myModule);
  assertIsGradleBuildFile(buildFile);

  verify(project, tasks);
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
public void testIsCacheMissingModelsWhenCacheIsMissingAndroidModel() {
  FacetManager facetManager = FacetManager.getInstance(myModule);
  ModifiableFacetModel model = facetManager.createModifiableModel();
  try {
    model.addFacet(facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null));
    model.addFacet(facetManager.createFacet(AndroidFacet.getFacetType(), AndroidFacet.NAME, null));
  } finally {
    model.commit();
  }

  myCachedModule.createChild(IDE_GRADLE_PROJECT, createMock(IdeaGradleProject.class));
  assertTrue(GradleProjectImporter.isCacheMissingModels(myCachedProject, myProject));
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
public void testIsCacheMissingModelsWhenCacheIsMissingJavaModel() {
  FacetManager facetManager = FacetManager.getInstance(myModule);
  ModifiableFacetModel model = facetManager.createModifiableModel();
  try {
    model.addFacet(facetManager.createFacet(AndroidGradleFacet.getFacetType(), AndroidGradleFacet.NAME, null));
    model.addFacet(facetManager.createFacet(JavaGradleFacet.getFacetType(), JavaGradleFacet.NAME, null));
  } finally {
    model.commit();
  }

  myCachedModule.createChild(IDE_GRADLE_PROJECT, createMock(IdeaGradleProject.class));
  assertTrue(GradleProjectImporter.isCacheMissingModels(myCachedProject, myProject));
}
 

import com.intellij.facet.ModifiableFacetModel; //导入方法依赖的package包/类
@Nullable
private static LibraryContributingFacet<?> getOrCreatePythonFacet(
    BlazeContext context, Module module) {
  LibraryContributingFacet<?> facet = findPythonFacet(module);
  if (facet != null && facetHasSdk(facet)) {
    return facet;
  }
  FacetManager manager = FacetManager.getInstance(module);
  ModifiableFacetModel facetModel = manager.createModifiableModel();
  if (facet != null) {
    // we can't modify in place, IntelliJ has no hook to trigger change events. Instead we create
    // a new facet.
    facetModel.removeFacet(facet);
  }
  Sdk sdk = getOrCreatePythonSdk();
  if (sdk == null) {
    String msg =
        "Unable to find a Python SDK installed.\n"
            + "After configuring a suitable SDK in the \"Project Structure\" dialog, "
            + "sync the project again.";
    IssueOutput.error(msg).submit(context);
    return null;
  }
  facet = manager.createFacet(PythonFacetUtil.getTypeInstance(), "Python", null);
  facetModel.addFacet(facet);
  facetModel.commit();
  return facet;
}