[Exist-commits] eXist-1.0/src/org/exist/util MimeType.java,NONE,1.1 MimeTable.java,NONE,1.1 mime-typ

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 454-5900

Update of /cvsroot/exist/eXist-1.0/src/org/exist/util
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv26168/src/org/exist/util

Added Files:
	MimeType.java MimeTable.java mime-types.xml 
Removed Files:
	MutableStringTokenizer.java 
Log Message:
Improved handling of mime-types for resources.

--- NEW FILE: MimeType.java ---
/*
 *  eXist Open Source Native XML Database
 *  Copyright (C) 2001-04 The eXist Project
 *  http://exist-db.org
 *  
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *  
 *  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 Lesser General Public License for more details.
 *  
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *  
 *  $Id: MimeType.java,v 1.1 2005/01/30 14:17:09 wolfgang_m Exp $
 */
package org.exist.util;

public class MimeType {

    public final static int XML = 0;
    public final static int BINARY = 1;

    private String name;
    private String description;
    private int type = MimeType.XML;

    public MimeType(String name, int type) {
        this.name = name;
        this.type = type;
    }
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public String getName() {
        return name;
    }
    public int getType() {
        return type;
    }

    public String getXMLDBType() {
        return type == XML ? "XMLResource" : "BinaryResource";
    }

    public String toString() {
        return name + ": " + description;
    }
}
--- NEW FILE: MimeTable.java ---
/*
 *  eXist Open Source Native XML Database
 *  Copyright (C) 2001-04 The eXist Project
 *  http://exist-db.org
 *  
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *  
 *  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 Lesser General Public License for more details.
 *  
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *  
 *  $Id: MimeTable.java,v 1.1 2005/01/30 14:17:09 wolfgang_m Exp $
 */
package org.exist.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.apache.log4j.Logger;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;

/**
 * Global table of mime types. This singleton class maintains a list
 * of mime types known to the system. It is used to look up the
 * mime type for a specific file extension and to check if a file
 * is an XML or binary resource.
 * 
 * The mime type table is read from a file "mime-types.xml",
 * which should reside in the directory identified by the system
 * property "exist.home". If no such file is found, the class tries
 * to load the default map from the org.exist.util package via the 
 * class loader.
 * 
 * @author wolf
 */
public class MimeTable {

    private static final String FILE_LOAD_FAILED_ERR = "Failed to load mime-type table from ";
    private static final String LOAD_FAILED_ERR = "Failed to load mime-type table from class loader";
    private static final String MIME_TYPES_XML_DEFAULT = "org/exist/util/mime-types.xml";
    private static final String MIME_TYPES_XML = "mime-types.xml";

    private final static Logger LOG = Logger.getLogger(MimeTable.class);

    private static MimeTable instance = null;

    /**
     * Returns the singleton.
     * 
     * @return
     */
    public static MimeTable getInstance() {
        if (instance == null)
            instance = new MimeTable();
        return instance;
    }

    private Map mimeTypes = new TreeMap();
    private Map extensions = new TreeMap();

    public MimeTable() {
        load();
    }

    public MimeType getContentTypeFor(String fileName) {
        String ext = getExtension(fileName);
        return ext == null ? null : (MimeType) extensions.get(ext);
    }

    public boolean isXMLContent(String fileName) {
        String ext = getExtension(fileName);
        if (ext == null)
            return false;
        MimeType type = (MimeType) extensions.get(ext);
        if (type == null)
            return false;
        return type.getType() == MimeType.XML;
    }

    private String getExtension(String fileName) {
        File f = new File(fileName);
        fileName = f.getName();
        int p = fileName.lastIndexOf('.');
        if (p < 0 || p + 1 == fileName.length())
            return null;
        return fileName.substring(p);
    }

    private void load() {
        boolean loaded = false;
        String home = System.getProperty("exist.home");
        if (home != null) {
            File f = new File(home + File.separatorChar + MIME_TYPES_XML);
            if (f.canRead()) {
                try {
                    LOG.debug("Loading mime table from file " + f.getAbsolutePath());
                    loadMimeTypes(new FileInputStream(f));
                    loaded = true;
                } catch (FileNotFoundException e) {
                    LOG.warn(FILE_LOAD_FAILED_ERR + f.getAbsolutePath(), e);
                } catch (ParserConfigurationException e) {
                    LOG.warn(FILE_LOAD_FAILED_ERR + f.getAbsolutePath(), e);
                } catch (SAXException e) {
                    LOG.warn(FILE_LOAD_FAILED_ERR + f.getAbsolutePath(), e);
                } catch (IOException e) {
                    LOG.warn(FILE_LOAD_FAILED_ERR + f.getAbsolutePath(), e);
                }
            }
        }
        if (!loaded) {
            LOG.debug("Loading mime table");
            ClassLoader cl = Thread.currentThread().getContextClassLoader();
            InputStream is = cl.getResourceAsStream(MIME_TYPES_XML_DEFAULT);
            if (is == null) {
                LOG.warn(LOAD_FAILED_ERR);
            }
            try {
                loadMimeTypes(is);
            } catch (ParserConfigurationException e) {
                LOG.warn(LOAD_FAILED_ERR, e);
            } catch (SAXException e) {
                LOG.warn(LOAD_FAILED_ERR, e);
            } catch (IOException e) {
                LOG.warn(LOAD_FAILED_ERR, e);
            }
        }
    }

    /**
     * @param stream
     * @throws SAXException 
     * @throws ParserConfigurationException 
     * @throws IOException 
     */
    private void loadMimeTypes(InputStream stream) throws ParserConfigurationException, SAXException, IOException {
        SAXParserFactory factory = SAXParserFactory.newInstance();
        factory.setNamespaceAware(true);
        factory.setValidating(false);
        InputSource src = new InputSource(stream);
        SAXParser parser = factory.newSAXParser();
        XMLReader reader = parser.getXMLReader();
        reader.setContentHandler(new MimeTableHandler());
        reader.parse(new InputSource(stream));
    }

    private class MimeTableHandler extends DefaultHandler {

        private static final String EXTENSIONS = "extensions";
        private static final String DESCRIPTION = "description";
        private static final String MIME_TYPE = "mime-type";

        private MimeType mime = null;
        private FastStringBuffer charBuf = new FastStringBuffer(6, 15, 5);

        /* (non-Javadoc)
         * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
         */
        public void startElement(String uri, String localName, String qName,
                Attributes attributes) throws SAXException {
            if (MIME_TYPE.equals(qName)) {
                String name = attributes.getValue("name");
                if (name == null || name.length() == 0) {
                    LOG.warn("No name specified for mime-type");
                    return;
                }
                int type = MimeType.BINARY;
                String typeAttr = attributes.getValue("type");
                if (typeAttr != null && "xml".equals(typeAttr))
                    type = MimeType.XML;
                mime = new MimeType(name, type);
                mimeTypes.put(name, mime);
            }
            charBuf.setLength(0);
        }

        /* (non-Javadoc)
         * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String, java.lang.String, java.lang.String)
         */
        public void endElement(String uri, String localName, String qName)
                throws SAXException {
            if (MIME_TYPE.equals(qName)) {
                mime = null;
            } else if (DESCRIPTION.equals(qName)) {
                if (mime != null) {
                    String description = charBuf.getNormalizedString(FastStringBuffer.SUPPRESS_BOTH);
                    mime.setDescription(description);
                }
            } else if (EXTENSIONS.equals(qName)) {
                if (mime != null) {
                    String extList = charBuf.getNormalizedString(FastStringBuffer.SUPPRESS_BOTH);
                    StringTokenizer tok = new StringTokenizer(extList, ", ");
                    while (tok.hasMoreTokens()) {
                        String ext = tok.nextToken();
                        if (!extensions.containsKey(ext))
                            extensions.put(ext, mime);
                    }
                }
            }
        }

        /* (non-Javadoc)
         * @see org.xml.sax.helpers.DefaultHandler#characters(char[], int, int)
         */
        public void characters(char[] ch, int start, int length)
                throws SAXException {
            charBuf.append(ch, start, length);
        }
    }

    public static void main(String[] args) {
        MimeTable table = MimeTable.getInstance();
        MimeType type = table.getContentTypeFor("samples/xquery/fibo.svg");
        if (type == null) {
            System.out.println("Not found!");
        } else {
            System.out.println(type.getName());
            System.out.println(type.getDescription());
        }
    }
}

--- MutableStringTokenizer.java DELETED ---

--- NEW FILE: mime-types.xml ---
<?xml version="1.0" encoding="UTF-8"?>

<!--
    ======================================================
    This file lists all mime types known to eXist.      
    When storing a document with the Java client, the type 
    of the resource is looked up here. A resource will be 
    stored as an XML or a binary resource, depending on the 
    "type" attribute of the corresponding mime-type entry.
    ======================================================= 
-->

<mime-types>
    <!-- Mime types stored as XML -->
    <mime-type name="text/xml" type="xml">
        <description>XML document</description>
        <extensions>.xml,.xsl,.xsd,.mods,.xmi,.xconf</extensions>
    </mime-type>
    <mime-type name="application/xml" type="xml">
        <description>XML document</description>
        <extensions>.xml</extensions>
    </mime-type>
    <mime-type name="application/rdf+xml" type="xml">
        <description>RDF document</description>
        <extensions>.rdf</extensions>
    </mime-type>
    <mime-type name="application/xhtml+xml" type="xml">
        <description>XHTML document</description>
        <extensions>.xht, .xhtml</extensions>
    </mime-type>
    <mime-type name="text/html" type="xml">
        <description>HTML document</description>
        <extensions>.html,.htm</extensions>
    </mime-type>
    <mime-type name="image/svg+xml" type="xml">
        <description>SVG image</description>
        <extensions>.svg,.svgz</extensions>
    </mime-type>

    <!-- Binary mime types -->
    <mime-type name="application/xquery" type="binary">
        <description>XQuery script</description>
        <extensions>.xq,.xql,.xqm,.xquery</extensions>
    </mime-type>
    <mime-type name="application/octet-stream" type="binary">
        <description>Generic binary stream</description>
        <extensions>.jar,.exe,.o</extensions>
    </mime-type>
    <mime-type name="application/zip" type="binary">
        <description>ZIP archive</description>
        <extensions>.zip</extensions>
    </mime-type>
    <mime-type name="text/plain" type="binary">
        <description>Plain text</description>
        <extensions>.txt,.text,.java</extensions>
    </mime-type>
    <mime-type name="text/css" type="binary">
        <description>CSS stylesheet</description>
        <extensions>.css</extensions>
    </mime-type>
    <mime-type name="image/gif" type="binary">
        <description>GIF image</description>
        <extensions>.gif</extensions>
    </mime-type>
    <mime-type name="image/jpeg" type="binary">
        <description>JPEG image</description>
        <extensions>.jpg,.jpeg</extensions>
    </mime-type>
    <mime-type name="image/x-portable-bitmap" type="binary">
        <description>PBM Bitmap Format</description>
        <extensions>.pbm</extensions>
    </mime-type>
</mime-types>

[Exist-commits] eXist-1.0/src/org/exist/util MimeType.java,NONE,1.1 MimeTable.java,NONE,1.1 mime-typ

eXist-db is a feature rich Open Source native XML database

[Exist-commits] eXist-1.0/src/org/exist/util MimeType.java,NONE,1.1 MimeTable.java,NONE,1.1 mime-types.xml,NONE,1.1 MutableStringTokenizer.java,1.2,NONE