Application: gvSIG desktop

import java.io.IOException;

import java.net.URI;

import java.net.URL;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentContext;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.spi.PersistentContextServices;

    private static Logger logger =

        LoggerFactory.getLogger(SymbolLibrary.class);

			// copy files and update fields

			try {

			    sym = (ISymbol) copyFilesToFolder(

			        sym, folder, new HashMap());

			} catch (Exception exc) {

			    logger.info("Error while copying symbol files.", exc);

			    return;

			}

    private static Object copyFilesToFolder(

        Object sym,

        File theFolder,

        Map processedFilesMap

        // Set processedObjSet,

        /*int dep*/) throws Exception {

        PersistenceManager manager =

            ToolsLocator.getPersistenceManager();

        PersistentState state = null;

        state = manager.getState(sym, true);

        PersistentContext context = state.getContext();

        List<PersistentState> states_list = getList(context);

        int len = states_list.size();

        for (int i=0; i<len; i++) {

            PersistentState aState = states_list.get(i);

            DynStruct definition = aState.getDefinition();

            DynField[] fields = definition.getDynFields();

            File value_file = null;

            File value_file_new = null;

            URL value_url = null;

            URI value_uri = null;

            File donefile = null;

            Object value_obj = null;

            Object value_obj_new = null;

            for (DynField field : fields) {

                if (field.getType() == DataTypes.FILE) {

                    value_file = aState.getFile(field.getName());

                    donefile = (File) processedFilesMap.get(value_file);

                    if (donefile == null) {

                        /*

                         * It was NOT processed before

                         */

                        value_file_new = copyFile(value_file, theFolder);

                        aState.set(field.getName(), value_file_new);

                        processedFilesMap.put(value_file, value_file_new);

                    } else {

                        /*

                         * It was processed before

                         */

                        aState.set(field.getName(), donefile);

                    }

                } else if (field.getType() == DataTypes.URL) {

                    value_url = aState.getURL(field.getName());

                    if ("FILE".equalsIgnoreCase(value_url.getProtocol())) {

                        File urlfile = new File(value_url.getFile());

                        donefile = (File) processedFilesMap.get(urlfile);

                        if (donefile == null) {

                            value_file_new = copyFile(urlfile, theFolder);

                            value_url = value_file_new.toURI().toURL();

                            aState.set(field.getName(), value_url);

                            processedFilesMap.put(urlfile, value_file_new);

                        } else {

                            value_url = donefile.toURI().toURL();

                            aState.set(field.getName(), value_url);

                        }

                    }

                } else if (field.getType() == DataTypes.URI) {

                    value_uri = aState.getURI(field.getName());

                    if (value_uri.getScheme() == null ||

                        "FILE".equalsIgnoreCase(value_uri.getScheme())) {

                        File urifile = new File(value_uri.toURL().getFile());

                        donefile = (File) processedFilesMap.get(urifile);

                        if (donefile == null) {

                            value_file_new = copyFile(urifile, theFolder);

                            value_uri = value_file_new.toURI();

                            aState.set(field.getName(), value_uri);

                            processedFilesMap.put(urifile, value_file_new);

                        } else {

                            value_uri = donefile.toURI();

                            aState.set(field.getName(), value_uri);

                        }

                    }

                }

            }

        }

        // ================================

        if (context instanceof PersistentContextServices) {

            /*

             * Ensure that previous instances are not used,

             * so objects are recreated

             */

            ((PersistentContextServices) context).clear();

        }

        Object resp = manager.create(state);

        return resp;

    }

    /**

     * @param context

     * @return

     */

    private static List<PersistentState> getList(PersistentContext context) {

        Iterator<PersistentState> iter = context.iterator();

        List<PersistentState> resp = new ArrayList<PersistentState>();

        while (iter.hasNext()) {

            resp.add(iter.next());

        }

        return resp;

    }

    /*

    private static Object recreate(PersistentState stat)

        throws Exception {

        File tmp = File.createTempFile("sym" + System.currentTimeMillis(), ".xml");

        FileOutputStream fos = new FileOutputStream(tmp);

        PersistenceManager mana = ToolsLocator.getPersistenceManager();

        mana.saveState(stat, fos);

        fos.flush();

        fos.close();

        FileInputStream fis = new FileInputStream(tmp);

        PersistentState nstat = mana.loadState(fis);

        fis.close();

        Object resp = mana.create(nstat);

        return resp;

    }

    */

    /**

     * Copies file to destination folder. If a file with same name

     * exists, destination name is changed. The final destination

     * file is returned.

     * 

     * @param srcfile

     * @param dstfolder

     * @return

     * @throws IOException

     */

    private static File copyFile(File srcfile, File dstfolder) 

    throws IOException {

        if (srcfile == null || dstfolder == null

            || !srcfile.isFile() || !dstfolder.isDirectory()

            || !srcfile.exists()) {

            throw new IOException("Bad parameters in copyFile method");

        }

        if (srcfile.getParentFile().equals(dstfolder)) {

            // already in place, nothing to do

            return srcfile;

        }

        if (!dstfolder.exists()) {

            dstfolder.mkdirs();

        }

        String checkfile = dstfolder.getCanonicalPath()

            + File.separator + srcfile.getName();

        File aux = new File(checkfile);

        File targetFile = null;

        if (aux.exists()) {

            // a file with that name exists and is not the same file

            // so we must create a new target file name

            targetFile = getAvailableFileName(dstfolder, srcfile.getName());

        } else {

            targetFile = aux;

        }

        FileUtils.copyFile(srcfile, targetFile);

        return targetFile;

    }

    /**

     * 

     * Gets an available file name in the folder, using

     * the name provided. It will add an index until an

     * unused name is found

     * 

     * @param dstfolder

     * @param name

     * @return

     */

    private static File getAvailableFileName(

        File dstfolder, String name) throws IOException {

        int index = -1;

        boolean exists = true;

        String tryname = null;

        String checkfile = null;

        File tryfile = null;

        while (exists) {

            index++;

            tryname = "" + index + "_" + name;

            checkfile = dstfolder.getCanonicalPath()

                + File.separator + tryname;

            tryfile = new File(checkfile);

            exists = tryfile.exists();

        }

        return tryfile;

    }