39a9da53d7bd449aaeab54ed939da3854f42cb05
[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.NonNls;
28 import org.jetbrains.annotations.NotNull;
29 import org.jetbrains.annotations.Nullable;
30
31 import java.util.Collection;
32 import java.util.Collections;
33 import java.util.HashMap;
34 import java.util.Map;
35
36 public class ArtifactImpl extends UserDataHolderBase implements ModifiableArtifact {
37   private CompositePackagingElement<?> myRootElement;
38   private String myName;
39   private boolean myBuildOnMake;
40   private String myOutputPath;
41   private final EventDispatcher<? extends ArtifactListener> myDispatcher;
42   private ArtifactType myArtifactType;
43   private Map<ArtifactPropertiesProvider, ArtifactProperties<?>> myProperties;
44   private final ProjectModelExternalSource myExternalSource;
45
46   public ArtifactImpl(@NotNull String name, @NotNull ArtifactType artifactType, boolean buildOnMake,
47                       @NotNull CompositePackagingElement<?> rootElement, String outputPath,
48                       @Nullable ProjectModelExternalSource externalSource) {
49     this(name, artifactType, buildOnMake, rootElement, outputPath, externalSource, null);
50   }
51
52   public ArtifactImpl(@NotNull String name, @NotNull ArtifactType artifactType, boolean buildOnMake,
53                       @NotNull CompositePackagingElement<?> rootElement, String outputPath,
54                       @Nullable ProjectModelExternalSource externalSource, EventDispatcher<? extends ArtifactListener> dispatcher) {
55     myName = name;
56     myArtifactType = artifactType;
57     myBuildOnMake = buildOnMake;
58     myRootElement = rootElement;
59     myOutputPath = outputPath;
60     myDispatcher = dispatcher;
61     myExternalSource = externalSource;
62     myProperties = new HashMap<>();
63     resetProperties();
64   }
65
66   private void resetProperties() {
67     myProperties.clear();
68     for (ArtifactPropertiesProvider provider : ArtifactPropertiesProvider.getProviders()) {
69       if (provider.isAvailableFor(myArtifactType)) {
70         myProperties.put(provider, provider.createProperties(myArtifactType));
71       }
72     }
73   }
74
75   @Override
76   @NotNull
77   public ArtifactType getArtifactType() {
78     return myArtifactType;
79   }
80
81   @Override
82   public String getName() {
83     return myName;
84   }
85
86   @Override
87   public boolean isBuildOnMake() {
88     return myBuildOnMake;
89   }
90
91   @Override
92   @NotNull
93   public CompositePackagingElement<?> getRootElement() {
94     return myRootElement;
95   }
96
97   @Override
98   public String getOutputPath() {
99     return myOutputPath;
100   }
101
102   @Override
103   public Collection<? extends ArtifactPropertiesProvider> getPropertiesProviders() {
104     return Collections.unmodifiableCollection(myProperties.keySet());
105   }
106
107   @Nullable
108   @Override
109   public ProjectModelExternalSource getExternalSource() {
110     return myExternalSource;
111   }
112
113   public ArtifactImpl createCopy(EventDispatcher<? extends ArtifactListener> dispatcher) {
114     final ArtifactImpl artifact = new ArtifactImpl(myName, myArtifactType, myBuildOnMake, myRootElement, myOutputPath, myExternalSource,
115                                                    dispatcher);
116     for (Map.Entry<ArtifactPropertiesProvider, ArtifactProperties<?>> entry : myProperties.entrySet()) {
117       final ArtifactProperties newProperties = artifact.myProperties.get(entry.getKey());
118       //noinspection unchecked
119       newProperties.loadState(entry.getValue().getState());
120     }
121     return artifact;
122   }
123
124   @Override
125   public void setName(@NotNull String name) {
126     String oldName = myName;
127     myName = name;
128     if (myDispatcher != null) {
129       myDispatcher.getMulticaster().artifactChanged(this, oldName);
130     }
131   }
132
133   @NonNls @Override
134   public String toString() {
135     return "artifact:" + myName;
136   }
137
138   @Override
139   public void setRootElement(CompositePackagingElement<?> root) {
140     myRootElement = root;
141   }
142
143   @Override
144   public void setProperties(@NotNull ArtifactPropertiesProvider provider, @Nullable ArtifactProperties<?> properties) {
145     if (properties != null) {
146       myProperties.put(provider, properties);
147     }
148     else {
149       myProperties.remove(provider);
150     }
151   }
152
153   @Override
154   public void setArtifactType(@NotNull ArtifactType selected) {
155     myArtifactType = selected;
156     resetProperties();
157   }
158
159   @Override
160   public void setBuildOnMake(boolean buildOnMake) {
161     myBuildOnMake = buildOnMake;
162   }
163
164   @Override
165   public void setOutputPath(String outputPath) {
166     myOutputPath = outputPath;
167   }
168
169   @Override
170   public ArtifactProperties<?> getProperties(@NotNull ArtifactPropertiesProvider provider) {
171     return myProperties.get(provider);
172   }
173
174   @Override
175   public VirtualFile getOutputFile() {
176     String filePath = getOutputFilePath();
177     return !StringUtil.isEmpty(filePath) ? LocalFileSystem.getInstance().findFileByPath(filePath) : null;
178   }
179
180   @Override
181   public String getOutputFilePath() {
182     if (StringUtil.isEmpty(myOutputPath)) return null;
183
184     String filePath;
185     if (myRootElement instanceof ArchivePackagingElement) {
186       filePath = myOutputPath + "/" + ((ArchivePackagingElement)myRootElement).getArchiveFileName();
187     }
188     else {
189       filePath = myOutputPath;
190     }
191     return filePath;
192   }
193
194   public void copyFrom(ArtifactImpl modified) {
195     myName = modified.getName();
196     myOutputPath = modified.getOutputPath();
197     myBuildOnMake = modified.isBuildOnMake();
198     myRootElement = modified.getRootElement();
199     myProperties = modified.myProperties;
200     myArtifactType = modified.getArtifactType();
201   }
202 }