sort.c File Reference

Assorted sorting methods. More...

#include "config.h"
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "alias/lib.h"
#include "sort.h"
#include "globals.h"
#include "mutt_logging.h"
#include "mutt_thread.h"
#include "mx.h"
#include "score.h"
#include "nntp/lib.h"

Include dependency graph for sort.c:

Go to the source code of this file.

Data Structures
struct	EmailCompare
	Context for compare_email_shim() More...

Functions
static int	compare_email_shim (const void *a, const void *b, void *arg)
	qsort_r() comparator to drive mutt_compare_emails More...
static int	compare_score (const struct Email *a, const struct Email *b, bool reverse)
	Compare two emails using their scores - Implements sort_mail_t -. More...
static int	compare_size (const struct Email *a, const struct Email *b, bool reverse)
	Compare the size of two emails - Implements sort_mail_t -. More...
static int	compare_date_sent (const struct Email *a, const struct Email *b, bool reverse)
	Compare the sent date of two emails - Implements sort_mail_t -. More...
static int	compare_subject (const struct Email *a, const struct Email *b, bool reverse)
	Compare the subject of two emails - Implements sort_mail_t -. More...
const char *	mutt_get_name (const struct Address *a)
	Pick the best name to display from an address. More...
static int	compare_to (const struct Email *a, const struct Email *b, bool reverse)
	Compare the 'to' fields of two emails - Implements sort_mail_t -. More...
static int	compare_from (const struct Email *a, const struct Email *b, bool reverse)
	Compare the 'from' fields of two emails - Implements sort_mail_t -. More...
static int	compare_date_received (const struct Email *a, const struct Email *b, bool reverse)
	Compare the date received of two emails - Implements sort_mail_t -. More...
static int	compare_order (const struct Email *a, const struct Email *b, bool reverse)
	Restore the 'unsorted' order of emails - Implements sort_mail_t -. More...
static int	compare_spam (const struct Email *a, const struct Email *b, bool reverse)
	Compare the spam values of two emails - Implements sort_mail_t -. More...
static int	compare_label (const struct Email *a, const struct Email *b, bool reverse)
	Compare the labels of two emails - Implements sort_mail_t -. More...
static sort_mail_t	get_sort_func (enum SortType method, enum MailboxType type)
	Get the sort function for a given sort id. More...
int	mutt_compare_emails (const struct Email *a, const struct Email *b, enum MailboxType type, short sort, short sort_aux)
	Compare two emails using up to two sort methods. More...
void	mutt_sort_headers (struct Mailbox *m, struct ThreadsContext *threads, bool init, off_t *vsize)
	Sort emails by their headers. More...

Detailed Description

Assorted sorting methods.

Authors

• Michael R. Elkins
• Pietro Cerutti
• R Primus

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file sort.c.

Function Documentation

compare_email_shim()

static int compare_email_shim ( const void *  a, const void *  b, void *  arg  )

static

qsort_r() comparator to drive mutt_compare_emails

Parameters

a	Pointer to first email
b	Pointer to second email
arg	EmailCompare with needed context

Return values

<0	a precedes b
0	a identical to b (should not happen in practice)
>0	b precedes a

Definition at line 70 of file sort.c.

{
  const struct Email *ea = *(struct Email const *const *) a;
  const struct Email *eb = *(struct Email const *const *) b;
  const struct EmailCompare *cmp = arg;
  return mutt_compare_emails(ea, eb, cmp->type, cmp->sort, cmp->sort_aux);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_get_name()

const char * mutt_get_name

(

const struct Address *

a

)

Pick the best name to display from an address.

Parameters

a	Address to use

Return values

ptr	Display name

This function uses:

1. Alias for email address
2. Personal name
3. Email address

Definition at line 136 of file sort.c.

{
  struct Address *ali = NULL;
 
  if (a)
  {
    const bool c_reverse_alias = cs_subset_bool(NeoMutt->sub, "reverse_alias");
    if (c_reverse_alias && (ali = alias_reverse_lookup(a)) && ali->personal)
      return ali->personal;
    if (a->personal)
      return a->personal;
    if (a->mailbox)
      return mutt_addr_for_display(a);
  }
  /* don't return NULL to avoid segfault when printing/comparing */
  return "";
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_sort_func()

static sort_mail_t get_sort_func ( enum SortType  method, enum MailboxType  type  )

static

Get the sort function for a given sort id.

Parameters

method	Sort type, see SortType
type	The Mailbox type

Return values

ptr	sort function - Implements sort_mail_t

Definition at line 281 of file sort.c.

{
  switch (method)
  {
    case SORT_DATE:
      return compare_date_sent;
    case SORT_FROM:
      return compare_from;
    case SORT_LABEL:
      return compare_label;
    case SORT_ORDER:
#ifdef USE_NNTP
      if (type == MUTT_NNTP)
        return nntp_compare_order;
      else
#endif
        return compare_order;
    case SORT_RECEIVED:
      return compare_date_received;
    case SORT_SCORE:
      return compare_score;
    case SORT_SIZE:
      return compare_size;
    case SORT_SPAM:
      return compare_spam;
    case SORT_SUBJECT:
      return compare_subject;
    case SORT_TO:
      return compare_to;
    default:
      mutt_error(_("Could not find sorting function [report this bug]"));
      return NULL;
  }
  /* not reached */
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_compare_emails()

int mutt_compare_emails	(	const struct Email *	a,
		const struct Email *	b,
		enum MailboxType	type,
		short	sort,
		short	sort_aux
	)

Compare two emails using up to two sort methods.

Parameters

a	First email
b	Second email
type	Mailbox type
sort	Primary sort to use (generally $sort)
sort_aux	Secondary sort (generally $sort_aux or SORT_ORDER)

Return values

<0	a precedes b
0	a and b are identical (should not happen in practice)
>0	b precedes a

Definition at line 328 of file sort.c.

{
  sort_mail_t func = get_sort_func(sort & SORT_MASK, type);
  int retval = func(a, b, (sort & SORT_REVERSE) != 0);
  if (retval == 0)
  {
    func = get_sort_func(sort_aux & SORT_MASK, type);
    retval = func(a, b, (sort_aux & SORT_REVERSE) != 0);
  }
  if (retval == 0)
  {
    /* Fallback of last resort to preserve stable order; will only
     * return 0 if a and b have the same index, which is probably a
     * bug in the code. */
    func = compare_order;
    retval = func(a, b, false);
  }
  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_sort_headers()

void mutt_sort_headers	(	struct Mailbox *	m,
		struct ThreadsContext *	threads,
		bool	init,
		off_t *	vsize
	)

Sort emails by their headers.

Parameters

	m	Mailbox
	threads	Threads context
	init	If true, rebuild the thread
[out]	vsize	Size in bytes of the messages in view

Definition at line 356 of file sort.c.

{
  if (!m || !m->emails[0])
    return;
 
  OptNeedResort = false;
 
  if (m->msg_count == 0)
  {
    /* this function gets called by mutt_sync_mailbox(), which may have just
     * deleted all the messages.  the virtual message numbers are not updated
     * in that routine, so we must make sure to zero the vcount member.  */
    m->vcount = 0;
    mutt_clear_threads(threads);
    *vsize = 0;
    return; /* nothing to do! */
  }
 
  if (m->verbose)
    mutt_message(_("Sorting mailbox..."));
 
  const bool c_score = cs_subset_bool(NeoMutt->sub, "score");
  if (OptNeedRescore && c_score)
  {
    for (int i = 0; i < m->msg_count; i++)
    {
      struct Email *e = m->emails[i];
      if (!e)
        break;
      mutt_score_message(m, e, true);
    }
  }
  OptNeedRescore = false;
 
  if (OptResortInit)
  {
    OptResortInit = false;
    init = true;
  }
 
  if (init)
    mutt_clear_threads(threads);
 
  const bool threaded = mutt_using_threads();
  if (threaded)
  {
    mutt_sort_threads(threads, init);
  }
  else
  {
    struct EmailCompare cmp;
    cmp.type = mx_type(m);
    cmp.sort = cs_subset_sort(NeoMutt->sub, "sort");
    cmp.sort_aux = cs_subset_sort(NeoMutt->sub, "sort_aux");
    mutt_qsort_r((void *) m->emails, m->msg_count, sizeof(struct Email *),
                 compare_email_shim, &cmp);
  }
 
  /* adjust the virtual message numbers */
  m->vcount = 0;
  for (int i = 0; i < m->msg_count; i++)
  {
    struct Email *e_cur = m->emails[i];
    if (!e_cur)
      break;
 
    if ((e_cur->vnum != -1) || (e_cur->collapsed && e_cur->visible))
    {
      e_cur->vnum = m->vcount;
      m->v2r[m->vcount] = i;
      m->vcount++;
    }
    e_cur->msgno = i;
  }
 
  /* re-collapse threads marked as collapsed */
  if (threaded)
  {
    mutt_thread_collapse_collapsed(threads);
    *vsize = mutt_set_vnum(m);
  }
 
  if (m->verbose)
    mutt_clear_error();
 
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function: