[Workspace Model] Do not fail with existing persistent id exception
[idea/community.git] / platform / lang-api / src / com / intellij / facet / FacetType.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
3 package com.intellij.facet;
4
5 import com.intellij.facet.autodetecting.FacetDetectorRegistry;
6 import com.intellij.facet.ui.DefaultFacetSettingsEditor;
7 import com.intellij.facet.ui.FacetEditor;
8 import com.intellij.facet.ui.MultipleFacetSettingsEditor;
9 import com.intellij.openapi.extensions.ExtensionPointName;
10 import com.intellij.openapi.extensions.PluginAware;
11 import com.intellij.openapi.extensions.PluginDescriptor;
12 import com.intellij.openapi.module.Module;
13 import com.intellij.openapi.module.ModuleType;
14 import com.intellij.openapi.project.Project;
15 import org.jetbrains.annotations.Nls;
16 import org.jetbrains.annotations.NonNls;
17 import org.jetbrains.annotations.NotNull;
18 import org.jetbrains.annotations.Nullable;
19
20 import javax.swing.*;
21
22 /**
23  * Override this class to provide custom type of facets. The implementation should be registered in your {@code plugin.xml}:
24  * <pre>
25  * &lt;extensions defaultExtensionNs="com.intellij"&gt;
26  * &nbsp;&nbsp;&lt;facetType implementation="qualified-class-name"/&gt;
27  * &lt;/extensions&gt;
28  * </pre>
29  */
30 public abstract class FacetType<F extends Facet, C extends FacetConfiguration> implements PluginAware {
31   public static final ExtensionPointName<FacetType> EP_NAME = ExtensionPointName.create("com.intellij.facetType");
32
33   private final @NotNull FacetTypeId<F> myId;
34   private final @NotNull String myStringId;
35   @Nls(capitalization = Nls.Capitalization.Title)
36   private final @NotNull String myPresentableName;
37   private final @Nullable FacetTypeId myUnderlyingFacetType;
38   private PluginDescriptor myPluginDescriptor;
39
40   public static <T extends FacetType> T findInstance(Class<T> aClass) {
41     return EP_NAME.findExtension(aClass);
42   }
43
44   /**
45    * @param id                  unique instance of {@link FacetTypeId}
46    * @param stringId            unique string id of the facet type
47    * @param presentableName     name of this facet type which will be shown in UI
48    * @param underlyingFacetType if this parameter is not {@code null} then you will be able to add facets of this type only as
49    *                            subfacets to a facet of the specified type. If this parameter is {@code null} it will be possible to add facet of this type
50    *                            directly to a module
51    */
52   public FacetType(final @NotNull FacetTypeId<F> id,
53                    final @NotNull @NonNls String stringId,
54                    final @NotNull @Nls(capitalization = Nls.Capitalization.Title) String presentableName,
55                    final @Nullable FacetTypeId underlyingFacetType) {
56     myId = id;
57     myStringId = stringId;
58     myPresentableName = presentableName;
59     myUnderlyingFacetType = underlyingFacetType;
60   }
61
62   /**
63    * @param id              unique instance of {@link FacetTypeId}
64    * @param stringId        unique string id of the facet type
65    * @param presentableName name of this facet type which will be shown in UI
66    */
67   public FacetType(final @NotNull FacetTypeId<F> id,
68                    final @NotNull @NonNls String stringId,
69                    final @NotNull @Nls(capitalization = Nls.Capitalization.Title) String presentableName) {
70     this(id, stringId, presentableName, null);
71   }
72
73   @NotNull
74   public final FacetTypeId<F> getId() {
75     return myId;
76   }
77
78   @NotNull
79   public final String getStringId() {
80     return myStringId;
81   }
82
83   @NotNull
84   @Nls(capitalization = Nls.Capitalization.Title)
85   public String getPresentableName() {
86     return myPresentableName;
87   }
88
89   /**
90    * Default name which will be used then user creates a facet of this type.
91    */
92   @NotNull
93   @NonNls
94   public String getDefaultFacetName() {
95     return myPresentableName;
96   }
97
98   @Nullable
99   public FacetTypeId<?> getUnderlyingFacetType() {
100     return myUnderlyingFacetType;
101   }
102
103   @Override
104   public void setPluginDescriptor(@NotNull PluginDescriptor pluginDescriptor) {
105     myPluginDescriptor = pluginDescriptor;
106   }
107
108   public final PluginDescriptor getPluginDescriptor() {
109     return myPluginDescriptor;
110   }
111
112   /**
113    * @deprecated this method is not called by IDE core anymore. Use {@link com.intellij.framework.detection.FrameworkDetector} extension
114    * to provide automatic detection for facets
115    */
116   @SuppressWarnings("unused")
117   @Deprecated
118   public void registerDetectors(FacetDetectorRegistry<C> registry) {
119   }
120
121   /**
122    * Create default configuration of facet. See {@link FacetConfiguration} for details.
123    */
124   public abstract C createDefaultConfiguration();
125
126   /**
127    * Create a new facet instance.
128    *
129    * @param module          parent module for facet. Must be passed to {@link Facet} constructor
130    * @param name            name of facet. Must be passed to {@link Facet} constructor
131    * @param configuration   facet configuration. Must be passed to {@link Facet} constructor
132    * @param underlyingFacet underlying facet. Must be passed to {@link Facet} constructor
133    * @return a created facet
134    */
135   public abstract F createFacet(@NotNull Module module, final String name, @NotNull C configuration, @Nullable Facet underlyingFacet);
136
137   /**
138    * @return {@code true} if only one facet of this type is allowed within the containing module (if this type doesn't have the underlying
139    * facet type) or within the underlying facet
140    */
141   public boolean isOnlyOneFacetAllowed() {
142     return true;
143   }
144
145   /**
146    * @param moduleType type of module
147    * @return {@code true} if facet of this type are allowed in module of type {@code moduleType}
148    */
149   public abstract boolean isSuitableModuleType(ModuleType moduleType);
150
151   @Nullable
152   public Icon getIcon() {
153     return null;
154   }
155
156   /**
157    * Returns the topic in the help file which is shown when help for this facet type is requested.
158    *
159    * @return the help topic, or null if no help is available.
160    */
161   @Nullable
162   @NonNls
163   public String getHelpTopic() {
164     return null;
165   }
166
167   @Nullable
168   public DefaultFacetSettingsEditor createDefaultConfigurationEditor(@NotNull Project project, @NotNull C configuration) {
169     return null;
170   }
171
172   /**
173    * Override to allow editing several facets at once.
174    *
175    * @param project project
176    * @param editors editors of selected facets
177    * @return editor
178    */
179   @Nullable
180   public MultipleFacetSettingsEditor createMultipleConfigurationsEditor(@NotNull Project project, FacetEditor @NotNull [] editors) {
181     return null;
182   }
183 }