Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 /*

 * Copyright 2007-2009 Medsea Business Solutions S.L.

 *

 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except

 * in compliance with the License. You may obtain a copy of the License at

 *

 * http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software distributed under the License

 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express

 * or implied. See the License for the specific language governing permissions and limitations under

 * the License.

 */

package org.openconcerto.utils.mime;

import java.io.Serializable;

import java.util.regex.Pattern;

/**

 * This class represents a simple MimeType object. A mime type is made up of two parts

 * <code>&lt;media type&gt;/&lt;sub type&gt;</code>. The media type can be something like

 * <code>application</code> or <code>text</code> and the the sub type can be something like

 * <code>xml</code> or <code>plain</code>.

 *

 * Both the media type and sub type can also be the wild card <code>*</code> such as

 * <code>*&#47;*</code> and <code>text&#47;*</code>. Note, if the media type is the wild card then

 * the sub type must also be a wild card.

 *

 * @author Steven McArdle

 *

 */

public class MimeType implements Serializable {

    private static final long serialVersionUID = -1324243127744494894L;

    private static final Pattern mimeSplitter = Pattern.compile("[/;]++");

    protected String mediaType = "*";

    protected String subType = "*";

    // This is a estimate of how specific this mime type is

    private int specificity = 1;

    /**

     * Construct a MimeType from another MimeType instance

     *

     * @param mimeType

     */

    public MimeType(final MimeType mimeType) {

        this.mediaType = mimeType.mediaType;

        this.subType = mimeType.subType;

        this.specificity = mimeType.specificity;

    }

    /**

     * Construct a mime type from a String such as <code>text/plain</code>. It tries to ensure that

     * the mime type pattern passed in is correctly formatted.

     *

     * @param mimeType

     * @throws IllegalArgumentException

     */

    public MimeType(final String mimeType) throws IllegalArgumentException {

        if (mimeType == null || mimeType.trim().length() == 0) {

            throw new IllegalArgumentException("Invalid MimeType [" + mimeType + "]");

        }

        String[] parts = mimeSplitter.split(mimeType.trim());

        if (parts.length > 0) {

            // Treat as the mediaType

            mediaType = getValidMediaType(parts[0]);

        }

        if (parts.length > 1) {

            subType = getValidSubType(parts[1]);

        }

    }

    /**

     * Get the media type part of the mime type.

     *

     * @return media type

     */

    public String getMediaType() {

        return mediaType;

    }

    /**

     * Get the sub type of the mime type

     *

     * @return sub type

     */

    public String getSubType() {

        return subType;

    }

    /**

     * See if this MimeType is the same as the passed in mime type string

     *

     * @param mimeType as a String

     * @return true if the MimeType passed in has the same media and sub types, else returns false.

     */

    private boolean match(final String mimeType) {

        return toString().equals(mimeType);

    }

    /**

     * Get the hashCode of this MimeType. The hashCode is calculate as (31 * mediaType.hashCode()) +

     * subType.hashCode()

     *

     * @return calculated hashCode

     * @see Object#hashCode()

     */

    public int hashCode() {

        return (31 * mediaType.hashCode()) + subType.hashCode();

    }

    /**

     * Overrides the equals method of <code>java.lang.Object</code>. This is able to compare against

     * another MimeType instance or a string representation of a mime type.

     *

     * @return true if the types match else false.

     * @see Object#equals(Object o)

     */

    public boolean equals(Object o) {

        if (o instanceof MimeType) {

            if (this.mediaType.equals(((MimeType) o).mediaType) && this.subType.equals(((MimeType) o).subType)) {

                return true;

            }

        } else if (o instanceof String) {

            return match((String) o);

        }

        return false;

    }

    /**

     * Overrides the toString method of <code>java.lang.Object</code>.

     *

     * @return String representation i.e. <code>&lt;media type&gt;/&lt;sub type&gt;.

     * @see Object#toString()

     */

    public String toString() {

        return mediaType + "/" + subType;

    }

    /**

     * This indicates how specific the mime types is i.e. how good a match the mime type is when

     * returned from the getMimeTypes(...) calls.

     * <p>

     * This is calculated by the number of times this MimeType would be returned if the Collection

     * was not normalised. The higher the count the more MimeDetectors have matched this type. As

     * this can be a false positive for types such as application/octect-stream and text/plain where

     * they would be returned by multiple MimeDetector(s). These types are referred to as root mime

     * types where ALL mime types derive from application/octet-stream and all text/* types derive

     * from text/plan so in these cases we set the specificity to 0 no matter how many times they

     * match. This ensures they are regarded as the least specific in the returned Collection.

     * </p>

     *

     * @return how specific this MimeType is according to the rest of the MimeTypes in a Collection.

     */

    public int getSpecificity() {

        return specificity;

    }

    /*

     * Set the value of the specificity. The higher the value the more specific a MimeType is.

     */

    void setSpecificity(final int specificity) {

        this.specificity = specificity;

    }

    /*

     * Check the media type at least looks valid. TODO: Enforce more rigorous checking of valid

     * media types.

     */

    private String getValidMediaType(final String mediaType) {

        if (mediaType == null || mediaType.trim().length() == 0) {

            return "*";

        }

        return mediaType;

    }

    /*

     * Check the sub type at least looks valid. TODO: Enforce more rigorous checking of valid sub

     * types.

     */

    private String getValidSubType(final String subType) {

        if (subType == null || subType.trim().length() == 0 || "*".equals(mediaType)) {

            // If the mediaType is a wild card then the sub type must also be a wild card

            return "*";

        }

        return subType;

    }

}