Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (Debian-5.0)
Apropos / Subsearch:
optional field

Mail::Box::Manager(3pmUser Contributed Perl DocumentatiMail::Box::Manager(3pm)

       Mail::Box::Manager - manage a set of folders

          is a Mail::Reporter

        Mail::Box::Manager is extended by

        use Mail::Box::Manager;
        my $mgr     = new Mail::Box::Manager;

        # Create folder objects.
        my $folder   = $mgr->open(folder => $ENV{MAIL});
        my $message1 = $folder->message(0);
        $mgr->copyMessage('Draft', $message);

        my @messages = $folder->message(0,3);
        $mgr->moveMessage('Outbox', @messages, create => 1 );

        # Create thread-detectors (see Mail::Box::Thread::Manager)
        my $t       = $mgr->threads($inbox, $outbox);

        my $threads = $mgr->threads(folder => $folder);
        foreach my $thread ($threads->all)
        {   $thread->print;

        $mgr->registerType(mbox => 'Mail::Box::MyType');

       The manager keeps track on a set of open folders and a set of message-
       thread supporting objects.  You are not obliged to use this object (you
       can directly create a Mail::Box::Mbox if you prefer), but you will
       create more portable and safer code if you do use it.



        Option             --Defined in     --Default
        autodetect                            undef
        default_folder_type                   'mbox'
        folder_types                          <all standard types>
        folderdir                             [ '.' ]
        folderdirs                            <synonym for C<folderdir>>
        log                  Mail::Reporter   'WARNINGS'
        trace                Mail::Reporter   'WARNINGS'

           . autodetect => TYPE|ARRAY-OF-TYPES

               Select only a subset of the folder types which are implemented
               by MailBox to be detected automatically.  This may improve the
               auto-detection of folder types.  Normally, all folder types
               will be tried when a folder's name is incorrect, but this
               option limits the types which are checked and therefore may
               respond faster.

           . default_folder_type => NAME|CLASS

               Specifies the default folder type for newly created folders.
               If this option is not specified, the most recently registered
               type is used (see registerType() and the new(folder_types)

           . folder_types => NEW-TYPE | ARRAY-OF-NEW-TYPES

               Add one or more new folder types to the list of known types.
               The order is important: when you open a file without specifying
               its type, the manager will start trying the last added list of
               types, in order.

               Each TYPE is specified as an array which contains name, class,
               and defaults for options which overrule the usual defaults.
               You may specify folder-specific defaults as OPTIONS.  They
               override the settings of the manager.

           . folderdir => DIRECTORY

               The default directory, or directories, where folders are
               located. The "Mail::Box::Manager" can autodetect the existing
               folder-types.  There may be different kinds of folders opened
               at the same time, and messages can be moved between those
               types, although that may result in a loss of information
               depending on the folder types.

           . folderdirs => [DIRECTORIES]

           . log => LEVEL

           . trace => LEVEL



           Returns the default folder type, some class name.


           Returns the list of currently defined folder types.


            print join("\n", $manager->folderTypes), "\n";


           In list context, this returns all folderdirs specified.  In SCALAR
           context only the first.

       $obj->registerType(TYPE, CLASS [,OPTIONS])

           With "registerType" you can register one TYPE of folders.  The
           CLASS is compiled automatically, so you do not need to "use" them
           in your own modules.  The TYPE is just an arbitrary name.

           The added types are prepended to the list of known types, so they
           are checked first when a folder is opened in autodetect mode.


            $manager->registerType(mbox => 'Mail::Box::Mbox',
                save_on_exit => 0, folderdir => '/tmp');

       Manage open folders

       $obj->close(FOLDER, OPTIONS)

           "close" removes the specified folder from the list of open folders.
           Indirectly it will update the files on disk if needed (depends on
           the Mail::Box::new(save_on_exit) flag for each folder). OPTIONS are
           passed to Mail::Box::close() of the folder.

           The folder's messages will also be withdrawn from the known message
           threads.  You may also close the folder directly. The manager will
           be informed about this event and take appropriate actions.

            Option       --Default
            close_by_self  <false>

           . close_by_self => BOOLEAN

               Used internally to avoid confusion about how the close was
               started.  Do not change this.


            my $inbox = $mgr->open('inbox');
            $inbox->close;        # alternative

       $obj->closeAllFolders(, OPTIONS)

           "closeAllFolders" calls close() for each folder managed by this
           object.  It is called just before the program stops (before global


           Returns true if the FOLDER is currently open.


            print "Yes\n" if $mgr->isOpenFolder('Inbox');

       $obj->open([FOLDERNAME], OPTIONS)

           Open a folder which name is specified as first parameter or with
           the option flag "folder".  The folder type is autodetected unless
           the "type" is specified.

           "open" carries options for the manager which are described here,
           but may also have additional options for the folder type.  For a
           description of the folder options, see the options to the
           constructor Mail::Box::new() for each type of mail box.

            Option      --Default
            authenticate  'AUTO'
            create        <false>
            folder        $ENV{MAIL}
            folderdir     '.'
            type          <first, usually C<mbox>>

           . authenticate => TYPE|ARRAY-OF-TYPES|'AUTO'

               The TYPE of authentication to be used, or a list of TYPES which
               the client prefers.  The server may provide preferences as
               well, and that order will be kept.  This option is only
               supported by a small subset of folder types, especially by POP
               and IMAP.

           . create => BOOLEAN

               Create the folder if it does not exist. By default, this is not
               done.  The "type" option specifies which type of folder is

           . folder => NAME|URL

               Which folder to open, specified by NAME or special URL.  The
               URL format is composed as


               Like real URLs, all fields are optional and have smart
               defaults, as long as the string starts with a known folder
               type.  Far from all folder types support all these options, but
               at least they are always split-out.  Be warned that special
               characters in the password should be properly url-encoded.

               When you specify anything which does not match the URL format,
               it is passed directly to the "new" method of the folder which
               is opened.

           . folderdir => DIRECTORY

               The directory where the folders are usually stored.


               Specify the type of the folder.  If you do not specify this
               option while opening a folder for reading, the manager checks
               all registered folder types in order for the ability to open
               the folder. If you open a new folder for writing, then the
               default will be the most recently registered type. (If you add
               more than one type at once, the first of the list is used.)

           example: opening folders via the manager

            my $jack  = $manager->open(folder => '=jack',
               type => 'mbox');

            my $rcvd  = $manager->open('myMail',
               type => 'Mail::Box::Mbox', access => 'rw');

            my $inbox = $manager->open('Inbox')
               or die "Cannot open Inbox.\n";

            my $pop   = 'pop3://myself:secretATpop3.com:120/x';
            my $send  = $manager->open($url);

            my $send  = $manager->open(folder => '/x',
              type => 'pop3', username => 'myself', password => 'secret'
              server_name => 'pop3.server.com', server_port => '120');


           Returns a list of all open folders.

       Manage existing folders

       $obj->delete(FOLDERNAME, OPTIONS)

           Remove the named folder.  The OPTIONS are the same as those for

           The deletion of a folder can take some time.  Dependent on the type
           of folder, the folder must be read first.  For some folder-types
           this will be fast.

            Option   --Default
            recursive  <folder's default>

           . recursive => BOOLEAN

               Some folder can only be recursively deleted, other have more

       Move messages to folders

       $obj->appendMessage([FOLDER|FOLDERNAME,] MESSAGES, OPTIONS)

           Append one or more messages to a folder (therefore, an
           "appendMessages()" is defined as well). You may specify a
           FOLDERNAME or an opened folder as the first argument. When the name
           is that of an open folder, it is treated as if the folder-object
           was specified, and not directly access the folder-files.  You may
           also specify the foldername as part of the options list.

           If a message is added to an already opened folder, it is only added
           to the structure internally in the program.  The data will not be
           written to disk until a write of that folder takes place.  When the
           name of an unopened folder is given, the folder is opened, the
           messages stored on disk, and then the folder is closed.

           A message must be an instance of a Mail::Message.  The actual
           message type does not have to match the folder type--the folder
           will try to resolve the differences with minimal loss of
           information.  The coerced messages (how the were actually written)
           are returned as list.

           The OPTIONS is a list of key/values, which are added to
           (overriding) the default options for the detected folder type.


            $mgr->appendMessage('=send', $message, folderdir => '/');
            $mgr->appendMessage($received, $inbox->messages);

            my @appended = $mgr->appendMessages($inbox->messages,
               folder => 'Drafts');
            $_->label(seen => 1) foreach @appended;

       $obj->copyMessage([FOLDER|FOLDERNAME,] MESSAGES, OPTIONS)

           Copy a message from one folder into another folder.  If the
           destination folder is already opened, Mail::Box::copyTo() is used.
           Otherwise, Mail::Box::appendMessages() is called.

           You need to specify a folder's name or folder object as the first
           argument, or in the options list.  The options are the same as
           those which can be specified when opening a folder.

            share   <false>

           . share => BOOLEAN

               Try to share the physical storage of the messages.  The folder
               types may be different, but it all depends on the actual folder
               where the message is copied to.  Silently ignored when not
               possible to share.


            my $drafts = $mgr->open(folder => 'Drafts');
            my $outbox = $mgr->open(folder => 'Outbox');
            $mgr->copyMessage($outbox, $drafts->message(0));

            my @messages = $drafts->message(1,2);
            $mgr->copyMessage('=Trash', @messages,
               folderdir => '/tmp', create => 1);

               folder => '=Drafts' folderdir => '/tmp',
               create => 1);

       $obj->moveMessage([FOLDER|FOLDERNAME,] MESSAGES, OPTIONS)

           Move a message from one folder to another.  Be warned that removals
           from a folder only take place when the folder is closed, so the
           message is only flagged to be deleted in the opened source folder.

            $mgr->moveMessage($received, $inbox->message(1))

           is equivalent to

            $mgr->copyMessage($received, $inbox->message(1), share => 1);

            share   <true>

           . share => BOOLEAN

       Manage message threads

       $obj->threads([FOLDERS], OPTIONS)

           Create a new object which keeps track of message threads.  You can
           read about the possible options in Mail::Box::Thread::Manager.  As
           OPTIONS specify one folder or an array of FOLDERS.  It is also
           permitted to specify folders before the options.


            my $t1 = $mgr->threads(folders => [ $inbox, $send ]);
            my $t2 = $mgr->threads($inbox);
            my $t3 = $mgr->threads($inbox, $send);



           Try to decompose a folder name which is specified as URL (see
           open()) into separate options.

       $obj->toBeThreaded(FOLDER, MESSAGES)

           Signal to the manager that all thread managers which are using the
           specified folder must be informed that new messages are coming in.

       $obj->toBeUnthreaded(FOLDER, MESSAGES)

           Signal to the manager that all thread managers which are using the
           specified folder must be informed that new messages are or going

       Error handling


           See "Error handling" in Mail::Reporter


           See "Error handling" in Mail::Reporter

       $obj->defaultTrace([LEVEL]|[LOGLEVEL, TRACELEVEL]|[LEVEL, CALLBACK])

       Mail::Box::Manager->defaultTrace([LEVEL]|[LOGLEVEL, TRACELEVEL]|[LEVEL,

           See "Error handling" in Mail::Reporter


           See "Error handling" in Mail::Reporter

       $obj->log([LEVEL [,STRINGS]])

       Mail::Box::Manager->log([LEVEL [,STRINGS]])

           See "Error handling" in Mail::Reporter



           See "Error handling" in Mail::Reporter


           See "Error handling" in Mail::Reporter


           See "Error handling" in Mail::Reporter


           See "Error handling" in Mail::Reporter


           See "Error handling" in Mail::Reporter


           See "Error handling" in Mail::Reporter


           See "Error handling" in Mail::Reporter



           See "Cleanup" in Mail::Reporter


           See "Cleanup" in Mail::Reporter

       On many places in the documentation you can read that it is useful to
       have a manager object.  There are two of them: the Mail::Box::Manager,
       which maintains a set of open folders, and an extension of it: the

       Managing open folders

       It is useful to start your program by creating a folder manager object,
       an Mail::Box::Manager.  The object takes a few burdons from your neck:

       o   autodetect the type of folder which is used.

           This means that your application can be fully folder type

       o   autoload the required modules

           There are so many modules involved in MailBox, that it is useful to
           have some lazy autoloading of code.  The manager knows which
           modules belong to which type of folder.

       o   avoid double openings

           Your programming mistakes may cause the same folder to be opened
           twice.  The result of that could be very destructive.  Therefore,
           the manager keeps track on all open folders and avoids the same
           folder to be opened for the second time.

       o   close folders at clean-up

           When the program is ending, the manager will cleanly close all
           folders which are still open.  This is required, because the
           autodestruct sequence of Perl works in an unpredicatable order.

       o   message thread detection

           MailBox can discover message threads which span multiple folders.
           Any set of open folders may be grouped in a tree of replies on
           replies on replies.  When a folder is closed, it will automatically
           be removed from the threads, and a new folder can dynamically be
           added to the structure.

       The manager is really simplifying things, and should therefore be the
       base of all programs. However, it is possible to write useful programs
       without it.

       Managing a user

       One step further is the Mail::Box::Manage::User object (since MailBox
       v2.057), which not only keeps track on open folders, but also collects
       information about not-open folders.

       The user class is, as the name says, targeted on managing one single
       user.  Where the Mail::Box::Manager will open any set of folder files,
       probably from multiple users, the user class want one root folder

       In many aspects, the user manager simplifies the task for user-based
       servers and other user-centric applications by setting smart defaults.

       Error: Folder $name is already open.

           You cannot ask the manager for a folder which is already open. In
           some older releases (before MailBox 2.049), this was permitted, but
           then behaviour changed, because many nasty side-effects are to be
           expected.  For instance, an Mail::Box::update() on one folder
           handle would influence the second, probably unexpectedly.

       Error: Folder $name is not a Mail::Box; cannot add a message.

           The folder where the message should be appended to is an object
           which is not a folder type which extends Mail::Box.  Probably, it
           is not a folder at all.

       Warning: Folder does not exist, failed opening $type folder $name.

           The folder does not exist and creating is not permitted (see
           open(create)) or did not succeed.  When you do not have sufficient
           access rights to the folder (for instance wrong password for POP3),
           this warning will be produced as well.

           The manager tried to open a folder of the specified type.  It may
           help to explicitly state the type of your folder with the "type"
           option.  There will probably be another warning or error message
           which is related to this report and provides more details about its
           cause.  You may also have a look at new(autodetect) and

       Warning: Folder type $type is unknown, using autodetect.

           The specified folder type (see open(type), possibly derived from
           the folder name when specified as url) is not known to the manager.
           This may mean that you forgot to require the Mail::Box extension
           which implements this folder type, but probably it is a typo.
           Usually, the manager is able to figure-out which type to use by

       Error: Illegal folder URL '$url'.

           The folder name was specified as URL, but not according to the
           syntax.  See decodeFolderURL() for an description of the syntax.

       Error: No foldername specified to open.

           "open()" needs a folder name as first argument (before the list of
           options), or with the "folder" option within the list.  If no name
           was found, the MAIL environment variable is checked.  When even
           that does not result in a usable folder, then this error is
           produced.  The error may be caused by an accidental odd-length
           option list.

       Error: Package $package does not implement $method.

           Fatal error: the specific package (or one of its superclasses) does
           not implement this method where it should. This message means that
           some other related classes do implement this method however the
           class at hand does not.  Probably you should investigate this and
           probably inform the author of the package.

       Error: Use appendMessage() to add messages which are not in a folder.

           You do not need to copy this message into the folder, because you
           do not share the message between folders.

       Warning: Use moveMessage() or copyMessage() to move between open

           The message is already part of a folder, and now it should be
           appended to a different folder.  You need to decide between copy or
           move, which both will clone the message (not the body, because they
           are immutable).

       Warning: Will never create a folder $name without having write access.

           You have set open(create), but only want to read the folder.
           Create is only useful for folders which have write or append access
           modes (see Mail::Box::new(access)).

       This module is part of Mail-Box distribution version 2.082, built on
       April 28, 2008. Website: http://perl.overmeer.net/mailbox/

       Copyrights 2001-2008 by Mark Overmeer. For other contributors see

       This program is free software; you can redistribute it and/or modify it
       under the same terms as Perl itself.  See

perl v5.10.0                      2008-04-28           Mail::Box::Manager(3pm)