Changeset 5557 in subversion

Timestamp:

Dec 7, 2011 3:44:48 AM (18 months ago)

Author:

alec

Message:

• Fixed issues with big memory allocation of IMAP results, improved a lot of rcube_imap class

Location:

trunk/roundcubemail

Files:

• CHANGELOG (modified) (1 diff)
• program/include/rcube_imap.php (modified) (41 diffs)
• program/include/rcube_imap_cache.php (modified) (29 diffs)
• program/include/rcube_imap_generic.php (modified) (14 diffs)
• program/include/rcube_result_index.php (added)
• program/include/rcube_result_thread.php (added)
• program/steps/mail/func.inc (modified) (1 diff)
• program/steps/mail/pagenav.inc (modified) (2 diffs)
• program/steps/mail/search.inc (modified) (2 diffs)
• program/steps/mail/sendmail.inc (modified) (2 diffs)

trunk/roundcubemail/CHANGELOG

@@ -2 +2 @@
 ===========================
 
+- Fix issues with big memory allocation of IMAP results
 - Replace prompt() with jQuery UI dialog (#1485135)
 - Fix navigation in messages search results

trunk/roundcubemail/program/include/rcube_imap.php

@@ -432 +432 @@
      *
      * @param  string  IMAP Search query
-     * @param  array   List of message ids or NULL if empty
+     * @param  rcube_result_index|rcube_result_thread  Result set
      * @param  string  Charset of search string
      * @param  string  Sorting field
      * @param  string  True if set is sorted (SORT was used for searching)
      */
-    function set_search_set($str=null, $msgs=null, $charset=null, $sort_field=null, $threads=false, $sorted=false)
-    {
-        if (is_array($str) && $msgs == null)
-            list($str, $msgs, $charset, $sort_field, $threads, $sorted) = $str;
-        if ($msgs === false)
-            $msgs = array();
-        else if ($msgs != null && !is_array($msgs))
-            $msgs = explode(',', $msgs);
+    function set_search_set($str=null, $msgs=null, $charset=null, $sort_field=null, $sorted=false)
+    {
+        if (is_array($str) && $msgs === null)
+            list($str, $msgs, $charset, $sort_field, $sorted) = $str;
 
         $this->search_string     = $str;
@@ -450 +446 @@
         $this->search_charset    = $charset;
         $this->search_sort_field = $sort_field;
-        $this->search_threads    = $threads;
         $this->search_sorted     = $sorted;
+        $this->search_threads    = is_a($this->search_set, 'rcube_result_thread');
     }
 
@@ -457 +453 @@
     /**
      * Return the saved search set as hash array
+     *
+     * @param bool $clone Clone result object
+     *
      * @return array Search set
      */
     function get_search_set()
     {
-        return array($this->search_string,
+        return array(
+            $this->search_string,
                 $this->search_set,
                 $this->search_charset,
                 $this->search_sort_field,
-                $this->search_threads,
                 $this->search_sorted,
             );
@@ -690 +689 @@
         // count search set
         if ($this->search_string && $mailbox == $this->mailbox && ($mode == 'ALL' || $mode == 'THREADS') && !$force) {
-            if ($this->search_threads)
-                return $mode == 'ALL' ? count((array)$this->search_set['depth']) : count((array)$this->search_set['tree']);
+            if ($mode == 'ALL')
+                return $this->search_set->countMessages();
             else
-                return count((array)$this->search_set);
+                return $this->search_set->count();
         }
 
@@ -706 +705 @@
 
         if ($mode == 'THREADS') {
-            $res   = $this->_threadcount($mailbox, $msg_count);
-            $count = $res['count'];
+            $res   = $this->fetch_threads($mailbox, $force);
+            $count = $res->count();
 
             if ($status) {
-                $this->set_folder_stats($mailbox, 'cnt', $res['msgcount']);
-                $this->set_folder_stats($mailbox, 'maxuid', $res['maxuid'] ? $this->id2uid($res['maxuid'], $mailbox) : 0);
+                $msg_count = $res->countMessages();
+                $this->set_folder_stats($mailbox, 'cnt', $msg_count);
+                $this->set_folder_stats($mailbox, 'maxuid', $msg_count ? $this->id2uid($msg_count, $mailbox) : 0);
             }
         }
@@ -722 +722 @@
             $search_str = "ALL UNDELETED";
             $keys       = array('COUNT');
-            $need_uid   = false;
 
             if ($mode == 'UNSEEN') {
@@ -733 +732 @@
                 if ($status) {
                     $keys[]   = 'MAX';
-                    $need_uid = true;
                 }
             }
+
+            // @TODO: if $force==false && $mode == 'ALL' we could try to use cache index here
 
             // get message count using (E)SEARCH
             // not very performant but more precise (using UNDELETED)
-            $index = $this->conn->search($mailbox, $search_str, $need_uid, $keys);
-
-            $count = is_array($index) ? $index['COUNT'] : 0;
+            $index = $this->conn->search($mailbox, $search_str, true, $keys);
+            $count = $index->count();
 
             if ($mode == 'ALL') {
-                if ($this->messages_caching) {
-                    // Save additional info required by cache status check
-                    $this->icache['undeleted_idx'] = array($mailbox, $index['ALL'], $index['COUNT']);
-                }
+                // Cache index data, will be used in message_index_direct()
+                $this->icache['undeleted_idx'] = $index;
+
                 if ($status) {
                     $this->set_folder_stats($mailbox, 'cnt', $count);
-                    $this->set_folder_stats($mailbox, 'maxuid', is_array($index) ? $index['MAX'] : 0);
+                    $this->set_folder_stats($mailbox, 'maxuid', $index->max());
                 }
             }
@@ -776 +774 @@
 
     /**
-     * Private method for getting nr of threads
-     *
-     * @param string $mailbox   Folder name
-     *
-     * @returns array Array containing items: 'count' - threads count,
-     *                'msgcount' = messages count, 'maxuid' = max. UID in the set
-     * @access  private
-     */
-    private function _threadcount($mailbox)
-    {
-        $result = array();
-
-        if (!empty($this->icache['threads'])) {
-            $dcount = count($this->icache['threads']['depth']);
-            $result = array(
-                'count'    => count($this->icache['threads']['tree']),
-                'msgcount' => $dcount,
-                'maxuid'   => $dcount ? max(array_keys($this->icache['threads']['depth'])) : 0,
-            );
-        }
-        else if (is_array($result = $this->fetch_threads($mailbox))) {
-            $dcount = count($result[1]);
-            $result = array(
-                'count'    => count($result[0]),
-                'msgcount' => $dcount,
-                'maxuid'   => $dcount ? max(array_keys($result[1])) : 0,
-            );
-        }
-
-        return $result;
-    }
-
-
-    /**
      * Public method for listing headers
      * convert mailbox name with root dir first
@@ -818 +782 @@
      * @param   string   $sort_order Sort order [ASC|DESC]
      * @param   int      $slice      Number of slice items to extract from result array
+     *
      * @return  array    Indexed array with message header objects
      * @access  public
      */
-    function list_headers($mailbox='', $page=NULL, $sort_field=NULL, $sort_order=NULL, $slice=0)
+    public function list_headers($mailbox='', $page=NULL, $sort_field=NULL, $sort_order=NULL, $slice=0)
     {
         if (!strlen($mailbox)) {
@@ -845 +810 @@
     private function _list_headers($mailbox='', $page=NULL, $sort_field=NULL, $sort_order=NULL, $slice=0)
     {
-        if (!strlen($mailbox))
+        if (!strlen($mailbox)) {
             return array();
+        }
+
+        $this->set_sort_order($sort_field, $sort_order);
+        $page = $page ? $page : $this->list_page;
 
         // use saved message set
-        if ($this->search_string && $mailbox == $this->mailbox)
-            return $this->_list_header_set($mailbox, $page, $sort_field, $sort_order, $slice);
-
-        if ($this->threading)
-            return $this->_list_thread_headers($mailbox, $page, $sort_field, $sort_order, $slice);
-
-        $this->_set_sort_order($sort_field, $sort_order);
-
-        $page = $page ? $page : $this->list_page;
-
-        // Use messages cache
-        if ($mcache = $this->get_mcache_engine()) {
-            $msg_index = $mcache->get_index($mailbox, $this->sort_field, $this->sort_order);
-
-            if (empty($msg_index))
-                return array();
-
-            $from      = ($page-1) * $this->page_size;
-            $to        = $from + $this->page_size;
-            $msg_index = array_values($msg_index); // UIDs
-            $is_uid    = true;
-            $sorted    = true;
-
-            if ($from || $to)
-                $msg_index = array_slice($msg_index, $from, $to - $from);
-
-            if ($slice)
-                $msg_index = array_slice($msg_index, -$slice, $slice);
-
-            $a_msg_headers = $mcache->get_messages($mailbox, $msg_index);
-        }
-        // retrieve headers from IMAP
-        // use message index sort as default sorting (for better performance)
-        else if (!$this->sort_field) {
-            if ($this->skip_deleted) {
-                // @TODO: this could be cached
-                if ($msg_index = $this->_search_index($mailbox, 'ALL UNDELETED')) {
-                    list($begin, $end) = $this->_get_message_range(count($msg_index), $page);
-                    $msg_index = array_slice($msg_index, $begin, $end-$begin);
-                }
-            }
-            else if ($max = $this->conn->countMessages($mailbox)) {
-                list($begin, $end) = $this->_get_message_range($max, $page);
-                $msg_index = range($begin+1, $end);
-            }
-            else
-                $msg_index = array();
-
-            if ($slice && $msg_index)
-                $msg_index = array_slice($msg_index, ($this->sort_order == 'DESC' ? 0 : -$slice), $slice);
-
-            // fetch reqested headers from server
-            if ($msg_index)
-                $a_msg_headers = $this->fetch_headers($mailbox, $msg_index);
-        }
-        // use SORT command
-        else if ($this->get_capability('SORT') &&
-            // Courier-IMAP provides SORT capability but allows to disable it by admin (#1486959)
-            ($msg_index = $this->conn->sort($mailbox, $this->sort_field,
-                $this->skip_deleted ? 'UNDELETED' : '', true)) !== false
-        ) {
-            if (!empty($msg_index)) {
-                list($begin, $end) = $this->_get_message_range(count($msg_index), $page);
-                $msg_index = array_slice($msg_index, $begin, $end-$begin);
-                $is_uid    = true;
-
-                if ($slice)
-                    $msg_index = array_slice($msg_index, ($this->sort_order == 'DESC' ? 0 : -$slice), $slice);
-
-                // fetch reqested headers from server
-                $a_msg_headers = $this->fetch_headers($mailbox, $msg_index, true);
-            }
-        }
-        // fetch specified header for all messages and sort
-        else if ($msg_index = $this->conn->fetchHeaderIndex($mailbox, "1:*",
-            $this->sort_field, $this->skip_deleted)
-        ) {
-            asort($msg_index); // ASC
-            $msg_index = array_keys($msg_index);
-            list($begin, $end) = $this->_get_message_range(count($msg_index), $page);
-            $msg_index = array_slice($msg_index, $begin, $end-$begin);
-
-            if ($slice)
-                $msg_index = array_slice($msg_index, ($this->sort_order == 'DESC' ? 0 : -$slice), $slice);
-
-            // fetch reqested headers from server
-            $a_msg_headers = $this->fetch_headers($mailbox, $msg_index);
-        }
-
-        // return empty array if no messages found
-        if (!is_array($a_msg_headers) || empty($a_msg_headers))
+        if ($this->search_string && $mailbox == $this->mailbox) {
+            return $this->_list_header_set($mailbox, $page, $slice);
+        }
+
+        if ($this->threading) {
+            return $this->_list_thread_headers($mailbox, $page, $slice);
+        }
+
+        // get UIDs of all messages in the folder, sorted
+        $index = $this->message_index($mailbox, $this->sort_field, $this->sort_order);
+
+        if ($index->isEmpty()) {
             return array();
-
-        // use this class for message sorting
-        $sorter = new rcube_header_sorter();
-        $sorter->set_index($msg_index, $is_uid);
-        $sorter->sort_headers($a_msg_headers);
-
-        if ($this->sort_order == 'DESC' && !$sorted)
-            $a_msg_headers = array_reverse($a_msg_headers);
+        }
+
+        $from = ($page-1) * $this->page_size;
+        $to   = $from + $this->page_size;
+
+        $index->slice($from, $to - $from);
+
+        if ($slice)
+            $index->slice(-$slice, $slice);
+
+        // fetch reqested messages headers
+        $a_index = $index->get();
+        $a_msg_headers = $this->fetch_headers($mailbox, $a_index);
 
         return array_values($a_msg_headers);
@@ -959 +854 @@
      * @param   string   $mailbox    Mailbox/folder name
      * @param   int      $page       Current page to list
-     * @param   string   $sort_field Header field to sort by
-     * @param   string   $sort_order Sort order [ASC|DESC]
      * @param   int      $slice      Number of slice items to extract from result array
      *
@@ -966 +859 @@
      * @see     rcube_imap::list_headers
      */
-    private function _list_thread_headers($mailbox, $page=NULL, $sort_field=NULL, $sort_order=NULL, $slice=0)
-    {
-        $this->_set_sort_order($sort_field, $sort_order);
-
-        $page   = $page ? $page : $this->list_page;
-        $mcache = $this->get_mcache_engine();
-
+    private function _list_thread_headers($mailbox, $page, $slice=0)
+    {
         // get all threads (not sorted)
-        if ($mcache)
-            list ($thread_tree, $msg_depth, $has_children) = $mcache->get_thread($mailbox);
+        if ($mcache = $this->get_mcache_engine())
+            $threads = $mcache->get_thread($mailbox);
         else
-            list ($thread_tree, $msg_depth, $has_children) = $this->fetch_threads($mailbox);
-
-        if (empty($thread_tree))
-            return array();
-
-        $msg_index = $this->sort_threads($mailbox, $thread_tree);
-
-        return $this->_fetch_thread_headers($mailbox,
-            $thread_tree, $msg_depth, $has_children, $msg_index, $page, $slice);
+            $threads = $this->fetch_threads($mailbox);
+
+        return $this->_fetch_thread_headers($mailbox, $threads, $page, $slice);
     }
 
@@ -995 +877 @@
      * @param  bool   $force    Use IMAP server, no cache
      *
-     * @return  array    Array with thread data
+     * @return rcube_imap_thread Thread data object
      */
     function fetch_threads($mailbox, $force = false)
@@ -1007 +889 @@
             // get all threads
             $result = $this->conn->thread($mailbox, $this->threading,
-                $this->skip_deleted ? 'UNDELETED' : '');
+                $this->skip_deleted ? 'UNDELETED' : '', true);
 
             // add to internal (fast) cache
-            $this->icache['threads'] = array();
-            $this->icache['threads']['tree'] = is_array($result) ? $result[0] : array();
-            $this->icache['threads']['depth'] = is_array($result) ? $result[1] : array();
-            $this->icache['threads']['has_children'] = is_array($result) ? $result[2] : array();
-        }
-
-        return array(
-            $this->icache['threads']['tree'],
-            $this->icache['threads']['depth'],
-            $this->icache['threads']['has_children'],
-        );
+            $this->icache['threads'] = $result;
+        }
+
+        return $this->icache['threads'];
     }
 
@@ -1027 +902 @@
      * Private method for fetching threaded messages headers
      *
-     * @param string  $mailbox      Mailbox name
-     * @param array   $thread_tree  Thread tree data
-     * @param array   $msg_depth    Thread depth data
-     * @param array   $has_children Thread children data
-     * @param array   $msg_index    Messages index
-     * @param int     $page         List page number
-     * @param int     $slice        Number of threads to slice
+     * @param string              $mailbox    Mailbox name
+     * @param rcube_result_thread $threads    Threads data object
+     * @param int                 $page       List page number
+     * @param int                 $slice      Number of threads to slice
      *
      * @return array  Messages headers
      * @access  private
      */
-    private function _fetch_thread_headers($mailbox, $thread_tree, $msg_depth, $has_children, $msg_index, $page, $slice=0)
-    {
-        // now get IDs for current page
-        list($begin, $end) = $this->_get_message_range(count($msg_index), $page);
-        $msg_index = array_slice($msg_index, $begin, $end-$begin);
+    private function _fetch_thread_headers($mailbox, $threads, $page, $slice=0)
+    {
+        // Sort thread structure
+        $this->sort_threads($threads);
+
+        $from = ($page-1) * $this->page_size;
+        $to   = $from + $this->page_size;
+
+        $threads->slice($from, $to - $from);
 
         if ($slice)
-            $msg_index = array_slice($msg_index, ($this->sort_order == 'DESC' ? 0 : -$slice), $slice);
-
-        if ($this->sort_order == 'DESC')
-            $msg_index = array_reverse($msg_index);
-
-        // flatten threads array
-        // @TODO: fetch children only in expanded mode (?)
-        $all_ids = array();
-        foreach ($msg_index as $root) {
-            $all_ids[] = $root;
-            if (!empty($thread_tree[$root]))
-                $all_ids = array_merge($all_ids, array_keys_recursive($thread_tree[$root]));
-        }
+            $threads->slice(-$slice, $slice);
+
+        // Get UIDs of all messages in all threads
+        $a_index = $threads->get();
 
         // fetch reqested headers from server
-        $a_msg_headers = $this->fetch_headers($mailbox, $all_ids);
-
-        // return empty array if no messages found
-        if (!is_array($a_msg_headers) || empty($a_msg_headers))
-            return array();
-
-        // use this class for message sorting
-        $sorter = new rcube_header_sorter();
-        $sorter->set_index($all_ids);
-        $sorter->sort_headers($a_msg_headers);
+        $a_msg_headers = $this->fetch_headers($mailbox, $a_index);
+
+        unset($a_index);
 
         // Set depth, has_children and unread_children fields in headers
-        $this->_set_thread_flags($a_msg_headers, $msg_depth, $has_children);
+        $this->_set_thread_flags($a_msg_headers, $threads);
 
         return array_values($a_msg_headers);
@@ -1082 +942 @@
      * depth, has_children and unread_children
      *
-     * @param  array  $headers      Reference to headers array indexed by message ID
-     * @param  array  $msg_depth    Array of messages depth indexed by message ID
-     * @param  array  $msg_children Array of messages children flags indexed by message ID
-     * @return array   Message headers array indexed by message ID
+     * @param  array             $headers Reference to headers array indexed by message UID
+     * @param  rcube_imap_result $threads Threads data object
+     *
+     * @return array Message headers array indexed by message UID
      * @access private
      */
-    private function _set_thread_flags(&$headers, $msg_depth, $msg_children)
+    private function _set_thread_flags(&$headers, $threads)
     {
         $parents = array();
 
-        foreach ($headers as $idx => $header) {
-            $id = $header->id;
-            $depth = $msg_depth[$id];
+        list ($msg_depth, $msg_children) = $threads->getThreadData();
+
+        foreach ($headers as $uid => $header) {
+            $depth = $msg_depth[$uid];
             $parents = array_slice($parents, 0, $depth);
 
             if (!empty($parents)) {
-                $headers[$idx]->parent_uid = end($parents);
+                $headers[$uid]->parent_uid = end($parents);
                 if (empty($header->flags['SEEN']))
                     $headers[$parents[0]]->unread_children++;
             }
-            array_push($parents, $header->uid);
-
-            $headers[$idx]->depth = $depth;
-            $headers[$idx]->has_children = $msg_children[$id];
+            array_push($parents, $uid);
+
+            $headers[$uid]->depth = $depth;
+            $headers[$uid]->has_children = $msg_children[$uid];
         }
     }
@@ -1112 +973 @@
     /**
      * Private method for listing a set of message headers (search results)
+     *
+     * @param   string   $mailbox  Mailbox/folder name
+     * @param   int      $page     Current page to list
+     * @param   int      $slice    Number of slice items to extract from result array
+     *
+     * @return  array    Indexed array with message header objects
+     * @access  private
+     */
+    private function _list_header_set($mailbox, $page, $slice=0)
+    {
+        if (!strlen($mailbox) || empty($this->search_set) || $this->search_set->isEmpty()) {
+            return array();
+        }
+
+        // use saved messages from searching
+        if ($this->threading) {
+            return $this->_list_thread_header_set($mailbox, $page, $slice);
+        }
+
+        // search set is threaded, we need a new one
+        if ($this->search_threads) {
+            $this->search('', $this->search_string, $this->search_charset, $this->sort_field);
+        }
+
+        $index = clone $this->search_set;
+        $from  = ($page-1) * $this->page_size;
+        $to    = $from + $this->page_size;
+
+        // return empty array if no messages found
+        if ($index->isEmpty())
+            return array();
+
+        // quickest method (default sorting)
+        if (!$this->search_sort_field && !$this->sort_field) {
+            $got_index = true;
+        }
+        // sorted messages, so we can first slice array and then fetch only wanted headers
+        else if ($this->search_sorted) { // SORT searching result
+            $got_index = true;
+            // reset search set if sorting field has been changed
+            if ($this->sort_field && $this->search_sort_field != $this->sort_field) {
+                $this->search('', $this->search_string, $this->search_charset, $this->sort_field);
+
+                $index = clone $this->search_set;
+
+                // return empty array if no messages found
+                if ($index->isEmpty())
+                    return array();
+            }
+        }
+
+        if ($got_index) {
+            if ($this->sort_order != $index->getParameters('ORDER')) {
+                $index->revert();
+            }
+
+            // get messages uids for one page
+            $index->slice($from, $to-$from);
+
+            if ($slice)
+                $index->slice(-$slice, $slice);
+
+            // fetch headers
+            $a_index       = $index->get();
+            $a_msg_headers = $this->fetch_headers($mailbox, $a_index);
+
+            return array_values($a_msg_headers);
+        }
+
+        // SEARCH result, need sorting
+        $cnt = $index->count();
+
+        // 300: experimantal value for best result
+        if (($cnt > 300 && $cnt > $this->page_size) || !$this->sort_field) {
+            // use memory less expensive (and quick) method for big result set
+            $index = clone $this->message_index('', $this->sort_field, $this->sort_order);
+            // get messages uids for one page...
+            $index->slice($start_msg, min($cnt-$from, $this->page_size));
+
+            if ($slice)
+                $index->slice(-$slice, $slice);
+
+            // ...and fetch headers
+            $a_index       = $index->get();
+            $a_msg_headers = $this->fetch_headers($mailbox, $a_index);
+
+            return array_values($a_msg_headers);
+        }
+        else {
+            // for small result set we can fetch all messages headers
+            $a_index       = $index->get();
+            $a_msg_headers = $this->fetch_headers($mailbox, $a_index, false);
+
+            // return empty array if no messages found
+            if (!is_array($a_msg_headers) || empty($a_msg_headers))
+                return array();
+
+            // if not already sorted
+            $a_msg_headers = $this->conn->sortHeaders(
+                $a_msg_headers, $this->sort_field, $this->sort_order);
+
+            // only return the requested part of the set
+            $a_msg_headers = array_slice(array_values($a_msg_headers),
+                $from, min($cnt-$to, $this->page_size));
+
+            if ($slice)
+                $a_msg_headers = array_slice($a_msg_headers, -$slice, $slice);
+
+            return $a_msg_headers;
+        }
+    }
+
+
+    /**
+     * Private method for listing a set of threaded message headers (search results)
      *
      * @param   string   $mailbox    Mailbox/folder name
      * @param   int      $page       Current page to list
-     * @param   string   $sort_field Header field to sort by
-     * @param   string   $sort_order Sort order [ASC|DESC]
-     * @param   int  $slice      Number of slice items to extract from result array
+     * @param   int      $slice      Number of slice items to extract from result array
+     *
      * @return  array    Indexed array with message header objects
      * @access  private
      * @see     rcube_imap::list_header_set()
      */
-    private function _list_header_set($mailbox, $page=NULL, $sort_field=NULL, $sort_order=NULL, $slice=0)
-    {
-        if (!strlen($mailbox) || empty($this->search_set))
+    private function _list_thread_header_set($mailbox, $page, $slice=0)
+    {
+        // update search_set if previous data was fetched with disabled threading
+        if (!$this->search_threads) {
+            if ($this->search_set->isEmpty())
+                return array();
+            $this->search('', $this->search_string, $this->search_charset, $this->sort_field);
+        }
+
+        return $this->_fetch_thread_headers($mailbox, clone $this->search_set, $page, $slice);
+    }
+
+
+    /**
+     * Fetches messages headers (by UID)
+     *
+     * @param  string  $mailbox  Mailbox name
+     * @param  array   $msgs     Message UIDs
+     * @param  bool    $sort     Enables result sorting by $msgs
+     * @param  bool    $force    Disables cache use
+     *
+     * @return array Messages headers indexed by UID
+     * @access private
+     */
+    function fetch_headers($mailbox, $msgs, $sort = true, $force = false)
+    {
+        if (empty($msgs))
             return array();
 
-        // use saved messages from searching
-        if ($this->threading)
-            return $this->_list_thread_header_set($mailbox, $page, $sort_field, $sort_order, $slice);
-
-        // search set is threaded, we need a new one
-        if ($this->search_threads) {
-            if (empty($this->search_set['tree']))
-                return array();
-            $this->search('', $this->search_string, $this->search_charset, $sort_field);
-        }
-
-        $msgs = $this->search_set;
-        $a_msg_headers = array();
-        $page = $page ? $page : $this->list_page;
-        $start_msg = ($page-1) * $this->page_size;
-
-        $this->_set_sort_order($sort_field, $sort_order);
-
-        // quickest method (default sorting)
-        if (!$this->search_sort_field && !$this->sort_field) {
-            if ($sort_order == 'DESC')
-                $msgs = array_reverse($msgs);
-
-            // get messages uids for one page
-            $msgs = array_slice(array_values($msgs), $start_msg, min(count($msgs)-$start_msg, $this->page_size));
-
-            if ($slice)
-                $msgs = array_slice($msgs, -$slice, $slice);
-
-            // fetch headers
-            $a_msg_headers = $this->fetch_headers($mailbox, $msgs);
-
-            // I didn't found in RFC that FETCH always returns messages sorted by index
+        if (!$force && ($mcache = $this->get_mcache_engine())) {
+            $headers = $mcache->get_messages($mailbox, $msgs);
+        }
+        else {
+            // fetch reqested headers from server
+            $headers = $this->conn->fetchHeaders(
+                $mailbox, $msgs, true, false, $this->get_fetch_headers());
+        }
+
+        if (empty($headers))
+            return array();
+
+        foreach ($headers as $h) {
+            $a_msg_headers[$h->uid] = $h;
+        }
+
+        if ($sort) {
+            // use this class for message sorting
             $sorter = new rcube_header_sorter();
             $sorter->set_index($msgs);
             $sorter->sort_headers($a_msg_headers);
-
-            return array_values($a_msg_headers);
-        }
-
-        // sorted messages, so we can first slice array and then fetch only wanted headers
-        if ($this->search_sorted) { // SORT searching result
-            // reset search set if sorting field has been changed
-            if ($this->sort_field && $this->search_sort_field != $this->sort_field)
-                $msgs = $this->search('', $this->search_string, $this->search_charset, $this->sort_field);
-
-            // return empty array if no messages found
-            if (empty($msgs))
-                return array();
-
-            if ($sort_order == 'DESC')
-                $msgs = array_reverse($msgs);
-
-            // get messages uids for one page
-            $msgs = array_slice(array_values($msgs), $start_msg, min(count($msgs)-$start_msg, $this->page_size));
-
-            if ($slice)
-                $msgs = array_slice($msgs, -$slice, $slice);
-
-            // fetch headers
-            $a_msg_headers = $this->fetch_headers($mailbox, $msgs);
-
-            $sorter = new rcube_header_sorter();
-            $sorter->set_index($msgs);
-            $sorter->sort_headers($a_msg_headers);
-
-            return array_values($a_msg_headers);
-        }
-        else { // SEARCH result, need sorting
-            $cnt = count($msgs);
-            // 300: experimantal value for best result
-            if (($cnt > 300 && $cnt > $this->page_size) || !$this->sort_field) {
-                // use memory less expensive (and quick) method for big result set
-                $a_index = $this->message_index('', $this->sort_field, $this->sort_order);
-                // get messages uids for one page...
-                $msgs = array_slice($a_index, $start_msg, min($cnt-$start_msg, $this->page_size));
-                if ($slice)
-                    $msgs = array_slice($msgs, -$slice, $slice);
-                // ...and fetch headers
-                $a_msg_headers = $this->fetch_headers($mailbox, $msgs);
-
-
-                // return empty array if no messages found
-                if (!is_array($a_msg_headers) || empty($a_msg_headers))
-                    return array();
-
-                $sorter = new rcube_header_sorter();
-                $sorter->set_index($msgs);
-                $sorter->sort_headers($a_msg_headers);
-
-                return array_values($a_msg_headers);
-            }
-            else {
-                // for small result set we can fetch all messages headers
-                $a_msg_headers = $this->fetch_headers($mailbox, $msgs);
-
-                // return empty array if no messages found
-                if (!is_array($a_msg_headers) || empty($a_msg_headers))
-                    return array();
-
-                // if not already sorted
-                $a_msg_headers = $this->conn->sortHeaders(
-                    $a_msg_headers, $this->sort_field, $this->sort_order);
-
-                // only return the requested part of the set
-                $a_msg_headers = array_slice(array_values($a_msg_headers),
-                    $start_msg, min($cnt-$start_msg, $this->page_size));
-
-                if ($slice)
-                    $a_msg_headers = array_slice($a_msg_headers, -$slice, $slice);
-
-                return $a_msg_headers;
-            }
-        }
-    }
-
-
-    /**
-     * Private method for listing a set of threaded message headers (search results)
-     *
-     * @param   string   $mailbox    Mailbox/folder name
-     * @param   int      $page       Current page to list
-     * @param   string   $sort_field Header field to sort by
-     * @param   string   $sort_order Sort order [ASC|DESC]
-     * @param   int      $slice      Number of slice items to extract from result array
-     * @return  array    Indexed array with message header objects
-     * @access  private
-     * @see     rcube_imap::list_header_set()
-     */
-    private function _list_thread_header_set($mailbox, $page=NULL, $sort_field=NULL, $sort_order=NULL, $slice=0)
-    {
-        // update search_set if previous data was fetched with disabled threading
-        if (!$this->search_threads) {
-            if (empty($this->search_set))
-                return array();
-            $this->search('', $this->search_string, $this->search_charset, $sort_field);
-        }
-
-        // empty result
-        if (empty($this->search_set['tree']))
-            return array();
-
-        $thread_tree = $this->search_set['tree'];
-        $msg_depth = $this->search_set['depth'];
-        $has_children = $this->search_set['children'];
-        $a_msg_headers = array();
-
-        $page = $page ? $page : $this->list_page;
-        $start_msg = ($page-1) * $this->page_size;
-
-        $this->_set_sort_order($sort_field, $sort_order);
-
-        $msg_index = $this->sort_threads($mailbox, $thread_tree, array_keys($msg_depth));
-
-        return $this->_fetch_thread_headers($mailbox,
-            $thread_tree, $msg_depth, $has_children, $msg_index, $page, $slice=0);
-    }
-
-
-    /**
-     * Helper function to get first and last index of the requested set
-     *
-     * @param  int     $max  Messages count
-     * @param  mixed   $page Page number to show, or string 'all'
-     * @return array   Array with two values: first index, last index
-     * @access private
-     */
-    private function _get_message_range($max, $page)
-    {
-        $start_msg = ($page-1) * $this->page_size;
-
-        if ($page=='all') {
-            $begin  = 0;
-            $end    = $max;
-        }
-        else if ($this->sort_order=='DESC') {
-            $begin  = $max - $this->page_size - $start_msg;
-            $end    = $max - $start_msg;
-        }
-        else {
-            $begin  = $start_msg;
-            $end    = $start_msg + $this->page_size;
-        }
-
-        if ($begin < 0) $begin = 0;
-        if ($end < 0) $end = $max;
-        if ($end > $max) $end = $max;
-
-        return array($begin, $end);
-    }
-
-
-    /**
-     * Fetches messages headers
-     *
-     * @param  string  $mailbox  Mailbox name
-     * @param  array   $msgs     Messages sequence numbers
-     * @param  bool    $is_uid   Enable if $msgs numbers are UIDs
-     * @param  bool    $force    Disables cache use
-     *
-     * @return array Messages headers indexed by UID
-     * @access private
-     */
-    function fetch_headers($mailbox, $msgs, $is_uid = false, $force = false)
-    {
-        if (empty($msgs))
-            return array();
-
-        if (!$force && ($mcache = $this->get_mcache_engine())) {
-            return $mcache->get_messages($mailbox, $msgs, $is_uid);
-        }
-
-        // fetch reqested headers from server
-        $index = $this->conn->fetchHeaders(
-            $mailbox, $msgs, $is_uid, false, $this->get_fetch_headers());
-
-        if (empty($index))
-            return array();
-
-        foreach ($index as $headers) {
-            $a_msg_headers[$headers->uid] = $headers;
         }
 
@@ -1363 +1162 @@
      * @return int   Folder status
      */
-    function mailbox_status($mailbox = null)
+    public function mailbox_status($mailbox = null)
     {
         if (!strlen($mailbox)) {
@@ -1426 +1225 @@
 
     /**
-     * Return sorted array of message IDs (not UIDs)
+     * Return sorted list of message UIDs
      *
      * @param string $mailbox    Mailbox to get index from
      * @param string $sort_field Sort column
      * @param string $sort_order Sort order [ASC, DESC]
-     * @return array Indexed array with message IDs
-     */
-    function message_index($mailbox='', $sort_field=NULL, $sort_order=NULL)
+     *
+     * @return rcube_result_index|rcube_result_thread List of messages (UIDs)
+     */
+    public function message_index($mailbox='', $sort_field=NULL, $sort_order=NULL)
     {
         if ($this->threading)
             return $this->thread_index($mailbox, $sort_field, $sort_order);
 
-        $this->_set_sort_order($sort_field, $sort_order);
+        $this->set_sort_order($sort_field, $sort_order);
 
         if (!strlen($mailbox)) {
             $mailbox = $this->mailbox;
         }
-        $key = "{$mailbox}:{$this->sort_field}:{$this->sort_order}:{$this->search_string}.msgi";
 
         // we have a saved search result, get index from there
-        if (!isset($this->icache[$key]) && $this->search_string
-            && !$this->search_threads && $mailbox == $this->mailbox) {
+        if ($this->search_string) {
+            if ($this->search_threads) {
+                $this->search($mailbox, $this->search_string, $this->search_charset, $this->sort_field);
+            }
+
             // use message index sort as default sorting
-            if (!$this->sort_field) {
-                $msgs = $this->search_set;
-
-                if ($this->search_sort_field != 'date')
-                    sort($msgs);
-
-                if ($this->sort_order == 'DESC')
-                    $this->icache[$key] = array_reverse($msgs);
-                else
-                    $this->icache[$key] = $msgs;
-            }
-            // sort with SORT command
-            else if ($this->search_sorted) {
-                if ($this->sort_field && $this->search_sort_field != $this->sort_field)
-                    $this->search('', $this->search_string, $this->search_charset, $this->sort_field);
-
-                if ($this->sort_order == 'DESC')
-                    $this->icache[$key] = array_reverse($this->search_set);
-                else
-                    $this->icache[$key] = $this->search_set;
+            if (!$this->sort_field || $this->search_sorted) {
+                if ($this->sort_field && $this->search_sort_field != $this->sort_field) {
+                    $this->search($mailbox, $this->search_string, $this->search_charset, $this->sort_field);
+                }
+                $index = $this->search_set;
             }
             else {
-                $a_index = $this->conn->fetchHeaderIndex($mailbox,
-                    join(',', $this->search_set), $this->sort_field, $this->skip_deleted);
-
-                if (is_array($a_index)) {
-                    if ($this->sort_order=="ASC")
-                        asort($a_index);
-                    else if ($this->sort_order=="DESC")
-                        arsort($a_index);
-
-                    $this->icache[$key] = array_keys($a_index);
-                }
-                else {
-                    $this->icache[$key] = array();
-                }
-            }
-        }
-
-        // have stored it in RAM
-        if (isset($this->icache[$key]))
-            return $this->icache[$key];
+                $index = $this->conn->index($mailbox, $this->search_set->get(),
+                    $this->sort_field, $this->skip_deleted, true, true);
+            }
+
+            if ($this->sort_order != $index->getParameters('ORDER')) {
+                $index->revert();
+            }
+
+            return $index;
+        }
 
         // check local cache
         if ($mcache = $this->get_mcache_engine()) {
-            $a_index = $mcache->get_index($mailbox, $this->sort_field, $this->sort_order);
-            $this->icache[$key] = array_keys($a_index);
+            $index = $mcache->get_index($mailbox, $this->sort_field, $this->sort_order);
         }
         // fetch from IMAP server
         else {
-            $this->icache[$key] = $this->message_index_direct(
+            $index = $this->message_index_direct(
                 $mailbox, $this->sort_field, $this->sort_order);
         }
 
-        return $this->icache[$key];
-    }
-
-
-    /**
-     * Return sorted array of message IDs (not UIDs) directly from IMAP server.
-     * Doesn't use cache and ignores current search settings.
+        return $index;
+    }
+
+
+    /**
+     * Return sorted list of message UIDs ignoring current search settings.
+     * Doesn't uses cache by default.
      *
      * @param string $mailbox    Mailbox to get index from
      * @param string $sort_field Sort column
      * @param string $sort_order Sort order [ASC, DESC]
-     *
-     * @return array Indexed array with message IDs
-     */
-    function message_index_direct($mailbox, $sort_field = null, $sort_order = null)
-    {
+     * @param bool   $skip_cache Disables cache usage
+     *
+     * @return rcube_result_index Sorted list of message UIDs
+     */
+    public function message_index_direct($mailbox, $sort_field = null, $sort_order = null, $skip_cache = true)
+    {
+        if (!$skip_cache && ($mcache = $this->get_mcache_engine())) {
+            $index = $mcache->get_index($mailbox, $sort_field, $sort_order);
+        }
         // use message index sort as default sorting
-        if (!$sort_field) {
-            if ($this->skip_deleted) {
-                $a_index = $this->conn->search($mailbox, 'ALL UNDELETED');
-                // I didn't found that SEARCH should return sorted IDs
-                if (is_array($a_index))
-                    sort($a_index);
-            } else if ($max = $this->_messagecount($mailbox, 'ALL', true, false)) {
-                $a_index = range(1, $max);
-            }
-
-            if ($a_index !== false && $sort_order == 'DESC')
-                $a_index = array_reverse($a_index);
+        else if (!$sort_field) {
+            if ($this->skip_deleted && !empty($this->icache['undeleted_idx'])
+                && $this->icache['undeleted_idx']->getParameters('MAILBOX') == $mailbox
+            ) {
+                $index = $this->icache['undeleted_idx'];
+            }
+            else {
+                $index = $this->conn->search($mailbox,
+                    'ALL' .($this->skip_deleted ? ' UNDELETED' : ''), true);
+            }
         }
         // fetch complete message index
-        else if ($this->get_capability('SORT') &&
-            ($a_index = $this->conn->sort($mailbox,
-                $sort_field, $this->skip_deleted ? 'UNDELETED' : '')) !== false
-        ) {
-            if ($sort_order == 'DESC')
-                $a_index = array_reverse($a_index);
-        }
-        else if ($a_index = $this->conn->fetchHeaderIndex(
-            $mailbox, "1:*", $sort_field, $skip_deleted)) {
-            if ($sort_order=="ASC")
-                asort($a_index);
-            else if ($sort_order=="DESC")
-                arsort($a_index);
-
-            $a_index = array_keys($a_index);
-        }
-
-        return $a_index !== false ? $a_index : array();
-    }
-
-
-    /**
-     * Return sorted array of threaded message IDs (not UIDs)
+        else {
+            if ($this->get_capability('SORT')) {
+                $index = $this->conn->sort($mailbox, $sort_field,
+                    $this->skip_deleted ? 'UNDELETED' : '', true);
+            }
+
+            if (empty($index) || $index->isError()) {
+                $index = $this->conn->index($mailbox, "1:*", $sort_field,
+                    $this->skip_deleted, false, true);
+            }
+        }
+
+        if ($sort_order != $index->getParameters('ORDER')) {
+            $index->revert();
+        }
+
+        return $index;
+    }
+
+
+    /**
+     * Return index of threaded message UIDs
      *
      * @param string $mailbox    Mailbox to get index from
      * @param string $sort_field Sort column
      * @param string $sort_order Sort order [ASC, DESC]
-     * @return array Indexed array with message IDs
+     *
+     * @return rcube_result_thread Message UIDs
      */
     function thread_index($mailbox='', $sort_field=NULL, $sort_order=NULL)
     {
-        $this->_set_sort_order($sort_field, $sort_order);
-
         if (!strlen($mailbox)) {
             $mailbox = $this->mailbox;
         }
-        $key = "{$mailbox}:{$this->sort_field}:{$this->sort_order}:{$this->search_string}.thi";
 
         // we have a saved search result, get index from there
-        if (!isset($this->icache[$key]) && $this->search_string
-            && $this->search_threads && $mailbox == $this->mailbox) {
-            // use message IDs for better performance
-            $ids = array_keys_recursive($this->search_set['tree']);
-            $this->icache[$key] = $this->_flatten_threads($mailbox, $this->search_set['tree'], $ids);
-        }
-
-        // have stored it in RAM
-        if (isset($this->icache[$key]))
-            return $this->icache[$key];
-
-        // get all threads (default sort order)
-        list ($thread_tree) = $this->fetch_threads($mailbox);
-
-        $this->icache[$key] = $this->_flatten_threads($mailbox, $thread_tree);
-
-        return $this->icache[$key];
-    }
-
-
-    /**
-     * Return array of threaded messages (all, not only roots)
-     *
-     * @param string $mailbox     Mailbox to get index from
-     * @param array  $thread_tree Threaded messages array (see fetch_threads())
-     * @param array  $ids         Message IDs if we know what we need (e.g. search result)
-     *                            for better performance
-     * @return array Indexed array with message IDs
-     *
-     * @access private
-     */
-    private function _flatten_threads($mailbox, $thread_tree, $ids=null)
-    {
-        if (empty($thread_tree))
-            return array();
-
-        $msg_index = $this->sort_threads($mailbox, $thread_tree, $ids);
-
-        if ($this->sort_order == 'DESC')
-            $msg_index = array_reverse($msg_index);
-
-        // flatten threads array
-        $all_ids = array();
-        foreach ($msg_index as $root) {
-            $all_ids[] = $root;
-            if (!empty($thread_tree[$root])) {
-                foreach (array_keys_recursive($thread_tree[$root]) as $val)
-                    $all_ids[] = $val;
-            }
-        }
-
-        return $all_ids;
+        if ($this->search_string && $this->search_threads && $mailbox == $this->mailbox) {
+            $threads = $this->search_set;
+        }
+        else {
+            // get all threads (default sort order)
+            $threads = $this->fetch_threads($mailbox);
+        }
+
+        $this->set_sort_order($sort_field, $sort_order);
+        $this->sort_threads($threads);
+
+        return $threads;
+    }
+
+
+    /**
+     * Sort threaded result, using THREAD=REFS method
+     *
+     * @param rcube_result_thread $threads  Threads result set
+     */
+    private function sort_threads($threads)
+    {
+        if ($threads->isEmpty()) {
+            return;
+        }
+
+        // THREAD=ORDEREDSUBJECT: sorting by sent date of root message
+        // THREAD=REFERENCES:     sorting by sent date of root message
+        // THREAD=REFS:           sorting by the most recent date in each thread
+
+        if ($this->sort_field && ($this->sort_field != 'date' || $this->get_capability('THREAD') != 'REFS')) {
+            $index = $this->message_index_direct($this->mailbox, $this->sort_field, $this->sort_order, false);
+
+            if (!$index->isEmpty()) {
+                $threads->sort($index);
+            }
+        }
+        else {
+            if ($this->sort_order != $threads->getParameters('ORDER')) {
+                $threads->revert();
+            }
+        }
     }
 
@@ -1635 +1400 @@
      * @param  string  $charset    Search charset
      * @param  string  $sort_field Header field to sort by
-     * @return array   search results as list of message IDs
      * @access public
      */
-    function search($mailbox='', $str=NULL, $charset=NULL, $sort_field=NULL)
+    function search($mailbox='', $str='ALL', $charset=NULL, $sort_field=NULL)
     {
         if (!$str)
-            return false;
+            $str = 'ALL';
 
         if (!strlen($mailbox)) {
@@ -1649 +1413 @@
         $results = $this->_search_index($mailbox, $str, $charset, $sort_field);
 
-        $this->set_search_set($str, $results, $charset, $sort_field, (bool)$this->threading,
+        $this->set_search_set($str, $results, $charset, $sort_field,
             $this->threading || $this->search_sorted ? true : false);
-
-        return $results;
     }
 
@@ -1664 +1426 @@
      * @param string $sort_field Sorting field
      *
-     * @return array   search results as list of message ids
+     * @return rcube_result_index|rcube_result_thread  Search results (UIDs)
      * @see rcube_imap::search()
      */
@@ -1675 +1437 @@
 
         if ($this->threading) {
-            $a_messages = $this->conn->thread($mailbox, $this->threading, $criteria, $charset);
+            $threads = $this->conn->thread($mailbox, $this->threading, $criteria, true, $charset);
 
             // Error, try with US-ASCII (RFC5256: SORT/THREAD must support US-ASCII and UTF-8,
             // but I've seen that Courier doesn't support UTF-8)
-            if ($a_messages === false && $charset && $charset != 'US-ASCII')
-                $a_messages = $this->conn->thread($mailbox, $this->threading,
-                    $this->convert_criteria($criteria, $charset), 'US-ASCII');
-
-            if ($a_messages !== false) {
-                list ($thread_tree, $msg_depth, $has_children) = $a_messages;
-                $a_messages = array(
-                    'tree' => $thread_tree,
-                    'depth'=> $msg_depth,
-                    'children' => $has_children
-                );
-            }
-
-            return $a_messages;
+            if ($threads->isError() && $charset && $charset != 'US-ASCII')
+                $threads = $this->conn->thread($mailbox, $this->threading,
+                    $this->convert_criteria($criteria, $charset), true, 'US-ASCII');
+
+            return $threads;
         }
 
         if ($sort_field && $this->get_capability('SORT')) {
-            $charset = $charset ? $charset : $this->default_charset;
-            $a_messages = $this->conn->sort($mailbox, $sort_field, $criteria, false, $charset);
+            $charset  = $charset ? $charset : $this->default_charset;
+            $messages = $this->conn->sort($mailbox, $sort_field, $criteria, true, $charset);
 
             // Error, try with US-ASCII (RFC5256: SORT/THREAD must support US-ASCII and UTF-8,
             // but I've seen Courier with disabled UTF-8 support)
-            if ($a_messages === false && $charset && $charset != 'US-ASCII')
-                $a_messages = $this->conn->sort($mailbox, $sort_field,
-                    $this->convert_criteria($criteria, $charset), false, 'US-ASCII');
-
-            if ($a_messages !== false) {
+            if ($messages->isError() && $charset && $charset != 'US-ASCII')
+                $messages = $this->conn->sort($mailbox, $sort_field,
+                    $this->convert_criteria($criteria, $charset), true, 'US-ASCII');
+
+            if (!$messages->isError()) {
                 $this->search_sorted = true;
-                return $a_messages;
-            }
-        }
-
-        if ($orig_criteria == 'ALL') {
-            $max = $this->_messagecount($mailbox, 'ALL', true, false);
-            $a_messages = $max ? range(1, $max) : array();
-        }
-        else {
-            $a_messages = $this->conn->search($mailbox,
-                ($charset ? "CHARSET $charset " : '') . $criteria);
-
-            // Error, try with US-ASCII (some servers may support only US-ASCII)
-            if ($a_messages === false && $charset && $charset != 'US-ASCII')
-                $a_messages = $this->conn->search($mailbox,
-                    'CHARSET US-ASCII ' . $this->convert_criteria($criteria, $charset));
-
-            // I didn't found that SEARCH should return sorted IDs
-            if (is_array($a_messages) && !$this->sort_field)
-                sort($a_messages);
-        }
+                return $messages;
+            }
+        }
+
+        $messages = $this->conn->search($mailbox,
+            ($charset ? "CHARSET $charset " : '') . $criteria, true);
+
+        // Error, try with US-ASCII (some servers may support only US-ASCII)
+        if ($messages->isError() && $charset && $charset != 'US-ASCII')
+            $messages = $this->conn->search($mailbox,
+                'CHARSET US-ASCII ' . $this->convert_criteria($criteria, $charset), true);
 
         $this->search_sorted = false;
 
-        return $a_messages;
+        return $messages;
     }
 
@@ -1743 +1486 @@
      * @param  boolean $ret_uid True if UIDs should be returned
      *
-     * @return array   Search results as list of message IDs or UIDs
-     */
-    function search_once($mailbox='', $str=NULL, $ret_uid=false)
+     * @return rcube_result_index  Search result (UIDs)
+     */
+    function search_once($mailbox='', $str='ALL')
     {
         if (!$str)
-            return false;
+            return 'ALL';
 
         if (!strlen($mailbox)) {
@@ -1754 +1497 @@
         }
 
-        return $this->conn->search($mailbox, $str, $ret_uid);
+        $index = $this->conn->search($mailbox, $str, true);
+
+        return $index;
     }
 
@@ -1792 +1537 @@
 
     /**
-     * Sort thread
-     *
-     * @param string $mailbox     Mailbox name
-     * @param  array $thread_tree Unsorted thread tree (rcube_imap_generic::thread() result)
-     * @param  array $ids         Message IDs if we know what we need (e.g. search result)
-     *
-     * @return array Sorted roots IDs
-     */
-    function sort_threads($mailbox, $thread_tree, $ids = null)
-    {
-        // THREAD=ORDEREDSUBJECT: sorting by sent date of root message
-        // THREAD=REFERENCES:     sorting by sent date of root message
-        // THREAD=REFS:           sorting by the most recent date in each thread
-
-        // default sorting
-        if (!$this->sort_field || ($this->sort_field == 'date' && $this->threading == 'REFS')) {
-            return array_keys((array)$thread_tree);
-        }
-        // here we'll implement REFS sorting
-        else {
-            if ($mcache = $this->get_mcache_engine()) {
-                $a_index = $mcache->get_index($mailbox, $this->sort_field, 'ASC');
-                if (is_array($a_index)) {
-                    $a_index = array_keys($a_index);
-                    // now we must remove IDs that doesn't exist in $ids
-                    if (!empty($ids))
-                        $a_index = array_intersect($a_index, $ids);
-                }
-            }
-            // use SORT command
-            else if ($this->get_capability('SORT') &&
-                ($a_index = $this->conn->sort($mailbox, $this->sort_field,
-                    !empty($ids) ? $ids : ($this->skip_deleted ? 'UNDELETED' : ''))) !== false
-            ) {
-                // do nothing
-            }
-            else {
-                // fetch specified headers for all messages and sort them
-                $a_index = $this->conn->fetchHeaderIndex($mailbox, !empty($ids) ? $ids : "1:*",
-                    $this->sort_field, $this->skip_deleted);
-
-                // return unsorted tree if we've got no index data
-                if (!empty($a_index)) {
-                    asort($a_index); // ASC
-                    $a_index = array_values($a_index);
-                }
-            }
-
-            if (empty($a_index))
-                return array_keys((array)$thread_tree);
-
-            return $this->_sort_thread_refs($thread_tree, $a_index);
-        }
-    }
-
-
-    /**
-     * THREAD=REFS sorting implementation
-     *
-     * @param  array $tree   Thread tree array (message identifiers as keys)
-     * @param  array $index  Array of sorted message identifiers
-     *
-     * @return array   Array of sorted roots messages
-     */
-    private function _sort_thread_refs($tree, $index)
-    {
-        if (empty($tree))
-            return array();
-
-        $index = array_combine(array_values($index), $index);
-
-        // assign roots
-        foreach ($tree as $idx => $val) {
-            $index[$idx] = $idx;
-            if (!empty($val)) {
-                $idx_arr = array_keys_recursive($tree[$idx]);
-                foreach ($idx_arr as $subidx)
-                    $index[$subidx] = $idx;
-            }
-        }
-
-        $index = array_values($index);
-
-        // create sorted array of roots
-        $msg_index = array();
-        if ($this->sort_order != 'DESC') {
-            foreach ($index as $idx)
-                if (!isset($msg_index[$idx]))
-                    $msg_index[$idx] = $idx;
-            $msg_index = array_values($msg_index);
-        }
-        else {
-            for ($x=count($index)-1; $x>=0; $x--)
-                if (!isset($msg_index[$index[$x]]))
-                    $msg_index[$index[$x]] = $index[$x];
-            $msg_index = array_reverse($msg_index);
-        }
-
-        return $msg_index;
-    }
-
-
-    /**
      * Refresh saved search set
      *
@@ -1901 +1543 @@
     function refresh_search()
     {
-        if (!empty($this->search_string))
-            $this->search_set = $this->search('', $this->search_string, $this->search_charset,
-                $this->search_sort_field, $this->search_threads, $this->search_sorted);
+        if (!empty($this->search_string)) {
+            $this->search('', $this->search_string, $this->search_charset, $this->search_sort_field);
+        }
 
         return $this->get_search_set();
@@ -1910 +1552 @@
 
     /**
-     * Check if the given message ID is part of the current search set
-     *
-     * @param string $msgid Message id
+     * Check if the given message UID is part of the current search set
+     *
+     * @param string $msgid Message UID
+     *
      * @return boolean True on match or if no search request is stored
      */
-    function in_searchset($msgid)
+    function in_searchset($uid)
     {
         if (!empty($this->search_string)) {
-            if ($this->search_threads)
-                return isset($this->search_set['depth']["$msgid"]);
-            else
-                return in_array("$msgid", (array)$this->search_set, true);
-        }
-        else
-            return true;
+            return $this->search_set->exists($uid);
+        }
+        return true;
     }
 
@@ -1982 +1621 @@
         // message doesn't exist?
         if (empty($headers))
-            return null; 
+            return null;
 
         // structure might be cached
@@ -2657 +2296 @@
                 if ($this->search_threads || $all_mode)
                     $this->refresh_search();
-                else {
-                    $a_uids = explode(',', $uids);
-                    foreach ($a_uids as $uid)
-                        $a_mids[] = $this->uid2id($uid, $from_mbox);
-                    $this->search_set = array_diff($this->search_set, $a_mids);
-                }
-                unset($a_mids);
-                unset($a_uids);
+                else
+                    $this->search_set->filter(explode(',', $uids));
             }
 
@@ -2757 +2390 @@
                 if ($this->search_threads || $all_mode)
                     $this->refresh_search();
-                else {
-                    $a_uids = explode(',', $uids);
-                    foreach ($a_uids as $uid)
-                        $a_mids[] = $this->uid2id($uid, $mailbox);
-                    $this->search_set = array_diff($this->search_set, $a_mids);
-                    unset($a_uids);
-                    unset($a_mids);
-                }
+                else
+                    $this->search_set->filter(explode(',', $uids));
             }
 
@@ -2883 +2510 @@
             }
             // get UIDs from current search set
-            // @TODO: skip fetchUIDs() and work with IDs instead of UIDs (?)
             else {
-                if ($this->search_threads)
-                    $uids = $this->conn->fetchUIDs($mailbox, array_keys($this->search_set['depth']));
-                else
-                    $uids = $this->conn->fetchUIDs($mailbox, $this->search_set);
-
-                // save ID-to-UID mapping in local cache
-                if (is_array($uids))
-                    foreach ($uids as $id => $uid)
-                        $this->uid_id_map[$mailbox][$uid] = $id;
-
-                $uids = join(',', $uids);
+                $uids = join(',', $this->search_set->get());
             }
         }
@@ -2908 +2524 @@
         return array($uids, (bool) $all);
     }
-
-
-    /**
-     * Translate UID to message ID
-     *
-     * @param int    $uid     Message UID
-     * @param string $mailbox Mailbox name
-     *
-     * @return int   Message ID
-     */
-    function get_id($uid, $mailbox=null)
-    {
-        if (!strlen($mailbox)) {
-            $mailbox = $this->mailbox;
-        }
-
-        return $this->uid2id($uid, $mailbox);
-    }
-
-
-    /**
-     * Translate message number to UID
-     *
-     * @param int    $id      Message ID
-     * @param string $mailbox Mailbox name
-     *
-     * @return int   Message UID
-     */
-    function get_uid($id, $mailbox=null)
-    {
-        if (!strlen($mailbox)) {
-            $mailbox = $this->mailbox;
-        }
-
-        return $this->id2uid($id, $mailbox);
-    }
-
 
 
@@ -3593 +3172 @@
 
         // add (E)SEARCH result for ALL UNDELETED query
-        if (!empty($this->icache['undeleted_idx']) && $this->icache['undeleted_idx'][0] == $mailbox) {
-            $data['ALL_UNDELETED']   = $this->icache['undeleted_idx'][1];
-            $data['COUNT_UNDELETED'] = $this->icache['undeleted_idx'][2];
+        if (!empty($this->icache['undeleted_idx'])
+            && $this->icache['undeleted_idx']->getParameters('MAILBOX') == $mailbox
+        ) {
+            $data['UNDELETED'] = $this->icache['undeleted_idx'];
         }
 
@@ -4269 +3849 @@
 
 
-    /**
-     * Convert body charset to RCMAIL_CHARSET according to the ctype_parameters
-     *
-     * @param string $body        Part body to decode
-     * @param string $ctype_param Charset to convert from
-     * @return string Content converted to internal charset
-     */
-    function charset_decode($body, $ctype_param)
-    {
-        if (is_array($ctype_param) && !empty($ctype_param['charset']))
-            return rcube_charset_convert($body, $ctype_param['charset']);
-
-        // defaults to what is specified in the class header
-        return rcube_charset_convert($body,  $this->default_charset);
-    }
-
-
     /* --------------------------------
      *         private methods
@@ -4297 +3860 @@
      * @access private
      */
-    private function _set_sort_order($sort_field, $sort_order)
+    private function set_sort_order($sort_field, $sort_order)
     {
         if ($sort_field != null)
@@ -4367 +3930 @@
 
     /**
-     * Finds message sequence ID for specified UID
-     *
-     * @param int    $uid      Message UID
+     * Find UID of the specified message sequence ID
+     *
+     * @param int    $id       Message (sequence) ID
      * @param string $mailbox  Mailbox name
-     * @param bool   $force    True to skip cache
-     *
-     * @return int Message (sequence) ID
-     */
-    function uid2id($uid, $mailbox = null, $force = false)
+     *
+     * @return int Message UID
+     */
+    function id2uid($id, $mailbox = null)
     {
         if (!strlen($mailbox)) {
@@ -4381 +3943 @@
         }
 
-        if (!empty($this->uid_id_map[$mailbox][$uid])) {
-            return $this->uid_id_map[$mailbox][$uid];
-        }
-
-        if (!$force && ($mcache = $this->get_mcache_engine()))
-            $id = $mcache->uid2id($mailbox, $uid);
-
-        if (empty($id))
-            $id = $this->conn->UID2ID($mailbox, $uid);
-
-        $this->uid_id_map[$mailbox][$uid] = $id;
-
-        return $id;
-    }
-
-
-    /**
-     * Find UID of the specified message sequence ID
-     *
-     * @param int    $id       Message (sequence) ID
-     * @param string $mailbox  Mailbox name
-     * @param bool   $force    True to skip cache
-     *
-     * @return int Message UID
-     */
-    function id2uid($id, $mailbox = null, $force = false)
-    {
-        if (!strlen($mailbox)) {
-            $mailbox = $this->mailbox;
-        }
-
         if ($uid = array_search($id, (array)$this->uid_id_map[$mailbox])) {
             return $uid;
         }
 
-        if (!$force && ($mcache = $this->get_mcache_engine()))
-            $uid = $mcache->id2uid($mailbox, $id);
-
-        if (empty($uid))
-            $uid = $this->conn->ID2UID($mailbox, $id);
+        $uid = $this->conn->ID2UID($mailbox, $id);
 
         $this->uid_id_map[$mailbox][$uid] = $id;
@@ -4706 +4233 @@
 class rcube_header_sorter
 {
-    private $seqs = array();
     private $uids = array();
 
@@ -4713 +4239 @@
      * Set the predetermined sort order.
      *
-     * @param array $index  Numerically indexed array of IMAP ID or UIDs
-     * @param bool  $is_uid Set to true if $index contains UIDs
-     */
-    function set_index($index, $is_uid = false)
+     * @param array $index  Numerically indexed array of IMAP UIDs
+     */
+    function set_index($index)
     {
         $index = array_flip($index);
 
-        if ($is_uid)
-            $this->uids = $index;
-        else
-            $this->seqs = $index;
+        $this->uids = $index;
     }
 
@@ -4733 +4255 @@
     function sort_headers(&$headers)
     {
-        if (!empty($this->uids))
-            uksort($headers, array($this, "compare_uids"));
-        else
-            uasort($headers, array($this, "compare_seqnums"));
-    }
-
-    /**
-     * Sort method called by uasort()
-     *
-     * @param rcube_mail_header $a
-     * @param rcube_mail_header $b
-     */
-    function compare_seqnums($a, $b)
-    {
-        // First get the sequence number from the header object (the 'id' field).
-        $seqa = $a->id;
-        $seqb = $b->id;
-
-        // then find each sequence number in my ordered list
-        $posa = isset($this->seqs[$seqa]) ? intval($this->seqs[$seqa]) : -1;
-        $posb = isset($this->seqs[$seqb]) ? intval($this->seqs[$seqb]) : -1;
-
-        // return the relative position as the comparison value
-        return $posa - $posb;
+        uksort($headers, array($this, "compare_uids"));
     }
 

trunk/roundcubemail/program/include/rcube_imap_cache.php

@@ -109 +109 @@
 
     /**
-     * Return (sorted) messages index.
+     * Return (sorted) messages index (UIDs).
      * If index doesn't exist or is invalid, will be updated.
      *
@@ -123 +123 @@
         if (empty($this->icache[$mailbox]))
             $this->icache[$mailbox] = array();
-
+console('cache::get_index');
         $sort_order = strtoupper($sort_order) == 'ASC' ? 'ASC' : 'DESC';
 
@@ -129 +129 @@
         if (array_key_exists('index', $this->icache[$mailbox])) {
             // The index was fetched from database already, but not validated yet
-            if (!array_key_exists('result', $this->icache[$mailbox]['index'])) {
+            if (!array_key_exists('object', $this->icache[$mailbox]['index'])) {
                 $index = $this->icache[$mailbox]['index'];
             }
             // We've got a valid index
-            else if ($sort_field == 'ANY' || $this->icache[$mailbox]['index']['sort_field'] == $sort_field
-            ) {
-                if ($this->icache[$mailbox]['index']['sort_order'] == $sort_order)
-                    return $this->icache[$mailbox]['index']['result'];
-                else
-                    return array_reverse($this->icache[$mailbox]['index']['result'], true);
+            else if ($sort_field == 'ANY' || $this->icache[$mailbox]['index']['sort_field'] == $sort_field) {
+                $result = $this->icache[$mailbox]['index']['object'];
+                if ($result->getParameters('ORDER') != $sort_order) {
+                    $result->revert();
+                }
+                return $result;
             }
         }
@@ -174 +174 @@
                 $is_valid = $this->validate($mailbox, $index, $exists);
             }
-
+console("valid:".$is_valid);
             if ($is_valid) {
-                // build index, assign sequence IDs to unique IDs
-                $data = array_combine($index['seq'], $index['uid']);
+                $data = $index['object'];
                 // revert the order if needed
-                if ($index['sort_order'] != $sort_order)
-                    $data = array_reverse($data, true);
+                if ($data->getParameters('ORDER') != $sort_order) {
+                    $data->revert();
+                }
             }
         }
@@ -202 +202 @@
 
             // insert/update
-            $this->add_index_row($mailbox, $sort_field, $sort_order, $data, $mbox_data,
-                $exists, $index['modseq']);
+            $this->add_index_row($mailbox, $sort_field, $data, $mbox_data, $exists, $index['modseq']);
         }
 
         $this->icache[$mailbox]['index'] = array(
-            'result'     => $data,
+            'object'     => $data,
             'sort_field' => $sort_field,
-            'sort_order' => $sort_order,
             'modseq'     => !empty($index['modseq']) ? $index['modseq'] : $mbox_data['HIGHESTMODSEQ']
         );
@@ -234 +232 @@
         // Seek in internal cache
         if (array_key_exists('thread', $this->icache[$mailbox])) {
-            return array(
-                $this->icache[$mailbox]['thread']['tree'],
-                $this->icache[$mailbox]['thread']['depth'],
-                $this->icache[$mailbox]['thread']['children'],
-            );
+            return $this->icache[$mailbox]['thread']['object'];
         }
 
@@ -251 +245 @@
         }
 
-        $data = null;
-
         // Entry exist, check cache status
         if (!empty($index)) {
@@ -270 +262 @@
             if ($mbox_data['EXISTS']) {
                 // get all threads (default sort order)
-                list ($thread_tree, $msg_depth, $has_children) = $this->imap->fetch_threads($mailbox, true);
-            }
-
-            $index = array(
-                'tree'     => !empty($thread_tree) ? $thread_tree : array(),
-                'depth'    => !empty($msg_depth) ? $msg_depth : array(),
-                'children' => !empty($has_children) ? $has_children : array(),
-            );
+                $threads = $this->imap->fetch_threads($mailbox, true);
+            }
+            else {
+                $threads = new rcube_imap_result($mailbox, '');
+            }
+
+            $index['object'] = $threads;
 
             // insert/update
-            $this->add_thread_row($mailbox, $index, $mbox_data, $exists);
+            $this->add_thread_row($mailbox, $threads, $mbox_data, $exists);
         }
 
         $this->icache[$mailbox]['thread'] = $index;
 
-        return array($index['tree'], $index['depth'], $index['children']);
+        return $index['object'];
     }
 
@@ -293 +284 @@
      *
      * @param string $mailbox  Folder name
-     * @param array  $msgs     Message sequence numbers
-     * @param bool   $is_uid   True if $msgs contains message UIDs
+     * @param array  $msgs     Message UIDs
      *
      * @return array The list of messages (rcube_mail_header) indexed by UID
      */
-    function get_messages($mailbox, $msgs = array(), $is_uid = true)
+    function get_messages($mailbox, $msgs = array())
     {
         if (empty($msgs)) {
             return array();
-        }
-
-        // @TODO: it would be nice if we could work with UIDs only
-        // then index would be not needed. For now we need it to
-        // map id to uid here and to update message id for cached message
-
-        // Convert IDs to UIDs
-        $index = $this->get_index($mailbox, 'ANY');
-        if (!$is_uid) {
-            foreach ($msgs as $idx => $msgid)
-                if ($uid = $index[$msgid])
-                    $msgs[$idx] = $uid;
         }
 
@@ -335 +313 @@
             $result[$uid]->body = null;
 
-            // update message ID according to index data
-            if (!empty($index) && ($id = array_search($uid, $index)))
-                $result[$uid]->id = $id;
-
             if (!empty($result[$uid])) {
                 unset($msgs[$uid]);
@@ -346 +320 @@
         // Fetch not found messages from IMAP server
         if (!empty($msgs)) {
-            $messages = $this->imap->fetch_headers($mailbox, array_keys($msgs), true, true);
+            $messages = $this->imap->fetch_headers($mailbox, array_keys($msgs), false, true);
 
             // Insert to DB and add to result list
@@ -392 +366 @@
             $message = $this->build_message($sql_arr);
             $found   = true;
-
-            // update message ID according to index data
-            $index = $this->get_index($mailbox, 'ANY');
-            if (!empty($index) && ($id = array_search($uid, $index)))
-                $message->id = $id;
         }
 
@@ -618 +587 @@
 
     /**
-     * @param string $mailbox Folder name
-     * @param int    $id      Message (sequence) ID
-     *
-     * @return int Message UID
-     */
-    function id2uid($mailbox, $id)
-    {
-        if (!empty($this->icache['pending_index_update']))
-            return null;
-
-        // get index if it exists
-        $index = $this->get_index($mailbox, 'ANY', null, true);
-
-        return $index[$id];
-    }
-
-
-    /**
-     * @param string $mailbox Folder name
-     * @param int    $uid     Message UID
-     *
-     * @return int Message (sequence) ID
-     */
-    function uid2id($mailbox, $uid)
-    {
-        if (!empty($this->icache['pending_index_update']))
-            return null;
-
-        // get index if it exists
-        $index = $this->get_index($mailbox, 'ANY', null, true);
-
-        return array_search($uid, (array)$index);
-    }
-
-    /**
      * Fetches index data from database
      */
     private function get_index_row($mailbox)
     {
+console('cache::get_index_row');
         // Get index from DB
         $sql_result = $this->db->query(
@@ -666 +601 @@
 
         if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
-            $data = explode('@', $sql_arr['data']);
+            $data  = explode('@', $sql_arr['data']);
+            $index = @unserialize($data[0]);
+            unset($data[0]);
+
+            if (empty($index)) {
+                $index = new rcube_result_index($mailbox);
+            }
 
             return array(
                 'valid'      => $sql_arr['valid'],
-                'seq'        => explode(',', $data[0]),
-                'uid'        => explode(',', $data[1]),
-                'sort_field' => $data[2],
-                'sort_order' => $data[3],
-                'deleted'    => $data[4],
-                'validity'   => $data[5],
-                'uidnext'    => $data[6],
-                'modseq'     => $data[7],
+                'object'     => $index,
+                'sort_field' => $data[1],
+                'deleted'    => $data[2],
+                'validity'   => $data[3],
+                'uidnext'    => $data[4],
+                'modseq'     => $data[5],
             );
         }
@@ -699 +638 @@
 
         if ($sql_arr = $this->db->fetch_assoc($sql_result)) {
-            $data = explode('@', $sql_arr['data']);
-
-            // Uncompress data, see add_thread_row()
-  //          $data[0] = str_replace(array('*', '^', '#'), array(';a:0:{}', 'i:', ';a:1:'), $data[0]);
-            $data[0] = unserialize($data[0]);
-
-            // build 'depth' and 'children' arrays
-            $depth = $children = array();
-            $this->build_thread_data($data[0], $depth, $children);
+            $data   = explode('@', $sql_arr['data']);
+            $thread = @unserialize($data[0]);
+            unset($data[0]);
+
+            if (empty($thread)) {
+                $thread = new rcube_imap_result($mailbox);
+            }
 
             return array(
-                'tree'     => $data[0],
-                'depth'    => $depth,
-                'children' => $children,
+                'object'   => $thread,
                 'deleted'  => $data[1],
                 'validity' => $data[2],
@@ -726 +661 @@
      * Saves index data into database
      */
-    private function add_index_row($mailbox, $sort_field, $sort_order,
-        $data = array(), $mbox_data = array(), $exists = false, $modseq = null)
+    private function add_index_row($mailbox, $sort_field,
+        $data, $mbox_data = array(), $exists = false, $modseq = null)
     {
         $data = array(
-            implode(',', array_keys($data)),
-            implode(',', array_values($data)),
+            serialize($data),
             $sort_field,
-            $sort_order,
             (int) $this->skip_deleted,
             (int) $mbox_data['UIDVALIDITY'],
@@ -760 +693 @@
      * Saves thread data into database
      */
-    private function add_thread_row($mailbox, $data = array(), $mbox_data = array(), $exists = false)
-    {
-        $tree = serialize($data['tree']);
-        // This significantly reduces data length
-//        $tree = str_replace(array(';a:0:{}', 'i:', ';a:1:'), array('*', '^', '#'), $tree);
-
+    private function add_thread_row($mailbox, $data, $mbox_data = array(), $exists = false)
+    {
         $data = array(
-            $tree,
+            serialize($data),
             (int) $this->skip_deleted,
             (int) $mbox_data['UIDVALIDITY'],
@@ -795 +724 @@
     private function validate($mailbox, $index, &$exists = true)
     {
-        $is_thread = isset($index['tree']);
+        $object    = $index['object'];
+        $is_thread = is_a($object, 'rcube_result_thread');
 
         // Get mailbox data (UIDVALIDITY, counters, etc.) for status check
@@ -815 +745 @@
         // Folder is empty but cache isn't
         if (empty($mbox_data['EXISTS'])) {
-            if (!empty($index['seq']) || !empty($index['tree'])) {
+            if (!$object->isEmpty()) {
                 $this->clear($mailbox);
                 $exists = false;
@@ -822 +752 @@
         }
         // Folder is not empty but cache is
-        else if (empty($index['seq']) && empty($index['tree'])) {
+        else if ($object->isEmpty()) {
             unset($this->icache[$mailbox][$is_thread ? 'thread' : 'index']);
             return false;
@@ -829 +759 @@
         // Validation flag
         if (!$is_thread && empty($index['valid'])) {
-            unset($this->icache[$mailbox][$is_thread ? 'thread' : 'index']);
+            unset($this->icache[$mailbox]['index']);
             return false;
         }
@@ -854 +784 @@
         if ($is_thread) {
             // check messages number...
-            if (!$this->skip_deleted && $mbox_data['EXISTS'] != @max(array_keys($index['depth']))) {
+            if (!$this->skip_deleted && $mbox_data['EXISTS'] != $object->countMessages()) {
                 return false;
             }
@@ -863 +793 @@
         if (!empty($this->skip_deleted)) {
             // compare counts if available
-            if ($mbox_data['COUNT_UNDELETED'] != null
-                && $mbox_data['COUNT_UNDELETED'] != count($index['uid'])) {
+            if (!empty($mbox_data['UNDELETED'])
+                && $mbox_data['UNDELETED']->count() != $object->count()
+            ) {
                 return false;
             }
             // compare UID sets
-            if ($mbox_data['ALL_UNDELETED'] != null) {
-                $uids_new = rcube_imap_generic::uncompressMessageSet($mbox_data['ALL_UNDELETED']);
-                $uids_old = $index['uid'];
+            if (!empty($mbox_data['UNDELETED'])) {
+                $uids_new = $mbox_data['UNDELETED']->get();
+                $uids_old = $object->get();
 
                 if (count($uids_new) != count($uids_old)) {
@@ -885 +816 @@
                 // get all undeleted messages excluding cached UIDs
                 $ids = $this->imap->search_once($mailbox, 'ALL UNDELETED NOT UID '.
-                    rcube_imap_generic::compressMessageSet($index['uid']));
-
-                if (!empty($ids)) {
+                    rcube_imap_generic::compressMessageSet($object->get()));
+
+                if (!$ids->isEmpty()) {
                     return false;
                 }
@@ -894 +825 @@
         else {
             // check messages number...
-            if ($mbox_data['EXISTS'] != max($index['seq'])) {
+            if ($mbox_data['EXISTS'] != $object->count()) {
                 return false;
             }
             // ... and max UID
-            if (max($index['uid']) != $this->imap->id2uid($mbox_data['EXISTS'], $mailbox, true)) {
+            if ($object->max() != $this->imap->id2uid($mbox_data['EXISTS'], $mailbox, true)) {
                 return false;
             }
@@ -1061 +992 @@
 
         $sort_field = $index['sort_field'];
-        $sort_order = $index['sort_order'];
+        $sort_order = $index['object']->getParameters('ORDER');
         $exists     = true;
 
@@ -1070 +1001 @@
         }
         else {
-            $data = array_combine($index['seq'], $index['uid']);
+            $data = $index['object'];
         }
 
         // update index and/or HIGHESTMODSEQ value
-        $this->add_index_row($mailbox, $sort_field, $sort_order, $data, $mbox_data, $exists);
+        $this->add_index_row($mailbox, $sort_field, $data, $mbox_data, $exists);
 
         // update internal cache for get_index()
-        $this->icache[$mailbox]['index']['result'] = $data;
+        $this->icache[$mailbox]['index']['object'] = $data;
     }
 
@@ -1104 +1035 @@
 
     /**
-     * Creates 'depth' and 'children' arrays from stored thread 'tree' data.
-     */
-    private function build_thread_data($data, &$depth, &$children, $level = 0)
-    {
-        foreach ((array)$data as $key => $val) {
-            $children[$key] = !empty($val);
-            $depth[$key] = $level;
-            if (!empty($val))
-                $this->build_thread_data($val, $depth, $children, $level + 1);
-        }
-    }
-
-
-    /**
      * Saves message stored in internal cache
      */
@@ -1171 +1088 @@
     private function get_index_data($mailbox, $sort_field, $sort_order, $mbox_data = array())
     {
-        $data = array();
-
         if (empty($mbox_data)) {
             $mbox_data = $this->imap->mailbox_data($mailbox);
         }
 
-        // Prevent infinite loop.
-        // It happens when rcube_imap::message_index_direct() is called.
-        // There id2uid() is called which will again call get_index() and so on.
-        if (!$sort_field && !$this->skip_deleted)
-            $this->icache['pending_index_update'] = true;
-
         if ($mbox_data['EXISTS']) {
             // fetch sorted sequence numbers
-            $data_seq = $this->imap->message_index_direct($mailbox, $sort_field, $sort_order);
-            // fetch UIDs
-            if (!empty($data_seq)) {
-                // Seek in internal cache
-                if (array_key_exists('index', (array)$this->icache[$mailbox])
-                    && array_key_exists('result', (array)$this->icache[$mailbox]['index'])
-                )
-                    $data_uid = $this->icache[$mailbox]['index']['result'];
-                else
-                    $data_uid = $this->imap->conn->fetchUIDs($mailbox, $data_seq);
-
-                // build index
-                if (!empty($data_uid)) {
-                    foreach ($data_seq as $seq)
-                        if ($uid = $data_uid[$seq])
-                            $data[$seq] = $uid;
-                }
-            }
-        }
-
-        // Reset internal flags
-        $this->icache['pending_index_update'] = false;
-
-        return $data;
+            $index = $this->imap->message_index_direct($mailbox, $sort_field, $sort_order);
+        }
+        else {
+            $index = new rcube_result_index($mailbox, '* SORT');
+        }
+
+        return $index;
     }
 }

trunk/roundcubemail/program/include/rcube_imap_generic.php

@@ -26 +26 @@
 
 */
-
 
 /**
@@ -1219 +1218 @@
         // Invoke SEARCH as a fallback
         $index = $this->search($mailbox, 'ALL UNSEEN', false, array('COUNT'));
-        if (is_array($index)) {
-            return (int) $index['COUNT'];
+        if (!$index->isError()) {
+            return $index->count();
         }
 
@@ -1294 +1293 @@
     }
 
-    function sort($mailbox, $field, $add='', $is_uid=FALSE, $encoding = 'US-ASCII')
-    {
+    /**
+     * Executes SORT command
+     *
+     * @param string $mailbox    Mailbox name
+     * @param string $field      Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO)
+     * @param string $add        Searching criteria
+     * @param bool   $return_uid Enables UID SORT usage
+     * @param string $encoding   Character set
+     *
+     * @return rcube_result_index Response data
+     */
+    function sort($mailbox, $field, $add='', $return_uid=false, $encoding = 'US-ASCII')
+    {
+        require_once dirname(__FILE__) . '/rcube_result_index.php';
+
         $field = strtoupper($field);
         if ($field == 'INTERNALDATE') {
@@ -1305 +1317 @@
 
         if (!$fields[$field]) {
-            return false;
+            return new rcube_result_index($mailbox);
         }
 
         if (!$this->select($mailbox)) {
-            return false;
+            return new rcube_result_index($mailbox);
         }
 
@@ -1316 +1328 @@
             $add = $this->compressMessageSet($add);
 
-        list($code, $response) = $this->execute($is_uid ? 'UID SORT' : 'SORT',
+        list($code, $response) = $this->execute($return_uid ? 'UID SORT' : 'SORT',
             array("($field)", $encoding, 'ALL' . (!empty($add) ? ' '.$add : '')));
 
-        if ($code == self::ERROR_OK) {
-            // remove prefix and unilateral untagged server responses
-            $response = substr($response, stripos($response, '* SORT') + 7);
-            if ($pos = strpos($response, '*')) {
-                $response = substr($response, 0, $pos);
-            }
-            return preg_split('/[\s\r\n]+/', $response, -1, PREG_SPLIT_NO_EMPTY);
-        }
-
-        return false;
-    }
-
-    function fetchHeaderIndex($mailbox, $message_set, $index_field='', $skip_deleted=true, $uidfetch=false)
+        if ($code != self::ERROR_OK) {
+            $response = null;
+        }
+
+        return new rcube_result_index($mailbox, $response);
+    }
+
+    /**
+     * Simulates SORT command by using FETCH and sorting.
+     *
+     * @param string       $mailbox      Mailbox name
+     * @param string|array $message_set  Searching criteria (list of messages to return)
+     * @param string       $index_field  Field to sort by (ARRIVAL, CC, DATE, FROM, SIZE, SUBJECT, TO)
+     * @param bool         $skip_deleted Makes that DELETED messages will be skipped
+     * @param bool         $uidfetch     Enables UID FETCH usage
+     * @param bool         $return_uid   Enables returning UIDs instead of IDs
+     *
+     * @return rcube_result_index Response data
+     */
+    function index($mailbox, $message_set, $index_field='', $skip_deleted=true,
+        $uidfetch=false, $return_uid=false)
+    {
+        require_once dirname(__FILE__) . '/rcube_result_index.php';
+
+        $msg_index = $this->fetchHeaderIndex($mailbox, $message_set,
+            $index_field, $skip_deleted, $uidfetch, $return_uid);
+
+        if (!empty($msg_index)) {
+            asort($msg_index); // ASC
+            $msg_index = array_keys($msg_index);
+            $msg_index = '* SEARCH ' . implode(' ', $msg_index);
+        }
+        else {
+            $msg_index = is_array($msg_index) ? '* SEARCH' : null;
+        }
+
+        return new rcube_result_index($mailbox, $msg_index);
+    }
+
+    function fetchHeaderIndex($mailbox, $message_set, $index_field='', $skip_deleted=true,
+        $uidfetch=false, $return_uid=false)
     {
         if (is_array($message_set)) {
@@ -1371 +1411 @@
 
         // build FETCH command string
-        $key     = $this->nextTag();
-        $cmd     = $uidfetch ? 'UID FETCH' : 'FETCH';
-        $deleted = $skip_deleted ? ' FLAGS' : '';
-
-        if ($mode == 1 && $index_field == 'DATE')
-            $request = " $cmd $message_set (INTERNALDATE BODY.PEEK[HEADER.FIELDS (DATE)]$deleted)";
-        else if ($mode == 1)
-            $request = " $cmd $message_set (BODY.PEEK[HEADER.FIELDS ($index_field)]$deleted)";
+        $key    = $this->nextTag();
+        $cmd    = $uidfetch ? 'UID FETCH' : 'FETCH';
+        $fields = array();
+
+        if ($return_uid)
+            $fields[] = 'UID';
+        if ($skip_deleted)
+            $fields[] = 'FLAGS';
+
+        if ($mode == 1) {
+            if ($index_field == 'DATE')
+                $fields[] = 'INTERNALDATE';
+            $fields[] = "BODY.PEEK[HEADER.FIELDS ($index_field)]";
+        }
         else if ($mode == 2) {
             if ($index_field == 'SIZE')
-                $request = " $cmd $message_set (RFC822.SIZE$deleted)";
-            else
-                $request = " $cmd $message_set ($index_field$deleted)";
-        } else if ($mode == 3)
-            $request = " $cmd $message_set (FLAGS)";
-        else // 4
-            $request = " $cmd $message_set (INTERNALDATE$deleted)";
-
-        $request = $key . $request;
+                $fields[] = 'RFC822.SIZE';
+            else if (!$return_uid || $index_field != 'UID')
+                $fields[] = $index_field;
+        }
+        else if ($mode == 3 && !$skip_deleted)
+            $fields[] = 'FLAGS';
+        else if ($mode == 4)
+            $fields[] = 'INTERNALDATE';
+
+        $request = "$key $cmd $message_set (" . implode(' ', $fields) . ")";
 
         if (!$this->putLine($request)) {
@@ -1406 +1453 @@
                 $flags  = NULL;
 
+                if ($return_uid) {
+                    if (preg_match('/UID ([0-9]+)/', $line, $matches))
+                        $id = (int) $matches[1];
+                    else
+                        continue;
+                }
                 if ($skip_deleted && preg_match('/FLAGS \(([^)]+)\)/', $line, $matches)) {
                     $flags = explode(' ', strtoupper($matches[1]));
@@ -1535 +1588 @@
     {
         if ($uid > 0) {
-            $id_a = $this->search($mailbox, "UID $uid");
-            if (is_array($id_a) && count($id_a) == 1) {
-                return (int) $id_a[0];
+            $index = $this->search($mailbox, "UID $uid");
+
+            if ($index->count() == 1) {
+                $arr = $index->get();
+                return (int) $arr[0];
             }
         }
@@ -1561 +1616 @@
         }
 
-        list($code, $response) = $this->execute('FETCH', array($id, '(UID)'));
-
-        if ($code == self::ERROR_OK && preg_match("/^\* $id FETCH \(UID (.*)\)/i", $response, $m)) {
-            return (int) $m[1];
+        $index = $this->search($mailbox, $id, true);
+
+        if ($index->count() == 1) {
+            $arr = $index->get();
+            return (int) $arr[0];
         }
 
         return null;
-    }
-
-    function fetchUIDs($mailbox, $message_set=null)
-    {
-        if (empty($message_set))
-            $message_set = '1:*';
-
-        return $this->fetchHeaderIndex($mailbox, $message_set, 'UID', false);
     }
 
@@ -1971 +2019 @@
     }
 
-    // Don't be tempted to change $str to pass by reference to speed this up - it will slow it down by about
-    // 7 times instead :-) See comments on http://uk2.php.net/references and this article:
-    // http://derickrethans.nl/files/phparch-php-variables-article.pdf
-    private function parseThread($str, $begin, $end, $root, $parent, $depth, &$depthmap, &$haschildren)
-    {
-        $node = array();
-        if ($str[$begin] != '(') {
-            $stop = $begin + strspn($str, '1234567890', $begin, $end - $begin);
-            $msg = substr($str, $begin, $stop - $begin);
-            if ($msg == 0)
-                return $node;
-            if (is_null($root))
-                $root = $msg;
-            $depthmap[$msg] = $depth;
-            $haschildren[$msg] = false;
-            if (!is_null($parent))
-                $haschildren[$parent] = true;
-            if ($stop + 1 < $end)
-                $node[$msg] = $this->parseThread($str, $stop + 1, $end, $root, $msg, $depth + 1, $depthmap, $haschildren);
-            else
-                $node[$msg] = array();
-        } else {
-            $off = $begin;
-            while ($off < $end) {
-                $start = $off;
-                $off++;
-                $n = 1;
-                while ($n > 0) {
-                    $p = strpos($str, ')', $off);
-                    if ($p === false) {
-                        error_log("Mismatched brackets parsing IMAP THREAD response:");
-                        error_log(substr($str, ($begin < 10) ? 0 : ($begin - 10), $end - $begin + 20));
-                        error_log(str_repeat(' ', $off - (($begin < 10) ? 0 : ($begin - 10))));
-                        return $node;
-                    }
-                    $p1 = strpos($str, '(', $off);
-                    if ($p1 !== false && $p1 < $p) {
-                        $off = $p1 + 1;
-                        $n++;
-                    } else {
-                        $off = $p + 1;
-                        $n--;
-                    }
-                }
-                $node += $this->parseThread($str, $start + 1, $off - 1, $root, $parent, $depth, $depthmap, $haschildren);
-            }
-        }
-
-        return $node;
-    }
-
-    function thread($mailbox, $algorithm='REFERENCES', $criteria='', $encoding='US-ASCII')
-    {
+    /**
+     * Executes THREAD command
+     *
+     * @param string $mailbox    Mailbox name
+     * @param string $algorithm  Threading algorithm (ORDEREDSUBJECT, REFERENCES, REFS)
+     * @param string $criteria   Searching criteria
+     * @param bool   $return_uid Enables UIDs in result instead of sequence numbers
+     * @param string $encoding   Character set
+     *
+     * @return rcube_result_thread Thread data
+     */
+    function thread($mailbox, $algorithm='REFERENCES', $criteria='', $return_uid=false, $encoding='US-ASCII')
+    {
+        require_once dirname(__FILE__) . '/rcube_result_thread.php';
+
         $old_sel = $this->selected;
 
         if (!$this->select($mailbox)) {
-            return false;
+            return new rcube_result_thread($mailbox);
         }
 
         // return empty result when folder is empty and we're just after SELECT
         if ($old_sel != $mailbox && !$this->data['EXISTS']) {
-            return array(array(), array(), array());
+            return new rcube_result_thread($mailbox);
         }
 
@@ -2040 +2050 @@
         $data      = '';
 
-        list($code, $response) = $this->execute('THREAD', array(
-            $algorithm, $encoding, $criteria));
-
-        if ($code == self::ERROR_OK) {
-            // remove prefix...
-            $response = substr($response, stripos($response, '* THREAD') + 9);
-            // ...unilateral untagged server responses
-            if ($pos = strpos($response, '*')) {
-                $response = substr($response, 0, $pos);
-            }
-
-            $response    = str_replace("\r\n", '', $response);
-            $depthmap    = array();
-            $haschildren = array();
-
-            $tree = $this->parseThread($response, 0, strlen($response),
-                null, null, 0, $depthmap, $haschildren);
-
-            return array($tree, $depthmap, $haschildren);
-        }
-
-        return false;
+        list($code, $response) = $this->execute($return_uid ? 'UID THREAD' : 'THREAD',
+            array($algorithm, $encoding, $criteria));
+
+        if ($code != self::ERROR_OK) {
+            $response = null;
+        }
+
+        return new rcube_result_thread($mailbox, $response);
     }
 
@@ -2072 +2068 @@
      * @param array  $items      Return items (MIN, MAX, COUNT, ALL)
      *
-     * @return array Message identifiers or item-value hash 
+     * @return rcube_result_index Result data
      */
     function search($mailbox, $criteria, $return_uid=false, $items=array())
     {
+        require_once dirname(__FILE__) . '/rcube_result_index.php';
+
         $old_sel = $this->selected;
 
         if (!$this->select($mailbox)) {
-            return false;
+            return new rcube_result_index($mailbox);
         }
 
         // return empty result when folder is empty and we're just after SELECT
         if ($old_sel != $mailbox && !$this->data['EXISTS']) {
-            if (!empty($items))
-                return array_combine($items, array_fill(0, count($items), 0));
-            else
-                return array();
+            return new rcube_result_index($mailbox, '* SEARCH');
+        }
+
+        // If ESEARCH is supported always use ALL
+        // but not when items are specified or using simple id2uid search
+        if (empty($items) && ((int) $criteria != $criteria)) {
+            $items = array('ALL');
         }
 
@@ -2098 +2099 @@
             $params .= 'RETURN (' . implode(' ', $items) . ')';
         }
+
         if (!empty($criteria)) {
             $modseq = stripos($criteria, 'MODSEQ') !== false;
@@ -2109 +2111 @@
             array($params));
 
-        if ($code == self::ERROR_OK) {
-            // remove prefix...
-            $response = substr($response, stripos($response,
-                $esearch ? '* ESEARCH' : '* SEARCH') + ($esearch ? 10 : 9));
-            // ...and unilateral untagged server responses
-            if ($pos = strpos($response, '*')) {
-                $response = rtrim(substr($response, 0, $pos));
-            }
-
-            // remove MODSEQ response
-            if ($modseq) {
-                if (preg_match('/\(MODSEQ ([0-9]+)\)$/', $response, $m)) {
-                    $response = substr($response, 0, -strlen($m[0]));
-                }
-            }
-
-            if ($esearch) {
-                // Skip prefix: ... (TAG "A285") UID ...
-                $this->tokenizeResponse($response, $return_uid ? 2 : 1);
-
-                $result = array();
-                for ($i=0; $i<count($items); $i++) {
-                    // If the SEARCH returns no matches, the server MUST NOT
-                    // include the item result option in the ESEARCH response
-                    if ($ret = $this->tokenizeResponse($response, 2)) {
-                        list ($name, $value) = $ret;
-                        $result[$name] = $value;
-                    }
-                }
-
-                return $result;
-            }
-            else {
-                $response = preg_split('/[\s\r\n]+/', $response, -1, PREG_SPLIT_NO_EMPTY);
-
-                if (!empty($items)) {
-                    $result = array();
-                    if (in_array('COUNT', $items)) {
-                        $result['COUNT'] = count($response);
-                    }
-                    if (in_array('MIN', $items)) {
-                        $result['MIN'] = !empty($response) ? min($response) : 0;
-                    }
-                    if (in_array('MAX', $items)) {
-                        $result['MAX'] = !empty($response) ? max($response) : 0;
-                    }
-                    if (in_array('ALL', $items)) {
-                        $result['ALL'] = $this->compressMessageSet($response, true);
-                    }
-
-                    return $result;
-                }
-                else {
-                    return $response;
-                }
-            }
-        }
-
-        return false;
+        if ($code != self::ERROR_OK) {
+            $response = null;
+        }
+
+        return new rcube_result_index($mailbox, $response);
     }
 

trunk/roundcubemail/program/steps/mail/func.inc

@@ -94 +94 @@
       $_SESSION['search_request'] = $search_request;
       $OUTPUT->set_env('search_request', $search_request);
-      }
+    }
 
       $search_mods = $RCMAIL->config->get('search_mods', $SEARCH_MODS_DEFAULT);

trunk/roundcubemail/program/steps/mail/pagenav.inc

@@ -20 +20 @@
 */
 
-$uid = get_input_value('_uid', RCUBE_INPUT_GET);
+$uid   = get_input_value('_uid', RCUBE_INPUT_GET);
+$index = $IMAP->message_index(null, $_SESSION['sort_col'], $_SESSION['sort_order']);
+$cnt   = $index->countMessages();
 
-// Select mailbox first, for better performance
-$mbox_name = $IMAP->get_mailbox_name();
-$IMAP->select_mailbox($mbox_name);
-
-// Get messages count (only messages, no threads here)
-$cnt  = $IMAP->messagecount(NULL, 'ALL');
-
-if ($_SESSION['sort_col'] == 'date' && $_SESSION['sort_order'] == 'DESC'
-    && empty($_REQUEST['_search']) && !$CONFIG['skip_deleted'] && !$IMAP->threading
-) {
-    // this assumes that we are sorted by date_DESC
-    $seq   = $IMAP->get_id($uid);
-    $index = $cnt - $seq;
-
-    $prev  = $IMAP->get_uid($seq + 1);
-    $first = $IMAP->get_uid($cnt);
-    $next  = $IMAP->get_uid($seq - 1);
-    $last  = $IMAP->get_uid(1);
-}
-else {
-    // Only if we use custom sorting
-    $a_msg_index = $IMAP->message_index(NULL, $_SESSION['sort_col'], $_SESSION['sort_order']);
-
-    $index = array_search($IMAP->get_id($uid), $a_msg_index);
-
-    $count = count($a_msg_index);
-    $prev  = isset($a_msg_index[$index-1]) ? $IMAP->get_uid($a_msg_index[$index-1]) : -1;
-    $first = $count > 1 ? $IMAP->get_uid($a_msg_index[0]) : -1;
-    $next  = isset($a_msg_index[$index+1]) ? $IMAP->get_uid($a_msg_index[$index+1]) : -1;
-    $last  = $count > 1 ? $IMAP->get_uid($a_msg_index[$count-1]) : -1;
+if ($cnt && ($pos = $index->exists($uid, true)) !== false) {
+    $prev  = $pos ? $index->getElement($pos-1) : 0;
+    $first = $pos ? $index->getElement('FIRST') : 0;
+    $next  = $pos < $cnt-1 ? $index->getElement($pos+1) : 0;
+    $last  = $pos < $cnt-1 ? $index->getElement('LAST') : 0;
 }
 
 // Set UIDs and activate navigation buttons
-if ($prev > 0) {
+if ($prev) {
     $OUTPUT->set_env('prev_uid', $prev);
     $OUTPUT->command('enable_command', 'previousmessage', 'firstmessage', true);
 }
-if ($next > 0) {
+if ($next) {
     $OUTPUT->set_env('next_uid', $next);
     $OUTPUT->command('enable_command', 'nextmessage', 'lastmessage', true);
 }
-if ($first > 0)
+if ($first)
     $OUTPUT->set_env('first_uid', $first);
-if ($last > 0)
+if ($last)
     $OUTPUT->set_env('last_uid', $last);
 
@@ -74 +51 @@
 $OUTPUT->command('set_rowcount', rcube_label(array(
     'name' => 'messagenrof',
-    'vars' => array('nr'  => $index+1, 'count' => $cnt)
+    'vars' => array('nr'  => $pos+1, 'count' => $cnt)
 )));
 

trunk/roundcubemail/program/steps/mail/search.inc

@@ -110 +110 @@
   $IMAP->search($mbox, $search_str, $imap_charset, $_SESSION['sort_col']);
 
-// Get the headers
-$result_h = $IMAP->list_headers($mbox, 1, $_SESSION['sort_col'], $_SESSION['sort_order']);
-$count = $IMAP->messagecount(NULL, $IMAP->threading ? 'THREADS' : 'ALL');
-
 // save search results in session
 if (!is_array($_SESSION['search']))
@@ -123 +119 @@
 }
 $_SESSION['search_request'] = $search_request;
+
+
+// Get the headers
+$result_h = $IMAP->list_headers($mbox, 1, $_SESSION['sort_col'], $_SESSION['sort_order']);
+$count = $IMAP->messagecount($mbox, $IMAP->threading ? 'THREADS' : 'ALL');
+
 
 // Make sure we got the headers

trunk/roundcubemail/program/steps/mail/sendmail.inc

@@ -702 +702 @@
     // delete previous saved draft
     // @TODO: use message UID (remember to check UIDVALIDITY) to skip this SEARCH
-    $a_deleteid = $IMAP->search_once($CONFIG['drafts_mbox'],
-        'HEADER Message-ID '.$olddraftmessageid, true);
-
-    if (!empty($a_deleteid)) {
-      $deleted = $IMAP->delete_message($a_deleteid, $CONFIG['drafts_mbox']);
+    $delete_idx = $IMAP->search_once($CONFIG['drafts_mbox'],
+        'HEADER Message-ID '.$olddraftmessageid);
+
+    if ($del_uid = $delete_idx->getElement('FIRST')) {
+      $deleted = $IMAP->delete_message($del_uid, $CONFIG['drafts_mbox']);
 
       // raise error if deletion of old draft failed
@@ -727 +727 @@
   // remember new draft-uid ($saved could be an UID or TRUE here)
   if (is_bool($saved)) {
-    $draftuids = $IMAP->search_once($CONFIG['drafts_mbox'], 'HEADER Message-ID '.$msgid, true);
-    $saved     = $draftuids[0];
+    $draft_idx = $IMAP->search_once($CONFIG['drafts_mbox'], 'HEADER Message-ID '.$msgid);
+    $saved     = $draft_idx->getElement('FIRST');
   }
   $COMPOSE['param']['draft_uid'] = $saved;