MIME::Type(3pm) - phpMan

Command: man perldoc info search(apropos)  


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



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 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.24, built on May 23, 2008.
       Website: http://perl.overmeer.net/mimetypes/

LICENSE
       Copyrights 1999,2001-2008 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.10.0                                2008-05-23                            MIME::Type(3pm)

Generated by $Id: phpMan.php,v 4.49 2006/02/26 13:18:18 chedong Exp $ Author: Che Dong
On Apache
Under GNU General Public License
2012-05-24 16:54 @38.107.179.236 Crawled by CCBot/1.0 (+http://www.commoncrawl.org/bot.html)
Valid XHTML 1.0!Valid CSS!