Revision 167 org.gvsig.educa.thematicmap/trunk/org.gvsig.educa.thematicmap/org.gvsig.educa.thematicmap.lib/org.gvsig.educa.thematicmap.lib.impl/src/main/java/org/gvsig/educa/thematicmap/impl/compilation/process/CopyAllLayersFiles.java
| CopyAllLayersFiles.java | ||
|---|---|---|
| 77 | 77 |
* <li>{@link ProcessData#rootLayersFolder}</li>
|
| 78 | 78 |
* </ul> |
| 79 | 79 |
* </p> |
| 80 |
*
|
|
| 80 |
* |
|
| 81 | 81 |
* @author gvSIG Team |
| 82 | 82 |
* @version $Id$ |
| 83 |
*
|
|
| 83 |
* |
|
| 84 | 84 |
*/ |
| 85 | 85 |
public class CopyAllLayersFiles implements ProcessStep {
|
| 86 | 86 |
|
| ... | ... | |
| 119 | 119 |
mapContextFolder.getAbsolutePath()); |
| 120 | 120 |
data.values.put(ROOT_LAYERS_FOLDER_PATH_KEY, |
| 121 | 121 |
rootLayersFolder.getAbsolutePath()); |
| 122 |
saveLayers(data, data.mapContext.getLayers(), mapContextFolder, namer);
|
|
| 122 |
saveLayers(data, data.mapContext.getLayers(), "", namer);
|
|
| 123 | 123 |
} |
| 124 | 124 |
|
| 125 | 125 |
/** |
| ... | ... | |
| 130 | 130 |
* This creates a new folder (using layer's name) inside |
| 131 | 131 |
* <code>parentFolde</code> and iterates over children layers. |
| 132 | 132 |
* </p> |
| 133 |
*
|
|
| 133 |
* |
|
| 134 | 134 |
* @param data |
| 135 | 135 |
* Process data |
| 136 | 136 |
* @param layers |
| 137 | 137 |
* layers to save |
| 138 |
* @param parentFolder |
|
| 139 |
* parent folder to store al data |
|
| 138 |
* @param parentPath |
|
| 139 |
* parent path |
|
| 140 |
* |
|
| 140 | 141 |
* @param namer |
| 141 | 142 |
* a layer-namer instance |
| 142 | 143 |
* @return |
| 143 | 144 |
* @throws CompilationException |
| 144 | 145 |
*/ |
| 145 | 146 |
private boolean saveLayers(ProcessData data, FLayers layers, |
| 146 |
File parentFolder, LayerNamer namer) throws CompilationException {
|
|
| 147 |
// Get new folder for layer
|
|
| 148 |
File myFolder = getLayerFolder(parentFolder, layers, namer);
|
|
| 147 |
String parentPath, LayerNamer namer) throws CompilationException {
|
|
| 148 |
// Get path for layer
|
|
| 149 |
String layerPath = getLayerPath(parentPath, layers, namer);
|
|
| 149 | 150 |
|
| 150 |
// Useful to show a layer identification |
|
| 151 |
String relativePath = getRelativePath(data, myFolder); |
|
| 152 |
|
|
| 153 | 151 |
// As this process could take long time, notify progress to listener. |
| 154 |
notifyStatus(data, relativePath);
|
|
| 152 |
notifyStatus(data, layerPath);
|
|
| 155 | 153 |
|
| 156 | 154 |
// Iterates children layers |
| 157 | 155 |
FLayer theLayer; |
| ... | ... | |
| 162 | 160 |
theLayer = layers.getLayer(i); |
| 163 | 161 |
if (theLayer instanceof SingleLayer) {
|
| 164 | 162 |
// Layer |
| 165 |
saveLayer(data, (SingleLayer) theLayer, myFolder, namer);
|
|
| 163 |
saveLayer(data, (SingleLayer) theLayer, layerPath, namer);
|
|
| 166 | 164 |
} else {
|
| 167 | 165 |
// Group of layers |
| 168 |
saveLayers(data, (FLayers) theLayer, myFolder, namer);
|
|
| 166 |
saveLayers(data, (FLayers) theLayer, layerPath, namer);
|
|
| 169 | 167 |
} |
| 170 | 168 |
} |
| 171 | 169 |
return true; |
| ... | ... | |
| 173 | 171 |
|
| 174 | 172 |
/** |
| 175 | 173 |
* Updates process status and notify it to process listener. Utility method. |
| 176 |
*
|
|
| 174 |
* |
|
| 177 | 175 |
* @param data |
| 178 | 176 |
* @param relativePath |
| 179 | 177 |
*/ |
| ... | ... | |
| 190 | 188 |
* This creates a new folder (using layer's name) inside |
| 191 | 189 |
* <code>parentFolde</code> and copies all related files. |
| 192 | 190 |
* </p> |
| 193 |
*
|
|
| 191 |
* |
|
| 194 | 192 |
* @param data |
| 195 | 193 |
* Process data |
| 196 | 194 |
* @param layers |
| ... | ... | |
| 203 | 201 |
* @throws CompilationException |
| 204 | 202 |
*/ |
| 205 | 203 |
private void saveLayer(ProcessData data, SingleLayer layer, |
| 206 |
File parentFolder, LayerNamer namer) throws CompilationException {
|
|
| 204 |
String parentPath, LayerNamer namer) throws CompilationException {
|
|
| 207 | 205 |
// Get new folder for layer |
| 208 |
File myFolder = getLayerFolder(parentFolder, layer, namer);
|
|
| 206 |
String myPath = getLayerPath(parentPath, layer, namer);
|
|
| 209 | 207 |
|
| 210 |
// Useful to show a layer identification |
|
| 211 |
String relativePath = getRelativePath(data, myFolder); |
|
| 212 |
|
|
| 213 | 208 |
// As this process could take long time, notify progress to listener. |
| 214 |
notifyStatus(data, relativePath);
|
|
| 209 |
notifyStatus(data, myPath);
|
|
| 215 | 210 |
|
| 216 | 211 |
PersistentState layerPerStatus; |
| 217 | 212 |
Set<File> sourceFiles; |
| ... | ... | |
| 229 | 224 |
sourceFiles = PersistenceUtils.getRelatedFiles(layerPerStatus); |
| 230 | 225 |
} catch (PersistenceException e) {
|
| 231 | 226 |
throw new CompilationException( |
| 232 |
"problem getting info from layer: ".concat(relativePath), e);
|
|
| 227 |
"problem getting info from layer: ".concat(myPath), e);
|
|
| 233 | 228 |
} |
| 234 | 229 |
|
| 235 | 230 |
File target; |
| ... | ... | |
| 240 | 235 |
return; |
| 241 | 236 |
} |
| 242 | 237 |
|
| 243 |
// get a new filename to copy file |
|
| 244 |
target = FileUtils.getNewFileName(myFolder, source.getName()); |
|
| 245 |
// get relative file path to inform to the listener |
|
| 246 |
targetRelativePath = getRelativePath(data, target); |
|
| 247 |
notifyStatus(data, targetRelativePath); |
|
| 248 |
if (data.status.isCancellationRequested()) {
|
|
| 249 |
return; |
|
| 238 |
// Look at target folder for file (if its already copied |
|
| 239 |
target = findAlreadyCopied(data.rootLayersFolder, source); |
|
| 240 |
|
|
| 241 |
if (target == null) {
|
|
| 242 |
// File not copied or is not the very same |
|
| 243 |
|
|
| 244 |
// TODO normalize filename to avoid encoding problems |
|
| 245 |
String targetName = source.getName(); |
|
| 246 |
|
|
| 247 |
// get a new filename for target file |
|
| 248 |
target = |
|
| 249 |
FileUtils.getNewFileName(data.rootLayersFolder, targetName); |
|
| 250 |
|
|
| 251 |
// get relative file path to inform to the listener |
|
| 252 |
targetRelativePath = getRelativePath(data, target); |
|
| 253 |
notifyStatus(data, targetRelativePath); |
|
| 254 |
if (data.status.isCancellationRequested()) {
|
|
| 255 |
return; |
|
| 256 |
} |
|
| 257 |
try {
|
|
| 258 |
// Copy the file (preserve time stamp for better file |
|
| 259 |
// comparing in 'findAlreadyCopied' method ) |
|
| 260 |
FileUtils.copyFile(source, target, true); |
|
| 261 |
} catch (IOException e) {
|
|
| 262 |
throw new CompilationException( |
|
| 263 |
MessageFormat.format( |
|
| 264 |
"problem copying file related to layer '{0}': '{1}' --> '{2}'",
|
|
| 265 |
myPath, source.getAbsolutePath(), |
|
| 266 |
target.getAbsolutePath()), e); |
|
| 267 |
} |
|
| 250 | 268 |
} |
| 251 |
try {
|
|
| 252 |
// Copy the file |
|
| 253 |
FileUtils.copyFile(source, target); |
|
| 254 |
} catch (IOException e) {
|
|
| 255 |
throw new CompilationException( |
|
| 256 |
MessageFormat.format( |
|
| 257 |
"problem copying file related to layer '{0}': '{1}' --> '{2}'",
|
|
| 258 |
relativePath, source.getAbsolutePath(), |
|
| 259 |
target.getAbsolutePath()), e); |
|
| 260 |
} |
|
| 261 | 269 |
// Adds a new entry on finals file mapping |
| 262 | 270 |
data.fileMapping.put(source, target); |
| 263 | 271 |
} |
| 264 | 272 |
} |
| 265 | 273 |
|
| 266 | 274 |
/** |
| 275 |
* <p> |
|
| 276 |
* Look at <code>rootLayersFolder</code> for <code>source</code> |
|
| 277 |
* </p> |
|
| 278 |
* <p> |
|
| 279 |
* This compares not only name, but file length and modification time stamp |
|
| 280 |
* </p> |
|
| 281 |
* |
|
| 282 |
* @param rootLayersFolder |
|
| 283 |
* @param source |
|
| 284 |
* file to check |
|
| 285 |
* @return null if not found or file |
|
| 286 |
*/ |
|
| 287 |
private File findAlreadyCopied(File rootLayersFolder, File source) {
|
|
| 288 |
String fileName = FilenameUtils.getName(source.getAbsolutePath()); |
|
| 289 |
File target = new File(rootLayersFolder, fileName); |
|
| 290 |
if (!target.exists()) {
|
|
| 291 |
return null; |
|
| 292 |
} |
|
| 293 |
if (!target.isFile()) {
|
|
| 294 |
return null; |
|
| 295 |
} |
|
| 296 |
if (target.length() != source.length()) {
|
|
| 297 |
return null; |
|
| 298 |
} |
|
| 299 |
if (FileUtils.isFileNewer(target, source)) {
|
|
| 300 |
return null; |
|
| 301 |
} |
|
| 302 |
if (FileUtils.isFileOlder(target, source)) {
|
|
| 303 |
return null; |
|
| 304 |
} |
|
| 305 |
return target; |
|
| 306 |
} |
|
| 307 |
|
|
| 308 |
/** |
|
| 267 | 309 |
* Gets file path relative to layer folder |
| 268 |
*
|
|
| 310 |
* |
|
| 269 | 311 |
* @param data |
| 270 | 312 |
* @param file |
| 271 | 313 |
* @return |
| ... | ... | |
| 282 | 324 |
|
| 283 | 325 |
/** |
| 284 | 326 |
* <p> |
| 285 |
* Generate a layer folder based on its name
|
|
| 327 |
* Generate a layer path
|
|
| 286 | 328 |
* </p> |
| 287 |
* <p> |
|
| 288 |
* Avoid problems of duplicate layer name |
|
| 289 |
* </p> |
|
| 290 |
* |
|
| 329 |
* |
|
| 291 | 330 |
* @param parentFolder |
| 292 | 331 |
* @param flayer |
| 293 | 332 |
* @param namer |
| 294 | 333 |
* @return |
| 295 | 334 |
*/ |
| 296 |
private File getLayerFolder(File parentFolder, FLayer flayer,
|
|
| 335 |
private String getLayerPath(String parentFolder, FLayer flayer,
|
|
| 297 | 336 |
LayerNamer namer) {
|
| 298 |
// Uses FileUtils.getNewWritableFolder to avoid |
|
| 299 |
// duplicate names problem |
|
| 300 |
return FileUtils.getNewWritableFolder(parentFolder, |
|
| 301 |
namer.getLayerName(flayer)); |
|
| 337 |
return parentFolder.concat("/").concat(namer.getLayerName(flayer));
|
|
| 302 | 338 |
|
| 303 | 339 |
} |
| 304 | 340 |
|
| 305 | 341 |
/** |
| 306 | 342 |
* Utility class to get a layer name for those layers which hasn't |
| 307 |
*
|
|
| 343 |
* |
|
| 308 | 344 |
* @author gvSIG Team |
| 309 | 345 |
* @version $Id$ |
| 310 |
*
|
|
| 346 |
* |
|
| 311 | 347 |
*/ |
| 312 | 348 |
private class LayerNamer {
|
| 313 | 349 |
|
Also available in: Unified diff