new project model: initial

2026-09-27 10:03:11 +07:00 · 2012-06-06 13:28:38 +04:00
parent a9ae465bfb
commit ca6f19db92
91 changed files with 2607 additions and 0 deletions
@@ -68,6 +68,8 @@
      <module fileurl="file://$PROJECT_DIR$/jps/plugins/appLauncher/jps-appLauncher.iml" filepath="$PROJECT_DIR$/jps/plugins/appLauncher/jps-appLauncher.iml" group="jps" />
      <module fileurl="file://$PROJECT_DIR$/jps/jps-builders/jps-builders.iml" filepath="$PROJECT_DIR$/jps/jps-builders/jps-builders.iml" group="jps" />
      <module fileurl="file://$PROJECT_DIR$/jps/model/jps-model.iml" filepath="$PROJECT_DIR$/jps/model/jps-model.iml" group="jps" />
+      <module fileurl="file://$PROJECT_DIR$/jps/model-api/jps-model-api.iml" filepath="$PROJECT_DIR$/jps/model-api/jps-model-api.iml" group="jps" />
+      <module fileurl="file://$PROJECT_DIR$/jps/model-impl/jps-model-impl.iml" filepath="$PROJECT_DIR$/jps/model-impl/jps-model-impl.iml" group="jps" />
      <module fileurl="file://$PROJECT_DIR$/jps/plugins/scala/jps-scala.iml" filepath="$PROJECT_DIR$/jps/plugins/scala/jps-scala.iml" group="jps" />
      <module fileurl="file://$PROJECT_DIR$/jps/jps-tests.iml" filepath="$PROJECT_DIR$/jps/jps-tests.iml" group="jps" />
      <module fileurl="file://$PROJECT_DIR$/java/jsp-base-openapi/jsp-base-openapi.iml" filepath="$PROJECT_DIR$/java/jsp-base-openapi/jsp-base-openapi.iml" group="java" />
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module" module-name="annotations" />
+  </component>
+</module>
+
@@ -0,0 +1,8 @@
+package org.jetbrains.jps.model;
+
+/**
+ * @author nik
+ */
+public class DummyJpsElementProperties extends JpsElementProperties {
+  public static final DummyJpsElementProperties INSTANCE = new DummyJpsElementProperties();
+}
@@ -0,0 +1,11 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface JpsCompositeElement extends JpsParentElement {
+  @NotNull
+  JpsElementContainer getContainer();
+}
@@ -0,0 +1,18 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface JpsElement {
+  @NotNull
+  BulkModificationSupport<?> getBulkModificationSupport();
+
+  interface BulkModificationSupport<E extends JpsElement> extends JpsElement {
+    @NotNull
+    E createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent);
+
+    void applyChanges(@NotNull E modified);
+  }
+}
@@ -0,0 +1,22 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public interface JpsElementCollection<E extends JpsElement> extends JpsParentElement {
+  List<E> getElements();
+
+  @NotNull
+  <P> E addChild(@NotNull JpsElementFactoryWithParameter<E,P> factory, @NotNull P param);
+
+  @NotNull
+  E addChild(@NotNull JpsElementFactory<E> factory);
+
+  E addChild(E element);
+
+  void removeChild(@NotNull E element);
+}
@@ -0,0 +1,25 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface JpsElementContainer {
+  <T extends JpsElement>
+  T getChild(@NotNull JpsElementKind<T> kind);
+
+  @NotNull
+  <T extends JpsElement, K extends JpsElementKind<T>&JpsElementFactory<T>>
+  T setChild(@NotNull K kind);
+
+  @NotNull
+  <T extends JpsElement, P, K extends JpsElementKind<T>&JpsElementFactoryWithParameter<T, P>>
+  T setChild(@NotNull K kind, @NotNull P param);
+
+  <T extends JpsElement>
+  T setChild(JpsElementKind<T> kind, T child);
+
+  <T extends JpsElement>
+  void removeChild(@NotNull JpsElementKind<T> kind);
+}
@@ -0,0 +1,12 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface JpsElementFactory<E extends JpsElement> {
+
+  @NotNull
+  E create(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent);
+}
@@ -0,0 +1,11 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface JpsElementFactoryWithParameter<E extends JpsElement, P> {
+  @NotNull
+  E create(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent, @NotNull P param);
+}
@@ -0,0 +1,15 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public class JpsElementKind<E extends JpsElement> {
+
+  public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull E element) {
+  }
+
+  public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull E element) {
+  }
+}
@@ -0,0 +1,7 @@
+package org.jetbrains.jps.model;
+
+/**
+ * @author nik
+ */
+public abstract class JpsElementProperties {
+}
@@ -0,0 +1,11 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * @author nik
+ */
+public interface JpsElementReference<T extends JpsElement> extends JpsElement {
+  @Nullable
+  T resolve();
+}
@@ -0,0 +1,10 @@
+package org.jetbrains.jps.model;
+
+/**
+ * @author nik
+ */
+public abstract class JpsElementType<P extends JpsElementProperties> {
+  public abstract P createDefaultProperties();
+
+  public abstract P createCopy(P properties);
+}
@@ -0,0 +1,23 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.EventListener;
+
+/**
+ * @author nik
+ */
+public interface JpsEventDispatcher {
+  @NotNull
+  <T extends EventListener> T getPublisher(Class<T> listenerClass);
+
+  void fireElementRenamed(@NotNull JpsNamedElement element, @NotNull String oldName, @NotNull String newName);
+
+  void fireElementChanged(@NotNull JpsElement element);
+
+  <T extends JpsElement>
+  void fireElementAdded(@NotNull T element, @NotNull JpsElementKind<T> kind);
+
+  <T extends JpsElement>
+  void fireElementRemoved(@NotNull T element, @NotNull JpsElementKind<T> kind);
+}
@@ -0,0 +1,15 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.library.JpsLibrary;
+import org.jetbrains.jps.model.library.JpsLibraryType;
+
+/**
+ * @author nik
+ */
+public interface JpsGlobal extends JpsCompositeElement, JpsReferenceableElement<JpsGlobal> {
+  @NotNull
+  JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, final @NotNull String name);
+
+
+}
@@ -0,0 +1,19 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface JpsModel {
+  @NotNull
+  JpsProject getProject();
+
+  @NotNull
+  JpsGlobal getGlobal();
+
+  @NotNull
+  JpsModel createModifiableModel(@NotNull JpsEventDispatcher eventDispatcher);
+
+  void commit();
+}
@@ -0,0 +1,13 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface JpsNamedElement extends JpsElement {
+  @NotNull
+  String getName();
+
+  void setName(@NotNull String name);
+}
@@ -0,0 +1,7 @@
+package org.jetbrains.jps.model;
+
+/**
+ * @author nik
+ */
+public interface JpsParentElement extends JpsElement {
+}
@@ -0,0 +1,27 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.library.JpsLibrary;
+import org.jetbrains.jps.model.library.JpsLibraryType;
+import org.jetbrains.jps.model.module.JpsModule;
+import org.jetbrains.jps.model.module.JpsModuleType;
+
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public interface JpsProject extends JpsCompositeElement, JpsReferenceableElement<JpsProject> {
+
+  @NotNull
+  JpsModule addModule(@NotNull JpsModuleType<?> moduleType, @NotNull String name);
+
+  @NotNull
+  JpsLibrary addLibrary(@NotNull JpsLibraryType<?> libraryType, @NotNull String name);
+
+  @NotNull
+  List<? extends JpsLibrary> getLibraries();
+
+  @NotNull
+  List<? extends JpsModule> getModules();
+}
@@ -0,0 +1,11 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface JpsReferenceableElement<E extends JpsElement> {
+  @NotNull
+  JpsElementReference<E> createReference(JpsParentElement parent);
+}
@@ -0,0 +1,16 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface JpsTypedData<P extends JpsElementProperties> extends JpsElement {
+  @NotNull
+  JpsElementType<P> getType();
+
+  @NotNull
+  P getProperties();
+
+  void setProperties(@NotNull P properties);
+}
@@ -0,0 +1,17 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public interface JpsUrlList extends JpsElement {
+  @NotNull
+  List<String> getUrls();
+
+  void addUrl(@NotNull String url);
+
+  void removeUrl(@NotNull String url);
+}
@@ -0,0 +1,12 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface JpsUrlListChangeListener<T extends JpsElement> {
+  void urlAdded(@NotNull T element, @NotNull String url);
+
+  void urlRemoved(@NotNull T element, @NotNull String url);
+}
@@ -0,0 +1,13 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface SimpleJpsElement<P extends JpsElementProperties> extends JpsElement {
+  @NotNull
+  P getProperties();
+
+  void setProperties(@NotNull P properties);
+}
@@ -0,0 +1,21 @@
+package org.jetbrains.jps.model.java;
+
+import org.jetbrains.jps.model.JpsElement;
+
+/**
+ * @author nik
+ */
+public interface JavaModuleExtension extends JpsElement {
+
+  String getOutputUrl();
+
+  void setOutputUrl(String outputUrl);
+
+  String getTestOutputUrl();
+
+  void setTestOutputUrl(String testOutputUrl);
+
+  LanguageLevel getLanguageLevel();
+
+  void setLanguageLevel(LanguageLevel languageLevel);
+}
@@ -0,0 +1,22 @@
+package org.jetbrains.jps.model.java;
+
+import org.jetbrains.jps.model.JpsElementProperties;
+
+/**
+ * @author nik
+ */
+public class JavaSourceRootProperties extends JpsElementProperties {
+  private final String myPackagePrefix;
+
+  public JavaSourceRootProperties() {
+    myPackagePrefix = "";
+  }
+
+  public JavaSourceRootProperties(String packagePrefix) {
+    myPackagePrefix = packagePrefix;
+  }
+
+  public String getPackagePrefix() {
+    return myPackagePrefix;
+  }
+}
@@ -0,0 +1,21 @@
+package org.jetbrains.jps.model.java;
+
+import org.jetbrains.jps.model.module.JpsModuleSourceRootType;
+
+/**
+ * @author nik
+ */
+public class JavaSourceRootType extends JpsModuleSourceRootType<JavaSourceRootProperties> {
+  public static final JavaSourceRootType SOURCE = new JavaSourceRootType();
+  public static final JavaSourceRootType TEST_SOURCE = new JavaSourceRootType();
+
+  @Override
+  public JavaSourceRootProperties createDefaultProperties() {
+    return new JavaSourceRootProperties();
+  }
+
+  @Override
+  public JavaSourceRootProperties createCopy(JavaSourceRootProperties properties) {
+    return new JavaSourceRootProperties(properties.getPackagePrefix());
+  }
+}
@@ -0,0 +1,21 @@
+package org.jetbrains.jps.model.java;
+
+import org.jetbrains.jps.model.DummyJpsElementProperties;
+import org.jetbrains.jps.model.library.JpsLibraryType;
+
+/**
+ * @author nik
+ */
+public class JpsJavaLibraryType extends JpsLibraryType<DummyJpsElementProperties> {
+  public static final JpsJavaLibraryType INSTANCE = new JpsJavaLibraryType();
+
+  @Override
+  public DummyJpsElementProperties createDefaultProperties() {
+    return DummyJpsElementProperties.INSTANCE;
+  }
+
+  @Override
+  public DummyJpsElementProperties createCopy(DummyJpsElementProperties properties) {
+    return DummyJpsElementProperties.INSTANCE;
+  }
+}
@@ -0,0 +1,21 @@
+package org.jetbrains.jps.model.java;
+
+import org.jetbrains.jps.model.DummyJpsElementProperties;
+import org.jetbrains.jps.model.module.JpsModuleType;
+
+/**
+ * @author nik
+ */
+public class JpsJavaModuleType extends JpsModuleType<DummyJpsElementProperties> {
+  public static final JpsJavaModuleType INSTANCE = new JpsJavaModuleType();
+
+  @Override
+  public DummyJpsElementProperties createDefaultProperties() {
+    return DummyJpsElementProperties.INSTANCE;
+  }
+
+  @Override
+  public DummyJpsElementProperties createCopy(DummyJpsElementProperties properties) {
+    return DummyJpsElementProperties.INSTANCE;
+  }
+}
@@ -0,0 +1,7 @@
+package org.jetbrains.jps.model.java;
+
+/**
+ * @author nik
+ */
+public enum LanguageLevel {
+}
@@ -0,0 +1,26 @@
+package org.jetbrains.jps.model.library;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsNamedElement;
+import org.jetbrains.jps.model.JpsParentElement;
+import org.jetbrains.jps.model.JpsReferenceableElement;
+
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public interface JpsLibrary extends JpsNamedElement, JpsReferenceableElement<JpsLibrary> {
+
+  @NotNull
+  List<String> getUrls(@NotNull JpsLibraryRootType rootType);
+
+  void addUrl(@NotNull String url, @NotNull JpsLibraryRootType rootType);
+
+  void removeUrl(@NotNull String url, @NotNull JpsLibraryRootType rootType);
+
+  void delete();
+
+  @NotNull
+  JpsLibraryReference createReference(JpsParentElement parent);
+}
@@ -0,0 +1,13 @@
+package org.jetbrains.jps.model.library;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.EventListener;
+
+/**
+ * @author nik
+ */
+public interface JpsLibraryListener extends EventListener {
+  void libraryAdded(@NotNull JpsLibrary library);
+  void libraryRemoved(@NotNull JpsLibrary library);
+}
@@ -0,0 +1,12 @@
+package org.jetbrains.jps.model.library;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElementReference;
+
+/**
+ * @author nik
+ */
+public interface JpsLibraryReference extends JpsElementReference<JpsLibrary> {
+  @NotNull
+  String getLibraryName();
+}
@@ -0,0 +1,18 @@
+package org.jetbrains.jps.model.library;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElement;
+
+/**
+ * @author nik
+ */
+public interface JpsLibraryRoot extends JpsElement {
+  @NotNull
+  JpsLibraryRootType getRootType();
+
+  @NotNull
+  String getUrl();
+
+  @NotNull
+  JpsLibrary getLibrary();
+}
@@ -0,0 +1,13 @@
+package org.jetbrains.jps.model.library;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.EventListener;
+
+/**
+ * @author nik
+ */
+public interface JpsLibraryRootListener extends EventListener {
+  void rootAdded(@NotNull JpsLibraryRoot root);
+  void rootRemoved(@NotNull JpsLibraryRoot root);
+}
@@ -0,0 +1,24 @@
+package org.jetbrains.jps.model.library;
+
+/**
+ * @author nik
+ */
+public class JpsLibraryRootType {
+  public static final JpsLibraryRootType COMPILED = new JpsLibraryRootType(JpsOrderRootType.COMPILED, false);
+  public static final JpsLibraryRootType SOURCES = new JpsLibraryRootType(JpsOrderRootType.SOURCES, false);
+  private final boolean myJarDirectory;
+  private final JpsOrderRootType myType;
+
+  public JpsLibraryRootType(JpsOrderRootType type, boolean jarDirectory) {
+    myType = type;
+    myJarDirectory = jarDirectory;
+  }
+
+  public boolean isJarDirectory() {
+    return myJarDirectory;
+  }
+
+  public JpsOrderRootType getType() {
+    return myType;
+  }
+}
@@ -0,0 +1,10 @@
+package org.jetbrains.jps.model.library;
+
+import org.jetbrains.jps.model.JpsElementProperties;
+import org.jetbrains.jps.model.JpsElementType;
+
+/**
+ * @author nik
+ */
+public abstract class JpsLibraryType<P extends JpsElementProperties> extends JpsElementType<P> {
+}
@@ -0,0 +1,13 @@
+package org.jetbrains.jps.model.library;
+
+/**
+ * @author nik
+ */
+public abstract class JpsOrderRootType {
+  public static final JpsOrderRootType COMPILED = new JpsOrderRootType() {
+  };
+  public static final JpsOrderRootType SOURCES = new JpsOrderRootType() {
+  };
+  public static final JpsOrderRootType DOCUMENTATION = new JpsOrderRootType() {
+  };
+}
@@ -0,0 +1,21 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElement;
+import org.jetbrains.jps.model.library.JpsLibrary;
+
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public interface DependenciesList extends JpsElement {
+  @NotNull
+  JpsModuleDependency addModuleDependency(@NotNull JpsModule module);
+
+  @NotNull
+  JpsLibraryDependency addLibraryDependency(@NotNull JpsLibrary libraryElement);
+
+  @NotNull
+  List<? extends JpsDependencyElement> getDependencies();
+}
@@ -0,0 +1,9 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.jps.model.JpsElement;
+
+/**
+ * @author nik
+ */
+public interface JpsDependencyElement extends JpsElement {
+}
@@ -0,0 +1,12 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.library.JpsLibraryReference;
+
+/**
+ * @author nik
+ */
+public interface JpsLibraryDependency extends JpsDependencyElement {
+  @NotNull
+  JpsLibraryReference getLibraryReference();
+}
@@ -0,0 +1,41 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public interface JpsModule extends JpsNamedElement, JpsReferenceableElement<JpsModule> {
+  @NotNull
+  JpsUrlList getContentRootsList();
+
+  @NotNull
+  JpsUrlList getExcludeRootsList();
+
+
+  @NotNull
+  List<? extends JpsModuleSourceRoot> getSourceRoots();
+
+  @NotNull
+  <P extends JpsElementProperties>
+  JpsModuleSourceRoot addSourceRoot(@NotNull JpsModuleSourceRootType<P> rootType, @NotNull String url);
+
+  @NotNull
+  <P extends JpsElementProperties>
+  JpsModuleSourceRoot addSourceRoot(@NotNull JpsModuleSourceRootType<P> rootType, @NotNull String url, @NotNull P properties);
+
+  void removeSourceRoot(@NotNull JpsModuleSourceRootType rootType, @NotNull String url);
+
+  DependenciesList getDependenciesList();
+
+  @NotNull
+  JpsElementContainer getContainer();
+
+  @NotNull
+  JpsModuleReference createReference(JpsParentElement parent);
+
+  void delete();
+}
@@ -0,0 +1,9 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.jps.model.JpsUrlListChangeListener;
+
+/**
+ * @author nik
+ */
+public interface JpsModuleContentRootsListener extends JpsUrlListChangeListener<JpsModule> {
+}
@@ -0,0 +1,11 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author nik
+ */
+public interface JpsModuleDependency extends JpsDependencyElement {
+  @NotNull
+  JpsModuleReference getModuleReference();
+}
@@ -0,0 +1,9 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.jps.model.JpsUrlListChangeListener;
+
+/**
+ * @author nik
+ */
+public interface JpsModuleExcludeRootsListener extends JpsUrlListChangeListener<JpsModule> {
+}
@@ -0,0 +1,14 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.module.JpsModule;
+
+import java.util.EventListener;
+
+/**
+ * @author nik
+ */
+public interface JpsModuleListener extends EventListener {
+  void moduleAdded(@NotNull JpsModule module);
+  void moduleRemoved(@NotNull JpsModule module);
+}
@@ -0,0 +1,12 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElementReference;
+
+/**
+ * @author nik
+ */
+public interface JpsModuleReference extends JpsElementReference<JpsModule> {
+  @NotNull
+  String getModuleName();
+}
@@ -0,0 +1,23 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jps.model.JpsElement;
+import org.jetbrains.jps.model.JpsElementProperties;
+
+/**
+ * @author nik
+ */
+public interface JpsModuleSourceRoot extends JpsElement {
+  @NotNull
+  JpsModuleSourceRootType<?> getRootType();
+
+  @Nullable
+  <P extends JpsElementProperties> P getProperties(@NotNull JpsModuleSourceRootType<P> type);
+
+  <P extends JpsElementProperties>
+  void setProperties(JpsModuleSourceRootType<P> type, P properties);
+
+  @NotNull
+  String getUrl();
+}
@@ -0,0 +1,14 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.EventListener;
+
+/**
+ * @author nik
+ */
+public interface JpsModuleSourceRootListener extends EventListener {
+  void sourceRootAdded(@NotNull JpsModuleSourceRoot root);
+  void sourceRootRemoved(@NotNull JpsModuleSourceRoot root);
+  void sourceRootChanged(@NotNull JpsModuleSourceRoot root);
+}
@@ -0,0 +1,10 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.jps.model.JpsElementProperties;
+import org.jetbrains.jps.model.JpsElementType;
+
+/**
+ * @author nik
+ */
+public abstract class JpsModuleSourceRootType<P extends JpsElementProperties> extends JpsElementType<P> {
+}
@@ -0,0 +1,11 @@
+package org.jetbrains.jps.model.module;
+
+import org.jetbrains.jps.model.JpsElementProperties;
+import org.jetbrains.jps.model.JpsElementType;
+
+/**
+ * @author nik
+ */
+public abstract class JpsModuleType<P extends JpsElementProperties> extends JpsElementType<P> {
+
+}
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/testSrc" isTestSource="true" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module" module-name="util" />
+    <orderEntry type="module" module-name="jps-model-api" />
+    <orderEntry type="module" module-name="testFramework" scope="TEST" />
+  </component>
+</module>
+
@@ -0,0 +1,35 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+/**
+ * @author nik
+ */
+public abstract class JpsCompositeElementBase<Self extends JpsCompositeElementBase<Self>> extends JpsElementBase<Self> implements JpsCompositeElement {
+  protected final JpsElementContainerImpl myContainer;
+  protected final JpsModel myModel;
+
+  protected JpsCompositeElementBase(JpsModel model, JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(eventDispatcher, parent);
+    myModel = model;
+    myContainer = new JpsElementContainerImpl(model, eventDispatcher, this);
+  }
+
+  protected JpsCompositeElementBase(JpsCompositeElementBase<Self> original, JpsModel model, JpsEventDispatcher dispatcher,
+                                    JpsParentElement parent) {
+    super(original, dispatcher, parent);
+    myModel = model;
+    myContainer = new JpsElementContainerImpl(original.myContainer, model, dispatcher, this);
+  }
+
+  public void applyChanges(@NotNull Self element) {
+    myContainer.applyChanges(element.myContainer);
+  }
+
+  @Override
+  @NotNull
+  public JpsElementContainerImpl getContainer() {
+    return myContainer;
+  }
+}
@@ -0,0 +1,41 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+/**
+ * @author nik
+ */
+public abstract class JpsElementBase<Self extends JpsElementBase<Self>> implements JpsElement, JpsElement.BulkModificationSupport<Self> {
+  private JpsEventDispatcher myEventDispatcher;
+  protected JpsParentElement myParent;
+
+  protected JpsElementBase(JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    myEventDispatcher = eventDispatcher;
+    myParent = parent;
+  }
+
+  public JpsElementBase(JpsElementBase original, JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    myEventDispatcher = eventDispatcher;
+    myParent = parent;
+  }
+
+  protected JpsEventDispatcher getEventDispatcher() {
+    return myEventDispatcher;
+  }
+
+  @NotNull
+  @Override
+  public BulkModificationSupport<?> getBulkModificationSupport() {
+    return this;
+  }
+
+  @NotNull
+  public abstract Self createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent);
+
+  public abstract void applyChanges(@NotNull Self modified);
+
+  public JpsParentElement getParent() {
+    return myParent;
+  }
+}
@@ -0,0 +1,107 @@
+package org.jetbrains.jps.model.impl;
+
+import com.intellij.util.SmartList;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+import java.util.*;
+
+/**
+ * @author nik
+ */
+public class JpsElementCollectionImpl<E extends JpsElement> extends JpsElementBase<JpsElementCollectionImpl<E>> implements JpsElementCollection<E> {
+  private final List<E> myElements;
+  private final JpsModel myModel;
+  private final Map<E, E> myCopyToOriginal;
+  private final JpsElementKind<E> myKind;
+
+  public JpsElementCollectionImpl(JpsElementKind<E> kind, JpsModel model, JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(eventDispatcher, parent);
+    myKind = kind;
+    myModel = model;
+    myElements = new SmartList<E>();
+    myCopyToOriginal = null;
+  }
+
+  public JpsElementCollectionImpl(JpsElementCollectionImpl<E> original,
+                                  JpsModel model,
+                                  JpsEventDispatcher eventDispatcher,
+                                  JpsParentElement parent) {
+    super(original, eventDispatcher, parent);
+    myKind = original.myKind;
+    myModel = model;
+    myElements = new SmartList<E>();
+    myCopyToOriginal = new HashMap<E, E>();
+    for (E e : original.myElements) {
+      //noinspection unchecked
+      final E copy = (E)e.getBulkModificationSupport().createCopy(model, eventDispatcher, parent);
+      myElements.add(copy);
+      myCopyToOriginal.put(copy, e);
+    }
+  }
+
+  @Override
+  public List<E> getElements() {
+    return myElements;
+  }
+
+  @NotNull
+  @Override
+  public <P> E addChild(@NotNull JpsElementFactoryWithParameter<E, P> factory, @NotNull P param) {
+    return addChild(factory.create(myModel, getEventDispatcher(), myParent, param));
+  }
+
+  @NotNull
+  @Override
+  public E addChild(@NotNull JpsElementFactory<E> factory) {
+    return addChild(factory.create(myModel, getEventDispatcher(), myParent));
+  }
+
+  @Override
+  public E addChild(E element) {
+    myElements.add(element);
+    getEventDispatcher().fireElementAdded(element, myKind);
+    return element;
+  }
+
+  @Override
+  public void removeChild(@NotNull E element) {
+    final boolean removed = myElements.remove(element);
+    if (removed) {
+      getEventDispatcher().fireElementRemoved(element, myKind);
+    }
+  }
+
+  @NotNull
+  @Override
+  public JpsElementCollectionImpl<E> createCopy(@NotNull JpsModel model,
+                                                @NotNull JpsEventDispatcher eventDispatcher,
+                                                JpsParentElement parent) {
+    return new JpsElementCollectionImpl<E>(this, model, eventDispatcher, parent);
+  }
+
+  public void applyChanges(@NotNull JpsElementCollectionImpl<E> modified) {
+    Set<E> toRemove = new LinkedHashSet<E>(myElements);
+    List<E> toAdd = new ArrayList<E>();
+    final Map<E, E> copyToOriginal = modified.myCopyToOriginal;
+    for (E element : modified.myElements) {
+      final E original = copyToOriginal != null ? copyToOriginal.get(element) : null;
+      if (original != null) {
+        //noinspection unchecked
+        ((BulkModificationSupport<E>)original.getBulkModificationSupport()).applyChanges(element);
+        toRemove.remove(original);
+      }
+      else {
+        //noinspection unchecked
+        final E copy = (E)element.getBulkModificationSupport().createCopy(myModel, getEventDispatcher(), myParent);
+        toAdd.add(copy);
+      }
+    }
+    for (E e : toRemove) {
+      removeChild(e);
+    }
+    for (E e : toAdd) {
+      addChild(e);
+    }
+  }
+}
@@ -0,0 +1,24 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+/**
+ * @author nik
+ */
+public class JpsElementCollectionKind<E extends JpsElementBase<?>> extends JpsElementKind<JpsElementCollectionImpl<E>>
+  implements JpsElementFactory<JpsElementCollectionImpl<E>> {
+  private final JpsElementKind<E> myElementKind;
+
+  public JpsElementCollectionKind(JpsElementKind<E> elementKind) {
+    myElementKind = elementKind;
+  }
+
+  @NotNull
+  @Override
+  public JpsElementCollectionImpl<E> create(@NotNull JpsModel model,
+                                            @NotNull JpsEventDispatcher eventDispatcher,
+                                            JpsParentElement parent) {
+    return new JpsElementCollectionImpl<E>(myElementKind, model, eventDispatcher, parent);
+  }
+}
@@ -0,0 +1,98 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author nik
+ */
+public class JpsElementContainerImpl implements JpsElementContainer {
+  private final Map<JpsElementKind<?>, JpsElement> myElements = new HashMap<JpsElementKind<?>, JpsElement>();
+  private final @NotNull JpsModel myModel;
+  private final @NotNull JpsEventDispatcher myEventDispatcher;
+  private final @NotNull JpsParentElement myParent;
+
+  public JpsElementContainerImpl(@NotNull JpsModel model,
+                                 @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    myModel = model;
+    myEventDispatcher = eventDispatcher;
+    myParent = parent;
+  }
+
+  public JpsElementContainerImpl(@NotNull JpsElementContainerImpl original, @NotNull JpsModel model,
+                                 @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    myModel = model;
+    myEventDispatcher = eventDispatcher;
+    myParent = parent;
+    for (Map.Entry<JpsElementKind<?>, JpsElement> entry : original.myElements.entrySet()) {
+      final JpsElementKind kind = entry.getKey();
+      myElements.put(kind, entry.getValue().getBulkModificationSupport().createCopy(myModel, myEventDispatcher, myParent));
+    }
+  }
+
+  @Override
+  public <T extends JpsElement> T getChild(@NotNull JpsElementKind<T> kind) {
+    //noinspection unchecked
+    return (T)myElements.get(kind);
+  }
+
+  @NotNull
+  @Override
+  public <T extends JpsElement, P, K extends JpsElementKind<T> & JpsElementFactoryWithParameter<T, P>> T setChild(@NotNull K kind,
+                                                                                                                  @NotNull P param) {
+    final T child = kind.create(myModel, myEventDispatcher, myParent, param);
+    return setChild(kind, child);
+  }
+
+  @NotNull
+  @Override
+  public <T extends JpsElement, K extends JpsElementKind<T> & JpsElementFactory<T>> T setChild(@NotNull K kind) {
+    final T child = kind.create(myModel, myEventDispatcher, myParent);
+    return setChild(kind, child);
+  }
+
+  @Override
+  public <T extends JpsElement> T setChild(JpsElementKind<T> kind, T child) {
+    myElements.put(kind, child);
+    myEventDispatcher.fireElementAdded(child, kind);
+    return child;
+  }
+
+  @Override
+  public <T extends JpsElement> void removeChild(@NotNull JpsElementKind<T> kind) {
+    //noinspection unchecked
+    final T removed = (T)myElements.remove(kind);
+    myEventDispatcher.fireElementRemoved(removed, kind);
+  }
+
+  public void applyChanges(@NotNull JpsElementContainerImpl modified) {
+    for (JpsElementKind<?> kind : myElements.keySet()) {
+      applyChanges(kind, modified);
+    }
+    for (JpsElementKind<?> kind : modified.myElements.keySet()) {
+      if (!myElements.containsKey(kind)) {
+        applyChanges(kind, modified);
+      }
+    }
+  }
+
+  private <T extends JpsElement> void applyChanges(JpsElementKind<T> kind, JpsElementContainerImpl modified) {
+    final T child = getChild(kind);
+    final T modifiedChild = modified.getChild(kind);
+    if (child != null && modifiedChild != null) {
+      final JpsElement.BulkModificationSupport modificationSupport = child.getBulkModificationSupport();
+      //noinspection unchecked
+      modificationSupport.applyChanges(modifiedChild);
+    }
+    else if (modifiedChild == null) {
+      removeChild(kind);
+    }
+    else {
+      //noinspection unchecked
+      setChild(kind, (T)modifiedChild.getBulkModificationSupport().createCopy(myModel, myEventDispatcher, myParent));
+    }
+  }
+}
@@ -0,0 +1,40 @@
+package org.jetbrains.jps.model.impl;
+
+import com.intellij.util.EventDispatcher;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElement;
+import org.jetbrains.jps.model.JpsElementKind;
+import org.jetbrains.jps.model.JpsEventDispatcher;
+
+import java.util.EventListener;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * @author nik
+ */
+public abstract class JpsEventDispatcherBase implements JpsEventDispatcher {
+  private Map<Class<?>, EventDispatcher<?>> myDispatchers = new HashMap<Class<?>, EventDispatcher<?>>();
+
+  @NotNull
+  @Override
+  public <T extends EventListener> T getPublisher(Class<T> listenerClass) {
+    EventDispatcher<?> dispatcher = myDispatchers.get(listenerClass);
+    if (dispatcher == null) {
+      dispatcher = EventDispatcher.create(listenerClass);
+      myDispatchers.put(listenerClass, dispatcher);
+    }
+    //noinspection unchecked
+    return (T)dispatcher.getMulticaster();
+  }
+
+  @Override
+  public <T extends JpsElement> void fireElementAdded(@NotNull T element, @NotNull JpsElementKind<T> kind) {
+    kind.fireElementAdded(this, element);
+  }
+
+  @Override
+  public <T extends JpsElement> void fireElementRemoved(@NotNull T element, @NotNull JpsElementKind<T> kind) {
+    kind.fireElementRemoved(this, element);
+  }
+}
@@ -0,0 +1,33 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+/**
+ * @author nik
+ */
+public class JpsGlobalElementReference extends JpsElementBase<JpsGlobalElementReference> implements JpsElementReference<JpsGlobal> {
+  private final JpsModel myModel;
+
+  public JpsGlobalElementReference(JpsModel model, JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(eventDispatcher, parent);
+    myModel = model;
+  }
+
+  @Override
+  public JpsGlobal resolve() {
+    return myModel.getGlobal();
+  }
+
+  @NotNull
+  @Override
+  public JpsGlobalElementReference createCopy(@NotNull JpsModel model,
+                                              @NotNull JpsEventDispatcher eventDispatcher,
+                                              JpsParentElement parent) {
+    return new JpsGlobalElementReference(model, eventDispatcher, parent);
+  }
+
+  @Override
+  public void applyChanges(@NotNull JpsGlobalElementReference modified) {
+  }
+}
@@ -0,0 +1,41 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+import org.jetbrains.jps.model.library.JpsLibrary;
+import org.jetbrains.jps.model.library.JpsLibraryType;
+import org.jetbrains.jps.model.library.impl.JpsLibraryImpl;
+import org.jetbrains.jps.model.library.impl.JpsLibraryKind;
+
+/**
+ * @author nik
+ */
+public class JpsGlobalImpl extends JpsCompositeElementBase<JpsGlobalImpl> implements JpsGlobal {
+  public JpsGlobalImpl(JpsModel model, JpsEventDispatcher eventDispatcher) {
+    super(model, eventDispatcher, null);
+    myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND);
+  }
+
+  public JpsGlobalImpl(JpsGlobalImpl original, JpsModel model, JpsEventDispatcher eventDispatcher) {
+    super(original, model, eventDispatcher, null);
+  }
+
+  @NotNull
+  @Override
+  public JpsGlobalImpl createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new JpsGlobalImpl(this, model, eventDispatcher);
+  }
+
+  @NotNull
+  @Override
+  public JpsLibrary addLibrary(@NotNull JpsLibraryType libraryType, @NotNull final String name) {
+    final JpsElementCollectionImpl<JpsLibraryImpl> collection = myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND);
+    return collection.addChild(new JpsLibraryImpl(name, libraryType, myModel, getEventDispatcher(), collection));
+  }
+
+  @NotNull
+  @Override
+  public JpsElementReference<JpsGlobal> createReference(JpsParentElement parent) {
+    return new JpsGlobalElementReference(myModel, getEventDispatcher(), parent);
+  }
+}
@@ -0,0 +1,51 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsEventDispatcher;
+import org.jetbrains.jps.model.JpsModel;
+
+/**
+ * @author nik
+ */
+public class JpsModelImpl implements JpsModel {
+  private JpsProjectImpl myProject;
+  private JpsGlobalImpl myGlobal;
+  private JpsModelImpl myOriginalModel;
+
+  public JpsModelImpl(JpsEventDispatcher eventDispatcher) {
+    myProject = new JpsProjectImpl(this, eventDispatcher);
+    myGlobal = new JpsGlobalImpl(this, eventDispatcher);
+  }
+
+  private JpsModelImpl(JpsModelImpl original, JpsEventDispatcher eventDispatcher) {
+    myOriginalModel = original;
+    myProject = new JpsProjectImpl(original.myProject, this, eventDispatcher);
+    myGlobal = new JpsGlobalImpl(original.myGlobal, this, eventDispatcher);
+  }
+
+  @NotNull
+  public JpsProjectImpl getProject() {
+    return myProject;
+  }
+
+  @NotNull
+  public JpsGlobalImpl getGlobal() {
+    return myGlobal;
+  }
+
+  @NotNull
+  @Override
+  public JpsModel createModifiableModel(@NotNull JpsEventDispatcher eventDispatcher) {
+    return new JpsModelImpl(this, eventDispatcher);
+  }
+
+  @Override
+  public void commit() {
+    myOriginalModel.applyChanges(this);
+  }
+
+  private void applyChanges(@NotNull JpsModelImpl modifiedCopy) {
+    myProject.applyChanges(modifiedCopy.myProject);
+    myGlobal.applyChanges(modifiedCopy.myGlobal);
+  }
+}
@@ -0,0 +1,47 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+/**
+ * @author nik
+ */
+public abstract class JpsNamedCompositeElementBase<Self extends JpsNamedCompositeElementBase<Self, Parent>, Parent extends JpsCompositeElementBase> extends
+                                                                                                                                                    JpsCompositeElementBase<Self>
+  implements JpsNamedElement {
+  private String myName;
+
+  protected JpsNamedCompositeElementBase(JpsModel model,
+                                         JpsEventDispatcher eventDispatcher,
+                                         @NotNull String name, JpsParentElement parent) {
+    super(model, eventDispatcher, parent);
+    myName = name;
+  }
+
+  protected JpsNamedCompositeElementBase(JpsNamedCompositeElementBase<Self, Parent> original,
+                                         JpsModel model,
+                                         JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(original, model, eventDispatcher, parent);
+    myName = original.myName;
+  }
+
+  @NotNull
+  @Override
+  public String getName() {
+    return myName;
+  }
+
+  public void applyChanges(@NotNull Self modified) {
+    super.applyChanges(modified);
+    setName(modified.myName);
+  }
+
+  @Override
+  public void setName(@NotNull String name) {
+    if (!myName.equals(name)) {
+      String oldName = myName;
+      myName = name;
+      getEventDispatcher().fireElementRenamed(this, oldName, name);
+    }
+  }
+}
@@ -0,0 +1,45 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public abstract class JpsNamedElementReferenceBase<T extends JpsNamedElement, Self extends JpsNamedElementReferenceBase<T, Self>> extends JpsCompositeElementBase<Self> implements JpsElementReference<T> {
+  private static final JpsElementKind<JpsElementReference<? extends JpsCompositeElement>> PARENT_REFERENCE_KIND = new JpsElementKind<JpsElementReference<? extends JpsCompositeElement>>();
+  private final JpsElementCollectionKind<? extends T> myCollectionKind;
+  protected final String myElementName;
+
+  protected JpsNamedElementReferenceBase(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, @NotNull JpsElementCollectionKind<? extends T> kind, @NotNull String elementName,
+                                         @NotNull JpsElementReference<? extends JpsCompositeElement> parentReference, JpsParentElement parent) {
+    super(model, eventDispatcher, parent);
+    myCollectionKind = kind;
+    myElementName = elementName;
+    myContainer.setChild(PARENT_REFERENCE_KIND, parentReference);
+  }
+
+  protected JpsNamedElementReferenceBase(JpsNamedElementReferenceBase<T, Self> original,
+                                         JpsModel model, JpsEventDispatcher eventDispatcher,
+                                         JpsParentElement parent) {
+    super(original, model, eventDispatcher, parent);
+    myCollectionKind = original.myCollectionKind;
+    myElementName = original.myElementName;
+  }
+
+  @Override
+  public T resolve() {
+    final JpsCompositeElement parent = myContainer.getChild(PARENT_REFERENCE_KIND).resolve();
+    if (parent == null) return null;
+
+    final List<? extends T> elements = parent.getContainer().getChild(myCollectionKind).getElements();
+    for (T element : elements) {
+      if (element.getName().equals(myElementName)) {
+        return element;
+      }
+    }
+    return null;
+  }
+}
@@ -0,0 +1,33 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+/**
+ * @author nik
+ */
+public class JpsProjectElementReference extends JpsElementBase<JpsProjectElementReference> implements JpsElementReference<JpsProject> {
+  private final JpsModel myModel;
+
+  public JpsProjectElementReference(JpsModel model, JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(eventDispatcher, parent);
+    myModel = model;
+  }
+
+  @Override
+  public JpsProject resolve() {
+    return myModel.getProject();
+  }
+
+  @NotNull
+  @Override
+  public JpsProjectElementReference createCopy(@NotNull JpsModel model,
+                                               @NotNull JpsEventDispatcher eventDispatcher,
+                                               JpsParentElement parent) {
+    return new JpsProjectElementReference(model, eventDispatcher, parent);
+  }
+
+  @Override
+  public void applyChanges(@NotNull JpsProjectElementReference modified) {
+  }
+}
@@ -0,0 +1,67 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+import org.jetbrains.jps.model.library.JpsLibrary;
+import org.jetbrains.jps.model.library.JpsLibraryType;
+import org.jetbrains.jps.model.library.impl.JpsLibraryImpl;
+import org.jetbrains.jps.model.library.impl.JpsLibraryKind;
+import org.jetbrains.jps.model.module.JpsModule;
+import org.jetbrains.jps.model.module.JpsModuleType;
+import org.jetbrains.jps.model.module.impl.JpsModuleImpl;
+import org.jetbrains.jps.model.module.impl.JpsModuleKind;
+
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public class JpsProjectImpl extends JpsCompositeElementBase<JpsProjectImpl> implements JpsProject {
+  public JpsProjectImpl(JpsModel model, JpsEventDispatcher eventDispatcher) {
+    super(model, eventDispatcher, null);
+    myContainer.setChild(JpsModuleKind.MODULE_COLLECTION_KIND);
+    myContainer.setChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND);
+  }
+
+  public JpsProjectImpl(JpsProjectImpl original, JpsModel model, JpsEventDispatcher eventDispatcher) {
+    super(original, model, eventDispatcher, null);
+  }
+
+  @NotNull
+  @Override
+  public JpsModule addModule(@NotNull JpsModuleType<?> moduleType, @NotNull final String name) {
+    final JpsElementCollectionImpl<JpsModuleImpl> collection = myContainer.getChild(JpsModuleKind.MODULE_COLLECTION_KIND);
+    return collection.addChild(new JpsModuleImpl(myModel, getEventDispatcher(), moduleType, name, collection));
+  }
+
+  @NotNull
+  @Override
+  public JpsLibrary addLibrary(@NotNull JpsLibraryType<?> libraryType, @NotNull final String name) {
+    final JpsElementCollectionImpl<JpsLibraryImpl> collection = myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND);
+    return collection.addChild(new JpsLibraryImpl(name, libraryType, myModel, getEventDispatcher(), collection));
+  }
+
+  @NotNull
+  @Override
+  public List<? extends JpsLibrary> getLibraries() {
+    return myContainer.getChild(JpsLibraryKind.LIBRARIES_COLLECTION_KIND).getElements();
+  }
+
+  @NotNull
+  @Override
+  public List<? extends JpsModule> getModules() {
+    return myContainer.getChild(JpsModuleKind.MODULE_COLLECTION_KIND).getElements();
+  }
+
+  @NotNull
+  @Override
+  public JpsElementReference<JpsProject> createReference(JpsParentElement parent) {
+    return new JpsProjectElementReference(myModel, getEventDispatcher(), parent);
+  }
+
+  @NotNull
+  @Override
+  public JpsProjectImpl createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new JpsProjectImpl(this, model, eventDispatcher);
+  }
+}
@@ -0,0 +1,65 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jps.model.*;
+
+/**
+ * @author nik
+ */
+public class JpsTypedDataImpl<T extends JpsElementType> extends JpsElementBase<JpsTypedDataImpl<T>> {
+  private final T myType;
+  private JpsElementProperties myProperties;
+
+  public JpsTypedDataImpl(T type, JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(eventDispatcher, parent);
+    myType = type;
+    myProperties = type.createDefaultProperties();
+  }
+
+  public JpsTypedDataImpl(JpsTypedDataImpl<T> original,
+                          JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(original, eventDispatcher, parent);
+    myType = original.getType();
+    myProperties = createCopy(original.getType(), original.myProperties);
+  }
+
+  @Nullable
+  public <P extends JpsElementProperties> P getProperties(JpsElementType<P> type) {
+    //noinspection unchecked
+    return myType.equals(type) ? (P)myProperties : null;
+  }
+
+  private static <P extends JpsElementProperties> P createCopy(final JpsElementType<P> type,
+                                                               final JpsElementProperties properties) {
+    //noinspection unchecked
+    return type.createCopy((P)properties);
+  }
+
+  @NotNull
+  public T getType() {
+    return myType;
+  }
+
+  @NotNull
+  @Override
+  public JpsTypedDataImpl<T> createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new JpsTypedDataImpl<T>(this, eventDispatcher, parent);
+  }
+
+  @NotNull
+  public JpsElementProperties getProperties() {
+    return myProperties;
+  }
+
+  public void setProperties(@NotNull JpsElementProperties properties) {
+    if (!myProperties.equals(properties)) {
+      myProperties = properties;
+      getEventDispatcher().fireElementChanged(this);
+    }
+  }
+
+  public void applyChanges(@NotNull JpsTypedDataImpl<T> data) {
+    setProperties(data.getProperties());
+  }
+}
@@ -0,0 +1,10 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.jps.model.JpsElementKind;
+import org.jetbrains.jps.model.JpsElementType;
+
+/**
+ * @author nik
+ */
+public class JpsTypedDataKind<T extends JpsElementType> extends JpsElementKind<JpsTypedDataImpl<T>> {
+}
@@ -0,0 +1,55 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public class JpsUrlListImpl extends JpsElementBase<JpsUrlListImpl> implements JpsUrlList {
+  private List<String> myUrls = new ArrayList<String>();
+
+  public JpsUrlListImpl(JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(eventDispatcher, parent);
+  }
+
+  public JpsUrlListImpl(JpsUrlListImpl list, JpsEventDispatcher dispatcher, JpsParentElement parent) {
+    super(list, dispatcher, parent);
+    myUrls.addAll(list.myUrls);
+  }
+
+  @NotNull
+  @Override
+  public JpsUrlListImpl createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new JpsUrlListImpl(this, eventDispatcher, parent);
+  }
+
+  @NotNull
+  @Override
+  public List<String> getUrls() {
+    return myUrls;
+  }
+
+  @Override
+  public void addUrl(@NotNull String url) {
+    myUrls.add(url);
+    getEventDispatcher().fireElementChanged(this);
+  }
+
+  @Override
+  public void removeUrl(@NotNull String url) {
+    myUrls.remove(url);
+    getEventDispatcher().fireElementChanged(this);
+  }
+
+  public void applyChanges(@NotNull JpsUrlListImpl modified) {
+    if (!myUrls.equals(modified.myUrls)) {
+      myUrls.clear();
+      myUrls.addAll(modified.myUrls);
+      getEventDispatcher().fireElementChanged(this);
+    }
+  }
+}
@@ -0,0 +1,45 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+
+/**
+ * @author nik
+ */
+public class SimpleJpsElementImpl<P extends JpsElementProperties> extends JpsElementBase<SimpleJpsElementImpl<P>> implements SimpleJpsElement<P> {
+  private P myProperties;
+
+  public SimpleJpsElementImpl(JpsEventDispatcher eventDispatcher, P properties, JpsParentElement parent) {
+    super(eventDispatcher, parent);
+    myProperties = properties;
+  }
+
+  public SimpleJpsElementImpl(SimpleJpsElementImpl<P> original, JpsEventDispatcher dispatcher, JpsParentElement parent) {
+    super(original, dispatcher, parent);
+  }
+
+  @NotNull
+  @Override
+  public P getProperties() {
+    return myProperties;
+  }
+
+  @Override
+  public void setProperties(@NotNull P properties) {
+    if (!myProperties.equals(properties)) {
+      myProperties = properties;
+      getEventDispatcher().fireElementChanged(this);
+    }
+  }
+
+  @NotNull
+  @Override
+  public SimpleJpsElementImpl<P> createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new SimpleJpsElementImpl<P>(this, eventDispatcher, parent);
+  }
+
+  @Override
+  public void applyChanges(@NotNull SimpleJpsElementImpl<P> modified) {
+    setProperties(modified.getProperties());
+  }
+}
@@ -0,0 +1,11 @@
+package org.jetbrains.jps.model.impl;
+
+import org.jetbrains.jps.model.JpsElementKind;
+import org.jetbrains.jps.model.JpsElementProperties;
+
+/**
+ * @author nik
+ */
+public class SimpleJpsElementKind<P extends JpsElementProperties, Parent extends JpsCompositeElementBase<?>> extends
+                                                                                                             JpsElementKind<SimpleJpsElementImpl<P>> {
+}
@@ -0,0 +1,81 @@
+package org.jetbrains.jps.model.java.impl;
+
+import com.intellij.openapi.util.Comparing;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsEventDispatcher;
+import org.jetbrains.jps.model.JpsModel;
+import org.jetbrains.jps.model.JpsParentElement;
+import org.jetbrains.jps.model.impl.JpsElementBase;
+import org.jetbrains.jps.model.java.JavaModuleExtension;
+import org.jetbrains.jps.model.java.LanguageLevel;
+
+/**
+ * @author nik
+ */
+public class JavaModuleExtensionImpl extends JpsElementBase<JavaModuleExtensionImpl> implements JavaModuleExtension {
+  private String myOutputUrl;
+  private String myTestOutputUrl;
+  private LanguageLevel myLanguageLevel;
+
+  public JavaModuleExtensionImpl(JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(eventDispatcher, parent);
+  }
+
+  public JavaModuleExtensionImpl(JavaModuleExtensionImpl original, JpsEventDispatcher dispatcher, JpsParentElement parent) {
+    super(original, dispatcher, parent);
+    myOutputUrl = original.myOutputUrl;
+    myTestOutputUrl = original.myTestOutputUrl;
+    myLanguageLevel = original.myLanguageLevel;
+  }
+
+  @NotNull
+  @Override
+  public JavaModuleExtensionImpl createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new JavaModuleExtensionImpl(this, eventDispatcher, parent);
+  }
+
+  @Override
+  public String getOutputUrl() {
+    return myOutputUrl;
+  }
+
+  @Override
+  public void setOutputUrl(String outputUrl) {
+    if (!Comparing.equal(myOutputUrl, outputUrl)) {
+      myOutputUrl = outputUrl;
+      getEventDispatcher().fireElementChanged(this);
+    }
+  }
+
+  @Override
+  public String getTestOutputUrl() {
+    return myTestOutputUrl;
+  }
+
+  @Override
+  public void setTestOutputUrl(String testOutputUrl) {
+    if (!Comparing.equal(myTestOutputUrl, testOutputUrl)) {
+      myTestOutputUrl = testOutputUrl;
+      getEventDispatcher().fireElementChanged(this);
+    }
+  }
+
+  @Override
+  public LanguageLevel getLanguageLevel() {
+    return myLanguageLevel;
+  }
+
+  @Override
+  public void setLanguageLevel(LanguageLevel languageLevel) {
+    if (!Comparing.equal(myLanguageLevel, languageLevel)) {
+      myLanguageLevel = languageLevel;
+      getEventDispatcher().fireElementChanged(this);
+    }
+  }
+
+  public void applyChanges(@NotNull JavaModuleExtensionImpl modified) {
+    setLanguageLevel(modified.myLanguageLevel);
+    setOutputUrl(modified.myOutputUrl);
+    setTestOutputUrl(modified.myTestOutputUrl);
+  }
+}
@@ -0,0 +1,28 @@
+package org.jetbrains.jps.model.java.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+import org.jetbrains.jps.model.java.JavaModuleExtension;
+import org.jetbrains.jps.model.module.JpsModule;
+
+/**
+ * @author nik
+ */
+public class JavaModuleExtensionKind extends JpsElementKind<JavaModuleExtensionImpl> implements JpsElementFactory<JavaModuleExtensionImpl> {
+  public static final JavaModuleExtensionKind INSTANCE = new JavaModuleExtensionKind();
+
+  @NotNull
+  @Override
+  public JavaModuleExtensionImpl create(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new JavaModuleExtensionImpl(eventDispatcher, parent);
+  }
+
+  @NotNull
+  public static JavaModuleExtension getExtension(@NotNull JpsModule module) {
+    JavaModuleExtension child = module.getContainer().getChild(INSTANCE);
+    if (child == null) {
+      child = module.getContainer().setChild(INSTANCE);
+    }
+    return child;
+  }
+}
@@ -0,0 +1,87 @@
+package org.jetbrains.jps.model.library.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+import org.jetbrains.jps.model.impl.*;
+import org.jetbrains.jps.model.library.JpsLibrary;
+import org.jetbrains.jps.model.library.JpsLibraryReference;
+import org.jetbrains.jps.model.library.JpsLibraryRootType;
+import org.jetbrains.jps.model.library.JpsLibraryType;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public class JpsLibraryImpl extends JpsNamedCompositeElementBase<JpsLibraryImpl, JpsProjectImpl> implements JpsLibrary {
+  private static final JpsElementCollectionKind<JpsLibraryRootImpl> LIBRARY_ROOTS_COLLECTION = new JpsElementCollectionKind<JpsLibraryRootImpl>(JpsLibraryRootKind.INSTANCE);
+  private static final JpsTypedDataKind<JpsLibraryType<?>> TYPED_DATA_KIND = new JpsTypedDataKind<JpsLibraryType<?>>();
+
+  public JpsLibraryImpl(@NotNull String name, @NotNull JpsLibraryType<?> type, @NotNull JpsModel model,
+                        @NotNull JpsEventDispatcher eventDispatcher, JpsElementCollection<JpsLibraryImpl> parent) {
+    super(model, eventDispatcher, name, parent);
+    myContainer.setChild(TYPED_DATA_KIND, new JpsTypedDataImpl<JpsLibraryType<?>>(type, eventDispatcher, this));
+    myContainer.setChild(LIBRARY_ROOTS_COLLECTION);
+  }
+
+  public JpsLibraryImpl(@NotNull JpsLibraryImpl original, JpsModel model, JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(original, model, eventDispatcher, parent);
+  }
+
+  @NotNull
+  @Override
+  public List<String> getUrls(@NotNull JpsLibraryRootType rootType) {
+    final List<String> urls = new ArrayList<String>();
+    for (JpsLibraryRootImpl root : getRootsCollection().getElements()) {
+      if (root.getRootType().equals(rootType)) {
+        urls.add(root.getUrl());
+      }
+    }
+    return urls;
+  }
+
+  @Override
+  public void addUrl(@NotNull final String url, @NotNull final JpsLibraryRootType rootType) {
+    getRootsCollection().addChild(new JpsLibraryRootImpl(getEventDispatcher(), url, rootType, this));
+  }
+
+  private JpsElementCollectionImpl<JpsLibraryRootImpl> getRootsCollection() {
+    return myContainer.getChild(LIBRARY_ROOTS_COLLECTION);
+  }
+
+  @Override
+  public void removeUrl(@NotNull final String url, @NotNull final JpsLibraryRootType rootType) {
+    final JpsElementCollectionImpl<JpsLibraryRootImpl> rootsCollection = getRootsCollection();
+    for (JpsLibraryRootImpl root : rootsCollection.getElements()) {
+      if (root.getUrl().equals(url) && root.getRootType().equals(rootType)) {
+        rootsCollection.removeChild(root);
+        break;
+      }
+    }
+  }
+
+  @Override
+  public void delete() {
+    getParent().removeChild(this);
+  }
+
+  public JpsElementCollectionImpl<JpsLibraryImpl> getParent() {
+    //noinspection unchecked
+    return (JpsElementCollectionImpl<JpsLibraryImpl>)myParent;
+  }
+
+  @NotNull
+  @Override
+  public JpsLibraryImpl createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new JpsLibraryImpl(this, model, eventDispatcher, parent);
+  }
+
+  @NotNull
+  @Override
+  public JpsLibraryReference createReference(JpsParentElement parent) {
+    //noinspection unchecked
+    final JpsElementReference<JpsCompositeElement> parentReference = ((JpsReferenceableElement<JpsCompositeElement>)getParent().getParent()).createReference(parent);
+    return new JpsLibraryReferenceImpl(myModel, getEventDispatcher(), getName(), parentReference, parent);
+  }
+}
@@ -0,0 +1,28 @@
+package org.jetbrains.jps.model.library.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElementKind;
+import org.jetbrains.jps.model.JpsEventDispatcher;
+import org.jetbrains.jps.model.impl.JpsElementCollectionKind;
+import org.jetbrains.jps.model.library.JpsLibraryListener;
+
+/**
+ * @author nik
+ */
+public class JpsLibraryKind extends JpsElementKind<JpsLibraryImpl> {
+  public static final JpsLibraryKind INSTANCE = new JpsLibraryKind();
+  public static final JpsElementCollectionKind<JpsLibraryImpl> LIBRARIES_COLLECTION_KIND = new JpsElementCollectionKind<JpsLibraryImpl>(INSTANCE);
+
+  private JpsLibraryKind() {
+  }
+
+  @Override
+  public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryImpl element) {
+    dispatcher.getPublisher(JpsLibraryListener.class).libraryAdded(element);
+  }
+
+  @Override
+  public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryImpl element) {
+    dispatcher.getPublisher(JpsLibraryListener.class).libraryRemoved(element);
+  }
+}
@@ -0,0 +1,35 @@
+package org.jetbrains.jps.model.library.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+import org.jetbrains.jps.model.impl.JpsNamedElementReferenceBase;
+import org.jetbrains.jps.model.library.JpsLibrary;
+import org.jetbrains.jps.model.library.JpsLibraryReference;
+
+/**
+ * @author nik
+ */
+public class JpsLibraryReferenceImpl extends JpsNamedElementReferenceBase<JpsLibrary, JpsLibraryReferenceImpl> implements JpsLibraryReference {
+  public JpsLibraryReferenceImpl(JpsModel model, JpsEventDispatcher eventDispatcher, String elementName, JpsElementReference<? extends JpsCompositeElement> parentReference,
+                                 JpsParentElement parent) {
+    super(model, eventDispatcher, JpsLibraryKind.LIBRARIES_COLLECTION_KIND, elementName, parentReference, parent);
+  }
+
+  public JpsLibraryReferenceImpl(JpsLibraryReferenceImpl original, JpsModel model, JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(original, model, eventDispatcher, parent);
+  }
+
+  @NotNull
+  @Override
+  public String getLibraryName() {
+    return myElementName;
+  }
+
+  @NotNull
+  @Override
+  public JpsLibraryReferenceImpl createCopy(@NotNull JpsModel model,
+                                            @NotNull JpsEventDispatcher eventDispatcher,
+                                            JpsParentElement parent) {
+    return new JpsLibraryReferenceImpl(this, model, eventDispatcher, parent);
+  }
+}
@@ -0,0 +1,56 @@
+package org.jetbrains.jps.model.library.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsEventDispatcher;
+import org.jetbrains.jps.model.JpsModel;
+import org.jetbrains.jps.model.JpsParentElement;
+import org.jetbrains.jps.model.impl.JpsElementBase;
+import org.jetbrains.jps.model.library.JpsLibrary;
+import org.jetbrains.jps.model.library.JpsLibraryRoot;
+import org.jetbrains.jps.model.library.JpsLibraryRootType;
+
+/**
+ * @author nik
+ */
+public class JpsLibraryRootImpl extends JpsElementBase<JpsLibraryRootImpl> implements JpsLibraryRoot {
+  private final String myUrl;
+  private final JpsLibraryRootType myRootType;
+
+  public JpsLibraryRootImpl(JpsEventDispatcher eventDispatcher, @NotNull String url, @NotNull JpsLibraryRootType rootType, @NotNull JpsParentElement parent) {
+    super(eventDispatcher, parent);
+    myUrl = url;
+    myRootType = rootType;
+  }
+
+  public JpsLibraryRootImpl(JpsLibraryRootImpl original, JpsEventDispatcher dispatcher, JpsParentElement parent) {
+    super(original, dispatcher, parent);
+    myUrl = original.myUrl;
+    myRootType = original.myRootType;
+  }
+
+  @NotNull
+  @Override
+  public JpsLibraryRootType getRootType() {
+    return myRootType;
+  }
+
+  @NotNull
+  public String getUrl() {
+    return myUrl;
+  }
+
+  @NotNull
+  @Override
+  public JpsLibraryRootImpl createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new JpsLibraryRootImpl(this, eventDispatcher, parent);
+  }
+
+  public void applyChanges(@NotNull JpsLibraryRootImpl modified) {
+  }
+
+  @Override
+  @NotNull
+  public JpsLibrary getLibrary() {
+    return (JpsLibrary)myParent;
+  }
+}
@@ -0,0 +1,23 @@
+package org.jetbrains.jps.model.library.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElementKind;
+import org.jetbrains.jps.model.JpsEventDispatcher;
+import org.jetbrains.jps.model.library.JpsLibraryRootListener;
+
+/**
+ * @author nik
+ */
+public class JpsLibraryRootKind extends JpsElementKind<JpsLibraryRootImpl> {
+  public static final JpsLibraryRootKind INSTANCE = new JpsLibraryRootKind();
+
+  @Override
+  public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryRootImpl element) {
+    dispatcher.getPublisher(JpsLibraryRootListener.class).rootAdded(element);
+  }
+
+  @Override
+  public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsLibraryRootImpl element) {
+    dispatcher.getPublisher(JpsLibraryRootListener.class).rootRemoved(element);
+  }
+}
@@ -0,0 +1,58 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElementKind;
+import org.jetbrains.jps.model.JpsEventDispatcher;
+import org.jetbrains.jps.model.JpsModel;
+import org.jetbrains.jps.model.JpsParentElement;
+import org.jetbrains.jps.model.impl.JpsCompositeElementBase;
+import org.jetbrains.jps.model.impl.JpsElementCollectionKind;
+import org.jetbrains.jps.model.library.JpsLibrary;
+import org.jetbrains.jps.model.module.*;
+
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public class DependenciesListImpl extends JpsCompositeElementBase<DependenciesListImpl> implements DependenciesList {
+  public static final JpsElementKind<JpsDependencyElementBase<?>> DEPENDENCY_ELEMENT_KIND = new JpsElementKind<JpsDependencyElementBase<?>>();
+  public static final JpsElementCollectionKind<JpsDependencyElementBase<?>> DEPENDENCY_COLLECTION_KIND = new JpsElementCollectionKind<JpsDependencyElementBase<?>>(DEPENDENCY_ELEMENT_KIND);
+
+  public DependenciesListImpl(JpsModel model, JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(model, eventDispatcher, parent);
+    myContainer.setChild(DEPENDENCY_COLLECTION_KIND);
+  }
+
+  public DependenciesListImpl(DependenciesListImpl original, JpsModel model, JpsEventDispatcher dispatcher, JpsParentElement parent) {
+    super(original, model, dispatcher, parent);
+  }
+
+  @Override
+  @NotNull
+  public List<? extends JpsDependencyElement> getDependencies() {
+    return myContainer.getChild(DEPENDENCY_COLLECTION_KIND).getElements();
+  }
+
+  @Override
+  @NotNull
+  public JpsModuleDependency addModuleDependency(@NotNull JpsModule module) {
+    final JpsModuleDependencyImpl dependency = new JpsModuleDependencyImpl(myModel, getEventDispatcher(), module, this);
+    myContainer.getChild(DEPENDENCY_COLLECTION_KIND).addChild(dependency);
+    return dependency;
+  }
+
+  @Override
+  @NotNull
+  public JpsLibraryDependency addLibraryDependency(@NotNull JpsLibrary libraryElement) {
+    JpsLibraryDependencyImpl dependency = new JpsLibraryDependencyImpl(myModel, getEventDispatcher(), libraryElement, this);
+    myContainer.getChild(DEPENDENCY_COLLECTION_KIND).addChild(dependency);
+    return dependency;
+  }
+
+  @NotNull
+  @Override
+  public DependenciesListImpl createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new DependenciesListImpl(this, model, eventDispatcher, parent);
+  }
+}
@@ -0,0 +1,21 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.jps.model.JpsEventDispatcher;
+import org.jetbrains.jps.model.JpsModel;
+import org.jetbrains.jps.model.JpsParentElement;
+import org.jetbrains.jps.model.impl.JpsCompositeElementBase;
+import org.jetbrains.jps.model.module.JpsDependencyElement;
+
+/**
+ * @author nik
+ */
+public abstract class JpsDependencyElementBase<Self extends JpsDependencyElementBase<Self>> extends JpsCompositeElementBase<Self> implements JpsDependencyElement {
+  protected JpsDependencyElementBase(JpsModel model, JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(model, eventDispatcher, parent);
+  }
+
+  protected JpsDependencyElementBase(JpsDependencyElementBase<Self> original, JpsModel model, JpsEventDispatcher dispatcher, JpsParentElement parent) {
+    super(original, model, dispatcher, parent);
+  }
+
+}
@@ -0,0 +1,37 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+import org.jetbrains.jps.model.library.JpsLibrary;
+import org.jetbrains.jps.model.library.JpsLibraryReference;
+import org.jetbrains.jps.model.module.JpsLibraryDependency;
+
+/**
+ * @author nik
+ */
+public class JpsLibraryDependencyImpl extends JpsDependencyElementBase<JpsLibraryDependencyImpl> implements JpsLibraryDependency {
+  public static final JpsElementKind<JpsLibraryReference> LIBRARY_REFERENCE_KIND = new JpsElementKind<JpsLibraryReference>();
+
+  public JpsLibraryDependencyImpl(JpsModel model, JpsEventDispatcher eventDispatcher, JpsLibrary library, JpsParentElement parent) {
+    super(model, eventDispatcher, parent);
+    myContainer.setChild(LIBRARY_REFERENCE_KIND, library.createReference(parent));
+  }
+
+  public JpsLibraryDependencyImpl(JpsLibraryDependencyImpl original, @NotNull JpsModel model, JpsEventDispatcher dispatcher, JpsParentElement parent) {
+    super(original, model, dispatcher, parent);
+  }
+
+  @NotNull
+  @Override
+  public JpsLibraryReference getLibraryReference() {
+    return myContainer.getChild(LIBRARY_REFERENCE_KIND);
+  }
+
+  @NotNull
+  @Override
+  public JpsLibraryDependencyImpl createCopy(@NotNull JpsModel model,
+                                             @NotNull JpsEventDispatcher eventDispatcher,
+                                             JpsParentElement parent) {
+    return new JpsLibraryDependencyImpl(this, model, eventDispatcher, parent);
+  }
+}
@@ -0,0 +1,37 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+import org.jetbrains.jps.model.module.JpsModule;
+import org.jetbrains.jps.model.module.JpsModuleDependency;
+import org.jetbrains.jps.model.module.JpsModuleReference;
+
+/**
+ * @author nik
+ */
+public class JpsModuleDependencyImpl extends JpsDependencyElementBase<JpsModuleDependencyImpl> implements JpsModuleDependency {
+  private static final JpsElementKind<JpsModuleReference> MODULE_REFERENCE_KIND = new JpsElementKind<JpsModuleReference>();
+
+  public JpsModuleDependencyImpl(JpsModel model, JpsEventDispatcher eventDispatcher, JpsModule module, JpsParentElement parent) {
+    super(model, eventDispatcher, parent);
+    myContainer.setChild(MODULE_REFERENCE_KIND, module.createReference(this));
+  }
+
+  public JpsModuleDependencyImpl(JpsModuleDependencyImpl original, JpsModel model, JpsEventDispatcher dispatcher, JpsParentElement parent) {
+    super(original, model, dispatcher, parent);
+  }
+
+  @NotNull
+  @Override
+  public JpsModuleReference getModuleReference() {
+    return myContainer.getChild(MODULE_REFERENCE_KIND);
+  }
+
+  @NotNull
+  @Override
+  public JpsModuleDependencyImpl createCopy(@NotNull JpsModel model,
+                                            @NotNull JpsEventDispatcher eventDispatcher,
+                                            JpsParentElement parent) {
+    return new JpsModuleDependencyImpl(this, model, eventDispatcher, parent);
+  }
+}
@@ -0,0 +1,100 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+import org.jetbrains.jps.model.impl.*;
+import org.jetbrains.jps.model.module.*;
+
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public class JpsModuleImpl extends JpsNamedCompositeElementBase<JpsModuleImpl, JpsProjectImpl> implements JpsModule {
+  private static final JpsTypedDataKind<JpsModuleType> TYPED_DATA_KIND = new JpsTypedDataKind<JpsModuleType>();
+  private static final JpsElementKind<JpsUrlListImpl> CONTENT_ROOTS_KIND = new JpsElementKind<JpsUrlListImpl>();
+  private static final JpsElementKind<JpsUrlListImpl> EXCLUDED_ROOTS_KIND = new JpsElementKind<JpsUrlListImpl>();
+  public static final JpsElementKind<DependenciesListImpl> DEPENDENCIES_LIST_KIND = new JpsElementKind<DependenciesListImpl>();
+
+  public JpsModuleImpl(JpsModel model, JpsEventDispatcher eventDispatcher, JpsModuleType type, @NotNull String name, JpsElementCollectionImpl<JpsModuleImpl> parent) {
+    super(model, eventDispatcher, name, parent);
+    myContainer.setChild(TYPED_DATA_KIND, new JpsTypedDataImpl<JpsModuleType>(type, eventDispatcher, this));
+    myContainer.setChild(CONTENT_ROOTS_KIND, new JpsUrlListImpl(eventDispatcher, parent));
+    myContainer.setChild(EXCLUDED_ROOTS_KIND, new JpsUrlListImpl(eventDispatcher, parent));
+    myContainer.setChild(DEPENDENCIES_LIST_KIND, new DependenciesListImpl(model, eventDispatcher, this));
+    myContainer.setChild(JpsModuleSourceRootKind.ROOT_COLLECTION_KIND);
+  }
+
+  public JpsModuleImpl(JpsModuleImpl original, JpsEventDispatcher eventDispatcher, JpsModel model, JpsParentElement parent) {
+    super(original, model, eventDispatcher, parent);
+  }
+
+  @NotNull
+  @Override
+  public JpsModuleImpl createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new JpsModuleImpl(this, eventDispatcher, model, parent);
+  }
+
+  @NotNull
+  @Override
+  public JpsUrlList getContentRootsList() {
+    return myContainer.getChild(CONTENT_ROOTS_KIND);
+  }
+
+  @NotNull
+  public JpsUrlList getExcludeRootsList() {
+    return myContainer.getChild(EXCLUDED_ROOTS_KIND);
+  }
+
+  @NotNull
+  @Override
+  public List<? extends JpsModuleSourceRootImpl> getSourceRoots() {
+    return myContainer.getChild(JpsModuleSourceRootKind.ROOT_COLLECTION_KIND).getElements();
+  }
+
+  @NotNull
+  @Override
+  public <P extends JpsElementProperties> JpsModuleSourceRoot addSourceRoot(@NotNull JpsModuleSourceRootType<P> rootType,
+                                                                            @NotNull String url) {
+    return addSourceRoot(rootType, url, rootType.createDefaultProperties());
+  }
+
+  @NotNull
+  @Override
+  public <P extends JpsElementProperties> JpsModuleSourceRoot addSourceRoot(@NotNull JpsModuleSourceRootType<P> rootType,
+                                                                            @NotNull String url,
+                                                                            @NotNull P properties) {
+    final JpsModuleSourceRootImpl root = new JpsModuleSourceRootImpl(myModel, getEventDispatcher(), url, rootType, this);
+    myContainer.getChild(JpsModuleSourceRootKind.ROOT_COLLECTION_KIND).addChild(root);
+    root.setProperties(rootType, properties);
+    return root;
+  }
+
+  @Override
+  public void removeSourceRoot(@NotNull JpsModuleSourceRootType rootType, @NotNull String url) {
+    final JpsElementCollectionImpl<JpsModuleSourceRootImpl> roots = myContainer.getChild(JpsModuleSourceRootKind.ROOT_COLLECTION_KIND);
+    for (JpsModuleSourceRootImpl root : roots.getElements()) {
+      if (root.getRootType().equals(rootType) && root.getUrl().equals(url)) {
+        roots.removeChild(root);
+        break;
+      }
+    }
+  }
+
+  @Override
+  public DependenciesList getDependenciesList() {
+    return myContainer.getChild(DEPENDENCIES_LIST_KIND);
+  }
+
+  @Override
+  public void delete() {
+    //noinspection unchecked
+    ((JpsElementCollectionImpl<JpsModuleImpl>)myParent).removeChild(this);
+  }
+
+  @NotNull
+  @Override
+  public JpsModuleReference createReference(JpsParentElement parent) {
+    return new JpsModuleReferenceImpl(myModel, getName(), getEventDispatcher(), parent);
+  }
+}
@@ -0,0 +1,25 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElementKind;
+import org.jetbrains.jps.model.JpsEventDispatcher;
+import org.jetbrains.jps.model.impl.JpsElementCollectionKind;
+import org.jetbrains.jps.model.module.JpsModuleListener;
+
+/**
+ * @author nik
+ */
+public class JpsModuleKind extends JpsElementKind<JpsModuleImpl> {
+  public static final JpsElementKind<JpsModuleImpl> INSTANCE = new JpsModuleKind();
+  public static final JpsElementCollectionKind<JpsModuleImpl> MODULE_COLLECTION_KIND = new JpsElementCollectionKind<JpsModuleImpl>(INSTANCE);
+
+  @Override
+  public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsModuleImpl element) {
+    dispatcher.getPublisher(JpsModuleListener.class).moduleAdded(element);
+  }
+
+  @Override
+  public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsModuleImpl element) {
+    dispatcher.getPublisher(JpsModuleListener.class).moduleRemoved(element);
+  }
+}
@@ -0,0 +1,34 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsCompositeElement;
+import org.jetbrains.jps.model.JpsEventDispatcher;
+import org.jetbrains.jps.model.JpsModel;
+import org.jetbrains.jps.model.JpsParentElement;
+import org.jetbrains.jps.model.impl.JpsNamedElementReferenceBase;
+import org.jetbrains.jps.model.impl.JpsProjectElementReference;
+import org.jetbrains.jps.model.module.JpsModule;
+import org.jetbrains.jps.model.module.JpsModuleReference;
+
+/**
+ * @author nik
+ */
+public class JpsModuleReferenceImpl extends JpsNamedElementReferenceBase<JpsModule, JpsModuleReferenceImpl> implements JpsModuleReference {
+  public JpsModuleReferenceImpl(JpsModel model, String elementName, JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    super(model, eventDispatcher, JpsModuleKind.MODULE_COLLECTION_KIND, elementName, new JpsProjectElementReference(model, eventDispatcher, parent), parent);
+  }
+
+  @NotNull
+  @Override
+  public JpsModuleReferenceImpl createCopy(@NotNull JpsModel model,
+                                           @NotNull JpsEventDispatcher eventDispatcher,
+                                           JpsParentElement parent) {
+    return new JpsModuleReferenceImpl(model, myElementName, eventDispatcher, parent);
+  }
+
+  @NotNull
+  @Override
+  public String getModuleName() {
+    return myElementName;
+  }
+}
@@ -0,0 +1,57 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.*;
+import org.jetbrains.jps.model.impl.JpsCompositeElementBase;
+import org.jetbrains.jps.model.impl.JpsTypedDataImpl;
+import org.jetbrains.jps.model.impl.JpsTypedDataKind;
+import org.jetbrains.jps.model.module.JpsModuleSourceRoot;
+import org.jetbrains.jps.model.module.JpsModuleSourceRootType;
+
+/**
+ * @author nik
+ */
+public class JpsModuleSourceRootImpl extends JpsCompositeElementBase<JpsModuleSourceRootImpl> implements JpsModuleSourceRoot {
+  private static final JpsTypedDataKind<JpsModuleSourceRootType> TYPED_DATA_KIND = new JpsTypedDataKind<JpsModuleSourceRootType>();
+  private String myUrl;
+
+  public JpsModuleSourceRootImpl(JpsModel model, JpsEventDispatcher eventDispatcher,
+                                 String url,
+                                 JpsModuleSourceRootType type, JpsParentElement parent) {
+    super(model, eventDispatcher, parent);
+    myContainer.setChild(TYPED_DATA_KIND, new JpsTypedDataImpl<JpsModuleSourceRootType>(type, eventDispatcher, this));
+    myUrl = url;
+  }
+
+  public JpsModuleSourceRootImpl(JpsModuleSourceRootImpl original, JpsModel model, JpsEventDispatcher dispatcher, JpsParentElement parent) {
+    super(original, model, dispatcher, parent);
+    myUrl = original.myUrl;
+  }
+
+  @Override
+  public <P extends JpsElementProperties> P getProperties(@NotNull JpsModuleSourceRootType<P> type) {
+    return myContainer.getChild(TYPED_DATA_KIND).getProperties(type);
+  }
+
+  @Override
+  public <P extends JpsElementProperties> void setProperties(JpsModuleSourceRootType<P> type, P properties) {
+    myContainer.getChild(TYPED_DATA_KIND).setProperties(properties);
+  }
+
+  @NotNull
+  @Override
+  public JpsModuleSourceRootType<?> getRootType() {
+    return myContainer.getChild(TYPED_DATA_KIND).getType();
+  }
+
+  @NotNull
+  public String getUrl() {
+    return myUrl;
+  }
+
+  @NotNull
+  @Override
+  public JpsModuleSourceRootImpl createCopy(@NotNull JpsModel model, @NotNull JpsEventDispatcher eventDispatcher, JpsParentElement parent) {
+    return new JpsModuleSourceRootImpl(this, model, eventDispatcher, parent);
+  }
+}
@@ -0,0 +1,25 @@
+package org.jetbrains.jps.model.module.impl;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.JpsElementKind;
+import org.jetbrains.jps.model.JpsEventDispatcher;
+import org.jetbrains.jps.model.impl.JpsElementCollectionKind;
+import org.jetbrains.jps.model.module.JpsModuleSourceRootListener;
+
+/**
+ * @author nik
+ */
+public class JpsModuleSourceRootKind extends JpsElementKind<JpsModuleSourceRootImpl> {
+  public static final JpsModuleSourceRootKind INSTANCE = new JpsModuleSourceRootKind();
+  public static final JpsElementCollectionKind<JpsModuleSourceRootImpl> ROOT_COLLECTION_KIND = new JpsElementCollectionKind<JpsModuleSourceRootImpl>(INSTANCE);
+
+  @Override
+  public void fireElementAdded(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsModuleSourceRootImpl element) {
+    dispatcher.getPublisher(JpsModuleSourceRootListener.class).sourceRootAdded(element);
+  }
+
+  @Override
+  public void fireElementRemoved(@NotNull JpsEventDispatcher dispatcher, @NotNull JpsModuleSourceRootImpl element) {
+    dispatcher.getPublisher(JpsModuleSourceRootListener.class).sourceRootRemoved(element);
+  }
+}
@@ -0,0 +1,16 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.jps.model.java.JpsJavaModuleType;
+import org.jetbrains.jps.model.java.impl.JavaModuleExtensionKind;
+import org.jetbrains.jps.model.module.JpsModule;
+
+/**
+ * @author nik
+ */
+public class JpsJavaExtensionTest extends JpsModelTestCase {
+  public void test() {
+    final JpsModule module = myModel.getProject().addModule(JpsJavaModuleType.INSTANCE, "m");
+    JavaModuleExtensionKind.getExtension(module).setOutputUrl("file://path");
+    assertEquals("file://path", JavaModuleExtensionKind.getExtension(module).getOutputUrl());
+  }
+}
@@ -0,0 +1,48 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.jps.model.impl.JpsProjectImpl;
+import org.jetbrains.jps.model.java.JpsJavaLibraryType;
+import org.jetbrains.jps.model.library.JpsLibrary;
+import org.jetbrains.jps.model.library.JpsLibraryReference;
+import org.jetbrains.jps.model.library.JpsLibraryRootType;
+import org.jetbrains.jps.model.library.impl.JpsLibraryReferenceImpl;
+
+/**
+ * @author nik
+ */
+public class JpsLibraryTest extends JpsModelTestCase {
+  public void testAddRoot() {
+    final JpsLibrary library = myModel.getProject().addLibrary(JpsJavaLibraryType.INSTANCE, "a");
+    library.addUrl("file://my-url", JpsLibraryRootType.COMPILED);
+    assertEquals("file://my-url", assertOneElement(library.getUrls(JpsLibraryRootType.COMPILED)));
+  }
+
+  public void testModifiableCopy() {
+    myModel.getProject().addLibrary(JpsJavaLibraryType.INSTANCE, "a");
+
+    final JpsModel modifiableModel = myModel.createModifiableModel(new TestJpsEventDispatcher());
+    final JpsLibrary modifiable = assertOneElement(modifiableModel.getProject().getLibraries());
+    modifiable.addUrl("file://my-url", JpsLibraryRootType.COMPILED);
+    modifiableModel.commit();
+
+    final JpsLibrary library = assertOneElement(myModel.getProject().getLibraries());
+    assertEquals("file://my-url", assertOneElement(library.getUrls(JpsLibraryRootType.COMPILED)));
+  }
+
+  public void testCreateReferenceByLibrary() {
+    final JpsLibrary library = myModel.getProject().addLibrary(JpsJavaLibraryType.INSTANCE, "l");
+    final JpsLibraryReference reference = library.createReference(myModel.getProject());
+    assertEquals("l", reference.getLibraryName());
+    assertSame(library, reference.resolve());
+  }
+
+  public void testCreateReferenceByName() {
+    final JpsProjectImpl project = myModel.getProject();
+    JpsLibraryReference reference = new JpsLibraryReferenceImpl(myModel, myDispatcher, "l", myModel.getProject().createReference(project), project);
+    assertEquals("l", reference.getLibraryName());
+    assertNull(reference.resolve());
+
+    final JpsLibrary library = myModel.getProject().addLibrary(JpsJavaLibraryType.INSTANCE, "l");
+    assertSame(library, reference.resolve());
+  }
+}
@@ -0,0 +1,18 @@
+package org.jetbrains.jps.model;
+
+import com.intellij.testFramework.UsefulTestCase;
+import org.jetbrains.jps.model.impl.JpsModelImpl;
+
+/**
+ * @author nik
+ */
+public abstract class JpsModelTestCase extends UsefulTestCase {
+  protected JpsModelImpl myModel;
+  protected TestJpsEventDispatcher myDispatcher;
+
+  public void setUp() throws Exception {
+    super.setUp();
+    myDispatcher = new TestJpsEventDispatcher();
+    myModel = new JpsModelImpl(myDispatcher);
+  }
+}
@@ -0,0 +1,83 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.jps.model.impl.JpsProjectImpl;
+import org.jetbrains.jps.model.java.JpsJavaLibraryType;
+import org.jetbrains.jps.model.java.JpsJavaModuleType;
+import org.jetbrains.jps.model.java.JavaSourceRootProperties;
+import org.jetbrains.jps.model.java.JavaSourceRootType;
+import org.jetbrains.jps.model.library.JpsLibrary;
+import org.jetbrains.jps.model.module.*;
+import org.jetbrains.jps.model.module.impl.JpsModuleReferenceImpl;
+
+import java.util.List;
+
+/**
+ * @author nik
+ */
+public class JpsModuleTest extends JpsModelTestCase {
+  public void testAddSourceRoot() {
+    final JpsModule module = myModel.getProject().addModule(JpsJavaModuleType.INSTANCE, "m");
+    final JpsModuleSourceRoot sourceRoot = module.addSourceRoot(JavaSourceRootType.SOURCE, "file://url", new JavaSourceRootProperties("com.xxx"));
+
+    assertSameElements(myDispatcher.retrieveAdded(JpsModule.class), module);
+    assertSameElements(myDispatcher.retrieveAdded(JpsModuleSourceRoot.class), sourceRoot);
+
+    final JpsModuleSourceRoot root = assertOneElement(module.getSourceRoots());
+    assertEquals("file://url", root.getUrl());
+    final JavaSourceRootProperties properties = root.getProperties(JavaSourceRootType.SOURCE);
+    assertNotNull(properties);
+    assertEquals("com.xxx", properties.getPackagePrefix());
+  }
+
+  public void testModifiableModel() {
+    final JpsModule module = myModel.getProject().addModule(JpsJavaModuleType.INSTANCE, "m");
+    final JpsModuleSourceRoot root0 = module.addSourceRoot(JavaSourceRootType.SOURCE, "url1");
+    myDispatcher.clear();
+
+    final JpsModel modifiableModel = myModel.createModifiableModel(new TestJpsEventDispatcher());
+    final JpsModule modifiableModule = assertOneElement(modifiableModel.getProject().getModules());
+    modifiableModule.addSourceRoot(JavaSourceRootType.TEST_SOURCE, "url2");
+    modifiableModel.commit();
+
+    assertEmpty(myDispatcher.retrieveAdded(JpsModule.class));
+    assertEmpty(myDispatcher.retrieveRemoved(JpsModule.class));
+
+    final List<? extends JpsModuleSourceRoot> roots = module.getSourceRoots();
+    assertEquals(2, roots.size());
+    assertSame(root0, roots.get(0));
+    final JpsModuleSourceRoot root1 = roots.get(1);
+    assertEquals("url2", root1.getUrl());
+    assertOrderedEquals(myDispatcher.retrieveAdded(JpsModuleSourceRoot.class), root1);
+    assertEmpty(myDispatcher.retrieveChanged(JpsModuleSourceRoot.class));
+  }
+
+  public void testAddDependency() {
+    final JpsModule module = myModel.getProject().addModule(JpsJavaModuleType.INSTANCE, "m");
+    final JpsLibrary library = myModel.getProject().addLibrary(JpsJavaLibraryType.INSTANCE, "l");
+    final JpsModule dep = myModel.getProject().addModule(JpsJavaModuleType.INSTANCE, "dep");
+    module.getDependenciesList().addLibraryDependency(library);
+    module.getDependenciesList().addModuleDependency(dep);
+
+    final List<? extends JpsDependencyElement> dependencies = module.getDependenciesList().getDependencies();
+    assertEquals(2, dependencies.size());
+    assertSame(library, assertInstanceOf(dependencies.get(0), JpsLibraryDependency.class).getLibraryReference().resolve());
+    assertSame(dep, assertInstanceOf(dependencies.get(1), JpsModuleDependency.class).getModuleReference().resolve());
+  }
+
+  public void testCreateReferenceByModule() {
+    final JpsModule module = myModel.getProject().addModule(JpsJavaModuleType.INSTANCE, "m");
+    final JpsModuleReference reference = module.createReference(myModel.getProject());
+    assertEquals("m", reference.getModuleName());
+    assertSame(module, reference.resolve());
+  }
+
+  public void testCreateReferenceByName() {
+    final JpsProjectImpl project = myModel.getProject();
+    final JpsModuleReference reference = new JpsModuleReferenceImpl(myModel, "m", myDispatcher, project);
+    assertEquals("m", reference.getModuleName());
+    assertNull(reference.resolve());
+
+    final JpsModule module = project.addModule(JpsJavaModuleType.INSTANCE, "m");
+    assertSame(module, reference.resolve());
+  }
+}
@@ -0,0 +1,70 @@
+package org.jetbrains.jps.model;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jps.model.impl.JpsEventDispatcherBase;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * @author nik
+ */
+class TestJpsEventDispatcher extends JpsEventDispatcherBase implements JpsEventDispatcher {
+  private List<JpsElement> myAdded = new ArrayList<JpsElement>();
+  private List<JpsElement> myRemoved = new ArrayList<JpsElement>();
+  private List<JpsElement> myChanged = new ArrayList<JpsElement>();
+
+  @Override
+  public <T extends JpsElement> void fireElementAdded(@NotNull T element, @NotNull JpsElementKind<T> kind) {
+    super.fireElementAdded(element, kind);
+    myAdded.add(element);
+  }
+
+  @Override
+  public <T extends JpsElement> void fireElementRemoved(@NotNull T element, @NotNull JpsElementKind<T> kind) {
+    super.fireElementRemoved(element, kind);
+    myRemoved.add(element);
+  }
+
+  @Override
+  public void fireElementChanged(@NotNull JpsElement element) {
+    myChanged.add(element);
+  }
+
+  @Override
+  public void fireElementRenamed(@NotNull JpsNamedElement element, @NotNull String oldName, @NotNull String newName) {
+  }
+
+  public <T extends JpsElement> List<T> retrieveAdded(Class<T> type) {
+    return retrieve(type, myAdded);
+  }
+
+  public <T extends JpsElement> List<T> retrieveRemoved(Class<T> type) {
+    return retrieve(type, myRemoved);
+  }
+
+  public <T extends JpsElement> List<T> retrieveChanged(Class<T> type) {
+    return retrieve(type, myChanged);
+  }
+
+  public void clear() {
+    myAdded.clear();
+    myRemoved.clear();
+    myChanged.clear();
+  }
+
+
+  private static <T extends JpsElement> List<T> retrieve(Class<T> type, List<JpsElement> list) {
+    final List<T> result = new ArrayList<T>();
+    final Iterator<JpsElement> iterator = list.iterator();
+    while (iterator.hasNext()) {
+      JpsElement element = iterator.next();
+      if (type.isInstance(element)) {
+        result.add(type.cast(element));
+        iterator.remove();
+      }
+    }
+    return result;
+  }
+}