thread.h File Reference

Create/manipulate threading in emails. More...

#include <stdbool.h>

Include dependency graph for thread.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	MuttThread
	An Email conversation. More...

Functions
void	clean_references (struct MuttThread *brk, struct MuttThread *cur)
	Update email references for a broken Thread.
struct Email *	find_virtual (struct MuttThread *cur, bool reverse)
	Find an email with a Virtual message number.
void	insert_message (struct MuttThread **add, struct MuttThread *parent, struct MuttThread *cur)
	Insert a message into a thread.
bool	is_descendant (const struct MuttThread *a, const struct MuttThread *b)
	Is one thread a descendant of another.
void	mutt_break_thread (struct Email *e)
	Break the email Thread.
void	unlink_message (struct MuttThread **old, struct MuttThread *cur)
	Break the message out of the thread.

Detailed Description

Create/manipulate threading in emails.

Authors

• Richard Russon

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 thread.h.

Function Documentation

clean_references()

void clean_references	(	struct MuttThread *	brk,
		struct MuttThread *	cur
	)

Update email references for a broken Thread.

Parameters

brk	Broken thread
cur	Current thread

Definition at line 174 of file thread.c.

{
  struct ListNode *ref = NULL;
  bool done = false;
 
  for (; cur; cur = cur->next, done = false)
  {
    /* parse subthread recursively */
    clean_references(brk, cur->child);
 
    if (!cur->message)
      break; /* skip pseudo-message */
 
    /* Looking for the first bad reference according to the new threading.
     * Optimal since NeoMutt stores the references in reverse order, and the
     * first loop should match immediately for mails respecting RFC2822. */
    for (struct MuttThread *p = brk; !done && p; p = p->parent)
    {
      for (ref = STAILQ_FIRST(&cur->message->env->references);
           p->message && ref; ref = STAILQ_NEXT(ref, entries))
      {
        if (mutt_istr_equal(ref->data, p->message->env->message_id))
        {
          done = true;
          break;
        }
      }
    }
 
    if (done)
    {
      struct Email *e = cur->message;
 
      /* clearing the References: header from obsolete Message-ID(s) */
      struct ListNode *np = NULL;
      while ((np = STAILQ_NEXT(ref, entries)))
      {
        STAILQ_REMOVE_AFTER(&cur->message->env->references, ref, entries);
        FREE(&np->data);
        FREE(&np);
      }
 
      e->changed = true;
      e->env->changed |= MUTT_ENV_CHANGED_REFS;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_virtual()

struct Email * find_virtual	(	struct MuttThread *	cur,
		bool	reverse
	)

Find an email with a Virtual message number.

Parameters

cur	Thread to search
reverse	If true, reverse the direction of the search

Return values

ptr	Matching Email

Definition at line 121 of file thread.c.

{
  if (!cur)
    return NULL;
 
  struct MuttThread *top = NULL;
 
  if (cur->message && (cur->message->vnum >= 0))
    return cur->message;
 
  top = cur;
  cur = cur->child;
  if (!cur)
    return NULL;
 
  while (reverse && cur->next)
    cur = cur->next;
 
  while (true)
  {
    if (cur->message && (cur->message->vnum >= 0))
      return cur->message;
 
    if (cur->child)
    {
      cur = cur->child;
 
      while (reverse && cur->next)
        cur = cur->next;
    }
    else if (reverse ? cur->prev : cur->next)
    {
      cur = reverse ? cur->prev : cur->next;
    }
    else
    {
      while (!(reverse ? cur->prev : cur->next))
      {
        cur = cur->parent;
        if (cur == top)
          return NULL;
      }
      cur = reverse ? cur->prev : cur->next;
    }
    /* not reached */
  }
}

Here is the caller graph for this function:

insert_message()

void insert_message	(	struct MuttThread **	add,
		struct MuttThread *	parent,
		struct MuttThread *	cur
	)

Insert a message into a thread.

Parameters

[in,out]	add	New thread to add
[in]	parent	Parent of new thread
[in]	cur	Current thread to add after

add cur as a prior sibling of *add, with parent parent

Definition at line 101 of file thread.c.

{
  if (!cur || !add)
    return;
 
  if (*add)
    (*add)->prev = cur;
 
  cur->parent = parent;
  cur->next = *add;
  cur->prev = NULL;
  *add = cur;
}

Here is the caller graph for this function:

is_descendant()

bool is_descendant	(	const struct MuttThread *	a,
		const struct MuttThread *	b
	)

Is one thread a descendant of another.

Parameters

a	Parent thread
b	Child thread

Return values

true	b is a descendent of a (child, grandchild, etc)

Definition at line 43 of file thread.c.

{
  while (a)
  {
    if (a == b)
      return true;
    a = a->parent;
  }
  return false;
}

Here is the caller graph for this function:

mutt_break_thread()

void mutt_break_thread

(

struct Email *

e

)

Break the email Thread.

Parameters

e	Email to break at

Definition at line 226 of file thread.c.

{
  if (!e)
    return;
 
  mutt_list_free(&e->env->in_reply_to);
  mutt_list_free(&e->env->references);
  e->changed = true;
  e->env->changed |= (MUTT_ENV_CHANGED_IRT | MUTT_ENV_CHANGED_REFS);
 
  clean_references(e->thread, e->thread->child);
}

Here is the call graph for this function:

Here is the caller graph for this function:

unlink_message()

void unlink_message	(	struct MuttThread **	old,
		struct MuttThread *	cur
	)

Break the message out of the thread.

Parameters

[in,out]	old	Root of thread
[in]	cur	Child thread to separate

Remove cur and its descendants from their current location. Also make sure ancestors of cur no longer are sorted by the fact that cur is their descendant.

Definition at line 63 of file thread.c.

{
  if (!old || !cur)
    return;
 
  struct MuttThread *tmp = NULL;
 
  if (cur->prev)
    cur->prev->next = cur->next;
  else
    *old = cur->next;
 
  if (cur->next)
    cur->next->prev = cur->prev;
 
  if (cur->sort_thread_key)
  {
    for (tmp = cur->parent;
         tmp && (tmp->sort_thread_key == cur->sort_thread_key); tmp = tmp->parent)
    {
      tmp->sort_thread_key = NULL;
    }
  }
  if (cur->sort_aux_key)
  {
    for (tmp = cur->parent; tmp && (tmp->sort_aux_key == cur->sort_aux_key); tmp = tmp->parent)
      tmp->sort_aux_key = NULL;
  }
}

Here is the caller graph for this function: