|
1 package org.antlr.works.project;
2
3 import org.antlr.xjlib.foundation.XJUtils;
4
5 import java.io.File  ;
6 import java.io.Serializable ;
7 import java.util.*;
8
38
39 public class ProjectBuildList {
40
41 protected Map<String , Map<Object , BuildFile>> files = new HashMap<String , Map<Object , BuildFile>>();
42
43 public ProjectBuildList() {
44 }
45
46 public void addFile(String filePath, String type) {
47 getMapForType(type).put(filePath, new BuildFile(filePath));
48 }
49
50 public void removeFile(String filePath, String type) {
51 getMapForType(type).remove(filePath);
52 }
53
54 public void setFileDirty(ProjectFileItem item, boolean dirty) {
55 setFileDirty(item.getFilePath(), item.getFileType(), dirty);
56 }
57
58 public void setFileDirty(String filePath, String type, boolean dirty) {
59 BuildFile f = getMapForType(type).get(filePath);
60 if(f != null)
61 f.setDirty(dirty);
62 }
63
64 public void setIgnoreBuild(ProjectFileItem item, boolean ignore) {
65 setIgnoreBuild(item.getFilePath(), item.getFileType(), ignore);
66 }
67
68 public void setIgnoreBuild(String filePath, String fileType, boolean ignore) {
69 BuildFile f = getMapForType(fileType).get(filePath);
70 if(f != null)
71 f.setIgnore(ignore);
72 }
73
74 public boolean isIgnoreBuild(ProjectFileItem item) {
75 return isIgnoreBuild(item.getFilePath(), item.getFileType());
76 }
77
78 public boolean isIgnoreBuild(String filePath, String fileType) {
79 BuildFile f = getMapForType(fileType).get(filePath);
80 if(f != null)
81 return f.isIgnore();
82 else
83 return false;
84 }
85
86 public void setAllFilesToDirty(boolean flag) {
87 for (Iterator<Map<Object , BuildFile>> typeIterator = files.values().iterator(); typeIterator.hasNext();) {
88 Map<Object , BuildFile> m = typeIterator.next();
89 for (Iterator<BuildFile> fileIterator = m.values().iterator(); fileIterator.hasNext();) {
90 BuildFile file = fileIterator.next();
91 file.setDirty(true);
92 }
93 }
94 }
95
96 public boolean isFileExisting(String filePath, String type) {
97 return getMapForType(type).containsKey(filePath);
98 }
99
100 public BuildFile getBuildFile(ProjectFileItem item) {
101 return getBuildFile(item.getFilePath(), item.getFileType());
102 }
103
104 public BuildFile getBuildFile(String filePath, String type) {
105 for (Iterator<BuildFile> iterator = getBuildFilesOfType(type).iterator(); iterator.hasNext();) {
106 BuildFile file = iterator.next();
107 if(file.getFilePath().equals(filePath))
108 return file;
109 }
110 return null;
111 }
112
113 public List<BuildFile> getBuildFilesOfType(String type) {
114 List<BuildFile> files = new ArrayList<BuildFile>();
115 for (Iterator<BuildFile> iterator = getMapForType(type).values().iterator(); iterator.hasNext();) {
116 files.add(iterator.next());
117 }
118 return files;
119 }
120
121 public List<BuildFile> getDirtyBuildFilesOfType(String type) {
122 List<BuildFile> dirtyFiles= new ArrayList<BuildFile>();
123 for (Iterator<BuildFile> iterator = getBuildFilesOfType(type).iterator(); iterator.hasNext();) {
124 BuildFile file = iterator.next();
125 if(file.isDirty() && !file.isIgnore())
126 dirtyFiles.add(file);
127 }
128 return dirtyFiles;
129 }
130
131 public boolean handleExternalModification(String filePath, String type) {
132 BuildFile f = getBuildFile(filePath, type);
133 if(f == null)
134 return false;
135
136 return f.handleExternalModification();
137 }
138
139 public void resetModificationDate(ProjectFileItem item) {
140 BuildFile f = getBuildFile(item);
141 if(f != null)
142 f.resetModificationDate();
143 }
144
145 public boolean handleExternalModification() {
146 boolean modified = false;
147 for (Iterator<Map<Object , BuildFile>> typeIterator = files.values().iterator(); typeIterator.hasNext();) {
148 Map<Object , BuildFile> m = typeIterator.next();
149 for (Iterator<BuildFile> fileIterator = m.values().iterator(); fileIterator.hasNext();) {
150 BuildFile file = fileIterator.next();
151 if(file.handleExternalModification()) {
152 modified = true;
153 }
154 }
155 }
156 return modified;
157 }
158
159 public void setPersistentData(Map<String ,Map> data) {
160 files.clear();
161
162 for (Iterator<String > typeIterator = data.keySet().iterator(); typeIterator.hasNext();) {
163 String type = typeIterator.next();
164 files.put(type, new HashMap<Object , BuildFile>());
165
166 for (Iterator fileDataIterator = (data.get(type)).values().iterator(); fileDataIterator.hasNext();) {
167 Map persistentData = (Map) fileDataIterator.next();
168 BuildFile file = new BuildFile();
169 file.setPersistentData(persistentData);
170 (files.get(type)).put(file.filePath, file);
171 }
172 }
173 }
174
175 public Map<String ,Map<Object ,Map<Object ,Serializable >>> getPersistentData() {
176 Map<String ,Map<Object ,Map<Object ,Serializable >>> data = new HashMap<String , Map<Object ,Map<Object , Serializable >>>();
177
178 for (Iterator<String > typeIterator = files.keySet().iterator(); typeIterator.hasNext();) {
179 String type = typeIterator.next();
180 Map<Object ,Map<Object ,Serializable >> dataFiles = new HashMap<Object , Map<Object ,Serializable >>();
181 for (Iterator<BuildFile> fileIterator = (files.get(type)).values().iterator(); fileIterator.hasNext();) {
182 BuildFile file = fileIterator.next();
183 dataFiles.put(file.filePath, file.getPersistentData());
184 }
185 data.put(type, dataFiles);
186 }
187
188 return data;
189 }
190
191 private Map<Object , BuildFile> getMapForType(String type) {
192 Map<Object , BuildFile> m = files.get(type);
193 if(m == null) {
194 m = new HashMap<Object , BuildFile>();
195 files.put(type, m);
196 }
197 return m;
198 }
199
200 public class BuildFile {
201
202 private String filePath;
203 private boolean dirty;
204 private boolean ignore;
205 private long modificationDate;
206
207 public BuildFile() {
208 this.dirty = true;
209 this.ignore = false;
210 resetModificationDate();
211 }
212
213 public BuildFile(String filePath) {
214 this.filePath = filePath;
215 this.dirty = true;
216 this.ignore = false;
217 resetModificationDate();
218 }
219
220 public void setDirty(boolean flag) {
221 this.dirty = flag;
222 }
223
224 public boolean isDirty() {
225 return dirty;
226 }
227
228 public void setIgnore(boolean ignore) {
229 this.ignore = ignore;
230 }
231
232 public boolean isIgnore() {
233 return ignore;
234 }
235
236 public String getFilePath() {
237 return filePath;
238 }
239
240 public String getFileFolder() {
241 return XJUtils.getPathByDeletingLastComponent(getFilePath());
242 }
243
244 public boolean isModifiedOnDisk() {
245 return modificationDate != getDateOfModificationOnDisk();
246 }
247
248 public void resetModificationDate() {
249 modificationDate = getDateOfModificationOnDisk();
250 }
251
252 public boolean handleExternalModification() {
253 if(isModifiedOnDisk()) {
254 setDirty(true);
255 resetModificationDate();
256 return true;
257 } else
258 return false;
259 }
260
261 public long getDateOfModificationOnDisk() {
262 File f = null;
263 try {
264 f = new File (filePath);
265 } catch(Exception e) {
266 }
268
269 if(f == null)
270 return 0;
271 else
272 return f.lastModified();
273 }
274
275 static final String KEY_FILE_PATH = "KEY_FILE_PATH";
276 static final String KEY_DIRTY = "KEY_DIRTY";
277 static final String KEY_IGNORE = "KEY_IGNORE";
278 static final String KEY_MODIFICATION_DATE = "KEY_MODIFICATION_DATE";
279
280 public void setPersistentData(Map data) {
281 filePath = (String ) data.get(KEY_FILE_PATH);
282 dirty = ((Boolean ) data.get(KEY_DIRTY)).booleanValue();
283 ignore = ((Boolean ) data.get(KEY_IGNORE)).booleanValue();
284 modificationDate = ((Long ) data.get(KEY_MODIFICATION_DATE)).longValue();
285 }
286
287 public Map<Object ,Serializable > getPersistentData() {
288 Map<Object ,Serializable > m = new HashMap<Object , Serializable >();
289 m.put(KEY_FILE_PATH, filePath);
290 m.put(KEY_DIRTY, Boolean.valueOf(dirty));
291 m.put(KEY_IGNORE, Boolean.valueOf(ignore));
292 m.put(KEY_MODIFICATION_DATE, new Long (modificationDate));
293 return m;
294 }
295
296 }
297 }
298 |
Popular Tags |
Java API By Example, From Geeks To Geeks.