MIME::Type(3)						User Contributed Perl Documentation					     MIME::Type(3)

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
";   # 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.29, built on March 16, 2010. Website: http://perl.overmeer.net/mimetypes/

LICENSE

       Copyrights 1999,2001-2010 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

perl v5.12.1							    2010-03-16							     MIME::Type(3)