MIME::Type(3p)

NAME
MIME::Type - Definition of one MIME type

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

 my @ext = $plaintext->extensions;
 print "@ext"                   # txt asc 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 official IANA registry at http://www.iana.org/assignments/media-types/ and the collection kept at http://www.ltsw.se/knbase/internet/mime.htp

OVERLOADED
overload: string comparison

    When a MIME::Type object is compared to either a string or an other MIME::TYpe, the equals() method is called. Comparison is smart, which means that it extends common string comparison with some features which are defined in the related RFCs.

overload: stringification

    The stringification (use of the object in a place where a string is required) will result in the type name, the same as type() returns.

    example: use of stringification

     my $mime = MIME::Type->new('text/html');
     print "$mime\n";   # explicit stringification
     print $mime;       # implicit stringification

METHODS

  Initiation
MIME::Type->new(OPTIONS)

    Create (instantiate) a new MIME::Type object which manages one mime type.

     Option    --Default
     encoding    <depends on type>
     extensions  []
     simplified  <derived from type>
     system      undef
     type        <required>

    . 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".

    . extensions => REF-ARRAY

        An array of extensions which are using this mime.

    . 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.

    . system => REGEX

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

    . 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.

  Attributes
$obj->encoding

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

$obj->extensions

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

$obj->simplified([STRING])

MIME::Type->simplified([STRING])

    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.

    example: results of simplified()

     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'

$obj->system

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

$obj->type

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

  Knowledge
$obj->equals(STRING|MIME)

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

$obj->isAscii

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

$obj->isBinary

    Returns true when the encoding is base64.

$obj->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.

$obj->isSignature

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

$obj->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.

$obj->subType

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

DIAGNOSTICS
Error: Type parameter is obligatory.

    When a MIME::Type object is created, the type itself must be specified with the "type" option flag.

SEE ALSO
This module is part of MIME-Types distribution version 1.28, built on September 07, 2009. Website: http://perl.overmeer.net/mimetypes/

LICENSE
Copyrights 1999,2001-2009 by Mark Overmeer. For other contributors see ChangeLog.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See http://www.perl.com/perl/misc/Artistic.html