MIME::Type

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



NAME
       MIME::Type - Definition of one MIME type

INHERITANCE
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 confu-
	       sion.  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 spec-
	   ified with the "type" option flag.

SEE ALSO
       This module is part of MIME-Types distribution version 1.22, built on
       November 14, 2007. Website: http://perl.overmeer.net/mimetypes/

LICENSE
       Copyrights 1999,2001-2007 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.8.8			  2007-11-14			MIME::Type(3)