[project-model] findModuleForPsiElement: check original file if PsiFile is supplied
[idea/community.git] / java / compiler / impl / src / com / intellij / packaging / impl / artifacts / ArtifactImpl.java
1 /*
2  * Copyright 2000-2009 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.packaging.impl.artifacts;
17
18 import com.intellij.openapi.roots.ProjectModelExternalSource;
19 import com.intellij.openapi.util.UserDataHolderBase;
20 import com.intellij.openapi.util.text.StringUtil;
21 import com.intellij.openapi.vfs.LocalFileSystem;
22 import com.intellij.openapi.vfs.VirtualFile;
23 import com.intellij.packaging.artifacts.*;
24 import com.intellij.packaging.elements.CompositePackagingElement;
25 import com.intellij.packaging.impl.elements.ArchivePackagingElement;
26 import com.intellij.util.EventDispatcher;
27 import org.jetbrains.annotations.Nls;
28 import org.jetbrains.annotations.NonNls;
29 import org.jetbrains.annotations.NotNull;
30 import org.jetbrains.annotations.Nullable;
31
32 import java.util.Collection;
33 import java.util.Collections;
34 import java.util.HashMap;
35 import java.util.Map;
36
37 public class ArtifactImpl extends UserDataHolderBase implements ModifiableArtifact {
38   private CompositePackagingElement<?> myRootElement;
39   private @Nls(capitalization = Nls.Capitalization.Title) String myName;
40   private boolean myBuildOnMake;
41   private String myOutputPath;
42   private final EventDispatcher<? extends ArtifactListener> myDispatcher;
43   private ArtifactType myArtifactType;
44   private Map<ArtifactPropertiesProvider, ArtifactProperties<?>> myProperties;
45   private final ProjectModelExternalSource myExternalSource;
46
47   public ArtifactImpl(@NotNull @Nls(capitalization = Nls.Capitalization.Title) String name,
48                       @NotNull ArtifactType artifactType, boolean buildOnMake,
49                       @NotNull CompositePackagingElement<?> rootElement, String outputPath,
50                       @Nullable ProjectModelExternalSource externalSource) {
51     this(name, artifactType, buildOnMake, rootElement, outputPath, externalSource, null);
52   }
53
54   public ArtifactImpl(@NotNull @Nls(capitalization = Nls.Capitalization.Title) String name,
55                       @NotNull ArtifactType artifactType, boolean buildOnMake,
56                       @NotNull CompositePackagingElement<?> rootElement, String outputPath,
57                       @Nullable ProjectModelExternalSource externalSource, EventDispatcher<? extends ArtifactListener> dispatcher) {
58     myName = name;
59     myArtifactType = artifactType;
60     myBuildOnMake = buildOnMake;
61     myRootElement = rootElement;
62     myOutputPath = outputPath;
63     myDispatcher = dispatcher;
64     myExternalSource = externalSource;
65     myProperties = new HashMap<>();
66     resetProperties();
67   }
68
69   private void resetProperties() {
70     myProperties.clear();
71     for (ArtifactPropertiesProvider provider : ArtifactPropertiesProvider.getProviders()) {
72       if (provider.isAvailableFor(myArtifactType)) {
73         myProperties.put(provider, provider.createProperties(myArtifactType));
74       }
75     }
76   }
77
78   @Override
79   @NotNull
80   public ArtifactType getArtifactType() {
81     return myArtifactType;
82   }
83
84   @Override
85   public String getName() {
86     return myName;
87   }
88
89   @Override
90   public boolean isBuildOnMake() {
91     return myBuildOnMake;
92   }
93
94   @Override
95   @NotNull
96   public CompositePackagingElement<?> getRootElement() {
97     return myRootElement;
98   }
99
100   @Override
101   public String getOutputPath() {
102     return myOutputPath;
103   }
104
105   @Override
106   public Collection<? extends ArtifactPropertiesProvider> getPropertiesProviders() {
107     return Collections.unmodifiableCollection(myProperties.keySet());
108   }
109
110   @Nullable
111   @Override
112   public ProjectModelExternalSource getExternalSource() {
113     return myExternalSource;
114   }
115
116   public ArtifactImpl createCopy(EventDispatcher<? extends ArtifactListener> dispatcher) {
117     final ArtifactImpl artifact = new ArtifactImpl(myName, myArtifactType, myBuildOnMake, myRootElement, myOutputPath, myExternalSource,
118                                                    dispatcher);
119     for (Map.Entry<ArtifactPropertiesProvider, ArtifactProperties<?>> entry : myProperties.entrySet()) {
120       final ArtifactProperties newProperties = artifact.myProperties.get(entry.getKey());
121       //noinspection unchecked
122       newProperties.loadState(entry.getValue().getState());
123     }
124     return artifact;
125   }
126
127   @Override
128   public void setName(@NotNull String name) {
129     String oldName = myName;
130     myName = name;
131     if (myDispatcher != null) {
132       myDispatcher.getMulticaster().artifactChanged(this, oldName);
133     }
134   }
135
136   @NonNls @Override
137   public String toString() {
138     return "artifact:" + myName;
139   }
140
141   @Override
142   public void setRootElement(CompositePackagingElement<?> root) {
143     myRootElement = root;
144   }
145
146   @Override
147   public void setProperties(@NotNull ArtifactPropertiesProvider provider, @Nullable ArtifactProperties<?> properties) {
148     if (properties != null) {
149       myProperties.put(provider, properties);
150     }
151     else {
152       myProperties.remove(provider);
153     }
154   }
155
156   @Override
157   public void setArtifactType(@NotNull ArtifactType selected) {
158     myArtifactType = selected;
159     resetProperties();
160   }
161
162   @Override
163   public void setBuildOnMake(boolean buildOnMake) {
164     myBuildOnMake = buildOnMake;
165   }
166
167   @Override
168   public void setOutputPath(String outputPath) {
169     myOutputPath = outputPath;
170   }
171
172   @Override
173   public ArtifactProperties<?> getProperties(@NotNull ArtifactPropertiesProvider provider) {
174     return myProperties.get(provider);
175   }
176
177   @Override
178   public VirtualFile getOutputFile() {
179     String filePath = getOutputFilePath();
180     return !StringUtil.isEmpty(filePath) ? LocalFileSystem.getInstance().findFileByPath(filePath) : null;
181   }
182
183   @Override
184   public String getOutputFilePath() {
185     if (StringUtil.isEmpty(myOutputPath)) return null;
186
187     String filePath;
188     if (myRootElement instanceof ArchivePackagingElement) {
189       filePath = myOutputPath + "/" + ((ArchivePackagingElement)myRootElement).getArchiveFileName();
190     }
191     else {
192       filePath = myOutputPath;
193     }
194     return filePath;
195   }
196
197   public void copyFrom(ArtifactImpl modified) {
198     myName = modified.getName();
199     myOutputPath = modified.getOutputPath();
200     myBuildOnMake = modified.isBuildOnMake();
201     myRootElement = modified.getRootElement();
202     myProperties = modified.myProperties;
203     myArtifactType = modified.getArtifactType();
204   }
205 }