platform/lang-impl/src/com/intellij/facet/impl/ProjectFacetManagerImpl.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
  17 package com.intellij.facet.impl;
  18
  19 import com.intellij.facet.*;
  20 import com.intellij.openapi.components.PersistentStateComponent;
  21 import com.intellij.openapi.components.State;
  22 import com.intellij.openapi.components.Storage;
  23 import com.intellij.openapi.diagnostic.Logger;
  24 import com.intellij.openapi.module.Module;
  25 import com.intellij.openapi.module.ModuleManager;
  26 import com.intellij.openapi.project.Project;
  27 import com.intellij.openapi.util.InvalidDataException;
  28 import com.intellij.openapi.util.WriteExternalException;
  29 import com.intellij.util.xmlb.annotations.MapAnnotation;
  30 import com.intellij.util.xmlb.annotations.Tag;
  31 import org.jdom.Element;
  32 import org.jetbrains.annotations.NonNls;
  33 import org.jetbrains.annotations.NotNull;
  34
  35 import java.util.*;
  36
  37 /**
  38  * @author nik
  39  */
  40 @State(
  41     name = ProjectFacetManagerImpl.COMPONENT_NAME,
  42     storages = {
  43         @Storage(
  44             id="other",
  45             file="$PROJECT_FILE$"
  46         )
  47     }
  48 )
  49 public class ProjectFacetManagerImpl extends ProjectFacetManagerEx implements PersistentStateComponent<ProjectFacetManagerImpl.ProjectFacetManagerState> {
  50   @NonNls public static final String COMPONENT_NAME = "ProjectFacetManager";
  51   private static final Logger LOG = Logger.getInstance("#com.intellij.facet.impl.ProjectFacetManagerImpl");
  52   private ProjectFacetManagerState myState = new ProjectFacetManagerState();
  53   private Project myProject;
  54
  55   public ProjectFacetManagerImpl(Project project) {
  56     myProject = project;
  57   }
  58
  59   public ProjectFacetManagerState getState() {
  60     return myState;
  61   }
  62
  63   public void loadState(final ProjectFacetManagerState state) {
  64     myState = state;
  65   }
  66
  67   @Override
  68   public <F extends Facet> List<F> getFacets(@NotNull FacetTypeId<F> typeId) {
  69     return getFacets(typeId, ModuleManager.getInstance(myProject).getModules());
  70   }
  71
  72   @Override
  73   public <F extends Facet> List<F> getFacets(@NotNull FacetTypeId<F> typeId, final Module[] modules) {
  74     final List<F> result = new ArrayList<F>();
  75     for (Module module : modules) {
  76       result.addAll(FacetManager.getInstance(module).getFacetsByType(typeId));
  77     }
  78     return result;
  79   }
  80
  81   public <C extends FacetConfiguration> C createDefaultConfiguration(@NotNull final FacetType<?, C> facetType) {
  82     C configuration = facetType.createDefaultConfiguration();
  83     DefaultFacetConfigurationState state = myState.getDefaultConfigurations().get(facetType.getStringId());
  84     if (state != null) {
  85       Element defaultConfiguration = state.getDefaultConfiguration();
  86       try {
  87         FacetUtil.loadFacetConfiguration(configuration, defaultConfiguration);
  88       }
  89       catch (InvalidDataException e) {
  90         LOG.info(e);
  91       }
  92     }
  93     return configuration;
  94   }
  95
  96   public <C extends FacetConfiguration> void setDefaultConfiguration(@NotNull final FacetType<?, C> facetType, @NotNull final C configuration) {
  97     Map<String, DefaultFacetConfigurationState> defaultConfigurations = myState.getDefaultConfigurations();
  98     DefaultFacetConfigurationState state = defaultConfigurations.get(facetType.getStringId());
  99     if (state == null) {
 100       state = new DefaultFacetConfigurationState();
 101       defaultConfigurations.put(facetType.getStringId(), state);
 102     }
 103     try {
 104       Element element = FacetUtil.saveFacetConfiguration(configuration);
 105       state.setDefaultConfiguration(element);
 106     }
 107     catch (WriteExternalException e) {
 108       LOG.info(e);
 109     }
 110   }
 111
 112   @Tag("default-facet-configuration")
 113   public static class DefaultFacetConfigurationState {
 114     private Element myDefaultConfiguration;
 115
 116     @Tag("configuration")
 117     public Element getDefaultConfiguration() {
 118       return myDefaultConfiguration;
 119     }
 120
 121     public void setDefaultConfiguration(final Element defaultConfiguration) {
 122       myDefaultConfiguration = defaultConfiguration;
 123     }
 124   }
 125
 126   public static class ProjectFacetManagerState {
 127     private Map<String, DefaultFacetConfigurationState> myDefaultConfigurations = new HashMap<String, DefaultFacetConfigurationState>();
 128
 129     @Tag("default-configurations")
 130     @MapAnnotation(surroundWithTag = false, surroundKeyWithTag = false, surroundValueWithTag = false, //entryTagName = "default-configuration",
 131                    keyAttributeName = "facet-type")
 132     public Map<String, DefaultFacetConfigurationState> getDefaultConfigurations() {
 133       return myDefaultConfigurations;
 134     }
 135
 136     public void setDefaultConfigurations(final Map<String, DefaultFacetConfigurationState> defaultConfigurations) {
 137       myDefaultConfigurations = defaultConfigurations;
 138     }
 139   }
 140 }