Application: gvSIG desktop

        logger.error(err, e);

        try {

            dispatchError(err, e);

        } catch(Exception ex) {

        }

	public void saveState(OutputStream out, File rootFolder) throws PersistenceException;

import java.io.IOException;

import java.util.zip.ZipException;

import java.util.zip.ZipFile;

        if( !isValidZIP(out) ) {

            throw new PersistenceException(new ZipException());

        }

    boolean isValidZIP(final File file) {

        ZipFile zipfile = null;

        try {

            zipfile = new ZipFile(file);

            return true;

        } catch (IOException e) {

            return false;

        } finally {

            try {

                if (zipfile != null) {

                    zipfile.close();

                    zipfile = null;

                }

            } catch (IOException e) {

            }

        }

    }

import java.util.zip.ZipException;

import java.util.zip.ZipFile;

    /**

     * Escribe el proyecto en disco. 

     * Pero permite decidir si se pide confirmaci?n para sobreescribir

     *

     * @param file Fichero.

     * @param p Proyecto.

     * @param askConfirmation boolean

     * @return

     */

public boolean writeProject(File file, Project p, boolean askConfirmation) {

        I18nManager i18n = ToolsLocator.getI18nManager();

        ApplicationManager application = ApplicationLocator.getManager();

        if (askConfirmation && file.exists()) {

            int resp = application.confirmDialog(

                    i18n.getTranslation("fichero_ya_existe_seguro_desea_guardarlo"), 

                    i18n.getTranslation("guardar"), 

                    JOptionPane.YES_NO_OPTION, 

                    JOptionPane.QUESTION_MESSAGE, 

                    "Overwrite_project_file"

            );

            if (resp != JOptionPane.YES_OPTION) {

                return false;

            }

        }

        FileOutputStream fout=null;

        ZipOutputStream zout=null;

        LOG.info("Writing project '"+ file.getAbsolutePath()+"'.");

        try {

            fireBeforeSavingFileEvent(new SaveEvent(this,SaveEvent.BEFORE_SAVING, file));

            fout = new FileOutputStream(file);

            zout = new ZipOutputStream(fout);

            p.saveState(zout, file.getParentFile());

                LOG.warn("Can't save preview image'.", ex);

            fireAfterSavingFileEvent(new SaveEvent(this, SaveEvent.AFTER_SAVING, file));

            if( !isValidZIP(file) ) {

                throw new ZipException("Invalid project file '"+file.getAbsolutePath()+"'");

            }

            PluginServices.getMainFrame().setTitle(file.getName());

            setPath(file.toString());

        } catch (Exception e) {

            application.messageDialog(

                    i18n.getTranslation("_Problems_saving_the_project_XnlX_It_is_possible_that_this_was_not_saved_properly_and_can_not_be_loaded_again"), 

                    null, 

                    i18n.getTranslation("guardar"), 

                    JOptionPane.ERROR_MESSAGE, 

                    "Problems_saving_the_project"

            );

            LOG.warn("Error writing project '"+file.getAbsolutePath()+"'.", e);

            return false;

        } finally {

            IOUtils.closeQuietly(zout);

            IOUtils.closeQuietly(fout);

        }

        LOG.warn("Wrote project '"+file.getAbsolutePath()+"'.");

        return true;

    }

    boolean isValidZIP(final File file) {

        ZipFile zipfile = null;

        try {

            zipfile = new ZipFile(file);

            return true;

        } catch (IOException e) {

            return false;

        } finally {

            try {

                if (zipfile != null) {

                    zipfile.close();

                    zipfile = null;

                }

            } catch (IOException e) {

            }

        }

    }

_default_expression_evaluator=Evaluador de expresiones por defecto

_Problems_saving_the_project_XnlX_It_is_possible_that_this_was_not_saved_properly_and_can_not_be_loaded_again=Problemas guardando el proyecto.\nEs posible que este no se haya guardado correctamente y no se pueda volver a cargar.

_default_expression_evaluator=Default expression evaluator

_Problems_saving_the_project_XnlX_It_is_possible_that_this_was_not_saved_properly_and_can_not_be_loaded_again=Problems saving the project.\nIt is possible that this was not saved properly and can not be loaded again.

org.gvsig.temporarystorage.TemporaryStorageLibrary

    public static TemporaryStorageManager getTemporaryStorageManager() throws LocatorException {

org.gvsig.temporarystorage.impl.TemporaryStorageImplLibrary

package org.gvsig.temporarystorage.impl;

import org.gvsig.temporarystorage.TemporaryStorageLibrary;

import org.gvsig.temporarystorage.TemporaryStorageLocator;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

public class TemporaryStorageImplLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsImplementationOf(TemporaryStorageLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

        TemporaryStorageLocator.registerManager(DefaultTemporaryStorageManager.class);

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

    }

}

import org.gvsig.expressionevaluator.integration.DefaultEvaluatorFactory;

import org.gvsig.expressionevaluator.integration.DefaultExpressionEvaluator;

    private SymbolTable delegatedSymbolTable;

    private Map<String,Object> vars;

    private Map<String,Function> functions;

    public DefaultSymbolTable(SymbolTable delegatedSymbolTable) {

        this.delegatedSymbolTable = delegatedSymbolTable;

    @Override

    public MutableSymbolTable clone() throws CloneNotSupportedException {

        DefaultSymbolTable other = (DefaultSymbolTable) super.clone();

        if( this.delegatedSymbolTable!=null ) {

            other.delegatedSymbolTable = this.delegatedSymbolTable.clone();

        }

        other.vars = new HashMap<>(vars);

        other.functions = new HashMap<>(functions);

        return other;

    }

        if( fn == null && this.delegatedSymbolTable != null ) {

            fn = this.delegatedSymbolTable.function(name);

            e = this.delegatedSymbolTable.exists(name);

        return this.delegatedSymbolTable.value(name);

        this.delegatedSymbolTable = symbolTable;

        return this.delegatedSymbolTable;

    private String literal;

    @Override

    public Token clone() throws CloneNotSupportedException {

        // We will assume that the properties of the class are immutable, so 

        // it would suffice to call the super class.

        DefaultToken other = (DefaultToken) super.clone(); 

        return other;

    }

    @Override

    @Override

    @Override

    @Override

    @Override

    public void setLiteral(String literal) {

        this.literal = literal;

    }

    public CodeBuilder clone() throws CloneNotSupportedException {

        // This implementation of CodeBuilder does not maintain state, so 

        // we only call the super class.

        DefaultCodeBuilder other = (DefaultCodeBuilder) super.clone();

        return other;

    }

    @Override

        ((BaseArguments)args).add(arg1);

        ((BaseArguments)args).add(arg1);

        ((BaseArguments)args).add(arg2);

import org.gvsig.expressionevaluator.LexicalAnalyzer;

    public LexicalAnalyzer clone() throws CloneNotSupportedException {

        // As this implementation does not add state to the abstract class, we 

        // just call the super class.

        SQLLexicalAnalyzer other = (SQLLexicalAnalyzer) super.clone();

        return other;

    }

    @Override

            token.setLiteral("+" + token.getLiteral());

    private Cache cache;

    public Interpreter clone() throws CloneNotSupportedException {

        DefaultInterpreter other = (DefaultInterpreter) super.clone();

        other.cache = new DefaultCache();

        if( this.symbolTable!=null ) {

            other.symbolTable = this.symbolTable.clone();

        }

        return other;

    }

    @Override

        if( this.symbolTable==null ) {

            this.symbolTable = SQLSymbolTable.getInstance();

        }

                caller.function(this.getSymbolTable().function(caller.name()));

            if( !this.getSymbolTable().exists(name) ) {

            value = this.getSymbolTable().value(name);

                function = this.getSymbolTable().function(caller.name());

import org.gvsig.tools.lang.Cloneable;

    protected class Buffer implements Cloneable {

        @Override

        public Buffer clone() throws CloneNotSupportedException {

            Buffer other = (Buffer) super.clone(); 

            other.builder = new StringBuilder(builder);

            return other;

        }

    private NumberFormat nf;

    private ParsePosition nfPos;

    private Stack<Integer> states;

    protected Buffer buffer;

    protected DefaultToken token;

    protected Map<String, Integer> tokens;

    public LexicalAnalyzer clone() throws CloneNotSupportedException {

        AbstractLexicalAnalyzer other = (AbstractLexicalAnalyzer) super.clone();

        other.nf = NumberFormat.getInstance(Locale.UK);

        other.nfPos = new ParsePosition(0);

        other.buffer = buffer.clone();

        other.token = (DefaultToken) token.clone();

        other.states = new Stack<>();

        other.states.addAll(states);

        other.tokens = new HashMap<>(tokens);

        return other;

    }

    @Override

    @Override

    @SuppressWarnings("CloneDoesntCallSuperClone")

    public SymbolTable clone() throws CloneNotSupportedException {

        // SQLSymbolTable is singleton and immutable, so we just return 

        // the same instance.

        return this;

    }

    public Compiler clone() throws CloneNotSupportedException {

        DefaultCompiler other = (DefaultCompiler) super.clone();

        other.lexer = lexer.clone();

        other.codeBuilder = codeBuilder.clone();

        return other;

    }

    @Override

    public CodeBuilder getCodeBuilder() {

        return this.codeBuilder;

    }

    @Override

                ((DefaultCodeBuilder.BaseArguments)args).add(arg);

import org.gvsig.tools.lang.Cloneable;

public interface CodeBuilder extends Cloneable {

    @Override

    public CodeBuilder clone() throws CloneNotSupportedException;    

import org.gvsig.tools.lang.Cloneable;

public interface ExpressionEvaluator extends EvaluatorWithDescriptions, Cloneable  {

    @Override

    public ExpressionEvaluator clone() throws CloneNotSupportedException;

import org.gvsig.tools.lang.Cloneable;

public interface Interpreter extends Cloneable {

    @Override

    public Interpreter clone() throws CloneNotSupportedException;

import org.gvsig.tools.lang.Cloneable;

public interface LexicalAnalyzer extends Cloneable {

    public interface Token extends Cloneable {

        @Override

        public Token clone() throws CloneNotSupportedException;

    @Override

    public LexicalAnalyzer clone() throws CloneNotSupportedException;

    @Override

    public MutableSymbolTable clone() throws CloneNotSupportedException;

import org.gvsig.tools.lang.Cloneable;

public interface Compiler extends Cloneable {

    public CodeBuilder getCodeBuilder();

    @Override

    public Compiler clone() throws CloneNotSupportedException;

import org.gvsig.tools.lang.Cloneable;

public interface SymbolTable extends Iterable<Function>, Cloneable {

    @Override

    public SymbolTable clone() throws CloneNotSupportedException;

    public FeatureReference getFeatureReference(String code);

        public String getCode();

    @Override

    public FeatureReference getFeatureReference(String code) {

        FeatureReference featureReference = new DefaultFeatureReference(this, code);

        return featureReference;

    }

import java.util.Base64;

import org.json.JSONArray;

import org.json.JSONObject;

        private final int OID_INDEX = 0;

        private final int MYHASHCODE_INDEX = 1;

        private final int ISNEWFEATURE_INDEX = 2;

        private final int FEATURETYPEID_INDEX = 3;

        private final int PKNAMES_SIZE_INDEX = 4;

        private final int PKNAMES_INDEX = 5;

        private final int PK_INDEX = 6;

	public DefaultFeatureReference(FeatureStore store, String code) {

            this.storeRef = new WeakReference(store);

            String json = new String(Base64.getDecoder().decode(code.getBytes()));

            JSONArray x = new JSONArray(json);

            this.oid = x.get(OID_INDEX);

            if( x.get(MYHASHCODE_INDEX)==JSONObject.NULL ) {

                this.myHashCode = null;

            } else {

                this.myHashCode = x.getInt(MYHASHCODE_INDEX);

            }

            this.isNewFeature = x.getBoolean(ISNEWFEATURE_INDEX);

            this.featureTypeId = x.getString(FEATURETYPEID_INDEX);

            int pkNames_size = x.getInt(PKNAMES_SIZE_INDEX);

            if( pkNames_size<0 ) {

                this.pk = null;

                this.pkNames = null;

            } else {

                this.pk = new Object[pkNames_size];

                this.pkNames = new String[pkNames_size];

                JSONArray xx = x.getJSONArray(PKNAMES_INDEX);

                for( int i=0; i<xx.length(); i++ ) {

                    this.pkNames[i] = xx.getString(i);

                }

                xx = x.getJSONArray(PKNAMES_INDEX);

                for( int i=0; i<xx.length(); i++ ) {

                    this.pk[i] = xx.get(i);

                }

            }

//            JSONObject x = new JSONObject(json);

//            this.oid = x.get("oid");

//            this.myHashCode = x.getInt("myHashCode");

//            this.isNewFeature = x.getBoolean("isNewFeature");

//            this.featureTypeId = x.getString("featureTypeId");

//            int pkNames_size = x.getInt("pkNames_size");

//            if( pkNames_size<0 ) {

//                this.pk = null;

//                this.pkNames = null;

//            } else {

//                this.pk = new Object[pkNames_size];

//                this.pkNames = new String[pkNames_size];

//                JSONArray xx = x.getJSONArray("pkNames");

//                for( int i=0; i<xx.length(); i++ ) {

//                    this.pkNames[i] = xx.getString(i);

//                }

//                xx = x.getJSONArray("pk");

//                for( int i=0; i<xx.length(); i++ ) {

//                    this.pk[i] = xx.get(i);

//                }

//            }

        }

        private DefaultFeatureStore getStore() {

        @Override

        public String getCode() {

//            JSONObject x = new JSONObject();

////            x.put("store", (Persistent) storeRef.get());

//            x.put("oid", oid);

//            x.put("myHashCode", myHashCode);

//            x.put("isNewFeature", isNewFeature);

//            x.put("featureTypeId", featureTypeId);

//            if( this.pk == null ) {

//                x.put("pkNames_size", -1);

//                x.put("pkNames", JSONObject.NULL);

//                x.put("pk", JSONObject.NULL);

//            } else {

//                x.put("pkNames_size", pkNames.length);

//                x.put("pkNames", new JSONArray(this.pkNames));

//                x.put("pk", new JSONArray(this.pk));

//            }

//

            Object[] data = new Object[7];

            data[OID_INDEX] = this.oid;

            data[MYHASHCODE_INDEX] = this.myHashCode;

            data[ISNEWFEATURE_INDEX] = this.isNewFeature;

            data[FEATURETYPEID_INDEX] = this.featureTypeId;

            if( this.pk == null ) {

                data[PKNAMES_SIZE_INDEX] = -1;

                data[PKNAMES_INDEX] = JSONObject.NULL;

                data[PK_INDEX] = JSONObject.NULL;

            } else {

                data[PKNAMES_SIZE_INDEX] = pkNames.length;

                data[PKNAMES_INDEX] = new JSONArray(this.pkNames);

                data[PK_INDEX] = new JSONArray(this.pk);            

            }            

            String s = new JSONArray(data).toString();

            String r = Base64.getEncoder().encodeToString(s.getBytes());

            return r;

        }

/**

 * 

 * @deprecated use org.gvsig.tools.util.PropertiesSupport

 */