NAME
     MIME::Type - Definition of one MIME type

SYNOPSIS
     use MIME::Types;
     my $mimetypes = MIME::Types->new;
     my MIME::Type $plaintext = $mimetype->type('text/plain');
     print $plaintext->mediaType;   # text
     print $plaintext->subType;     # plain

     my @ext = $plaintext->extensions;
     print "@ext"                   # asc txt c cc h hh cpp

     print $plaintext->encoding     # 8bit
     if($plaintext->isBinary)       # false
     if($plaintext->isAscii)        # true
     if($plaintext->equals('text/plain') {...}
     if($plaintext eq 'text/plain') # same

     print MIME::Type->simplified('x-appl/x-zip') #  'appl/zip'

DESCRIPTION
    MIME types are used in MIME entities, for instance as part of e-mail and
    HTTP traffic. Sometimes real knowledge about a mime-type is need.
    Objects of "MIME::Type" store the information on one such type.

    This module is built to conform to the MIME types of RFC's 2045 and
    2231. It follows the collection kept at
    http://www.ltsw.se/knbase/internet/mime.htp

METHODS
    new OPTIONS
        Create a new "MIME::Type" object which manages one mime type.

         OPTION                    DEFAULT
         type                      <obligatory>
         simplified                <derived from type>
         extensions                undef
         encoding                  <depends on type>
         system                    undef

        *   type => STRING

            The type which is defined here. It consists of a *type* and a
            *sub-type*, both case-insensitive. This module will return
            lower-case, but accept upper-case.

        *   simplified => STRING

            The mime types main- and sub-label can both start with "x-", to
            indicate that is a non-registered name. Of course, after
            registration this flag can disappear which adds to the
            confusion. The simplified string has the "x-" thingies removed
            and are translated to lower-case.

        *   extensions => REF-ARRAY

            An array of extensions which are using this mime.

        *   encoding => '7bit'|'8bit'|'base64'|'quoted-printable'

            How must this data be encoded to be transported safely. The
            default depends on the type: mimes with as main type "text/"
            will default to "quoted-printable" and all other to "base64".

        *   system => REGEX

            Regular expression which defines for which systems this rule is
            valid. The REGEX is matched on $^O.

    type
        Returns the long type of this object, for instance 'text/plain'

    simplified [STRING]
        (Instance method or Class method) Returns the simplified mime type
        for this object or the specified STRING. Mime type names can get
        officially registered. Until then, they have to carry an "x-"
        preamble to indicate that. Of course, after recognition, the "x-"
        can disappear. In many cases, we prefer the simplified version of
        the type.

        Examples:

         my $mime = MIME::Type->new(type => 'x-appl/x-zip');
         print $mime->simplified;                     # 'appl/zip'
         print $mime->simplified('text/plain');       # 'text/plain'
         print MIME::Type->simplified('x-xyz/x-abc'); # 'xyz/abc'

    mediaType
        The media type of the simplified mime. For 'text/plain' it will
        return 'text'.

        For historical reasons, the 'mainType' method still can be used to
        retreive the same value. However, that method is deprecated.

    subType
        The sub type of the simplified mime. For 'text/plain' it will return
        'plain'.

    isRegistered
        Mime-types which are not registered by IANA nor defined in RFCs
        shall start with an "x-". This counts for as well the media-type as
        the sub-type. In case either one of the types starts with "x-" this
        method will return false.

    extensions
        Returns a list of extensions which are known to be used for this
        mime type.

    encoding
        Returns the type of encoding which is required to transport data of
        this type safely.

    system
        Returns the regular expression which can be used to determine
        whether this type is active on the system where you are working on.

    isBinary
        Returns true when the encoding is base64.

    isAscii
        Returns false when the encoding is base64, and true otherwise. All
        encodings except base64 are text encodings.

    isSignature
        Returns true when the type is in the list of known signatures.

    equals STRING|MIME
        Compare this mime-type object with a STRING or other object. In case
        of a STRING, simplification will take place.

SEE ALSO
    MIME::Types

AUTHOR
    Mark Overmeer (mimetypes@overmeer.net).

VERSION
    This code is stable, version 1.003.

    Copyright (c) 2001-2002 Mark Overmeer. All rights reserved. This program
    is free software; you can redistribute it and/or modify it under the
    same terms as Perl itself.