[platform] get rid of some raw types in facets API and impl
[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   public Facet<?> @NotNull [] getAllFacets() {
77     return getModel().getAllFacets();
78   }
79
80   @Override
81   @Nullable
82   public <F extends Facet<?>> F getFacetByType(FacetTypeId<F> typeId) {
83     return getModel().getFacetByType(typeId);
84   }
85
86   protected abstract FacetModel getModel();
87
88   @Override
89   @Nullable
90   public <F extends Facet<?>> F findFacet(final FacetTypeId<F> type, final String name) {
91     return getModel().findFacet(type, name);
92   }
93
94   @Override
95   @Nullable
96   public <F extends Facet<?>> F getFacetByType(@NotNull final Facet<?> underlyingFacet, final FacetTypeId<F> typeId) {
97     return getModel().getFacetByType(underlyingFacet, typeId);
98   }
99
100   @Override
101   @NotNull
102   public <F extends Facet<?>> Collection<F> getFacetsByType(@NotNull final Facet<?> underlyingFacet, final FacetTypeId<F> typeId) {
103     return getModel().getFacetsByType(underlyingFacet, typeId);
104   }
105
106   @Override
107   @NotNull
108   public <F extends Facet<?>> Collection<F> getFacetsByType(FacetTypeId<F> typeId) {
109     return getModel().getFacetsByType(typeId);
110   }
111
112   @Override
113   public Facet<?> @NotNull [] getSortedFacets() {
114     return getModel().getSortedFacets();
115   }
116
117   @Override
118   @NotNull
119   public String getFacetName(@NotNull Facet<?> facet) {
120     return getModel().getFacetName(facet);
121   }
122
123   protected abstract Module getModule();
124
125   @ApiStatus.Internal
126   @NotNull
127   public static InvalidFacet createInvalidFacet(@NotNull Module module, @NotNull FacetState state, @Nullable Facet<?> underlyingFacet,
128                                                 @NotNull String errorMessage,
129                                                 boolean unknownType) {
130     Project project = module.getProject();
131     final InvalidFacetManager invalidFacetManager = InvalidFacetManager.getInstance(project);
132     final InvalidFacetType type = InvalidFacetType.getInstance();
133     final InvalidFacetConfiguration configuration = new InvalidFacetConfiguration(state, errorMessage);
134     final InvalidFacet facet = createFacet(module, type, StringUtil.notNullize(state.getName()), configuration, underlyingFacet);
135     if (!invalidFacetManager.isIgnored(facet)) {
136       FacetLoadingErrorDescription description = new FacetLoadingErrorDescription(facet);
137       ProjectLoadingErrorsNotifier.getInstance(project).registerError(description);
138       if (unknownType) {
139         UnknownFeaturesCollector.getInstance(project).registerUnknownFeature("com.intellij.facetType", state.getFacetType(), "Facet");
140       }
141     }
142     return facet;
143   }
144
145   private static void assertTrue(final boolean value, final Facet<?> facet, final String parameter) {
146     if (!value) {
147       LOG.error("Facet type " + facet.getType().getClass().getName() + " violates the contract of FacetType.createFacet method about '" +
148                parameter + "' parameter");
149     }
150   }
151
152   @TestOnly
153   public void checkConsistency() {
154   }
155 }