Application: gvSIG desktop

    public JDBCNewStoreParameters getAddParameters() throws DataException {

    public JDBCStoreParameters get(String name) throws DataException {

    JDBCStoreParameters get(String name) throws DataException;

    JDBCNewStoreParameters getAddParameters() throws DataException;

    List<String> getDataStoreProviderNames();

    List<DataStoreParameters> list(int mode) throws DataException;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

    public List<DataStoreParameters> list(int mode) throws DataException;

    public JDBCStoreParameters get(String name) throws DataException;

import java.sql.Blob;

                        if( value instanceof Blob ) {

                            Blob blob = (Blob)value;

                            value = blob.getBytes(0, (int) blob.length());

                            blob.free();

                        }

package org.gvsig.fmap.dal.store.jdbc2.spi;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.URL;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import static org.gvsig.fmap.dal.DataManager.RESOURCES_FIELD_NAME;

import static org.gvsig.fmap.dal.DataManager.RESOURCES_FIELD_RESOURCE;

import static org.gvsig.fmap.dal.DataManager.RESOURCES_TABLE_NAME;

import org.gvsig.fmap.dal.feature.EditableFeature;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.resourcesstorage.AbstractResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class JDBCResourcesStorage extends AbstractResourcesStorage {

    private static final Logger LOGGER = LoggerFactory.getLogger(JDBCResourcesStorage.class);

    private static class DataBaseResource implements Resource {

        private class ResourceInputStream extends InputStream {

            @Override

            public int read() throws IOException {

                return in.read();

            }

            @Override

            public void close() throws IOException {

                DataBaseResource.this.close();

            }

        }

        private class ResourceOutputStream extends OutputStream {

            @Override

            public void write(int b) throws IOException {

                out.write(b);

            }

            @Override

            public void flush() throws IOException {

                out.flush();

            }

            @Override

            public void close() throws IOException {

                DataBaseResource.this.close();

            }

        }

        private final JDBCStoreParameters storeParameters;

        private final String tableName;

        private final String name;

        private ByteArrayInputStream in;

        private ByteArrayOutputStream out;

        public DataBaseResource(JDBCStoreParameters storeParameters, String tableName, String name) {

            this.storeParameters = storeParameters;

            this.tableName = tableName;

            this.name = name;

        }

        @Override

        public boolean isReadOnly() {

            return false;

        }

        @Override

        public URL getURL() {

            try {

                String url = this.storeParameters.getUrl();

                return new URL(url + "&tableName=" + this.tableName + "&resourceName=" + this.name);

            } catch (Throwable ex) {

                return null;

            }

        }

        @Override

        public boolean exists() {

            FeatureStore store = null;

            try {

                DataManager dataManager = DALLocator.getDataManager();

                store = (FeatureStore) dataManager.openStore(

                        this.storeParameters.getDataStoreName(),

                        this.storeParameters

                );

                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                String filter = builder.eq(

                        builder.column(RESOURCES_FIELD_NAME),

                        builder.constant(this.tableName+"/"+this.name)

                ).toString();

                Feature feature = store.findFirst(filter);

                return feature!=null;

            } catch (Throwable ex) {

                LOGGER.warn("Can't access to the resoure '" + this.getURL() + "'.", ex);

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

            return false;

        }

        @Override

        public InputStream asInputStream() throws IOException {

            if (this.in != null || this.out != null) {

                throw new IllegalStateException("Resource is already open (" + this.getURL() + ")");

            }

            FeatureStore store = null;

            try {

                DataManager dataManager = DALLocator.getDataManager();

                store = (FeatureStore) dataManager.openStore(

                        this.storeParameters.getDataStoreName(),

                        this.storeParameters

                );

                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                String filter = builder.eq(

                        builder.column(RESOURCES_FIELD_NAME),

                        builder.constant(this.tableName+"/"+this.name)

                ).toString();

                Feature feature = store.findFirst(filter);

                if (feature == null) {

                    return null;

                }

                byte[] resource = feature.getByteArray(RESOURCES_FIELD_RESOURCE);

                this.in = new ByteArrayInputStream(resource);

                return new ResourceInputStream();

            } catch (Throwable ex) {

                LOGGER.warn("Can't access to the resoure '" + this.getURL() + "'.", ex);

            } finally {

                DisposeUtils.disposeQuietly(store);

            }

            return null;

        }

        @Override

        public OutputStream asOutputStream() throws IOException {

            if (this.in != null || this.out != null) {

                throw new IllegalStateException("Resource is already open (" + this.getURL() + ").");

            }

            this.out = new ByteArrayOutputStream();

            return new ResourceOutputStream();

        }

        @Override

        public void close() {

            if (this.in != null) {

                IOUtils.closeQuietly(this.in);

                this.in = null;

            }

            if (this.out != null) {

                FeatureStore store = null;

                try {

                    DataManager dataManager = DALLocator.getDataManager();

                    store = (FeatureStore) dataManager.openStore(

                            this.storeParameters.getDataStoreName(),

                            this.storeParameters

                    );

                    store.edit();

                    ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                    String filter = builder.eq(

                            builder.column(RESOURCES_FIELD_NAME),

                            builder.constant(this.tableName+"/"+this.name)

                    ).toString();

                    Feature feature = store.findFirst(filter);

                    EditableFeature efeature;

                    if (feature == null) {

                        efeature = store.createNewFeature();

                        efeature.set(RESOURCES_FIELD_NAME, this.tableName+"/"+this.name);

                        efeature.set(RESOURCES_FIELD_RESOURCE, this.out.toByteArray());

                        store.insert(efeature);

                    } else {

                        efeature = feature.getEditable();

                        efeature.set(RESOURCES_FIELD_RESOURCE, this.out.toByteArray());

                        store.update(efeature);

                    }

                    store.finishEditing();

                } catch (Throwable ex) {

                    LOGGER.warn("Can't write the resoure '" + this.getURL() + "'.", ex);

                } finally {

                    DisposeUtils.disposeQuietly(store);

                }

            }

        }

    }

    private final JDBCStoreParameters resourcesStoreParameters;

    private final String tableName;

    public JDBCResourcesStorage(JDBCStoreParameters resourcesStoreParameters, String tableName) {

        if( StringUtils.equals(RESOURCES_TABLE_NAME, tableName) ) {

            // No podemos buscar recursos de la tabla de recursos, ya que si no

            // al abrise la tabla de recursos entraria en bucle.

            this.resourcesStoreParameters = null;

        } else {

            this.resourcesStoreParameters = resourcesStoreParameters;

        }

        this.tableName = tableName;

    }

    @Override

    public boolean isEmpty() {

        return this.resourcesStoreParameters == null;

    }

    @Override

    public Resource getResource(String name) {

        if (this.resourcesStoreParameters == null) {

            return null;

        }

        return new DataBaseResource(

                this.resourcesStoreParameters, 

                this.tableName, 

                name

        );

    }

    @Override

    public List<Resource> getResources(String name) {

        if (this.resourcesStoreParameters == null) {

            return null;

        }

        FeatureStore store = null;

        try {

            DataManager dataManager = DALLocator.getDataManager();

            store = (FeatureStore) dataManager.openStore(

                    this.resourcesStoreParameters.getDataStoreName(),

                    this.resourcesStoreParameters

            );

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            List<ResourcesStorage.Resource> ress = new ArrayList<>();

            int n = 0;

            while (true) {

                String multiresourceName;

                if (n == 0) {

                    multiresourceName = name;

                } else {

                    multiresourceName = String.valueOf(n) + "." + name;

                }

                String filter = builder.eq(

                        builder.column(RESOURCES_FIELD_NAME),

                        builder.constant(multiresourceName)

                ).toString();

                Feature feature = store.findFirst(filter);

                if( feature==null ) {

                    break;

                }

                ress.add(new DataBaseResource(

                        this.resourcesStoreParameters, 

                        this.tableName,

                        multiresourceName

                    )

                );

                n++;

            }

            if (ress.isEmpty()) {

                return null;

            }

            return ress;

        } catch (Throwable ex) {

            LOGGER.warn("Can't get resources for '" + this.resourcesStoreParameters.getUrl()+"&resourceName="+name + "'.", ex);

            return null;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

}

import static org.gvsig.fmap.dal.DataManager.RESOURCES_TABLE_NAME;

import org.gvsig.tools.resourcesstorage.EmptyResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

@SuppressWarnings("UseSpecificCatch")

    public JDBCStoreParameters get(String name) throws DataException {

    @Override

    public ResourcesStorage getResourcesStorage(DataStore dataStore) {

        if( this.resourcesStorage==null ) {

            try {

                List<JDBCStoreParameters> tables = this.list();

                for (JDBCStoreParameters params : tables) {

                    String theTableName = params.getTable();

                    if (StringUtils.equals(theTableName, RESOURCES_TABLE_NAME)) {

                        this.resourcesStorage = new JDBCResourcesStorage(

                                params,

                                dataStore.getName()

                        );

                        return this.resourcesStorage;

                    }

                }

                this.resourcesStorage = new EmptyResourcesStorage();

            } catch (Throwable ex) {

                LOG.warn("Can't retrieve reources storage from table '" + RESOURCES_TABLE_NAME + "' in '"+this.getParameters().getUrl()+"'.", ex);

            }

        }

        return this.resourcesStorage;

    }

import org.gvsig.fmap.dal.spi.ZipResourcesStorage;

import org.gvsig.tools.resourcesstorage.EmptyResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

    public ResourcesStorage getResourcesStorage(DataStore dataStore) {

        ResourcesStorage ress = super.getResourcesStorage(dataStore);

        if( ress instanceof EmptyResourcesStorage ) {

            String zipPath = this.getParameters().getFile().getAbsolutePath();

            String zipPathName = FilenameUtils.removeExtension(zipPath);

            this.resourcesStorage = new ZipResourcesStorage(zipPathName, dataStore.getName());

        return this.resourcesStorage;

        this.type_bytearray = "BLOB";

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

            Class theClass = attrdesc.getDataType().getDefaultClass();

            if( theClass==null ) {

                return String.class;

            }

            return theClass;

    private int maxSearhFields = 4;

            this.maxSearhFields = Integer.min(orderedAttributes.size(), 4);

                if( n<this.maxSearhFields ) {

                    searchField.setAttribute(orderedAttributes.get(n++).getName());

                } else {

                    searchField.setEnabled(false);

                }

        int n=0;

            if( n<this.maxSearhFields ) {

                searchField.setEnabled(enabled);

            } else {

                searchField.setEnabled(false);

            }

            n++;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.resourcesstorage.EmptyResourcesStorage;

        return new EmptyResourcesStorage();

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

    public List<DataStoreParameters> list() throws DataException;

    public List<DataStoreParameters> list(int mode) throws DataException;

     * @param provider

    public List<String> getDataStoreProviderNames();

     * @deprecated use getResourcesStorage

    public ResourcesStorage getResourcesStorage(DataStore dataStore);

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

    public ResourcesStorage getResourcesStorage();

    public StoresRepository getStoresRepository();

    // Constant to manage ResourcesStorage in a DDBB.

    public static final String RESOURCES_TABLE_NAME = "gvsigd_resources";

    public static final String RESOURCES_FIELD_NAME = "name";

    public static final String RESOURCES_FIELD_RESOURCE = "resource";

import org.gvsig.tools.resourcesstorage.ResourcesStorage.Resource;

	public byte[] getByteArray(String name);

	public byte[] getByteArray(int index);

        /**

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

package org.gvsig.fmap.dal.spi;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.nio.file.FileSystem;

import java.nio.file.FileSystems;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.StandardCopyOption;

import java.util.Collections;

import java.util.Objects;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.AbstractDataResource;

import org.gvsig.tools.resourcesstorage.AbstractResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage.Resource;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class ZipResourcesStorage extends AbstractResourcesStorage {

    private static final Logger LOGGER = LoggerFactory.getLogger(ZipResourcesStorage.class);

    public class ZipFileResource

            extends AbstractDataResource

            implements Resource {

        private class ResourceInputStream extends InputStream {

            @Override

            public int read() throws IOException {

                return in.read();

            }

            @Override

            public void close() throws IOException {

                ZipFileResource.this.close();

            }

        }

        private class ResourceOutputStream extends OutputStream {

            @Override

            public void write(int b) throws IOException {

                out.write(b);

            }

            @Override

            public void flush() throws IOException {

                out.flush();

            }

            @Override

            public void close() throws IOException {

                ZipFileResource.this.close();

            }

        }

        private final File zipFile;

        private final String tableName;

        private final String resourceName;

        private ZipFile zip;

        private InputStream in;

        private ByteArrayOutputStream out;

        public ZipFileResource(File zipFile, String tableName, String resourceName) {

            this.zipFile = zipFile;

            this.tableName = tableName;

            this.resourceName = resourceName;

            this.zip = null;

            this.in = null;

            this.out = null;

            if (StringUtils.isBlank(this.tableName)) {

                LOGGER.warn("The table name is empty (URL=" + this.getURL() + ").");

            }

            if (StringUtils.isBlank(this.resourceName)) {

                LOGGER.warn("The resource name is empty (URL=" + this.getURL() + ").");

            }

        }

        @Override

        public boolean isReadOnly() {

            return false;

        }

        @Override

        public final URL getURL() {

            try {

                return new URL("jar:" + this.zipFile.toURI().toString() + "!/" + this.tableName + "." + this.resourceName);

            } catch (Exception ex) {

                return null;

            }

        }

        @Override

        public boolean exists() {

            try {

                if (!this.zipFile.exists()) {

                    return false;

                }

                ZipFile z = new ZipFile(zipFile);

                try {

                    ZipEntry entry = z.getEntry(this.tableName + "." + this.resourceName);

                    if (entry == null) {

                        return false;

                    }

                    return true;

                } finally {

                    IOUtils.closeQuietly(z);

                }

            } catch (Exception ex) {

                LOGGER.warn("Can't access to the resource (" + Objects.toString(this.getURL()) + ").", ex);

                return false;

            }

        }

        @Override

        public InputStream asInputStream() throws IOException {

            if (!this.zipFile.exists()) {

                return null;

            }

            if (this.in != null || this.out != null) {

                throw new IllegalStateException("Resource is already open (" + this.zipFile.toString() + "!" + this.tableName + ")");

            }

            try {

                if (this.zip == null) {

                    this.zip = new ZipFile(zipFile);

                }

                ZipEntry entry = this.zip.getEntry(this.tableName + "." + this.resourceName);

                if (entry == null) {

                    return null;

                }

                this.in = this.zip.getInputStream(entry);

                return new ResourceInputStream();

            } catch (Exception ex) {

                LOGGER.warn("Can't create input stream (" + Objects.toString(this.getURL()) + ").", ex);

                return null;

            }

        }

        @Override

        public OutputStream asOutputStream() throws IOException {

            if (this.in != null || this.out != null) {

                throw new IllegalStateException("Resource is already open (" + Objects.toString(this.getURL()) + ").");

            }

            this.out = new ByteArrayOutputStream();

            return new ResourceOutputStream();

        }

        @Override

        public void close() {

            if (this.in != null) {

                IOUtils.closeQuietly(this.in);

                this.in = null;

            }

            if (this.out != null) {

                ByteArrayInputStream contents = new ByteArrayInputStream(this.out.toByteArray());

                try {

                    this.updateZipEntry(zipFile, this.tableName + "." + this.resourceName, contents);

                } catch (Exception ex) {

                    LOGGER.warn("Can't write resource (" + Objects.toString(this.getURL()) + ").", ex);

                } finally {

                    IOUtils.closeQuietly(contents);

                    IOUtils.closeQuietly(this.out);

                    this.out = null;

                }

            }

            if (this.zip != null) {

                IOUtils.closeQuietly(this.zip);

                this.zip = null;

            }

        }

        private void updateZipEntry(File zip, String entryName, InputStream entryContents) throws URISyntaxException, IOException {

            FileSystem zipfs = null;

            try {

                URI zipfsuri = new URI("jar:" + zip.toURI().toString());

                zipfs = FileSystems.newFileSystem(zipfsuri, Collections.singletonMap("create", "true"));

                Path entryPath = zipfs.getPath(entryName);

                Files.copy(entryContents, entryPath, StandardCopyOption.REPLACE_EXISTING);

            } finally {

                IOUtils.closeQuietly(zipfs);

            }

        }

    }

    private final File zipFile;

    private final String tableName;

    public ZipResourcesStorage(String pathName, String tableName) {

        this.zipFile = new File(pathName + ".gvres");

        this.tableName = tableName;

    }

    public static boolean existsStorage(String pathName) {

        File theZipFile = new File(pathName + ".gvres");

        return theZipFile.exists();

    }

    @Override

    public Resource getResource(String resourceName) {

        ZipFileResource res = new ZipFileResource(

                this.zipFile,

                this.tableName,

                resourceName

        );

        return res;

    }

    @Override

    public boolean isEmpty() {

        return !this.zipFile.exists();

    }

}

import org.gvsig.tools.resourcesstorage.EmptyResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage.Resource;

    protected ResourcesStorage resourcesStorage = null;

    public ResourcesStorage getResourcesStorage(DataStore dataStore) {

        if( this.resourcesStorage==null ) {

            this.resourcesStorage = new EmptyResourcesStorage();

        }

        return this.resourcesStorage;

import org.gvsig.fmap.dal.spi.ZipResourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.resourcesstorage.FilesResourcesStorage;

        try {

            ResourcesStorage theResourceStorage = this.getResourcesStorage(dataStore);

            if( theResourceStorage==null ) {

                return null;

            }

            FilesResourcesStorage.FileResource res = (FilesResourcesStorage.FileResource) theResourceStorage.getResource(resourceName);

            if( res==null ) {

                return null;

            }

            return res.getFile();

        } catch(Exception ex) {

    public ResourcesStorage getResourcesStorage(DataStore dataStore) {

        if( this.resourcesStorage==null ) {

            FilesystemServerExplorerProvider provider;

            try {

                provider = this.getProvider(dataStore.getProviderName());

            } catch (Exception ex) {

                return null;

            if (provider == null) {

                return null;

            String pathName = provider.getResourceRootPathName(dataStore);

            if (pathName == null) {

                return null;

            }

            pathName = FilenameUtils.removeExtension(pathName);

            if( dataStore.getChildren().isEmpty() ) {

                if( ZipResourcesStorage.existsStorage(pathName) ) {

                    this.resourcesStorage = new ZipResourcesStorage(

                            pathName,

                            dataStore.getName()

                    );

                } else {

                    this.resourcesStorage = new FilesResourcesStorage(

                            pathName

                    );

                }

            } else {

                this.resourcesStorage = new ZipResourcesStorage(

                        pathName,

                        dataStore.getName()

                );

            }

        return this.resourcesStorage;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

        org.gvsig.tools.resourcesstorage.ResourcesStorage.Resource resource = null;

            ResourcesStorage resourcesStorage = this.getResourcesStorage();

            if( resourcesStorage == null || resourcesStorage.isReadOnly() ) {

            resource = resourcesStorage.getResource("dal");

            if( resource == null || resource.isReadOnly() ) {