replaced <code></code> with more concise {@code}
[idea/community.git] / platform / platform-impl / src / com / intellij / openapi / options / SchemeExporterEP.java
1 /*
2  * Copyright 2000-2015 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 package com.intellij.openapi.options;
17
18 import com.intellij.openapi.extensions.AbstractExtensionPointBean;
19 import com.intellij.openapi.extensions.ExtensionPointName;
20 import com.intellij.openapi.util.LazyInstance;
21 import com.intellij.util.xmlb.annotations.Attribute;
22 import org.jetbrains.annotations.NotNull;
23 import org.jetbrains.annotations.Nullable;
24
25 import java.util.ArrayList;
26 import java.util.Collection;
27 import java.util.List;
28
29 /**
30  * Extension point for schemes exporters.
31  * 
32  * @author Rustam Vishnyakov
33  */
34 public class SchemeExporterEP <S extends Scheme> extends AbstractExtensionPointBean {
35   public static final ExtensionPointName<SchemeExporterEP> EP_NAME = ExtensionPointName.create("com.intellij.schemeExporter");
36   
37   @Attribute("name")
38   public String name;
39
40   @Attribute("schemeClass")
41   public String schemeClass;
42
43   @Attribute("implementationClass")
44   public String implementationClass;
45   
46   private final LazyInstance<SchemeExporter<S>> myExporterInstance = new LazyInstance<SchemeExporter<S>>() {
47     @Override
48     protected Class<SchemeExporter<S>> getInstanceClass() throws ClassNotFoundException {
49       return findClass(implementationClass);
50     }
51   };
52   
53   public SchemeExporter<S> getInstance() {
54     return myExporterInstance.getValue();
55   }
56   
57   /**
58    * Finds extensions supporting the given {@code schemeClass}
59    * @param schemeClass The class of the scheme to search extensions for.
60    * @return A collection of exporters capable of exporting schemes of the given class. An empty collection is returned if there are
61    *         no matching exporters.
62    */
63   @NotNull
64   public static <S extends Scheme> Collection<SchemeExporterEP<S>> getExtensions(Class<S> schemeClass) {
65     List<SchemeExporterEP<S>> exporters = new ArrayList<>();
66     for (SchemeExporterEP<?> exporterEP : EP_NAME.getExtensions()) {
67       if (schemeClass.getName().equals(exporterEP.schemeClass)) {
68         //noinspection unchecked
69         exporters.add((SchemeExporterEP<S>)exporterEP);
70       }
71     }
72     return exporters;
73   }
74
75   /**
76    * Find an exporter for the given name and scheme class. It is allowed for exporters to have the same name but different scheme classes.
77    * @param name        The exporter name as defined in plug-in configuration.
78    * @param schemeClass The scheme class the exporter has to support.
79    * @return The found exporter or null if there are no exporters for the given name and scheme class.
80    */
81   @Nullable
82   public static <S extends Scheme> SchemeExporter<S> getExporter(@NotNull String name, Class<S> schemeClass) {
83     for (SchemeExporterEP<S> exporterEP : getExtensions(schemeClass)) {
84       if (name.equals(exporterEP.name)) {
85         return exporterEP.getInstance();
86       }
87     }
88     return null;
89   }
90 }