dom/openapi/src/com/intellij/util/xml/model/impl/BaseDomModelFactory.java

   1 package com.intellij.util.xml.model.impl;
   2
   3 import com.intellij.openapi.project.Project;
   4 import com.intellij.openapi.roots.ProjectRootManager;
   5 import com.intellij.openapi.util.UserDataHolder;
   6 import com.intellij.psi.PsiElement;
   7 import com.intellij.psi.PsiFile;
   8 import com.intellij.psi.util.PsiModificationTracker;
   9 import com.intellij.psi.xml.XmlFile;
  10 import com.intellij.util.xml.DomElement;
  11 import com.intellij.util.xml.DomFileElement;
  12 import com.intellij.util.xml.ModelMerger;
  13 import com.intellij.util.xml.model.DomModel;
  14 import com.intellij.util.xml.model.MultipleDomModelFactory;
  15 import com.intellij.util.xml.model.SimpleModelFactory;
  16 import org.jetbrains.annotations.NonNls;
  17 import org.jetbrains.annotations.NotNull;
  18 import org.jetbrains.annotations.Nullable;
  19
  20 import java.util.ArrayList;
  21 import java.util.List;
  22 import java.util.Set;
  23
  24 /**
  25  * User: Sergey.Vasiliev
  26  */
  27 public abstract class BaseDomModelFactory<S extends UserDataHolder, T extends DomElement, M extends DomModel<T>, C extends PsiElement>
  28     extends DomModelFactoryHelper<T> implements SimpleModelFactory<T, M>, MultipleDomModelFactory<S, T, M> {
  29
  30   private Project myProject;
  31   private SimpleModelFactory<T,M> mySimpleDomModelFactory;
  32   private MultipleDomModelFactory<S, T, M> myMultipleDomModelFactory;
  33
  34   protected BaseDomModelFactory(@NotNull Class<T> aClass, @NotNull ModelMerger modelMerger, final Project project, @NonNls String name) {
  35     super(aClass, modelMerger);
  36
  37     myProject = project;
  38
  39     mySimpleDomModelFactory = createSimpleModelFactory(aClass, modelMerger, project, name);
  40
  41     myMultipleDomModelFactory = createMultipleDomModelFactory(aClass, modelMerger, project, name);
  42   }
  43
  44   protected abstract S getModelScope(final XmlFile file);
  45
  46   @Nullable
  47   protected abstract List<M> computeAllModels(@NotNull S scope);
  48
  49   protected abstract M createCombinedModel(Set<XmlFile> configFiles, DomFileElement<T> mergedModel, M firstModel, final S scope);
  50
  51   @Nullable
  52   public M getModel(@NotNull C context){
  53     final PsiFile psiFile = context.getContainingFile();
  54     if (psiFile instanceof XmlFile) {
  55       return getModelByConfigFile((XmlFile)psiFile);
  56     }
  57     return null;
  58   }
  59
  60   @NotNull
  61   public List<M> getAllModels(@NotNull S scope) {
  62     return myMultipleDomModelFactory.getAllModels(scope);
  63   }
  64
  65   @Nullable
  66   public M getModelByConfigFile(@Nullable XmlFile psiFile) {
  67     return mySimpleDomModelFactory.getModelByConfigFile(psiFile);
  68   }
  69
  70   @NotNull
  71   public Object[] computeDependencies(@Nullable M model, @Nullable S scope) {
  72
  73     final ArrayList<Object> dependencies = new ArrayList<Object>();
  74     final Set<XmlFile> files;
  75     if (model != null) {
  76       files = model.getConfigFiles();
  77       dependencies.addAll(files);
  78     }
  79     else {
  80       dependencies.add(PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT);
  81     }
  82     if (scope != null) {
  83       dependencies.add(ProjectRootManager.getInstance(getProject()));
  84     }
  85     return dependencies.toArray(new Object[dependencies.size()]);
  86   }
  87
  88   @Nullable
  89   protected M computeModel(@NotNull XmlFile psiFile, @Nullable S scope) {
  90     if (scope == null) {
  91       return null;
  92     }
  93     final List<M> models = getAllModels(scope);
  94     for (M model : models) {
  95       final Set<XmlFile> configFiles = model.getConfigFiles();
  96       if (configFiles.contains(psiFile)) {
  97         return model;
  98       }
  99     }
 100     return null;
 101   }
 102
 103   @Nullable
 104   public M getCombinedModel(@Nullable S scope) {
 105     return myMultipleDomModelFactory.getCombinedModel(scope);
 106   }
 107
 108   @NotNull
 109   public Set<XmlFile> getAllConfigFiles(@NotNull S scope) {
 110     return myMultipleDomModelFactory.getAllConfigFiles(scope);
 111   }
 112
 113   @NotNull
 114   public DomFileElement<T> createMergedModelRoot(final Set<XmlFile> configFiles) {
 115     return mySimpleDomModelFactory.createMergedModelRoot(configFiles);
 116   }
 117
 118   private CachedMultipleDomModelFactory<S, T, M, C> createMultipleDomModelFactory(final Class<T> aClass,
 119                                                                                   final ModelMerger modelMerger,
 120                                                                                   final Project project,
 121                                                                                   final String name) {
 122     return new CachedMultipleDomModelFactory<S, T, M, C>(aClass, modelMerger, project, name) {
 123       public M getModel(@NotNull final C context) {
 124         return BaseDomModelFactory.this.getModel(context);
 125       }
 126
 127       protected List<M> computeAllModels(@NotNull final S scope) {
 128         return BaseDomModelFactory.this.computeAllModels(scope);
 129       }
 130
 131       protected M createCombinedModel(final Set<XmlFile> configFiles,
 132                                       final DomFileElement<T> mergedModel,
 133                                       final M firstModel,
 134                                       final S scope) {
 135         return BaseDomModelFactory.this.createCombinedModel(configFiles, mergedModel, firstModel, scope);
 136       }
 137
 138       @NotNull
 139       public Object[] computeDependencies(@Nullable final M model, @Nullable final S scope) {
 140         return BaseDomModelFactory.this.computeDependencies(model, scope);
 141       }
 142
 143       public S getModelScope(@NotNull final XmlFile xmlFile) {
 144         return BaseDomModelFactory.this.getModelScope(xmlFile);
 145       }
 146     };
 147   }
 148
 149   private CachedSimpleDomModelFactory<T, M, S> createSimpleModelFactory(final Class<T> aClass,
 150                                                                         final ModelMerger modelMerger,
 151                                                                         final Project project,
 152                                                                         final String name) {
 153     return new CachedSimpleDomModelFactory<T, M, S>(aClass, modelMerger, project, name) {
 154
 155       protected M computeModel(@NotNull final XmlFile psiFile, @Nullable final S scope) {
 156         return BaseDomModelFactory.this.computeModel(psiFile, scope);
 157       }
 158
 159       @NotNull
 160       public Object[] computeDependencies(@Nullable final M model, @Nullable final S scope) {
 161         return BaseDomModelFactory.this.computeDependencies(model, scope);
 162       }
 163
 164       public S getModelScope(@NotNull XmlFile file) {
 165         return BaseDomModelFactory.this.getModelScope(file);
 166       }
 167     };
 168   }
 169
 170   public Project getProject() {
 171     return myProject;
 172   }
 173 }