platform/platform-impl/src/com/intellij/openapi/components/impl/stores/XmlElementStorage.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.openapi.components.impl.stores;
  17
  18 import com.intellij.application.options.PathMacrosCollector;
  19 import com.intellij.openapi.Disposable;
  20 import com.intellij.openapi.components.*;
  21 import com.intellij.openapi.diagnostic.Logger;
  22 import com.intellij.openapi.extensions.ExtensionPoint;
  23 import com.intellij.openapi.extensions.Extensions;
  24 import com.intellij.openapi.options.StreamProvider;
  25 import com.intellij.openapi.util.Disposer;
  26 import com.intellij.openapi.util.JDOMUtil;
  27 import com.intellij.openapi.util.Pair;
  28 import com.intellij.openapi.util.WriteExternalException;
  29 import com.intellij.openapi.vfs.VirtualFile;
  30 import com.intellij.util.containers.StringInterner;
  31 import com.intellij.util.io.fs.IFile;
  32 import org.jdom.Attribute;
  33 import org.jdom.Document;
  34 import org.jdom.Element;
  35 import org.jetbrains.annotations.NonNls;
  36 import org.jetbrains.annotations.NotNull;
  37 import org.jetbrains.annotations.Nullable;
  38
  39 import java.io.IOException;
  40 import java.util.*;
  41
  42 public abstract class XmlElementStorage implements StateStorage, Disposable {
  43   @NonNls private static final Set<String> OBSOLETE_COMPONENT_NAMES = new HashSet<String>(Arrays.asList(
  44     "Palette"
  45   ));
  46   private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.components.impl.stores.XmlElementStorage");
  47
  48   @NonNls private static final String COMPONENT = "component";
  49   @NonNls private static final String ATTR_NAME = "name";
  50   @NonNls private static final String NAME = ATTR_NAME;
  51
  52   protected TrackingPathMacroSubstitutor myPathMacroSubstitutor;
  53   @NotNull private final String myRootElementName;
  54   private Object mySession;
  55   private StorageData myLoadedData;
  56   protected static StringInterner ourInterner = new StringInterner();
  57   protected final StreamProvider myStreamProvider;
  58   protected final String myFileSpec;
  59   private final ComponentRoamingManager myComponentRoamingManager;
  60   protected final boolean myIsProjectSettings;
  61   protected boolean myBlockSavingTheContent = false;
  62   protected Integer myUpToDateHash;
  63   protected Integer myProviderUpToDateHash;
  64   private boolean mySavingDisabled = false;
  65
  66   private final Map<String, Element> myStorageComponentStates = new TreeMap<String, Element>();
  67
  68   private final ComponentVersionProvider myLocalVersionProvider;
  69   private final ComponentVersionProvider myRemoteVersionProvider;
  70
  71   protected Map<String, Long> myProviderVersions = null;
  72
  73   protected ComponentVersionListener myListener = new ComponentVersionListener(){
  74     public void componentStateChanged(String componentName) {
  75       myLocalVersionProvider.changeVersion(componentName,  System.currentTimeMillis());
  76     }
  77   };
  78
  79
  80   protected XmlElementStorage(@Nullable final TrackingPathMacroSubstitutor pathMacroSubstitutor,
  81                               @NotNull Disposable parentDisposable,
  82                               @NotNull String rootElementName,
  83                               StreamProvider streamProvider,
  84                               String fileSpec,
  85                               ComponentRoamingManager componentRoamingManager, ComponentVersionProvider localComponentVersionsProvider) {
  86     myPathMacroSubstitutor = pathMacroSubstitutor;
  87     myRootElementName = rootElementName;
  88     myStreamProvider = streamProvider;
  89     myFileSpec = fileSpec;
  90     myComponentRoamingManager = componentRoamingManager;
  91     Disposer.register(parentDisposable, this);
  92     myIsProjectSettings = "$PROJECT_FILE$".equals(myFileSpec) || myFileSpec.startsWith("$PROJECT_CONFIG_DIR$");
  93
  94     myLocalVersionProvider = localComponentVersionsProvider;
  95
  96     myRemoteVersionProvider = new ComponentVersionProvider(){
  97       public long getVersion(String name) {
  98         if (myProviderVersions == null) {
  99           loadProviderVersions();
 100         }
 101
 102         return myProviderVersions.containsKey(name) ? myProviderVersions.get(name).longValue() : 0;
 103
 104       }
 105
 106       public void changeVersion(String name, long version) {
 107         if (myProviderVersions == null) {
 108           loadProviderVersions();
 109         }
 110
 111         myProviderVersions.put(name, version);
 112       }
 113     };
 114   }
 115
 116   @Nullable
 117   protected abstract Document loadDocument() throws StateStorageException;
 118
 119   @Nullable
 120   public synchronized Element getState(final String componentName) throws StateStorageException {
 121     final StorageData storageData = getStorageData(false);
 122     final Element state = storageData.getState(componentName);
 123
 124
 125
 126     if (state != null) {
 127       if (!myStorageComponentStates.containsKey(componentName)) {
 128         myStorageComponentStates.put(componentName, state);
 129       }
 130       storageData.removeState(componentName);
 131     }
 132
 133     return state;
 134   }
 135
 136   public boolean hasState(final Object component, final String componentName, final Class<?> aClass, final boolean reloadData) throws StateStorageException {
 137     final StorageData storageData = getStorageData(reloadData);
 138     return storageData.hasState(componentName);
 139   }
 140
 141   @Nullable
 142   public <T> T getState(final Object component, final String componentName, Class<T> stateClass, @Nullable T mergeInto) throws StateStorageException {
 143     final Element element = getState(componentName);
 144     return DefaultStateSerializer.deserializeState(element, stateClass, mergeInto);
 145   }
 146
 147   @NotNull
 148   protected StorageData getStorageData(final boolean reloadData) throws StateStorageException {
 149     if (myLoadedData != null && !reloadData) return myLoadedData;
 150
 151     myLoadedData = loadData(true, myListener);
 152
 153     return myLoadedData;
 154   }
 155
 156   @NotNull
 157   protected StorageData loadData(final boolean useProvidersData, ComponentVersionListener listener) throws StateStorageException {
 158     Document document = loadDocument();
 159
 160     StorageData result = createStorageData();
 161
 162     if (document != null) {
 163       loadState(result, document.getRootElement());
 164     }
 165     else {
 166       LOG.info("Document was not loaded for " + myFileSpec);
 167     }
 168
 169     if (!myIsProjectSettings && useProvidersData) {
 170       for (RoamingType roamingType : RoamingType.values()) {
 171         if (roamingType != RoamingType.DISABLED && roamingType != RoamingType.GLOBAL) {
 172           try {
 173             if (myStreamProvider.isEnabled()) {
 174               final Document sharedDocument = StorageUtil.loadDocument(myStreamProvider.loadContent(myFileSpec, roamingType));
 175
 176               if (sharedDocument != null) {
 177                 filterComponentsDisabledForRoaming(sharedDocument.getRootElement(), roamingType);
 178                 filterOutOfDateComponents(sharedDocument.getRootElement());
 179
 180                 loadState(result, sharedDocument.getRootElement());
 181               }
 182             }
 183           }
 184           catch (Exception e) {
 185             LOG.warn(e);
 186           }
 187         }
 188
 189       }
 190     }
 191
 192
 193     return result;
 194   }
 195
 196   protected void loadState(final StorageData result, final Element element) throws StateStorageException {
 197     if (myPathMacroSubstitutor != null) {
 198       myPathMacroSubstitutor.expandPaths(element);
 199     }
 200
 201     JDOMUtil.internElement(element, ourInterner);
 202
 203     try {
 204       result.load(element);
 205       result.checkUnknownMacros(myPathMacroSubstitutor);
 206     }
 207     catch (IOException e) {
 208       throw new StateStorageException(e);
 209     }
 210   }
 211
 212   @NotNull
 213   protected StorageData createStorageData() {
 214     return new StorageData(myRootElementName);
 215   }
 216
 217   public void setDefaultState(final Element element) {
 218     myLoadedData = createStorageData();
 219     try {
 220       loadState(myLoadedData, element);
 221     }
 222     catch (StateStorageException e) {
 223       LOG.error(e);
 224     }
 225   }
 226
 227   @NotNull
 228   public ExternalizationSession startExternalization() {
 229     try {
 230       final ExternalizationSession session = new MyExternalizationSession(getStorageData(false).clone(), myListener);
 231
 232       mySession = session;
 233       return session;
 234     }
 235     catch (StateStorageException e) {
 236       throw new RuntimeException(e);
 237     }
 238   }
 239
 240   @NotNull
 241   public SaveSession startSave(final ExternalizationSession externalizationSession) {
 242     assert mySession == externalizationSession;
 243
 244     final SaveSession saveSession = mySavingDisabled ? createNullSession() : createSaveSession((MyExternalizationSession)externalizationSession);
 245     mySession = saveSession;
 246     return saveSession;
 247   }
 248
 249   private SaveSession createNullSession() {
 250     return new SaveSession(){
 251       public void save() throws StateStorageException {
 252
 253       }
 254
 255       public Set<String> analyzeExternalChanges(final Set<Pair<VirtualFile, StateStorage>> changedFiles) {
 256         return Collections.emptySet();
 257       }
 258
 259       public Collection<IFile> getStorageFilesToSave() throws StateStorageException {
 260         return Collections.emptySet();
 261       }
 262
 263       public List<IFile> getAllStorageFiles() {
 264         return Collections.emptyList();
 265       }
 266     };
 267   }
 268
 269   protected abstract MySaveSession createSaveSession(final MyExternalizationSession externalizationSession);
 270
 271   public void finishSave(final SaveSession saveSession) {
 272     try {
 273       LOG.assertTrue(mySession == saveSession, "mySession=" + mySession + " saveSession=" + saveSession);
 274     } finally {
 275       mySession = null;
 276     }
 277   }
 278
 279   public void disableSaving() {
 280     mySavingDisabled = true;
 281   }
 282
 283   protected class MyExternalizationSession implements ExternalizationSession {
 284     private final StorageData myStorageData;
 285     private final ComponentVersionListener myListener;
 286
 287     public MyExternalizationSession(final StorageData storageData, ComponentVersionListener listener) {
 288       myStorageData = storageData;
 289       myListener = listener;
 290     }
 291
 292     public void setState(final Object component, final String componentName, final Object state, final Storage storageSpec) throws StateStorageException {
 293       assert mySession == this;
 294
 295       try {
 296         setState(componentName, DefaultStateSerializer.serializeState(state, storageSpec));
 297       }
 298       catch (WriteExternalException e) {
 299         LOG.debug(e);
 300       }
 301     }
 302
 303     private synchronized void setState(final String componentName, final Element element)  {
 304       if (element.getAttributes().isEmpty() && element.getChildren().isEmpty()) return;
 305
 306       myStorageData.setState(componentName, element);
 307
 308       Element oldElement = myStorageComponentStates.get(componentName);
 309       try {
 310         if (oldElement != null && !JDOMUtil.areElementsEqual(oldElement, element)) {
 311           myListener.componentStateChanged(componentName);
 312         }
 313       }
 314       finally {
 315         myStorageComponentStates.put(componentName, (Element)element.clone());
 316       }
 317
 318
 319
 320     }
 321   }
 322
 323   protected Document getDocument(StorageData data)  {
 324     final Element element = data.save();
 325
 326     if (myPathMacroSubstitutor != null) {
 327       try {
 328         myPathMacroSubstitutor.collapsePaths(element);
 329       } finally {
 330         myPathMacroSubstitutor.reset();
 331       }
 332     }
 333
 334     return new Document(element);
 335   }
 336
 337   protected abstract class MySaveSession implements SaveSession {
 338     StorageData myStorageData;
 339     private Document myDocumentToSave;
 340
 341     public MySaveSession(MyExternalizationSession externalizationSession) {
 342       myStorageData = externalizationSession.myStorageData;
 343
 344     }
 345
 346     public final boolean needsSave() throws StateStorageException {
 347       assert mySession == this;
 348       return _needsSave(calcHash());
 349     }
 350
 351     private boolean _needsSave(final Integer hash) {
 352       if (myBlockSavingTheContent) return false;
 353       if (myUpToDateHash == null) {
 354         if (hash != null) {
 355           if (!physicalContentNeedsSave()) {
 356             myUpToDateHash = hash;
 357             return false;
 358           }
 359           else {
 360             return true;
 361           }
 362         }
 363         else {
 364           return true;
 365         }
 366       }
 367       else {
 368         if (hash != null) {
 369           if (hash.intValue() == myUpToDateHash.intValue()) {
 370             return false;
 371           }
 372           if (!physicalContentNeedsSave()) {
 373             myUpToDateHash = hash;
 374             return false;
 375           }
 376           else {
 377             return true;
 378           }
 379
 380         }
 381         else {
 382           return physicalContentNeedsSave();
 383         }
 384
 385       }
 386     }
 387
 388     protected boolean physicalContentNeedsSave() {
 389       return true;
 390     }
 391
 392     protected abstract void doSave() throws StateStorageException;
 393
 394     public void clearHash() {
 395       myUpToDateHash = null;
 396     }
 397
 398     protected Integer calcHash() {
 399       return null;
 400     }
 401
 402     public final void save() throws StateStorageException {
 403       assert mySession == this;
 404
 405       if (myBlockSavingTheContent) return;
 406
 407       Integer hash = calcHash();
 408
 409       try {
 410         saveForProviders(hash);
 411       }
 412       finally {
 413         saveLocally(hash);
 414       }
 415     }
 416
 417     private void saveLocally(final Integer hash) {
 418       try {
 419         if (!isHashUpToDate(hash)) {
 420           if (_needsSave(hash)) {
 421             doSave();
 422           }
 423         }
 424       }
 425       finally {
 426         myUpToDateHash = hash;
 427       }
 428     }
 429
 430     private void saveForProviders(final Integer hash) {
 431       if (myProviderUpToDateHash == null || !myProviderUpToDateHash.equals(hash)) {
 432         try {
 433           if (!myIsProjectSettings) {
 434             for (RoamingType roamingType : RoamingType.values()) {
 435               if (roamingType != RoamingType.DISABLED) {
 436                 try {
 437                   Document copy = (Document)getDocumentToSave().clone();
 438                   filterComponentsDisabledForRoaming(copy.getRootElement(), roamingType);
 439
 440                   if (copy.getRootElement().getChildren().size() > 0) {
 441                     StorageUtil.sendContent(myStreamProvider, myFileSpec, copy, roamingType, true);
 442                     Document versionDoc = createVersionDocument(copy);
 443                     if (versionDoc.getRootElement().getChildren().size() > 0) {
 444                       StorageUtil.sendContent(myStreamProvider, myFileSpec + ".ver", versionDoc, roamingType, true);
 445                     }
 446                   }
 447                 }
 448                 catch (IOException e) {
 449                   LOG.warn(e);
 450                 }
 451               }
 452
 453             }
 454           }
 455         }
 456         finally {
 457           myProviderUpToDateHash = hash;
 458         }
 459
 460       }
 461     }
 462
 463     private boolean isHashUpToDate(final Integer hash) {
 464       return myUpToDateHash != null && myUpToDateHash.equals(hash);
 465     }
 466
 467     public boolean isHashUpToDate() {
 468       return isHashUpToDate(calcHash());
 469     }
 470
 471     protected Document getDocumentToSave()  {
 472       if (myDocumentToSave != null) return myDocumentToSave;
 473
 474       final Element element = myStorageData.save();
 475       myDocumentToSave = new Document(element);
 476
 477       if (myPathMacroSubstitutor != null) {
 478         myPathMacroSubstitutor.collapsePaths(element);
 479       }
 480
 481       return myDocumentToSave;
 482     }
 483
 484     public StorageData getData() {
 485       return myStorageData;
 486     }
 487
 488     @Nullable
 489     public Set<String> analyzeExternalChanges(final Set<Pair<VirtualFile,StateStorage>> changedFiles) {
 490       try {
 491         Document document = loadDocument();
 492
 493         StorageData storageData = createStorageData();
 494
 495         if (document != null) {
 496           loadState(storageData, document.getRootElement());
 497           return storageData.getDifference(myStorageData, myPathMacroSubstitutor);
 498         }
 499         else {
 500           return Collections.emptySet();
 501         }
 502
 503
 504       }
 505       catch (StateStorageException e) {
 506         LOG.info(e);
 507       }
 508
 509       return null;
 510     }
 511   }
 512
 513   private Document createVersionDocument(Document copy) {
 514     return new Document(StateStorageManagerImpl.createComponentVersionsXml(loadVersions(copy)));
 515   }
 516
 517   private Map<String, Long> loadVersions(Document copy) {
 518
 519     HashMap<String, Long> result = new HashMap<String, Long>();
 520
 521     List list = copy.getRootElement().getChildren(COMPONENT);
 522     for (Object o : list) {
 523       if (o instanceof Element) {
 524         Element component = (Element)o;
 525         String name = component.getAttributeValue(ATTR_NAME);
 526         if (name != null) {
 527           long version = myLocalVersionProvider.getVersion(name);
 528           if (version != 0) {
 529             result.put(name, version);
 530           }
 531         }
 532       }
 533     }
 534
 535     return result;
 536   }
 537
 538   public void dispose() {
 539   }
 540
 541   protected static class StorageData {
 542     private final Map<String, Element> myComponentStates;
 543     protected final String myRootElementName;
 544     private Integer myHash;
 545
 546     public StorageData(final String rootElementName) {
 547       myComponentStates = new TreeMap<String, Element>();
 548       myRootElementName = rootElementName;
 549     }
 550
 551     protected StorageData(StorageData storageData) {
 552       myRootElementName = storageData.myRootElementName;
 553       myComponentStates = new TreeMap<String, Element>(storageData.myComponentStates);
 554     }
 555
 556     protected void load(@NotNull Element rootElement) throws IOException {
 557       final Element[] elements = JDOMUtil.getElements(rootElement);
 558       for (Element element : elements) {
 559         if (element.getName().equals(COMPONENT)) {
 560           final String name = element.getAttributeValue(NAME);
 561
 562           if (name == null) {
 563             LOG.info("Broken content in file : " + this);
 564             continue;
 565           }
 566
 567           if (OBSOLETE_COMPONENT_NAMES.contains(name)) continue;
 568
 569           element.detach();
 570
 571           if (element.getAttributes().size() > 1 || !element.getChildren().isEmpty()) {
 572             assert element.getAttributeValue(NAME) != null : "No name attribute for component: " + name + " in " + this;
 573
 574             Element existingElement = myComponentStates.get(name);
 575
 576             if (existingElement != null) {
 577               element = mergeElements(name, element, existingElement);
 578             }
 579
 580             myComponentStates.put(name, element);
 581           }
 582         }
 583       }
 584     }
 585
 586     private Element mergeElements(final String name, final Element element1, final Element element2) {
 587       ExtensionPoint<XmlConfigurationMerger> point = Extensions.getRootArea().getExtensionPoint("com.intellij.componentConfigurationMerger");
 588       XmlConfigurationMerger[] mergers = point.getExtensions();
 589       for (XmlConfigurationMerger merger : mergers) {
 590         if (merger.getComponentName().equals(name)) {
 591           return merger.merge(element1, element2);
 592         }
 593       }
 594       return element1;
 595     }
 596
 597     @NotNull
 598     protected Element save() {
 599       Element rootElement = new Element(myRootElementName);
 600
 601       for (String componentName : myComponentStates.keySet()) {
 602         assert componentName != null;
 603         final Element element = myComponentStates.get(componentName);
 604
 605         if (element.getAttribute(NAME) == null) element.setAttribute(NAME, componentName);
 606
 607         rootElement.addContent((Element)element.clone());
 608       }
 609
 610       return rootElement;
 611     }
 612
 613     @Nullable
 614     public Element getState(final String name) {
 615       final Element e = myComponentStates.get(name);
 616
 617       if (e != null) {
 618         assert e.getAttributeValue(NAME) != null : "No name attribute for component: " + name + " in " + this;
 619         e.removeAttribute(NAME);
 620       }
 621
 622       return e;
 623     }
 624
 625     public void removeState(final String componentName) {
 626       myComponentStates.remove(componentName);
 627       clearHash();
 628     }
 629
 630     private void setState(@NotNull final String componentName, final Element element) {
 631       element.setName(COMPONENT);
 632
 633       //componentName should be first!
 634       final List attributes = new ArrayList(element.getAttributes());
 635       for (Object attribute : attributes) {
 636         Attribute attr = (Attribute)attribute;
 637         element.removeAttribute(attr);
 638       }
 639
 640       element.setAttribute(NAME, componentName);
 641
 642       for (Object attribute : attributes) {
 643         Attribute attr = (Attribute)attribute;
 644         element.setAttribute(attr.getName(), attr.getValue());
 645       }
 646
 647       myComponentStates.put(componentName, element);
 648       clearHash();
 649     }
 650
 651     public StorageData clone() {
 652       return new StorageData(this);
 653     }
 654
 655     public final int getHash() {
 656       if (myHash == null) {
 657         myHash = computeHash();
 658       }
 659       return myHash.intValue();
 660     }
 661
 662     protected int computeHash() {
 663       int result = 0;
 664
 665       for (String name : myComponentStates.keySet()) {
 666         result = 31*result + name.hashCode();
 667         result = 31*result + JDOMUtil.getTreeHash(myComponentStates.get(name));
 668       }
 669
 670       return result;
 671     }
 672
 673     protected void clearHash() {
 674       myHash = null;
 675     }
 676
 677     public Set<String> getDifference(final StorageData storageData, PathMacroSubstitutor substitutor) {
 678       Set<String> bothStates = new HashSet<String>(myComponentStates.keySet());
 679       bothStates.retainAll(storageData.myComponentStates.keySet());
 680
 681       Set<String> diffs = new HashSet<String>();
 682       diffs.addAll(storageData.myComponentStates.keySet());
 683       diffs.addAll(myComponentStates.keySet());
 684       diffs.removeAll(bothStates);
 685
 686       for (String componentName : bothStates) {
 687         final Element e1 = myComponentStates.get(componentName);
 688         final Element e2 = storageData.myComponentStates.get(componentName);
 689
 690         // some configurations want to collapse path elements in writeExternal so make sure paths are expanded
 691         if (substitutor != null) {
 692           substitutor.expandPaths(e2);
 693         }
 694
 695         if (!JDOMUtil.areElementsEqual(e1, e2)) {
 696           diffs.add(componentName);
 697         }
 698       }
 699
 700
 701       return diffs;
 702     }
 703
 704     public boolean isEmpty() {
 705       return myComponentStates.size() == 0;
 706     }
 707
 708     public boolean hasState(final String componentName) {
 709         return myComponentStates.containsKey(componentName);
 710     }
 711
 712     public void checkUnknownMacros(TrackingPathMacroSubstitutor pathMacroSubstitutor) {
 713       for (String componentName : myComponentStates.keySet()) {
 714         final Set<String> unknownMacros = PathMacrosCollector.getMacroNames(myComponentStates.get(componentName));
 715         if (!unknownMacros.isEmpty()) {
 716           pathMacroSubstitutor.addUnknownMacros(componentName, unknownMacros);
 717         }
 718       }
 719     }
 720   }
 721
 722   public void resetData(){
 723     myLoadedData = null;
 724   }
 725
 726   public void reload(@NotNull final Set<String> changedComponents) throws StateStorageException {
 727     final StorageData storageData = loadData(false, myListener);
 728
 729     final StorageData oldLoadedData = myLoadedData;
 730
 731     if (oldLoadedData != null) {
 732       Set<String> componentsToRetain = new HashSet<String>(oldLoadedData.myComponentStates.keySet());
 733       componentsToRetain.addAll(changedComponents);
 734
 735       // add empty configuration tags for removed components
 736       for (String componentToRetain : componentsToRetain) {
 737         if (!storageData.myComponentStates.containsKey(componentToRetain) && myStorageComponentStates.containsKey(componentToRetain)) {
 738           Element emptyElement = new Element("component");
 739           LOG.info("Create empty component element for " + componentsToRetain);
 740           emptyElement.setAttribute(NAME, componentToRetain);
 741           storageData.myComponentStates.put(componentToRetain, emptyElement);
 742         }
 743       }
 744
 745       storageData.myComponentStates.keySet().retainAll(componentsToRetain);
 746     }
 747
 748     myLoadedData = storageData;
 749   }
 750
 751   private void filterComponentsDisabledForRoaming(final Element element, final RoamingType roamingType) {
 752     final List components = element.getChildren(COMPONENT);
 753
 754     List<Element> toDelete = new ArrayList<Element>();
 755
 756     for (Object componentObj : components) {
 757       final Element componentElement = (Element)componentObj;
 758       final String nameAttr = componentElement.getAttributeValue(NAME);
 759
 760       if (myComponentRoamingManager.getRoamingType(nameAttr) != roamingType) {
 761         toDelete.add(componentElement);
 762       }
 763     }
 764
 765     for (Element toDeleteElement : toDelete) {
 766       element.removeContent(toDeleteElement);
 767     }
 768   }
 769
 770   private void filterOutOfDateComponents(final Element element) {
 771     final List components = element.getChildren(COMPONENT);
 772
 773     List<Element> toDelete = new ArrayList<Element>();
 774
 775     for (Object componentObj : components) {
 776       final Element componentElement = (Element)componentObj;
 777       final String nameAttr = componentElement.getAttributeValue(NAME);
 778
 779       if (myRemoteVersionProvider.getVersion(nameAttr) <= myLocalVersionProvider.getVersion(nameAttr)) {
 780         toDelete.add(componentElement);
 781       }
 782       else {
 783         myLocalVersionProvider.changeVersion(nameAttr, myRemoteVersionProvider.getVersion(nameAttr));
 784       }
 785     }
 786
 787     for (Element toDeleteElement : toDelete) {
 788       element.removeContent(toDeleteElement);
 789     }
 790
 791   }
 792
 793   private void loadProviderVersions() {
 794     myProviderVersions = new TreeMap<String, Long>();
 795     for (RoamingType type : RoamingType.values()) {
 796       Document doc = null;
 797       if (myStreamProvider.isEnabled()) {
 798         try {
 799           doc = StorageUtil.loadDocument(myStreamProvider.loadContent(myFileSpec + ".ver", type));
 800         }
 801         catch (IOException e) {
 802           LOG.debug(e);
 803         }
 804       }
 805       if (doc != null) {
 806         StateStorageManagerImpl.loadComponentVersions(myProviderVersions, doc);
 807       }
 808
 809     }
 810   }
 811
 812 }