Subversion Repositories mkgmap

/*
 * Copyright (C) 2007 Steve Ratcliffe
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *
 * Author: Steve Ratcliffe
 * Create date: Feb 17, 2008
 */
package uk.me.parabola.mkgmap.osmstyle;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.net.JarURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

import uk.me.parabola.log.Logger;

/**
 * Load a style from a jar file.
 *
 * The style can just be jared up at the top level or it can be
 * contained within a directory in the jar.  You can have more than one
 * style in the jar.  In this case a name will be required to select
 * the one that you want to use.  It looks for a file with a name that
 * ends with 'version' to work out where the style is.  If a name is given
 * then it looks for a file path ending {@code name/version}.
 *
 * @author Steve Ratcliffe
 */
public class JarFileLoader extends StyleFileLoader {
        private static final Logger log = Logger.getLogger(JarFileLoader.class);
        private JarFile jarFile;
        private String prefix;

        public JarFileLoader(URL url) throws FileNotFoundException {
                jarInit(url, null);
        }

        public JarFileLoader(String url, String name) throws FileNotFoundException {
                try {
                        jarInit(new URL(makeJarUrl(url)), name);
                } catch (MalformedURLException e) {
                        throw new FileNotFoundException("Could not open style at " + url);
                }
        }

        private String makeJarUrl(String url) {
                if (url.toLowerCase().startsWith("jar:"))
                        return url;
                else
                        return "jar:" + url + "!/";
        }

        private void jarInit(URL url, String name) throws FileNotFoundException {
                log.debug("opening", url);
                try {
                        JarURLConnection jurl = (JarURLConnection) url.openConnection();
                        jurl.setUseCaches(false);
                        jarFile = jurl.getJarFile();
                        prefix = jurl.getEntryName();
                        if (prefix == null) {
                                prefix = searchVersion(jarFile, name);
                        }

                        log.debug("jar prefix is", prefix);
                } catch (IOException e) {
                        throw new FileNotFoundException("Could not open style at " + url);
                }
        }

        /**
         * Find path in archive
         * @param file the JarFile instance
         * @param style a style name or null to find any version file
         * @return return prefix of (first) entry that contains file version
         */
        private String searchVersion(JarFile file, String style) {
                Enumeration<JarEntry> en = file.entries();
                String flatEnd = style==null ? "version" : style + "/version";
                String end = "/" + flatEnd;
                while (en.hasMoreElements()) {
                        JarEntry entry = en.nextElement();
                        String ename = entry.getName();
                        if (ename.endsWith(end) || ename.equals(flatEnd))
                                return ename.substring(0, ename.length() - "version".length());
                }
                return null;
        }

        /**
         * Open the specified file in the style definition.
         *
         * @param filename The name of the file in the style.
         * @return An open file reader for the file.
         * @throws FileNotFoundException When the file can't be opened.
         */
        public Reader open(String filename) throws FileNotFoundException {
                if (jarFile == null)
                        throw new FileNotFoundException("Could not open file " + filename);

                String path = filename;
                if (prefix != null)
                        path = prefix + filename;
               
                JarEntry jarEntry = jarFile.getJarEntry(path);
                if (jarEntry == null)
                        throw new FileNotFoundException("Could not open style file " + filename);

                InputStream stream;
                try {
                        stream = jarFile.getInputStream(jarEntry);
                } catch (IOException e) {
                        throw new FileNotFoundException("Could not open " + filename);
                }
                Reader reader = null;
                try {
                        reader = new InputStreamReader(stream, "UTF-8");
                } catch (UnsupportedEncodingException e) {
                        System.out.println("JarFileLoader: Encoding UTF-8 not supported");
                        reader = new InputStreamReader(stream);
                }
                return new BufferedReader(reader);
        }

        public void close() {
                try {
                        jarFile.close();
                } catch (IOException e) {
                        log.debug("failed to close jar file");
                }
        }

        protected void finalize() throws Throwable {
                super.finalize();
                close();
        }

        public String[] list() {
                Enumeration<JarEntry> en = jarFile.entries();
                List<String> list = new ArrayList<String>();
                while (en.hasMoreElements()) {
                        JarEntry entry = en.nextElement();

                        if (!entry.isDirectory()) {
                                String name = entry.getName();
                                if (name.endsWith("version")) {
                                        log.debug("name is", name);
                                        String[] dirs = name.split("/");
                                        if (dirs.length == 1) {
                                                String s = jarFile.getName();
                                                s = s.replaceFirst("\\..*$", "");
                                                s = s.replaceAll(".*/", "");
                                                list.add(s);
                                        }
                                        else
                                                list.add(dirs[dirs.length - 2]);
                                }
                        }
                }

                return list.toArray(new String[list.size()]);
        }

}