import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
private static void addAsLibrary(VirtualFile virtualFile, ModuleRootLayerImpl layer)
{
	if(virtualFile.getFileType() == DotNetModuleFileType.INSTANCE)
	{
		VirtualFile archiveRootForLocalFile = ArchiveVfsUtil.getArchiveRootForLocalFile(virtualFile);
		if(archiveRootForLocalFile != null)
		{
			Library library = layer.getModuleLibraryTable().createLibrary();
			Library.ModifiableModel modifiableModel = library.getModifiableModel();
			modifiableModel.addRoot(archiveRootForLocalFile, BinariesOrderRootType.getInstance());
			VirtualFile docFile = virtualFile.getParent().findChild(virtualFile.getNameWithoutExtension() + ".xml");
			if(docFile != null)
			{
				modifiableModel.addRoot(docFile, DocumentationOrderRootType.getInstance());
			}
			modifiableModel.commit();

			LibraryOrderEntry libraryOrderEntry = layer.findLibraryOrderEntry(library);
			assert libraryOrderEntry != null;
			libraryOrderEntry.setExported(true);
		}
	}
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@Override
public List<OrderEntry> createOrderEntries(@NotNull ModifiableModuleRootLayer layer, DialogWrapper dialogWrapper)
{
	Object[] selectedValues = myLibraryList.getSelectedValues();
	List<OrderEntry> orderEntries = new ArrayList<OrderEntry>(selectedValues.length);
	for(Object selectedValue : selectedValues)
	{
		Map.Entry<String, String> entry = (Map.Entry<String, String>) selectedValue;

		DotNetLibraryOrderEntryImpl orderEntry = new DotNetLibraryOrderEntryImpl((ModuleRootLayerImpl) layer, entry.getKey());

		layer.addOrderEntry(orderEntry);

		orderEntries.add(orderEntry);
	}
	return orderEntries;
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@Nullable
public static OrderEntry loadOrderEntry(@Nonnull Element element, @Nonnull ModuleRootLayer moduleRootLayer) {
  String type = element.getAttributeValue(ORDER_ENTRY_TYPE_ATTR);
  if(type == null) {
    return null;
  }
  OrderEntryType orderEntryType = getProvidersAsMap().get(type);
  if(orderEntryType == null) {
    return new UnknownOrderEntryImpl(new UnknownOrderEntryType(type, element), (ModuleRootLayerImpl)moduleRootLayer);
  }

  try {
    return orderEntryType.loadOrderEntry(element, moduleRootLayer);
  }
  catch (InvalidDataException e) {
    return new UnknownOrderEntryImpl(new UnknownOrderEntryType(type, element), (ModuleRootLayerImpl)moduleRootLayer);
  }
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
private LibraryImpl(@Nonnull LibraryImpl from, LibraryImpl newSource, ModuleRootLayerImpl rootModel) {
  this(from.myLibraryTable, rootModel, newSource, from.myName, from.myKind);
  from.checkDisposed();

  if (from.myKind != null && from.myProperties != null) {
    myProperties = myKind.createDefaultProperties();
    //noinspection unchecked
    myProperties.loadState(from.myProperties.getState());
  }
  for (OrderRootType rootType : OrderRootType.getAllTypes()) {
    final VirtualFilePointerContainer thisContainer = myRoots.get(rootType);
    final VirtualFilePointerContainer thatContainer = from.myRoots.get(rootType);
    thisContainer.addAll(thatContainer);
  }
  if (from.myExcludedRoots != null) {
    myExcludedRoots = from.myExcludedRoots.clone(myPointersDisposable);
  }
  myJarDirectories.copyFrom(from.myJarDirectories);
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@RequiredReadAction
private void loadState(Element element, @Nullable ProgressIndicator progressIndicator) {
  String currentLayer = element.getAttributeValue("current-layer");
  if (currentLayer != null) {
    setCurrentLayerSafe(currentLayer);

    for (Element moduleLayerElement : element.getChildren("module-layer")) {
      String name = moduleLayerElement.getAttributeValue("name");

      ModuleRootLayerImpl moduleRootLayer = new ModuleRootLayerImpl(null, this);
      moduleRootLayer.loadState(moduleLayerElement, progressIndicator);

      ModuleRootLayerImpl layer = myLayers.put(name, moduleRootLayer);
      if (layer != null) {
        // dispose old layout
        Disposer.dispose(layer);
      }
    }
  }

  // old format - create default profile and load it
  if (myLayers.isEmpty()) {
    initDefaultLayer(element);
  }
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@Nonnull
@Override
public ModifiableModuleRootLayer addLayer(@Nonnull String name, @Nullable String nameForCopy, boolean activate) {
  ModuleRootLayerImpl moduleRootLayer = myLayers.get(name);
  if (moduleRootLayer != null) {
    return moduleRootLayer;
  }

  ModuleRootLayerImpl layer = new ModuleRootLayerImpl(null, this);

  if (nameForCopy != null) {
    ModuleRootLayerImpl original = myLayers.get(nameForCopy);
    if (original != null) {
      original.copy(layer, false);
    }
  }
  myLayers.put(name, layer);
  if (activate) {
    setCurrentLayerSafe(name);
  }
  return layer;
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@Override
public boolean removeLayer(@Nonnull String name, boolean initDefault) {
  assertWritable();
  ModuleRootLayerImpl removedLayer = myLayers.remove(name);
  if (removedLayer != null) {
    Disposer.dispose(removedLayer);

    if (initDefault && myLayers.isEmpty()) {
      initDefaultLayer(null);
    }

    if (Comparing.equal(myCurrentLayerName, name)) {
      setCurrentLayerSafe(myLayers.isEmpty() ? null : ContainerUtil.getFirstItem(myLayers.keySet()));
    }
  }
  return removedLayer != null;
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@Override
public void removeAllLayers(boolean initDefault) {
  assertWritable();

  for (ModuleRootLayerImpl layer : myLayers.values()) {
    Disposer.dispose(layer);
  }
  myLayers.clear();

  if (initDefault) {
    initDefaultLayer(null);
  }
  else {
    setCurrentLayerSafe(null);
  }
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@NotNull
@Override
public DotNetLibraryOrderEntryImpl loadOrderEntry(@NotNull Element element, @NotNull ModuleRootLayer moduleRootLayer) throws InvalidDataException
{
	String name = element.getAttributeValue("name");
	if(name.endsWith(".dll"))
	{
		int lastIndex = name.lastIndexOf(".dll");
		name = name.substring(0, lastIndex);
	}
	return new DotNetLibraryOrderEntryImpl((ModuleRootLayerImpl) moduleRootLayer, name);
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@NotNull
@Override
public CellAppearanceEx getCellAppearance(@NotNull DotNetLibraryOrderEntryImpl dotNetLibraryOrderEntry)
{
	ModuleRootLayerImpl moduleRootLayer = dotNetLibraryOrderEntry.getModuleRootLayer();

	DotNetSimpleModuleExtension extension = moduleRootLayer.getExtension(DotNetSimpleModuleExtension.class);

	ModuleExtensionProviderEP providerEP = extension == null ? null : ModuleExtensionProviders.findProvider(extension.getId());

	return SimpleTextCellAppearance.synthetic(dotNetLibraryOrderEntry.getPresentableName(), providerEP == null ? AllIcons.Toolbar.Unknown :
			providerEP.getIcon());
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
public DotNetLibraryOrderEntryImpl(@NotNull ModuleRootLayerImpl rootLayer, String name, boolean init)
{
	super(DotNetLibraryOrderEntryType.getInstance(), rootLayer, ProjectRootManagerImpl.getInstanceImpl(rootLayer.getProject()));
	myName = name;
	if(init)
	{
		init();

		myProjectRootManagerImpl.addOrderWithTracking(this);
	}
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@Nonnull
@Override
public ModuleExtensionWithSdkOrderEntryImpl loadOrderEntry(@Nonnull Element element, @Nonnull ModuleRootLayer moduleRootLayer) throws InvalidDataException {
  String moduleExtensionId = element.getAttributeValue(EXTENSION_ID_ATTRIBUTE);
  if (moduleExtensionId == null) {
    throw new InvalidDataException();
  }
  return new ModuleExtensionWithSdkOrderEntryImpl(moduleExtensionId, (ModuleRootLayerImpl)moduleRootLayer, false);
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@Nonnull
@Override
public LibraryOrderEntryImpl loadOrderEntry(@Nonnull Element element, @Nonnull ModuleRootLayer moduleRootLayer) throws InvalidDataException {
  String name = element.getAttributeValue(NAME_ATTR);
  if (name == null) {
    throw new InvalidDataException();
  }

  String level = element.getAttributeValue(LEVEL_ATTR, LibraryTablesRegistrar.PROJECT_LEVEL);
  DependencyScope dependencyScope = DependencyScope.readExternal(element);
  boolean exported = element.getAttributeValue(EXPORTED_ATTR) != null;
  return new LibraryOrderEntryImpl(name, level, (ModuleRootLayerImpl)moduleRootLayer, dependencyScope, exported, false);
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@Nonnull
@Override
public ModuleOrderEntryImpl loadOrderEntry(@Nonnull Element element, @Nonnull ModuleRootLayer moduleRootLayer) throws InvalidDataException {
  String moduleName = element.getAttributeValue(MODULE_NAME_ATTR);
  if (moduleName == null) {
    throw new InvalidDataException();
  }
  DependencyScope dependencyScope = DependencyScope.readExternal(element);
  boolean exported = element.getAttributeValue(EXPORTED_ATTR) != null;
  boolean productionOnTestDependency = element.getAttributeValue(PRODUCTION_ON_TEST_ATTRIBUTE) != null;
  return new ModuleOrderEntryImpl(moduleName, (ModuleRootLayerImpl)moduleRootLayer, dependencyScope, exported, productionOnTestDependency);
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@Nonnull
@Override
public ModuleLibraryOrderEntryImpl loadOrderEntry(@Nonnull Element element, @Nonnull ModuleRootLayer moduleRootLayer) throws InvalidDataException {
  boolean exported = element.getAttributeValue(EXPORTED_ATTR) != null;
  DependencyScope scope = DependencyScope.readExternal(element);
  Library library = LibraryTableImplUtil.loadLibrary(element, (ModuleRootLayerImpl)moduleRootLayer);
  return new ModuleLibraryOrderEntryImpl(library, (ModuleRootLayerImpl)moduleRootLayer, exported, scope, false);
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
public ModuleExtensionWithSdkOrderEntryImpl(@Nonnull String moduleExtensionId, @Nonnull ModuleRootLayerImpl rootModel, boolean init) {
  super(ModuleExtensionWithSdkOrderEntryType.getInstance(), rootModel, ProjectRootManagerImpl.getInstanceImpl(rootModel.getProject()));
  myModuleExtensionId = moduleExtensionId;
  if (init) {
    init();

    myProjectRootManagerImpl.addOrderWithTracking(this);
  }
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
public ContentEntryImpl(@Nonnull Element e, @Nonnull ModuleRootLayerImpl m) {
  this(getUrlFrom(e), m);

  for (Element child : e.getChildren(ContentFolderImpl.ELEMENT_NAME)) {
    myContentFolders.add(new ContentFolderImpl(child, this));
  }
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@Override
@Nonnull
public ContentEntry cloneEntry(@Nonnull ModuleRootLayerImpl rootModel) {
  assert !isDisposed();

  ContentEntryImpl cloned = new ContentEntryImpl(myRoot.getUrl(), rootModel);
  for (ContentFolder contentFolder : myContentFolders) {
    if (contentFolder instanceof ClonableContentFolder) {
      ContentFolderImpl folder = (ContentFolderImpl)((ClonableContentFolder)contentFolder).cloneFolder(cloned);
      cloned.addFolder(folder);
    }
  }

  return cloned;
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@Nonnull
public Library cloneLibrary(ModuleRootLayerImpl moduleRootLayer) {
  LOG.assertTrue(myLibraryTable == null);
  final LibraryImpl clone = new LibraryImpl(this, null, moduleRootLayer);
  clone.myRootsWatcher.updateWatchedRoots();
  return clone;
}
 

import consulo.roots.impl.ModuleRootLayerImpl; //导入依赖的package包/类
@RequiredReadAction
RootModelImpl(@Nonnull RootModelImpl rootModel, @Nonnull ModuleRootManagerImpl moduleRootManager, @Nonnull RootConfigurationAccessor rootConfigurationAccessor) {
  myModuleRootManager = moduleRootManager;
  myWritable = true;
  myConfigurationAccessor = rootConfigurationAccessor;

  myLayers.clear();
  for (Map.Entry<String, ModuleRootLayerImpl> entry : rootModel.myLayers.entrySet()) {
    ModuleRootLayerImpl moduleRootLayer = new ModuleRootLayerImpl(entry.getValue(), this);
    myLayers.put(entry.getKey(), moduleRootLayer);
  }
  setCurrentLayerSafe(rootModel.myCurrentLayerName);
}