lang-impl/src/com/intellij/openapi/components/impl/stores/ModuleStoreImpl.java

   1 package com.intellij.openapi.components.impl.stores;
   2
   3 import com.intellij.ide.impl.convert.ProjectConversionHelper;
   4 import com.intellij.openapi.application.ApplicationManager;
   5 import com.intellij.openapi.components.PathMacroManager;
   6 import com.intellij.openapi.components.StateStorage;
   7 import com.intellij.openapi.components.impl.ComponentManagerImpl;
   8 import com.intellij.openapi.diagnostic.Logger;
   9 import com.intellij.openapi.module.Module;
  10 import com.intellij.openapi.module.ModuleTypeManager;
  11 import com.intellij.openapi.module.impl.ModuleImpl;
  12 import com.intellij.openapi.project.ex.ProjectEx;
  13 import com.intellij.openapi.vfs.LocalFileSystem;
  14 import com.intellij.openapi.vfs.VirtualFile;
  15 import org.jdom.Attribute;
  16 import org.jdom.Element;
  17 import org.jetbrains.annotations.NonNls;
  18 import org.jetbrains.annotations.NotNull;
  19 import org.jetbrains.annotations.Nullable;
  20
  21 import java.io.File;
  22 import java.io.IOException;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Set;
  26 import java.util.TreeMap;
  27
  28 public class ModuleStoreImpl extends BaseFileConfigurableStoreImpl implements IModuleStore {
  29   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.components.impl.stores.ModuleStoreImpl");
  30   @NonNls private static final String MODULE_FILE_MACRO = "MODULE_FILE";
  31
  32   private ModuleImpl myModule;
  33
  34   public static final String DEFAULT_STATE_STORAGE = "$" + MODULE_FILE_MACRO + "$";
  35
  36
  37   @SuppressWarnings({"UnusedDeclaration"})
  38   public ModuleStoreImpl(final ComponentManagerImpl componentManager, final ModuleImpl module) {
  39     super(componentManager);
  40     myModule = module;
  41   }
  42
  43   protected XmlElementStorage getMainStorage() {
  44     final XmlElementStorage storage = (XmlElementStorage)getStateStorageManager().getFileStateStorage(DEFAULT_STATE_STORAGE);
  45     assert storage != null;
  46     return storage;
  47   }
  48
  49
  50
  51   @Override
  52   public void load() throws IOException, StateStorage.StateStorageException {
  53     super.load();
  54
  55     final ModuleFileData storageData = getMainStorageData();
  56     final String moduleTypeId = storageData.myOptions.get(ModuleImpl.ELEMENT_TYPE);
  57     myModule.setModuleType(ModuleTypeManager.getInstance().findByID(moduleTypeId));
  58   }
  59
  60
  61   public ModuleFileData getMainStorageData() throws StateStorage.StateStorageException {
  62     return (ModuleFileData)super.getMainStorageData();
  63   }
  64
  65   static class ModuleFileData extends BaseStorageData {
  66     private final Map<String, String> myOptions;
  67     private final Module myModule;
  68
  69     public ModuleFileData(final String rootElementName, Module module) {
  70       super(rootElementName);
  71       myModule = module;
  72       myOptions = new TreeMap<String, String>();
  73     }
  74
  75     protected ModuleFileData(final ModuleFileData storageData) {
  76       super(storageData);
  77
  78       myOptions = new TreeMap<String, String>(storageData.myOptions);
  79       myModule = storageData.myModule;
  80     }
  81
  82     protected void load(@NotNull final Element rootElement) throws IOException {
  83       final ProjectConversionHelper conversionHelper = getConversionHelper(myModule);
  84       if (conversionHelper != null) {
  85         conversionHelper.convertModuleRootToNewFormat(rootElement, myModule.getName());
  86         PathMacroManager.getInstance(myModule).expandPaths(rootElement);
  87       }
  88
  89       super.load(rootElement);
  90
  91       final List attributes = rootElement.getAttributes();
  92       for (Object attribute : attributes) {
  93         final Attribute attr = (Attribute)attribute;
  94         myOptions.put(attr.getName(), attr.getValue());
  95       }
  96     }
  97
  98     @NotNull
  99     protected Element save() {
 100       final Element root = super.save();
 101
 102       myOptions.put(VERSION_OPTION, Integer.toString(myVersion));
 103       Set<String> options = myOptions.keySet();
 104       for (String option : options) {
 105         root.setAttribute(option, myOptions.get(option));
 106       }
 107
 108       final ProjectConversionHelper conversionHelper = getConversionHelper(myModule);
 109       if (conversionHelper != null) {
 110         conversionHelper.convertModuleRootToOldFormat(root, myModule.getName());
 111       }
 112
 113       //need be last for compat reasons
 114       root.removeAttribute(VERSION_OPTION);
 115       root.setAttribute(VERSION_OPTION, Integer.toString(myVersion));
 116
 117       return root;
 118     }
 119
 120     public XmlElementStorage.StorageData clone() {
 121       return new ModuleFileData(this);
 122     }
 123
 124     protected int computeHash() {
 125       return super.computeHash()*31 + myOptions.hashCode();
 126     }
 127
 128     @Nullable
 129     public Set<String> getDifference(final XmlElementStorage.StorageData storageData) {
 130       final ModuleFileData data = (ModuleFileData)storageData;
 131       if (!myOptions.equals(data.myOptions)) return null;
 132       return super.getDifference(storageData);
 133     }
 134
 135     public void setOption(final String optionName, final String optionValue) {
 136       clearHash();
 137       myOptions.put(optionName, optionValue);
 138     }
 139
 140     public void clearOption(final String optionName) {
 141       clearHash();
 142       myOptions.remove(optionName);
 143     }
 144
 145     public String getOptionValue(final String optionName) {
 146       return myOptions.get(optionName);
 147     }
 148   }
 149
 150
 151   @Nullable
 152   private static ProjectConversionHelper getConversionHelper(Module module) {
 153     return (ProjectConversionHelper)module.getProject().getPicoContainer().getComponentInstance(ProjectConversionHelper.class);
 154   }
 155
 156   public void setModuleFilePath(@NotNull final String filePath) {
 157     final String path = filePath.replace(File.separatorChar, '/');
 158     ApplicationManager.getApplication().runWriteAction(new Runnable() {
 159       public void run() {
 160         LocalFileSystem.getInstance().refreshAndFindFileByPath(path);
 161       }
 162     });
 163     final StateStorageManager storageManager = getStateStorageManager();
 164     storageManager.clearStateStorage(DEFAULT_STATE_STORAGE);
 165     storageManager.addMacro(MODULE_FILE_MACRO, path);
 166   }
 167
 168   @Nullable
 169   public VirtualFile getModuleFile() {
 170     final FileBasedStorage storage = (FileBasedStorage)getStateStorageManager().getFileStateStorage(DEFAULT_STATE_STORAGE);
 171     assert storage != null;
 172     return storage.getVirtualFile();
 173   }
 174
 175   @NotNull
 176   public String getModuleFilePath() {
 177     final FileBasedStorage storage = (FileBasedStorage)getStateStorageManager().getFileStateStorage(DEFAULT_STATE_STORAGE);
 178     assert storage != null;
 179     return storage.getFilePath();
 180   }
 181
 182   @NotNull
 183   public String getModuleFileName() {
 184     final FileBasedStorage storage = (FileBasedStorage)getStateStorageManager().getFileStateStorage(DEFAULT_STATE_STORAGE);
 185     assert storage != null;
 186     return storage.getFileName();
 187   }
 188
 189   public void setSavePathsRelative(final boolean b) {
 190     super.setSavePathsRelative(b);
 191     setOption(RELATIVE_PATHS_OPTION, String.valueOf(b));
 192   }
 193
 194   public void setOption(final String optionName, final String optionValue) {
 195     try {
 196       getMainStorageData().setOption(optionName,  optionValue);
 197     }
 198     catch (StateStorage.StateStorageException e) {
 199       LOG.error(e);
 200     }
 201   }
 202
 203   public void clearOption(final String optionName) {
 204     try {
 205       getMainStorageData().clearOption(optionName);
 206     }
 207     catch (StateStorage.StateStorageException e) {
 208       LOG.error(e);
 209     }
 210   }
 211
 212   public String getOptionValue(final String optionName) {
 213     try {
 214       return getMainStorageData().getOptionValue(optionName);
 215     }
 216     catch (StateStorage.StateStorageException e) {
 217       LOG.error(e);
 218       return null;
 219     }
 220   }
 221
 222   @Override
 223   protected boolean optimizeTestLoading() {
 224     return ((ProjectEx)myModule.getProject()).isOptimiseTestLoadSpeed();
 225   }
 226
 227   protected StateStorageManager createStateStorageManager() {
 228     return new ModuleStateStorageManager(PathMacroManager.getInstance(getComponentManager()).createTrackingSubstitutor(), myModule);
 229   }
 230 }