alx/mu4e
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

* mu-msg-*: take mu_msg_cache into use

Browse Source
This commit is contained in:
Dirk-Jan C. Binnema
2011-05-14 18:07:51 +03:00
parent 0cd1e78239
commit c0a24cf7bc
5 changed files with 273 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

221
src/mu-msg-file.c
View File

@ -17,7 +17,6 @@
** **
*/ */
#include <string.h> #include <string.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
@ -26,6 +25,16 @@
#include <stdlib.h> #include <stdlib.h>
#include <ctype.h> #include <ctype.h>
/* hopefully, the should get us a sane PATH_MAX */
#include <limits.h>
/* not all systems provide PATH_MAX in limits.h */
#ifndef PATH_MAX
#include <sys/param.h>
#ifndef PATH_MAX
#define PATH_MAX MAXPATHLEN
#endif /*!PATH_MAX */
#endif /*PATH_MAX */
#include <gmime/gmime.h> #include <gmime/gmime.h>
#include "mu-util.h" #include "mu-util.h"
@ -33,31 +42,26 @@
#include "mu-maildir.h" #include "mu-maildir.h"
#include "mu-msg-priv.h" #include "mu-msg-priv.h"
static gboolean init_file_metadata (MuMsgFile *self, const char* path, static gboolean init_file_metadata (MuMsgFile *self, const char* path,
const char *mdir, GError **err); const char *mdir, GError **err);
static gboolean init_mime_msg (MuMsgFile *msg, GError **err); static gboolean init_mime_msg (MuMsgFile *msg, const char *path, GError **err);
#define CACHE(MFID) (self->_str_cache[(MFID)])
#define SET_CACHE(MFID,V)(self->_str_cache[(MFID)]=(V))
MuMsgFile* MuMsgFile*
mu_msg_file_new (const char* filepath, const char *mdir, GError **err) mu_msg_file_new (const char* filepath, const char *mdir, GError **err)
{ {
int i;
MuMsgFile *self; MuMsgFile *self;
g_return_val_if_fail (filepath, NULL); g_return_val_if_fail (filepath, NULL);
self = g_slice_new0 (MuMsgFile);
for (i = 0; i != MU_MSG_FIELD_ID_NUM; ++i) self = g_slice_new0 (MuMsgFile);
SET_CACHE(i,NULL);
if (!init_file_metadata (self, filepath, mdir, err)) { if (!init_file_metadata (self, filepath, mdir, err)) {
mu_msg_file_destroy (self); mu_msg_file_destroy (self);
return NULL; return NULL;
} }
if (!init_mime_msg (self, err)) { if (!init_mime_msg (self, filepath, err)) {
mu_msg_file_destroy (self); mu_msg_file_destroy (self);
return NULL; return NULL;
} }
@ -69,14 +73,9 @@ mu_msg_file_new (const char* filepath, const char *mdir, GError **err)
void void
mu_msg_file_destroy (MuMsgFile *self) mu_msg_file_destroy (MuMsgFile *self)
{ {
int i;
if (!self) if (!self)
return; return;
for (i = 0; i != MU_MSG_FIELD_ID_NUM; ++i)
g_free (self->_str_cache[i]);
if (self->_mime_msg) if (self->_mime_msg)
g_object_unref (self->_mime_msg); g_object_unref (self->_mime_msg);
@ -110,13 +109,11 @@ init_file_metadata (MuMsgFile *self, const char* path, const gchar* mdir,
return FALSE; return FALSE;
} }
self->_timestamp = statbuf.st_mtime; self->_timestamp = statbuf.st_mtime;
/* size_t should be enough for message size... */ self->_size = (size_t)statbuf.st_size;
self->_size = (size_t)statbuf.st_size; strncpy (self->_path, path, PATH_MAX);
strncpy (self->_maildir, mdir ? mdir : "", PATH_MAX);
SET_CACHE(MU_MSG_FIELD_ID_PATH, g_strdup(path));
SET_CACHE(MU_MSG_FIELD_ID_MAILDIR, mdir ? g_strdup(mdir): NULL);
return TRUE; return TRUE;
} }
@ -124,17 +121,16 @@ init_file_metadata (MuMsgFile *self, const char* path, const gchar* mdir,
static GMimeStream* static GMimeStream*
get_mime_stream (MuMsgFile *self, GError **err) get_mime_stream (MuMsgFile *self, const char *path, GError **err)
{ {
FILE *file; FILE *file;
GMimeStream *stream; GMimeStream *stream;
file = fopen (self->_str_cache [MU_MSG_FIELD_ID_PATH], "r"); file = fopen (path, "r");
if (!file) { if (!file) {
g_set_error (err, 0, MU_ERROR_FILE, g_set_error (err, 0, MU_ERROR_FILE,
"cannot open %s: %s", "cannot open %s: %s",
self->_str_cache [MU_MSG_FIELD_ID_PATH], path, strerror (errno));
strerror (errno));
return NULL; return NULL;
} }
@ -142,7 +138,7 @@ get_mime_stream (MuMsgFile *self, GError **err)
if (!stream) { if (!stream) {
g_set_error (err, 0, MU_ERROR_GMIME, g_set_error (err, 0, MU_ERROR_GMIME,
"cannot create mime stream for %s", "cannot create mime stream for %s",
self->_str_cache [MU_MSG_FIELD_ID_PATH]); path);
fclose (file); fclose (file);
return NULL; return NULL;
} }
@ -151,12 +147,12 @@ get_mime_stream (MuMsgFile *self, GError **err)
} }
static gboolean static gboolean
init_mime_msg (MuMsgFile *self, GError **err) init_mime_msg (MuMsgFile *self, const char* path, GError **err)
{ {
GMimeStream *stream; GMimeStream *stream;
GMimeParser *parser; GMimeParser *parser;
stream = get_mime_stream (self, err); stream = get_mime_stream (self, path, err);
if (!stream) if (!stream)
return FALSE; return FALSE;
@ -164,8 +160,8 @@ init_mime_msg (MuMsgFile *self, GError **err)
g_object_unref (stream); g_object_unref (stream);
if (!parser) { if (!parser) {
g_set_error (err, 0, MU_ERROR_GMIME, g_set_error (err, 0, MU_ERROR_GMIME,
"cannot create mime parser for %s", "%s: cannot create mime parser for %s",
self->_str_cache [MU_MSG_FIELD_ID_PATH]); __FUNCTION__, path);
return FALSE; return FALSE;
} }
@ -173,8 +169,8 @@ init_mime_msg (MuMsgFile *self, GError **err)
g_object_unref (parser); g_object_unref (parser);
if (!self->_mime_msg) { if (!self->_mime_msg) {
g_set_error (err, 0, MU_ERROR_GMIME, g_set_error (err, 0, MU_ERROR_GMIME,
"cannot construct mime message for %s", "%s: cannot construct mime message for %s",
self->_str_cache [MU_MSG_FIELD_ID_PATH]); __FUNCTION__, path);
return FALSE; return FALSE;
} }
@ -182,26 +178,12 @@ init_mime_msg (MuMsgFile *self, GError **err)
} }
static const char* static char*
get_recipient (MuMsgFile *self, GMimeRecipientType rtype) get_recipient (MuMsgFile *self, GMimeRecipientType rtype)
{ {
const char *val;
char *recep; char *recep;
InternetAddressList *receps; InternetAddressList *receps;
switch (rtype) {
case GMIME_RECIPIENT_TYPE_TO:
val = CACHE(MU_MSG_FIELD_ID_TO);
if (val) return val; else break;
case GMIME_RECIPIENT_TYPE_CC:
val = CACHE(MU_MSG_FIELD_ID_CC);
if (val) return val; else break;
case GMIME_RECIPIENT_TYPE_BCC:
val = CACHE(MU_MSG_FIELD_ID_BCC);
if (val) return val; else break;
default: g_return_val_if_reached (NULL);
}
receps = g_mime_message_get_recipients (self->_mime_msg, rtype); receps = g_mime_message_get_recipients (self->_mime_msg, rtype);
recep = (char*)internet_address_list_to_string (receps, TRUE); recep = (char*)internet_address_list_to_string (receps, TRUE);
@ -210,19 +192,7 @@ get_recipient (MuMsgFile *self, GMimeRecipientType rtype)
return NULL; return NULL;
} }
switch (rtype) { return recep;
case GMIME_RECIPIENT_TYPE_TO:
return SET_CACHE (MU_MSG_FIELD_ID_TO, recep);
case GMIME_RECIPIENT_TYPE_CC:
return SET_CACHE (MU_MSG_FIELD_ID_CC, recep);
case GMIME_RECIPIENT_TYPE_BCC:
return SET_CACHE (MU_MSG_FIELD_ID_BCC, recep);
default: g_return_val_if_reached (NULL);
}
} }
@ -317,15 +287,14 @@ get_content_flags (MuMsgFile *self)
static MuMsgFlags static MuMsgFlags
get_flags (MuMsgFile *self) get_flags (MuMsgFile *self)
{ {
MuMsgFlags flags;
g_return_val_if_fail (self, MU_MSG_FLAG_NONE); g_return_val_if_fail (self, MU_MSG_FLAG_NONE);
if (self->_flags == MU_MSG_FLAG_NONE) { flags = mu_maildir_get_flags_from_path (self->_path);
self->_flags = mu_maildir_get_flags_from_path flags |= get_content_flags (self);
(CACHE(MU_MSG_FIELD_ID_PATH));
self->_flags |= get_content_flags (self);
}
return self->_flags; return flags;
} }
@ -377,8 +346,8 @@ parse_prio_str (const char* priostr)
{ {
int i; int i;
struct { struct {
const char* _str; const char* _str;
MuMsgPrio _prio; MuMsgPrio _prio;
} str_prio[] = { } str_prio[] = {
{ "high", MU_MSG_PRIO_HIGH }, { "high", MU_MSG_PRIO_HIGH },
{ "1", MU_MSG_PRIO_HIGH }, { "1", MU_MSG_PRIO_HIGH },
@ -405,21 +374,19 @@ parse_prio_str (const char* priostr)
static MuMsgPrio static MuMsgPrio
get_prio (MuMsgFile *self) get_prio (MuMsgFile *self)
{ {
MuMsgPrio prio;
char* priostr; char* priostr;
g_return_val_if_fail (self, 0); g_return_val_if_fail (self, MU_MSG_PRIO_NONE);
if (self->_prio != MU_MSG_PRIO_NONE)
return self->_prio;
priostr = get_prio_header_field (self); priostr = get_prio_header_field (self);
if (!priostr) if (!priostr)
return MU_MSG_PRIO_NORMAL; return MU_MSG_PRIO_NORMAL;
self->_prio = parse_prio_str (priostr); prio = parse_prio_str (priostr);
g_free (priostr); g_free (priostr);
return self->_prio; return prio;
} }
@ -663,56 +630,10 @@ get_body (MuMsgFile *self, gboolean want_html)
if (err) if (err)
g_warning ("error occured while retrieving %s body" g_warning ("error occured while retrieving %s body"
"for message %s", "for message %s",
want_html ? "html" : "text", want_html ? "html" : "text", self->_path);
(CACHE(MU_MSG_FIELD_ID_PATH)));
return str; return str;
} }
static const char*
get_body_html (MuMsgFile *self)
{
g_return_val_if_fail (self, NULL);
if (CACHE(MU_MSG_FIELD_ID_BODY_HTML))
return CACHE(MU_MSG_FIELD_ID_BODY_HTML);
else
return SET_CACHE(MU_MSG_FIELD_ID_BODY_HTML,
get_body (self, TRUE));
}
static const char*
get_body_text (MuMsgFile *self)
{
g_return_val_if_fail (self, NULL);
if (CACHE(MU_MSG_FIELD_ID_BODY_TEXT))
return CACHE(MU_MSG_FIELD_ID_BODY_TEXT);
else
return SET_CACHE(MU_MSG_FIELD_ID_BODY_TEXT,
get_body (self, FALSE));
}
static const char*
get_summary (MuMsgFile *self, size_t max_lines)
{
const char *body;
g_return_val_if_fail (self, NULL);
g_return_val_if_fail (max_lines > 0, NULL);
if (CACHE(MU_MSG_FIELD_ID_SUMMARY))
return CACHE(MU_MSG_FIELD_ID_SUMMARY);
/* nope; calculate it */
body = get_body_text (self);
if (!body)
return NULL; /* there was no text body */
return SET_CACHE(MU_MSG_FIELD_ID_SUMMARY,
mu_str_summarize (body, max_lines));
}
static GSList* static GSList*
get_msgids_from_header (MuMsgFile *self, const char* header) get_msgids_from_header (MuMsgFile *self, const char* header)
@ -743,16 +664,13 @@ get_msgids_from_header (MuMsgFile *self, const char* header)
static const GSList* static GSList*
get_references (MuMsgFile *self) get_references (MuMsgFile *self)
{ {
GSList *refs, *inreply; GSList *refs, *inreply;
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
if (self->_refs)
return self->_refs;
refs = get_msgids_from_header (self, "References"); refs = get_msgids_from_header (self, "References");
/* now, add in-reply-to:, we only take the first one if there /* now, add in-reply-to:, we only take the first one if there
@ -765,22 +683,17 @@ get_references (MuMsgFile *self)
} }
/* put in proper order */ /* put in proper order */
self->_refs = g_slist_reverse (refs); return g_slist_reverse (refs);
return self->_refs;
} }
static const char* static char*
get_references_str (MuMsgFile *self) get_references_str (MuMsgFile *self)
{ {
const GSList *refs; GSList *refs;
gchar *refsstr; gchar *refsstr;
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
if (CACHE(MU_MSG_FIELD_ID_REFS))
return CACHE(MU_MSG_FIELD_ID_REFS);
refsstr = NULL; refsstr = NULL;
refs = get_references (self); refs = get_references (self);
if (refs) { if (refs) {
@ -790,59 +703,68 @@ get_references_str (MuMsgFile *self)
tmp = g_strdup_printf ("%s%s%s", tmp = g_strdup_printf ("%s%s%s",
refsstr ? refsstr : "", refsstr ? refsstr : "",
refsstr ? "," : "", refsstr ? "," : "",
g_strdup((gchar*)cur->data)); (gchar*)cur->data);
g_free (refsstr); g_free (refsstr);
refsstr = tmp; refsstr = tmp;
} }
} }
return SET_CACHE(MU_MSG_FIELD_ID_REFS, refsstr); g_slist_foreach (refs, (GFunc)g_free, NULL);
g_slist_free (refs);
return refsstr;
} }
char*
mu_msg_file_get_str_field (MuMsgFile *self, MuMsgFieldId mfid, gboolean *do_free)
const char*
mu_msg_file_get_str_field (MuMsgFile *self, MuMsgFieldId mfid)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
g_return_val_if_fail (mu_msg_field_is_string(mfid), NULL); g_return_val_if_fail (mu_msg_field_is_string(mfid), NULL);
*do_free = FALSE; /* default */
switch (mfid) { switch (mfid) {
case MU_MSG_FIELD_ID_BCC: case MU_MSG_FIELD_ID_BCC:
*do_free = TRUE;
return get_recipient (self, GMIME_RECIPIENT_TYPE_BCC); return get_recipient (self, GMIME_RECIPIENT_TYPE_BCC);
case MU_MSG_FIELD_ID_BODY_TEXT: return get_body_text (self); case MU_MSG_FIELD_ID_BODY_TEXT:
case MU_MSG_FIELD_ID_BODY_HTML: return get_body_html (self); *do_free = TRUE;
return get_body (self, FALSE);
case MU_MSG_FIELD_ID_BODY_HTML:
*do_free = TRUE;
return get_body (self, TRUE);
case MU_MSG_FIELD_ID_CC: case MU_MSG_FIELD_ID_CC:
*do_free = TRUE;
return get_recipient (self, GMIME_RECIPIENT_TYPE_CC); return get_recipient (self, GMIME_RECIPIENT_TYPE_CC);
case MU_MSG_FIELD_ID_FROM: case MU_MSG_FIELD_ID_FROM:
return g_mime_message_get_sender (self->_mime_msg); return (char*)g_mime_message_get_sender (self->_mime_msg);
case MU_MSG_FIELD_ID_PATH: case MU_MSG_FIELD_ID_PATH:
return CACHE(MU_MSG_FIELD_ID_PATH); return self->_path;
case MU_MSG_FIELD_ID_SUBJECT: case MU_MSG_FIELD_ID_SUBJECT:
return g_mime_message_get_subject (self->_mime_msg); return (char*)g_mime_message_get_subject (self->_mime_msg);
case MU_MSG_FIELD_ID_TO: case MU_MSG_FIELD_ID_TO:
*do_free = TRUE;
return get_recipient (self, GMIME_RECIPIENT_TYPE_TO); return get_recipient (self, GMIME_RECIPIENT_TYPE_TO);
case MU_MSG_FIELD_ID_MSGID: case MU_MSG_FIELD_ID_MSGID:
return g_mime_message_get_message_id (self->_mime_msg); return (char*)g_mime_message_get_message_id (self->_mime_msg);
case MU_MSG_FIELD_ID_MAILDIR: case MU_MSG_FIELD_ID_MAILDIR:
return CACHE(MU_MSG_FIELD_ID_MAILDIR); return self->_maildir;
case MU_MSG_FIELD_ID_REFS: case MU_MSG_FIELD_ID_REFS:
*do_free = TRUE;
return get_references_str (self); return get_references_str (self);
case MU_MSG_FIELD_ID_SUMMARY:
return get_summary (self, 5);
default: default:
g_return_val_if_reached (NULL); g_return_val_if_reached (NULL);
} }
@ -875,4 +797,3 @@ mu_msg_file_get_num_field (MuMsgFile *self, const MuMsgFieldId mfid)
} }
} }

15
src/mu-msg-file.h
View File

@ -32,8 +32,8 @@ typedef struct _MuMsgFile MuMsgFile;
* *
* @return a new MuMsg, or NULL in case of error * @return a new MuMsg, or NULL in case of error
*/ */
MuMsgFile *mu_msg_file_new (const char *path, const char* mdir, GError **err); MuMsgFile *mu_msg_file_new (const char *path,
const char* mdir, GError **err);
/** /**
* destroy a MuMsgFile object * destroy a MuMsgFile object
@ -47,12 +47,16 @@ void mu_msg_file_destroy (MuMsgFile *self);
* get a string value for this message * get a string value for this message
* *
* @param self a valid MuMsgFile * @param self a valid MuMsgFile
* @param msfid the message field id to get (must be string-based one) * @param msfid the message field id to get (must be string-based one) *
* @param do_free receives TRUE or FALSE, conveying if this string
* should be freed (TRUE) or not by caller. In case 'FALSE', this
* function should be treated as if it were return a const char*
* *
* @return a const string, or NULL * @return a const string, or NULL
*/ */
const char* mu_msg_file_get_str_field (MuMsgFile *self, char* mu_msg_file_get_str_field (MuMsgFile *self,
MuMsgFieldId msfid); MuMsgFieldId msfid,
gboolean *do_free);
/** /**
* get a numeric value for this message -- the return value should be * get a numeric value for this message -- the return value should be
@ -65,4 +69,5 @@ const char* mu_msg_file_get_str_field (MuMsgFile *self,
*/ */
gint64 mu_msg_file_get_num_field (MuMsgFile *self, MuMsgFieldId msfid); gint64 mu_msg_file_get_num_field (MuMsgFile *self, MuMsgFieldId msfid);
#endif /*__MU_MSG_FILE_H__*/ #endif /*__MU_MSG_FILE_H__*/

26
src/mu-msg-priv.h
View File

@ -1,5 +1,5 @@
/* /*
** Copyright (C) 2008-2010 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl> ** Copyright (C) 2008-2011 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
** **
** This program is free software; you can redistribute it and/or modify ** 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 ** it under the terms of the GNU General Public License as published by
@ -25,31 +25,27 @@
#include "mu-msg.h" #include "mu-msg.h"
#include "mu-msg-file.h" #include "mu-msg-file.h"
#include "mu-msg-cache.h"
G_BEGIN_DECLS G_BEGIN_DECLS
/* we put the the MuMsg definition in this separate -priv file, so we
* can split the mu_msg implementations over separate files */
struct _MuMsgFile { struct _MuMsgFile {
GMimeMessage *_mime_msg; GMimeMessage *_mime_msg;
time_t _timestamp;
/* we waste a few bytes here for none-string fields... */ size_t _size;
gchar *_str_cache[MU_MSG_FIELD_ID_NUM]; char _path [PATH_MAX + 1];
char _maildir [PATH_MAX + 1];
GSList *_refs;
time_t _timestamp;
size_t _size;
MuMsgFlags _flags;
MuMsgPrio _prio;
}; };
/* we put the the MuMsg definition in this separate -priv file, so we
* can split the mu_msg implementations over separate files */
struct _MuMsg { struct _MuMsg {
guint _refcount; guint _refcount;
MuMsgFile *_file; MuMsgFile *_file;
MuMsgCache *_cache;
}; };
G_END_DECLS G_END_DECLS

261
src/mu-msg.c
View File

@ -1,5 +1,5 @@
/* /*
** Copyright (C) 2008-2010 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl> ** Copyright (C) 2008-2011 Dirk-Jan C. Binnema <djcb@djcbsoftware.nl>
** **
** This program is free software; you can redistribute it and/or modify ** 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 ** it under the terms of the GNU General Public License as published by
@ -41,160 +41,241 @@ static gboolean _gmime_initialized = FALSE;
static void static void
gmime_init (void) gmime_init (void)
{ {
g_return_if_fail (!_gmime_initialized); g_return_if_fail (!_gmime_initialized);
#ifdef GMIME_ENABLE_RFC2047_WORKAROUNDS #ifdef GMIME_ENABLE_RFC2047_WORKAROUNDS
g_mime_init(GMIME_ENABLE_RFC2047_WORKAROUNDS); g_mime_init(GMIME_ENABLE_RFC2047_WORKAROUNDS);
#else #else
g_mime_init(0); g_mime_init(0);
#endif /* GMIME_ENABLE_RFC2047_WORKAROUNDS */ #endif /* GMIME_ENABLE_RFC2047_WORKAROUNDS */
_gmime_initialized = TRUE; _gmime_initialized = TRUE;
} }
static void static void
gmime_uninit (void) gmime_uninit (void)
{ {
g_return_if_fail (_gmime_initialized); g_return_if_fail (_gmime_initialized);
g_mime_shutdown(); g_mime_shutdown();
_gmime_initialized = FALSE; _gmime_initialized = FALSE;
} }
MuMsg* MuMsg*
mu_msg_new_from_file (const char *path, const char *mdir, GError **err) mu_msg_new_from_file (const char *path, const char *mdir, GError **err)
{ {
MuMsg *self; MuMsg *self;
MuMsgFile *msgfile; MuMsgFile *msgfile;
g_return_val_if_fail (path, NULL); g_return_val_if_fail (path, NULL);
if (G_UNLIKELY(!_gmime_initialized)) { if (G_UNLIKELY(!_gmime_initialized)) {
gmime_init (); gmime_init ();
g_atexit (gmime_uninit); g_atexit (gmime_uninit);
} }
msgfile = mu_msg_file_new (path, mdir, err); msgfile = mu_msg_file_new (path, mdir, err);
if (!msgfile) if (!msgfile)
return NULL; return NULL;
self = g_slice_new0 (MuMsg); self = g_slice_new0 (MuMsg);
self->_file = msgfile; self->_file = msgfile;
self->_refcount = 1; self->_refcount = 1;
self->_cache = mu_msg_cache_new ();
return self; return self;
} }
static void static void
mu_msg_destroy (MuMsg *self) mu_msg_destroy (MuMsg *self)
{ {
if (!self) if (!self)
return; return;
mu_msg_file_destroy (self->_file); mu_msg_file_destroy (self->_file);
mu_msg_cache_destroy (self->_cache);
g_slice_free (MuMsg, self); g_slice_free (MuMsg, self);
} }
MuMsg* MuMsg*
mu_msg_ref (MuMsg *self) mu_msg_ref (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
++self->_refcount; ++self->_refcount;
return self; return self;
} }
void void
mu_msg_unref (MuMsg *self) mu_msg_unref (MuMsg *self)
{ {
g_return_if_fail (self); g_return_if_fail (self);
g_return_if_fail (self->_refcount >= 1); g_return_if_fail (self->_refcount >= 1);
if (--self->_refcount == 0) if (--self->_refcount == 0)
mu_msg_destroy (self); mu_msg_destroy (self);
} }
const char*
mu_msg_get_path (MuMsg *self) /* for some data, we need to read the message file from disk */
static MuMsgFile*
get_msg_file (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); MuMsgFile *file;
return mu_msg_file_get_str_field (self->_file, const char *path;
MU_MSG_FIELD_ID_PATH); GError *err;
path = mu_msg_cache_str (self->_cache, MU_MSG_FIELD_ID_PATH);
if (!path) {
g_warning ("%s: cannot find path info", __FUNCTION__);
return NULL;
}
err = NULL;
file = mu_msg_file_new (path, NULL, &err);
if (!file) {
g_warning ("%s: failed to create MuMsgFile: %s",
__FUNCTION__,
err->message ? err->message : "?");
g_error_free (err);
return NULL;
}
return file;
}
static const char*
get_str_field (MuMsg *self, MuMsgFieldId mfid)
{
gboolean do_free;
char *val;
if (mu_msg_cache_cached (self->_cache, mfid))
return mu_msg_cache_str (self->_cache, mfid);
/* if we don't have a file object yet, we need to create from
* the file on disk */
if (!self->_file) {
self->_file = get_msg_file (self);
if (!self->_file) {
g_warning ("failed to open message file");
return NULL;
}
}
/* if we get a string that needs freeing, we tell the cache to
* mark the string as such, so it will be freed when the cache
* is freed (or when the value is overwritten) */
val = mu_msg_file_get_str_field (self->_file, mfid, &do_free);
if (do_free)
mu_msg_cache_set_str_alloc (self->_cache, mfid, val);
else
mu_msg_cache_set_str (self->_cache, mfid, val);
return val;
}
static gint64
get_num_field (MuMsg *self, MuMsgFieldId mfid)
{
guint64 val;
if (mu_msg_cache_cached (self->_cache, mfid))
return mu_msg_cache_num (self->_cache, mfid);
/* if we don't have a file object yet, we need to create from
* the file on disk */
if (!self->_file) {
self->_file = get_msg_file (self);
if (!self->_file) {
g_warning ("failed to open message file");
return -1;
}
}
val = mu_msg_file_get_num_field (self->_file, mfid);
mu_msg_cache_set_num (self->_cache, mfid, val);
return val;
}
const char*
mu_msg_get_path (MuMsg *self)
{
g_return_val_if_fail (self, NULL);
return get_str_field (self, MU_MSG_FIELD_ID_PATH);
} }
const char* const char*
mu_msg_get_subject (MuMsg *self) mu_msg_get_subject (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
return mu_msg_file_get_str_field (self->_file, return get_str_field (self, MU_MSG_FIELD_ID_SUBJECT);
MU_MSG_FIELD_ID_SUBJECT);
} }
const char* const char*
mu_msg_get_msgid (MuMsg *self) mu_msg_get_msgid (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
return mu_msg_file_get_str_field (self->_file, return get_str_field (self, MU_MSG_FIELD_ID_MSGID);
MU_MSG_FIELD_ID_MSGID);
} }
const char* const char*
mu_msg_get_maildir (MuMsg *self) mu_msg_get_maildir (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
return mu_msg_file_get_str_field (self->_file, return get_str_field (self, MU_MSG_FIELD_ID_MAILDIR);
MU_MSG_FIELD_ID_MAILDIR);
} }
const char* const char*
mu_msg_get_from (MuMsg *self) mu_msg_get_from (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
return mu_msg_file_get_str_field (self->_file, return get_str_field (self, MU_MSG_FIELD_ID_FROM);
MU_MSG_FIELD_ID_FROM);
} }
const char* const char*
mu_msg_get_to (MuMsg *self) mu_msg_get_to (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
return mu_msg_file_get_str_field (self->_file, return get_str_field (self, MU_MSG_FIELD_ID_TO);
MU_MSG_FIELD_ID_TO);
} }
const char* const char*
mu_msg_get_cc (MuMsg *self) mu_msg_get_cc (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
return mu_msg_file_get_str_field (self->_file, return get_str_field (self, MU_MSG_FIELD_ID_CC);
MU_MSG_FIELD_ID_CC);
} }
const char* const char*
mu_msg_get_bcc (MuMsg *self) mu_msg_get_bcc (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
return mu_msg_file_get_str_field (self->_file, return get_str_field (self, MU_MSG_FIELD_ID_BCC);
MU_MSG_FIELD_ID_BCC);
} }
time_t time_t
mu_msg_get_date (MuMsg *self) mu_msg_get_date (MuMsg *self)
{ {
g_return_val_if_fail (self, (time_t)-1); g_return_val_if_fail (self, (time_t)-1);
return (time_t)mu_msg_file_get_num_field (self->_file, return (time_t)get_num_field (self, MU_MSG_FIELD_ID_DATE);
MU_MSG_FIELD_ID_DATE);
} }
@ -202,26 +283,23 @@ mu_msg_get_date (MuMsg *self)
MuMsgFlags MuMsgFlags
mu_msg_get_flags (MuMsg *self) mu_msg_get_flags (MuMsg *self)
{ {
g_return_val_if_fail (self, MU_MSG_FLAG_NONE); g_return_val_if_fail (self, MU_MSG_FLAG_NONE);
return (MuMsgFlags)mu_msg_file_get_num_field (self->_file, return (MuMsgFlags)get_num_field (self, MU_MSG_FIELD_ID_FLAGS);
MU_MSG_FIELD_ID_FLAGS);
} }
size_t size_t
mu_msg_get_size (MuMsg *self) mu_msg_get_size (MuMsg *self)
{ {
g_return_val_if_fail (self, 0); g_return_val_if_fail (self, 0);
return (size_t)mu_msg_file_get_num_field (self->_file, return (size_t)get_num_field (self, MU_MSG_FIELD_ID_SIZE);
MU_MSG_FIELD_ID_SIZE);
} }
MuMsgPrio MuMsgPrio
mu_msg_get_prio (MuMsg *self) mu_msg_get_prio (MuMsg *self)
{ {
g_return_val_if_fail (self, (time_t)-1); g_return_val_if_fail (self, (time_t)-1);
return (MuMsgPrio)mu_msg_file_get_num_field (self->_file, return (MuMsgPrio)get_num_field (self, MU_MSG_FIELD_ID_PRIO);
MU_MSG_FIELD_ID_PRIO);
} }
@ -239,60 +317,47 @@ mu_msg_get_prio (MuMsg *self)
time_t time_t
mu_msg_get_timestamp (MuMsg *self) mu_msg_get_timestamp (MuMsg *self)
{ {
g_return_val_if_fail (self, (time_t)-1); g_return_val_if_fail (self, (time_t)-1);
return (MuMsgPrio)mu_msg_file_get_num_field (self->_file, return (MuMsgPrio)get_num_field (self, MU_MSG_FIELD_ID_TIMESTAMP);
MU_MSG_FIELD_ID_TIMESTAMP);
} }
const char* const char*
mu_msg_get_body_html (MuMsg *self) mu_msg_get_body_html (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
return mu_msg_file_get_str_field (self->_file, return get_str_field (self, MU_MSG_FIELD_ID_BODY_HTML);
MU_MSG_FIELD_ID_BODY_HTML);
} }
const char* const char*
mu_msg_get_body_text (MuMsg *self) mu_msg_get_body_text (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
return mu_msg_file_get_str_field (self->_file, return get_str_field (self, MU_MSG_FIELD_ID_BODY_TEXT);
MU_MSG_FIELD_ID_BODY_TEXT);
} }
const char*
mu_msg_get_summary (MuMsg *self, size_t max_lines)
{
g_return_val_if_fail (self, NULL);
g_return_val_if_fail (max_lines > 0, NULL);
return mu_msg_file_get_str_field (self->_file,
MU_MSG_FIELD_ID_SUMMARY);
}
const char* const char*
mu_msg_get_references_str (MuMsg *self) mu_msg_get_references_str (MuMsg *self)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
return mu_msg_file_get_str_field (self->_file, return get_str_field (self, MU_MSG_FIELD_ID_REFS);
MU_MSG_FIELD_ID_REFS);
} }
const char* const char*
mu_msg_get_field_string (MuMsg *self, MuMsgFieldId mfid) mu_msg_get_field_string (MuMsg *self, MuMsgFieldId mfid)
{ {
g_return_val_if_fail (self, NULL); g_return_val_if_fail (self, NULL);
return mu_msg_file_get_str_field (self->_file, mfid); return get_str_field (self, mfid);
} }
gint64 gint64
mu_msg_get_field_numeric (MuMsg *self, MuMsgFieldId mfid) mu_msg_get_field_numeric (MuMsg *self, MuMsgFieldId mfid)
{ {
g_return_val_if_fail (self, -1); g_return_val_if_fail (self, -1);
return mu_msg_file_get_num_field (self->_file, mfid); return get_num_field (self, mfid);
} }

28
src/mu-msg.h
View File

@ -69,6 +69,15 @@ void mu_msg_unref (MuMsg *msg);
/**
* cache the values from the backend (file or db), so we don't the
* backend anymore
*
* @param self a message
*/
void mu_msg_cache_values (MuMsg *self);
/** /**
* get the plain text body of this message * get the plain text body of this message
* *
@ -91,25 +100,6 @@ const char* mu_msg_get_body_text (MuMsg *msg);
*/ */
const char* mu_msg_get_body_html (MuMsg *msg); const char* mu_msg_get_body_html (MuMsg *msg);
/**
* get a summary of the body of this message; a summary takes up to
* the first @max_lines from the message, and replaces newlines
* etc. with single whitespace characters. This only works if there's
* a text-body for the message
*
* @param msg a valid MuMsg* instance
* @param max_lines the max number of lines to summarize
*
* @return the summary of the message or NULL in case of error or if
* there is no such body. the returned string should *not* be modified
* or freed. When called multiple times, the function will always
* return the same summary, regardless of a different max_lines value.
*/
const char* mu_msg_get_summary (MuMsg *msg, size_t max_lines);
/** /**
* get the sender (From:) of this message * get the sender (From:) of this message
* *