Application: gvSIG desktop

package org.gvsig.fmap.dal.store.h2;

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.MalformedURLException;

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.util.Collections;

import java.util.Objects;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.apache.commons.io.IOUtils;

import org.gvsig.fmap.dal.AbstractDataResource;

import org.gvsig.fmap.dal.DataServerExplorer.DataResource;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

class H2SpatialResource 

        extends AbstractDataResource

        implements DataResource 

    {

    private final File zipFile;

    private final String tableName;

    private InputStream in;

    private ByteArrayOutputStream out;

    private FileSystem zipfs;

    private final URI zipfsuri;

    public H2SpatialResource(File zipFile, String tableName) {

        this.zipFile = zipFile;

        this.tableName = tableName;

        try {

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

        } catch (URISyntaxException ex) {

            throw new IllegalArgumentException("The zip file '" + Objects.toString(zipFile) + "' is not a valid file name.", ex);

        }

    }

    @Override

    public URL getURL() {

        try {

            return new URL(this.zipfsuri.toString()+"!"+this.tableName);

        } catch (MalformedURLException ex) {

            return null;

        }

    }

    private void openzipfs(boolean create) throws IOException {

        if (this.zipfs == null) {

            this.zipfs = FileSystems.newFileSystem(this.zipfsuri, Collections.singletonMap("create", create ? "true" : "false"));

        }

    }

    @Override

    public boolean exists() {

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

            return false;

        }

        try {

            this.openzipfs(false);

            Path tablePath = this.zipfs.getPath(this.tableName);

            if (tablePath == null) {

                return false;

            }

            return true;

        } catch (Exception 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 {

            this.openzipfs(false);

            Path tablePath = this.zipfs.getPath(this.tableName);

            if (tablePath == null) {

                return null;

            }

            this.in = Files.newInputStream(tablePath);

            return this.in;

        } catch (Exception ex) {

            return null;

        }

    }

    @Override

    public OutputStream asOutputStream() throws IOException {

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

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

        }

        this.out = new ByteArrayOutputStream();

        return this.out;

    }

    @Override

    public void close() {

        if (this.in != null) {

            IOUtils.closeQuietly(this.in);

            this.in = null;

        }

        if (this.out != null) {

            ByteArrayInputStream pipe = null;

            try {

                this.openzipfs(true);

                Path tablePath = this.zipfs.getPath(this.tableName);

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

                Files.copy(pipe, tablePath);

            } catch (Exception ex) {

            } finally {

                IOUtils.closeQuietly(pipe);

                IOUtils.closeQuietly(this.out);

                this.out = null;

            }

        }

        if (this.zipfs != null) {

            IOUtils.closeQuietly(this.zipfs);

        }

    }

}