eu.esdihumboldt.hale.io.shp.ShapefileAdvisor.java Source code

Introduction

Here is the source code for eu.esdihumboldt.hale.io.shp.ShapefileAdvisor.java

Source

/*
 * Copyright (c) 2013 Data Harmonisation Panel
 * 
 * All rights reserved. This program and the accompanying materials are made
 * available under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this distribution. If not, see <http://www.gnu.org/licenses/>.
 * 
 * Contributors:
 *     Data Harmonisation Panel <http://www.dhpanel.eu>
 */

package eu.esdihumboldt.hale.io.shp;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.nio.file.Paths;

import org.eclipse.core.runtime.content.IContentType;
import org.geotools.data.shapefile.files.ShpFileType;

import com.google.common.io.ByteStreams;

import de.fhg.igd.slf4jplus.ALogger;
import de.fhg.igd.slf4jplus.ALoggerFactory;
import eu.esdihumboldt.hale.common.core.io.HaleIO;
import eu.esdihumboldt.hale.common.core.io.impl.DefaultResourceAdvisor;
import eu.esdihumboldt.hale.common.core.io.report.IOReporter;
import eu.esdihumboldt.hale.common.core.io.supplier.DefaultInputSupplier;
import eu.esdihumboldt.hale.common.core.io.supplier.LocatableInputSupplier;

/**
 * Resource advisor for Shapefiles. When copying a Shapefile it also copies the
 * auxiliary files.
 * 
 * @author Simon Templer
 */
public class ShapefileAdvisor extends DefaultResourceAdvisor {

    private static final ALogger log = ALoggerFactory.getLogger(ShapefileAdvisor.class);

    @Override
    public void copyResource(LocatableInputSupplier<? extends InputStream> resource, final Path target,
            IContentType resourceType, boolean includeRemote, IOReporter reporter) throws IOException {
        URI orgUri = resource.getLocation();
        if (orgUri == null) {
            throw new IOException("URI for original resource must be known");
        }

        // copy if files can be resolved as a Path
        Path orgPath = null;
        try {
            orgPath = Paths.get(orgUri);
        } catch (Exception e) {
            // ignore
        }

        if (orgPath != null) {
            // determine the filename w/o extension
            String filemain = orgPath.getFileName().toString();
            int extPos = filemain.lastIndexOf('.');
            if (extPos > 0) {
                filemain = filemain.substring(0, extPos);
            }
            // matcher for associated files
            final PathMatcher auxfiles = orgPath.getFileSystem().getPathMatcher("glob:" + filemain + ".???");

            // find all associated files
            Path orgDir = orgPath.getParent();
            try (DirectoryStream<Path> files = Files.newDirectoryStream(orgDir, new DirectoryStream.Filter<Path>() {

                @Override
                public boolean accept(Path entry) throws IOException {
                    return auxfiles.matches(entry.getFileName());
                }
            })) {
                // copy the files
                for (Path orgFile : files) {
                    Path targetFile = target.resolveSibling(orgFile.getFileName());
                    Files.copy(orgFile, targetFile);
                }
            }
        } else {
            // copy if not accessible through file system

            // copy the main file
            try (OutputStream out = new BufferedOutputStream(Files.newOutputStream(target));
                    InputStream in = new DefaultInputSupplier(orgUri).getInput()) {
                ByteStreams.copy(in, out);
            }

            // determine base URI w/o dot and extension
            String base = orgUri.toASCIIString();
            int extPos = base.lastIndexOf('.');
            if (extPos > 0) {
                base = base.substring(0, extPos);
            }

            // determine file base name w/o dot and extension
            String filemain = target.getFileName().toString();
            extPos = filemain.lastIndexOf('.');
            if (extPos > 0) {
                filemain = filemain.substring(0, extPos);
            }

            for (ShpFileType type : ShpFileType.values()) {
                if (!type.equals(ShpFileType.SHP)) {
                    try {
                        URI source = URI.create(base + type.extensionWithPeriod);
                        if (HaleIO.testStream(source, true)) {
                            Path targetFile = target.resolveSibling(filemain + type.extensionWithPeriod);
                            // copy the auxiliary file
                            try (OutputStream out = new BufferedOutputStream(Files.newOutputStream(targetFile));
                                    InputStream in = new DefaultInputSupplier(source).getInput()) {
                                ByteStreams.copy(in, out);
                            }
                        }
                    } catch (Exception e) {
                        log.debug("Failed to copy auxiliary file for Shapefile", e);
                    }
                }
            }
        }
    }

}