import com.intellij.openapi.roots.RootPolicy; //导入依赖的package包/类
private static boolean isOrphanProjectLibrary(@NotNull final Library library,
                                              @NotNull final IdeModifiableModelsProvider modelsProvider) {
  RootPolicy<Boolean> visitor = new RootPolicy<Boolean>() {
    @Override
    public Boolean visitLibraryOrderEntry(LibraryOrderEntry ideDependency, Boolean value) {
      return !ideDependency.isModuleLevel() && library == ideDependency.getLibrary();
    }
  };
  for (Module module : modelsProvider.getModules()) {
    for (OrderEntry entry : modelsProvider.getOrderEntries(module)) {
      if (entry.accept(visitor, false)) return false;
    }
  }
  return true;
}
 

import com.intellij.openapi.roots.RootPolicy; //导入依赖的package包/类
@Override
public <R> R accept(RootPolicy<R> rRootPolicy, @Nullable R r)
{
	if(rRootPolicy instanceof DotNetRootPolicy)
	{
		return (R) ((DotNetRootPolicy) rRootPolicy).visitDotNetLibrary(this, r);
	}
	else
	{
		return rRootPolicy.visitOrderEntry(this, r);
	}
}
 

import com.intellij.openapi.roots.RootPolicy; //导入依赖的package包/类
public void test2() throws Exception {
  final ModuleRootManager rootManager = ModuleRootManager.getInstance(myModule);
  ModuleRootModificationUtil.setSdkInherited(myModule);

  assertTrue("JDK is inherited after inheritSdk()", rootManager.isSdkInherited());
  assertNull("No JDK assigned", rootManager.getSdk());

  final Sdk mockJdk = IdeaTestUtil.getMockJdk17("mock 1.4");
  ApplicationManager.getApplication().runWriteAction(() -> {
    ProjectJdkTable.getInstance().addJdk(mockJdk);
  });
  final ProjectRootManagerEx projectRootManager = ProjectRootManagerEx.getInstanceEx(myProject);

  ApplicationManager.getApplication().runWriteAction(() -> {
    projectRootManager.setProjectSdk(mockJdk);
  });

  assertTrue(rootManager.isSdkInherited());
  assertEquals("mockJdk inherited", mockJdk, rootManager.getSdk());

  ApplicationManager.getApplication().runWriteAction(() -> {
    projectRootManager.setProjectSdkName("jdk1");
  });

  assertTrue(rootManager.isSdkInherited());
  Assert.assertEquals("Correct non-existing JDK inherited", "jdk1",
                      rootManager.orderEntries().process(new RootPolicy<String>() {
                        @Override
                        public String visitInheritedJdkOrderEntry(InheritedJdkOrderEntry inheritedJdkOrderEntry, String s) {
                          return inheritedJdkOrderEntry.getJdkName();
                        }
                      }, null));
  assertNull("Non-existing JDK", rootManager.getSdk());

  final Sdk jdk1 = IdeaTestUtil.getMockJdk17("jdk1");
  ApplicationManager.getApplication().runWriteAction(() -> {
    ProjectJdkTable.getInstance().addJdk(jdk1);
  });

  assertTrue(rootManager.isSdkInherited());
  assertNotNull("JDK appeared", rootManager.getSdk());
  assertEquals("jdk1 found", jdk1, rootManager.getSdk());
}
 

import com.intellij.openapi.roots.RootPolicy; //导入依赖的package包/类
@Override
public <R> R accept(RootPolicy<R> policy, @Nullable R initialValue) {
  return policy.visitInheritedJdkOrderEntry(this, initialValue);
}
 

import com.intellij.openapi.roots.RootPolicy; //导入依赖的package包/类
@Override
public <R> R accept(RootPolicy<R> policy, @Nullable R initialValue) {
  return policy.visitModuleJdkOrderEntry(this, initialValue);
}
 

import com.intellij.openapi.roots.RootPolicy; //导入依赖的package包/类
@Override
public <R> R accept(RootPolicy<R> policy, @Nullable R initialValue) {
  return policy.visitLibraryOrderEntry(this, initialValue);
}
 

import com.intellij.openapi.roots.RootPolicy; //导入依赖的package包/类
@Override
public <R> R accept(RootPolicy<R> policy, @Nullable R initialValue) {
  return policy.visitModuleOrderEntry(this, initialValue);
}
 

import com.intellij.openapi.roots.RootPolicy; //导入依赖的package包/类
@Override
public <R> R accept(@NotNull RootPolicy<R> policy, R initialValue) {
  return policy.visitModuleJdkOrderEntry(this, initialValue);
}
 

import com.intellij.openapi.roots.RootPolicy; //导入依赖的package包/类
@NotNull
private static OrderEntry createFakeOrderEntry(@NotNull final Module ownerModule) {
  return new OrderEntry() {
    @NotNull
    @Override
    public VirtualFile[] getFiles(OrderRootType type) {
      throw new IncorrectOperationException();
    }

    @NotNull
    @Override
    public String[] getUrls(OrderRootType rootType) {
      throw new IncorrectOperationException();
    }

    @NotNull
    @Override
    public String getPresentableName() {
      throw new IncorrectOperationException();
    }

    @Override
    public boolean isValid() {
      throw new IncorrectOperationException();
    }

    @NotNull
    @Override
    public Module getOwnerModule() {
      return ownerModule;
    }

    @Override
    public <R> R accept(RootPolicy<R> policy, @Nullable R initialValue) {
      throw new IncorrectOperationException();
    }

    @Override
    public int compareTo(OrderEntry o) {
      throw new IncorrectOperationException();
    }

    @Override
    public boolean isSynthetic() {
      throw new IncorrectOperationException();
    }
  };
}
 

import com.intellij.openapi.roots.RootPolicy; //导入依赖的package包/类
@Override
public <R> R accept(RootPolicy<R> policy, @Nullable R initialValue) {
  return policy.visitOrderEntry(this, initialValue);
}
 

import com.intellij.openapi.roots.RootPolicy; //导入依赖的package包/类
@Override
public <R> R accept(@Nonnull RootPolicy<R> policy, R initialValue) {
  return policy.visitModuleExtensionSdkOrderEntry(this, initialValue);
}