new project model: facets added

2026-09-27 10:03:11 +07:00 · 2012-07-12 10:44:50 +04:00
parent 43754da471
commit c6a4f9c6ea
11 changed files with 222 additions and 9 deletions
@@ -0,0 +1,20 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsNamedElement;
+import org.jetbrains.jps.model.JpsReferenceableElement;
+
+/**
+ * @author nik
+ */
+//todo[nik] I'm not sure that we really need separate interface for facets in the project model.
+//Perhaps facets should be replaced by extensions for module elements
+public interface JpsFacet extends JpsNamedElement, JpsReferenceableElement<JpsFacet> {
+
+  JpsModule getModule();
+
+  @NotNull
+  JpsFacetType<?> getType();
+
+  void delete();
+}
@@ -0,0 +1,11 @@
+package org.jetbrains.jps.model.module;
+
+import java.util.EventListener;
+
+/**
+ * @author nik
+ */
+public interface JpsFacetListener extends EventListener {
+  void facetAdded(JpsFacet facet);
+  void facetRemoved(JpsFacet facet);
+}
@@ -0,0 +1,11 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.jps.model.JpsElementProperties;
+import org.jetbrains.jps.model.JpsElementType;
+import org.jetbrains.jps.model.JpsElementTypeWithDefaultProperties;
+
+/**
+ * @author nik
+ */
+public abstract class JpsFacetType<P extends JpsElementProperties> extends JpsElementType<P> implements JpsElementTypeWithDefaultProperties<P> {
+}
@@ -11,7 +11,7 @@ import java.util.List;
 /**
 * @author nik
 */
-public interface JpsModule extends JpsNamedElement, JpsReferenceableElement<JpsModule> {
+public interface JpsModule extends JpsNamedElement, JpsReferenceableElement<JpsModule>, JpsCompositeElement {
  @NotNull
  JpsUrlList getContentRootsList();

@@ -32,10 +32,13 @@ public interface JpsModule extends JpsNamedElement, JpsReferenceableElement<JpsM

  void removeSourceRoot(@NotNull String url, @NotNull JpsModuleSourceRootType rootType);

-  JpsDependenciesList getDependenciesList();
+  @NotNull
+  JpsFacet addFacet(@NotNull String name, @NotNull JpsFacetType<?> type);

  @NotNull
-  JpsElementContainer getContainer();
+  List<JpsFacet> getFacets();
+
+  JpsDependenciesList getDependenciesList();

  @NotNull
  JpsModuleReference createReference();
@@ -53,4 +56,5 @@ public interface JpsModule extends JpsNamedElement, JpsReferenceableElement<JpsM
  JpsSdkReferencesTable getSdkReferencesTable();

  void delete();
+
 }
@@ -6,9 +6,7 @@ import org.jetbrains.jps.model.*;
 /**
 * @author nik
 */
-public abstract class JpsNamedCompositeElementBase<Self extends JpsNamedCompositeElementBase<Self, Parent>, Parent extends JpsCompositeElementBase> extends
-                                                                                                                                                    JpsCompositeElementBase<Self>
-  implements JpsNamedElement {
+public abstract class JpsNamedCompositeElementBase<Self extends JpsNamedCompositeElementBase<Self>> extends JpsCompositeElementBase<Self> implements JpsNamedElement {
  private String myName;

  protected JpsNamedCompositeElementBase(@NotNull String name) {
@@ -16,7 +14,7 @@ public abstract class JpsNamedCompositeElementBase<Self extends JpsNamedComposit
    myName = name;
  }

-  protected JpsNamedCompositeElementBase(JpsNamedCompositeElementBase<Self, Parent> original) {
+  protected JpsNamedCompositeElementBase(JpsNamedCompositeElementBase<Self> original) {
    super(original);
    myName = original.myName;
  }
@@ -10,7 +10,7 @@ import java.util.List;
 /**
 * @author nik
 */
-public class JpsLibraryImpl extends JpsNamedCompositeElementBase<JpsLibraryImpl, JpsProjectImpl> implements JpsLibrary {
+public class JpsLibraryImpl extends JpsNamedCompositeElementBase<JpsLibraryImpl> implements JpsLibrary {
  private static final JpsElementCollectionKind<JpsLibraryRoot> LIBRARY_ROOTS_COLLECTION =
    new JpsElementCollectionKind<JpsLibraryRoot>(JpsLibraryRootKind.INSTANCE);
  private static final JpsTypedDataKind<JpsLibraryType<?>> TYPED_DATA_KIND = new JpsTypedDataKind<JpsLibraryType<?>>();
@@ -0,0 +1,56 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElementCollection;
+import org.jetbrains.jps.model.JpsElementReference;
+import org.jetbrains.jps.model.impl.JpsNamedCompositeElementBase;
+import org.jetbrains.jps.model.impl.JpsTypedDataImpl;
+import org.jetbrains.jps.model.impl.JpsTypedDataKind;
+import org.jetbrains.jps.model.module.JpsFacet;
+import org.jetbrains.jps.model.module.JpsFacetType;
+import org.jetbrains.jps.model.module.JpsModule;
+
+/**
+ * @author nik
+ */
+public class JpsFacetImpl extends JpsNamedCompositeElementBase<JpsFacetImpl> implements JpsFacet {
+  private static final JpsTypedDataKind<JpsFacetType<?>> TYPED_DATA_KIND = new JpsTypedDataKind<JpsFacetType<?>>();
+
+  public JpsFacetImpl(JpsFacetType<?> facetType, @NotNull String name) {
+    super(name);
+    myContainer.setChild(TYPED_DATA_KIND, new JpsTypedDataImpl<JpsFacetType<?>>(facetType, facetType.createDefaultProperties()));
+  }
+
+  private JpsFacetImpl(JpsNamedCompositeElementBase<JpsFacetImpl> original) {
+    super(original);
+  }
+
+  @NotNull
+  @Override
+  public JpsFacetImpl createCopy() {
+    return new JpsFacetImpl(this);
+  }
+
+  @Override
+  @NotNull
+  public JpsFacetType<?> getType() {
+    return myContainer.getChild(TYPED_DATA_KIND).getType();
+  }
+
+  @Override
+  public JpsModule getModule() {
+    return myParent != null ? (JpsModule)myParent.getParent() : null;
+  }
+
+  @NotNull
+  @Override
+  public JpsElementReference<JpsFacet> createReference() {
+    return new JpsFacetReferenceImpl(getName(), getModule().createReference());
+  }
+
+  @Override
+  public void delete() {
+    //noinspection unchecked
+    ((JpsElementCollection<JpsFacet>)myParent).removeChild(this);
+  }
+}
@@ -0,0 +1,30 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsEventDispatcher;
+import org.jetbrains.jps.model.impl.JpsElementCollectionKind;
+import org.jetbrains.jps.model.impl.JpsElementKindBase;
+import org.jetbrains.jps.model.module.JpsFacet;
+import org.jetbrains.jps.model.module.JpsFacetListener;
+
+/**
+ * @author nik
+ */
+public class JpsFacetKind extends JpsElementKindBase<JpsFacet> {
+  public static final JpsFacetKind INSTANCE = new JpsFacetKind();
+  public static final JpsElementCollectionKind<JpsFacet> COLLECTION_KIND = new JpsElementCollectionKind<JpsFacet>(INSTANCE);
+
+  public JpsFacetKind() {
+    super("facet");
+  }
+
+  @Override
+  public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsFacet element) {
+    dispatcher.getPublisher(JpsFacetListener.class).facetAdded(element);
+  }
+
+  @Override
+  public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsFacet element) {
+    dispatcher.getPublisher(JpsFacetListener.class).facetRemoved(element);
+  }
+}
@@ -0,0 +1,33 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElementReference;
+import org.jetbrains.jps.model.JpsModel;
+import org.jetbrains.jps.model.impl.JpsNamedElementReferenceBase;
+import org.jetbrains.jps.model.module.JpsFacet;
+import org.jetbrains.jps.model.module.JpsModuleReference;
+
+/**
+ * @author nik
+ */
+public class JpsFacetReferenceImpl extends JpsNamedElementReferenceBase<JpsFacet, JpsFacetReferenceImpl> {
+  public JpsFacetReferenceImpl(String facetName, JpsModuleReference moduleReference) {
+    super(JpsFacetKind.COLLECTION_KIND, facetName, moduleReference);
+  }
+
+  private JpsFacetReferenceImpl(JpsFacetReferenceImpl original) {
+    super(original);
+  }
+
+  @NotNull
+  @Override
+  public JpsFacetReferenceImpl createCopy() {
+    return new JpsFacetReferenceImpl(this);
+  }
+
+  @Override
+  public JpsElementReference<JpsFacet> asExternal(@NotNull JpsModel model) {
+    model.registerExternalReference(this);
+    return this;
+  }
+}
@@ -16,7 +16,7 @@ import java.util.List;
 /**
 * @author nik
 */
-public class JpsModuleImpl extends JpsNamedCompositeElementBase<JpsModuleImpl, JpsProjectImpl> implements JpsModule {
+public class JpsModuleImpl extends JpsNamedCompositeElementBase<JpsModuleImpl> implements JpsModule {
  private static final JpsTypedDataKind<JpsModuleType<?>> TYPED_DATA_KIND = new JpsTypedDataKind<JpsModuleType<?>>();
  private static final JpsUrlListKind CONTENT_ROOTS_KIND = new JpsUrlListKind("content roots");
  private static final JpsUrlListKind EXCLUDED_ROOTS_KIND = new JpsUrlListKind("excluded roots");
@@ -28,6 +28,7 @@ public class JpsModuleImpl extends JpsNamedCompositeElementBase<JpsModuleImpl, J
    myContainer.setChild(TYPED_DATA_KIND, new JpsTypedDataImpl<JpsModuleType<?>>(type, properties));
    myContainer.setChild(CONTENT_ROOTS_KIND);
    myContainer.setChild(EXCLUDED_ROOTS_KIND);
+    myContainer.setChild(JpsFacetKind.COLLECTION_KIND);
    myContainer.setChild(DEPENDENCIES_LIST_KIND, new JpsDependenciesListImpl());
    myLibraryCollection = new JpsLibraryCollectionImpl(myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND));
    myContainer.setChild(JpsModuleSourceRootKind.ROOT_COLLECTION_KIND);
@@ -91,6 +92,18 @@ public class JpsModuleImpl extends JpsNamedCompositeElementBase<JpsModuleImpl, J
    }
  }

+  @Override
+  @NotNull
+  public JpsFacet addFacet(@NotNull String name, @NotNull JpsFacetType<?> type) {
+    return myContainer.getChild(JpsFacetKind.COLLECTION_KIND).addChild(new JpsFacetImpl(type, name));
+  }
+
+  @NotNull
+  @Override
+  public List<JpsFacet> getFacets() {
+    return myContainer.getChild(JpsFacetKind.COLLECTION_KIND).getElements();
+  }
+
  @NotNull
  @Override
  public JpsDependenciesList getDependenciesList() {
@@ -0,0 +1,37 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.java.JpsJavaModuleType;
+import org.jetbrains.jps.model.module.JpsFacet;
+import org.jetbrains.jps.model.module.JpsFacetType;
+import org.jetbrains.jps.model.module.JpsModule;
+
+/**
+ * @author nik
+ */
+public class JpsFacetTest extends JpsModelTestCase {
+  public void testAddFacet() {
+    final JpsModule m = myModel.getProject().addModule("m", JpsJavaModuleType.INSTANCE);
+    m.addFacet("f", MY_FACET_TYPE);
+    assertEquals("f", assertOneElement(m.getFacets()).getName());
+  }
+
+  public void testCreateReferenceByFacet() {
+    final JpsFacet facet = myModel.getProject().addModule("m", JpsJavaModuleType.INSTANCE).addFacet("f", MY_FACET_TYPE);
+    final JpsElementReference<JpsFacet> reference = facet.createReference().asExternal(myModel);
+    assertSame(facet, reference.resolve());
+  }
+
+  private static final JpsFacetType<DummyJpsElementProperties> MY_FACET_TYPE = new JpsFacetType<DummyJpsElementProperties>() {
+    @Override
+    public DummyJpsElementProperties createCopy(DummyJpsElementProperties properties) {
+      return DummyJpsElementProperties.INSTANCE;
+    }
+
+    @NotNull
+    @Override
+    public DummyJpsElementProperties createDefaultProperties() {
+      return DummyJpsElementProperties.INSTANCE;
+    }
+  };
+}