[workspace model] provide implementation of FacetManager which stores data in workspa...
[idea/community.git] / platform / lang-impl / src / com / intellij / facet / FacetManagerBase.java
1 // Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
2 package com.intellij.facet;
3
4 import com.intellij.facet.impl.FacetLoadingErrorDescription;
5 import com.intellij.facet.impl.invalid.InvalidFacet;
6 import com.intellij.facet.impl.invalid.InvalidFacetConfiguration;
7 import com.intellij.facet.impl.invalid.InvalidFacetManager;
8 import com.intellij.facet.impl.invalid.InvalidFacetType;
9 import com.intellij.openapi.diagnostic.Logger;
10 import com.intellij.openapi.module.Module;
11 import com.intellij.openapi.module.ProjectLoadingErrorsNotifier;
12 import com.intellij.openapi.project.Project;
13 import com.intellij.openapi.updateSettings.impl.pluginsAdvertisement.UnknownFeaturesCollector;
14 import com.intellij.openapi.util.Comparing;
15 import com.intellij.openapi.util.text.StringUtil;
16 import org.jetbrains.annotations.ApiStatus;
17 import org.jetbrains.annotations.NotNull;
18 import org.jetbrains.annotations.Nullable;
19 import org.jetbrains.annotations.TestOnly;
20 import org.jetbrains.jps.model.serialization.facet.FacetState;
21
22 import java.util.Collection;
23
24 @ApiStatus.Internal
25 public abstract class FacetManagerBase extends FacetManager {
26   private static final Logger LOG = Logger.getInstance(FacetManagerBase.class);
27
28   @Override
29   @NotNull
30   public <F extends Facet<?>, C extends FacetConfiguration> F createFacet(@NotNull final FacetType<F, C> type, @NotNull final String name, @NotNull final C configuration,
31                                                                           @Nullable final Facet<?> underlying) {
32     return createFacet(getModule(), type, name, configuration, underlying);
33   }
34
35   @ApiStatus.Internal
36   public static void setFacetName(Facet<?> facet, String newName) {
37     facet.setName(newName);
38   }
39
40   @NotNull
41   private static <F extends Facet<?>, C extends FacetConfiguration> F createFacet(@NotNull Module module, @NotNull FacetType<F, C> type,
42                                                                                   @NotNull String name,
43                                                                                   @NotNull C configuration,
44                                                                                   @Nullable Facet<?> underlying) {
45     final F facet = type.createFacet(module, name, configuration, underlying);
46     assertTrue(facet.getModule() == module, facet, "module");
47     assertTrue(facet.getConfiguration() == configuration, facet, "configuration");
48     assertTrue(Comparing.equal(facet.getName(), name), facet, "name");
49     assertTrue(facet.getUnderlyingFacet() == underlying, facet, "underlyingFacet");
50     return facet;
51   }
52
53   @Override
54   @NotNull
55   public <F extends Facet<?>, C extends FacetConfiguration> F createFacet(@NotNull final FacetType<F, C> type, @NotNull final String name, @Nullable final Facet<?> underlying) {
56     C configuration = ProjectFacetManager.getInstance(getModule().getProject()).createDefaultConfiguration(type);
57     return createFacet(type, name, configuration, underlying);
58   }
59
60   @Override
61   @NotNull
62   public <F extends Facet<?>, C extends FacetConfiguration> F addFacet(@NotNull final FacetType<F, C> type, @NotNull final String name, @Nullable final Facet<?> underlying) {
63     final ModifiableFacetModel model = createModifiableModel();
64     final F facet = createFacet(type, name, underlying);
65     model.addFacet(facet);
66     model.commit();
67     return facet;
68   }
69
70   @Override
71   public void facetConfigurationChanged(@NotNull Facet facet) {
72     getModule().getMessageBus().syncPublisher(FacetManager.FACETS_TOPIC).facetConfigurationChanged(facet);
73   }
74
75   @Override
76   @NotNull
77   public Facet<?>[] getAllFacets() {
78     return getModel().getAllFacets();
79   }
80
81   @Override
82   @Nullable
83   public <F extends Facet<?>> F getFacetByType(FacetTypeId<F> typeId) {
84     return getModel().getFacetByType(typeId);
85   }
86
87   protected abstract FacetModel getModel();
88
89   @Override
90   @Nullable
91   public <F extends Facet<?>> F findFacet(final FacetTypeId<F> type, final String name) {
92     return getModel().findFacet(type, name);
93   }
94
95   @Override
96   @Nullable
97   public <F extends Facet<?>> F getFacetByType(@NotNull final Facet<?> underlyingFacet, final FacetTypeId<F> typeId) {
98     return getModel().getFacetByType(underlyingFacet, typeId);
99   }
100
101   @Override
102   @NotNull
103   public <F extends Facet<?>> Collection<F> getFacetsByType(@NotNull final Facet<?> underlyingFacet, final FacetTypeId<F> typeId) {
104     return getModel().getFacetsByType(underlyingFacet, typeId);
105   }
106
107   @Override
108   @NotNull
109   public <F extends Facet<?>> Collection<F> getFacetsByType(FacetTypeId<F> typeId) {
110     return getModel().getFacetsByType(typeId);
111   }
112
113   @Override
114   @NotNull
115   public Facet<?>[] getSortedFacets() {
116     return getModel().getSortedFacets();
117   }
118
119   @Override
120   @NotNull
121   public String getFacetName(@NotNull Facet<?> facet) {
122     return getModel().getFacetName(facet);
123   }
124
125   protected abstract Module getModule();
126
127   @ApiStatus.Internal
128   @NotNull
129   public static InvalidFacet createInvalidFacet(@NotNull Module module, @NotNull FacetState state, @Nullable Facet<?> underlyingFacet,
130                                                 @NotNull String errorMessage,
131                                                 boolean unknownType) {
132     Project project = module.getProject();
133     final InvalidFacetManager invalidFacetManager = InvalidFacetManager.getInstance(project);
134     final InvalidFacetType type = InvalidFacetType.getInstance();
135     final InvalidFacetConfiguration configuration = new InvalidFacetConfiguration(state, errorMessage);
136     final InvalidFacet facet = createFacet(module, type, StringUtil.notNullize(state.getName()), configuration, underlyingFacet);
137     if (!invalidFacetManager.isIgnored(facet)) {
138       FacetLoadingErrorDescription description = new FacetLoadingErrorDescription(facet);
139       ProjectLoadingErrorsNotifier.getInstance(project).registerError(description);
140       if (unknownType) {
141         UnknownFeaturesCollector.getInstance(project).registerUnknownFeature("com.intellij.facetType", state.getFacetType(), "Facet");
142       }
143     }
144     return facet;
145   }
146
147   private static void assertTrue(final boolean value, final Facet<?> facet, final String parameter) {
148     if (!value) {
149       LOG.error("Facet type " + facet.getType().getClass().getName() + " violates the contract of FacetType.createFacet method about '" +
150                parameter + "' parameter");
151     }
152   }
153
154   @TestOnly
155   public void checkConsistency() {
156   }
157 }