* mu-msg-iter.*: cleanups, some renaming

src/mu-msg-iter.cc

@@ -50,19 +50,20 @@ private:
 
 
 struct _MuMsgIter {
+public:
 	_MuMsgIter (Xapian::Enquire &enq, size_t maxnum,
 		    gboolean threads, MuMsgFieldId sortfield):
-		_enq(enq), _msg(0), _threadhash (0) {
+		_enq(enq), _thread_hash (0), _msg(0) {
 
 		_matches = _enq.get_mset (0, maxnum);
 
 		if (threads && !_matches.empty()) {
 
 			_matches.fetch();
-			_threadhash = mu_threader_calculate
+			_thread_hash = mu_threader_calculate
 				(this, _matches.size(), sortfield);
 
-			ThreadKeyMaker keymaker(_threadhash);
+			ThreadKeyMaker keymaker(_thread_hash);
 
 			enq.set_sort_by_key (&keymaker, false);
 			_matches = _enq.get_mset (0, maxnum);
@@ -77,19 +78,33 @@ struct _MuMsgIter {
 	}
 
 	~_MuMsgIter () {
-		if (_msg)
+		if (_thread_hash)
-			mu_msg_unref (_msg);
+			g_hash_table_destroy (_thread_hash);
-
+		set_msg (NULL);
-		if (_threadhash)
-			g_hash_table_destroy (_threadhash);
 	}
 
+	const Xapian::Enquire& enquire() { return _enq; }
+	Xapian::MSet& matches() { return _matches; }
+
+	Xapian::MSet::const_iterator cursor () const { return _cursor; }
+	void set_cursor (Xapian::MSetIterator cur) { _cursor = cur; }
+	void cursor_next () { ++_cursor; }
+
+	GHashTable *thread_hash () { return _thread_hash; }
+
+	MuMsg *msg() { return _msg; }
+	MuMsg *set_msg (MuMsg *msg) {
+		if (_msg)
+			mu_msg_unref (_msg);
+		return _msg = msg;
+	}
+private:
 	const Xapian::Enquire		_enq;
 	Xapian::MSet			_matches;
 	Xapian::MSet::const_iterator	_cursor;
 
+	GHashTable      *_thread_hash;
 	MuMsg		*_msg;
-	GHashTable      *_threadhash;
 };
 
 MuMsgIter*
@@ -103,7 +118,6 @@ mu_msg_iter_new (XapianEnquire *enq, size_t maxnum,
 	g_return_val_if_fail (mu_msg_field_id_is_valid (sortfield) ||
 			      sortfield == MU_MSG_FIELD_ID_NONE,
 			      FALSE);
-	
 	try {
 		return new MuMsgIter ((Xapian::Enquire&)*enq, maxnum, threads,
 				      sortfield);
@@ -119,27 +133,26 @@ mu_msg_iter_destroy (MuMsgIter *iter)
 }
 
 MuMsg*
-mu_msg_iter_get_msg (MuMsgIter *iter, GError **err)
+mu_msg_iter_get_msg_floating (MuMsgIter *iter)
 {
-       Xapian::Document *docp;
-       
 	g_return_val_if_fail (iter, NULL);
 	g_return_val_if_fail (!mu_msg_iter_is_done(iter), NULL);
 
-       /* get a new MuMsg based on the current doc */
+	try {
-       if (iter->_msg) {
+		MuMsg *msg;
-               mu_msg_unref (iter->_msg);
+		GError *err;
-               iter->_msg = NULL;
+		Xapian::Document *docp;
-       }
 
-       docp = new Xapian::Document(iter->_cursor.get_document());
+		docp = new Xapian::Document(iter->cursor().get_document());
-       iter->_msg = mu_msg_new_from_doc ((XapianDocument*)docp, err);
-       if (!iter->_msg) {
-               g_warning ("%s: failed to create MuMsg",__FUNCTION__);
-               return NULL;
-       }
 
-       return iter->_msg;
+		err = NULL;
+		msg = iter->set_msg (mu_msg_new_from_doc ((XapianDocument*)docp, &err));
+		if (!msg)
+			MU_HANDLE_G_ERROR(err);
+
+		return msg;
+
+	} MU_XAPIAN_CATCH_BLOCK_RETURN (NULL);
 }
 
 gboolean
@@ -147,8 +160,10 @@ mu_msg_iter_reset (MuMsgIter *iter)
 {
 	g_return_val_if_fail (iter, FALSE);
 
+	iter->set_msg (NULL);
+
 	try {
-               iter->_cursor = iter->_matches.begin();
+		iter->set_cursor(iter->matches().begin());
 
 	} MU_XAPIAN_CATCH_BLOCK_RETURN (FALSE);
 
@@ -161,63 +176,31 @@ mu_msg_iter_next (MuMsgIter *iter)
 {
 	g_return_val_if_fail (iter, FALSE);
 
+	iter->set_msg (NULL);
+
 	if (mu_msg_iter_is_done(iter))
 		return FALSE;
 
 	try {
-               ++iter->_cursor;
+		iter->cursor_next();
-               return iter->_cursor == iter->_matches.end() ? FALSE:TRUE;
+		return iter->cursor() == iter->matches().end() ? FALSE:TRUE;
-               /* try to get a new MuMsg based on the current doc */
-               //return update_msg (iter);
 
 	} MU_XAPIAN_CATCH_BLOCK_RETURN(FALSE);
 }
 
 
-
-
 gboolean
 mu_msg_iter_is_done (MuMsgIter *iter)
 {
 	g_return_val_if_fail (iter, TRUE);
 
 	try {
-		return iter->_cursor == iter->_matches.end() ? TRUE : FALSE;
+		return iter->cursor() == iter->matches().end() ? TRUE : FALSE;
 
 	} MU_XAPIAN_CATCH_BLOCK_RETURN (TRUE);
 }
 
 
-static const gchar*
-get_field (MuMsgIter *iter, MuMsgFieldId mfid)
-{
-	return mu_msg_get_field_string (iter->_msg, mfid);
-}
-
-const gchar*
-mu_msg_iter_get_field (MuMsgIter *iter, MuMsgFieldId mfid)
-{
-	g_return_val_if_fail (!mu_msg_iter_is_done(iter), NULL);
-	g_return_val_if_fail (mu_msg_field_id_is_valid(mfid), NULL);
-	
-	return get_field (iter, mfid);
-}
-
-static gint64
-get_field_numeric (MuMsgIter *iter, MuMsgFieldId mfid)
-{
-	return mu_msg_get_field_numeric (iter->_msg, mfid);
-}
-
-
-gint64
-mu_msg_iter_get_field_numeric (MuMsgIter *iter, MuMsgFieldId mfid)
-{
-	g_return_val_if_fail (!mu_msg_iter_is_done(iter), -1);	
-	g_return_val_if_fail (mu_msg_field_is_numeric(mfid), -1);
-	
-	return get_field_numeric (iter, mfid);
-}
 
 /* hmmm.... is it impossible to get a 0 docid, or just very improbable? */
 unsigned int
@@ -226,17 +209,18 @@ mu_msg_iter_get_docid (MuMsgIter *iter)
 	g_return_val_if_fail (!mu_msg_iter_is_done(iter),
 			      (unsigned int)-1);
 	try {
-		return iter->_cursor.get_document().get_docid();
+		return iter->cursor().get_document().get_docid();
 
 	} MU_XAPIAN_CATCH_BLOCK_RETURN (0);
 }
 
 
+
 const MuMsgIterThreadInfo*
 mu_msg_iter_get_thread_info (MuMsgIter *iter)
 {
 	g_return_val_if_fail (!mu_msg_iter_is_done(iter), NULL);
-	g_return_val_if_fail (iter->_threadhash, NULL);
+	g_return_val_if_fail (iter->thread_hash(), NULL);
 
 	try {
 		const MuMsgIterThreadInfo *ti;
@@ -244,8 +228,7 @@ mu_msg_iter_get_thread_info (MuMsgIter *iter)
 
 		docid = mu_msg_iter_get_docid (iter);
 		ti    = (const MuMsgIterThreadInfo*)g_hash_table_lookup
-			(iter->_threadhash,
+			(iter->thread_hash(), GUINT_TO_POINTER(docid));
-			 GUINT_TO_POINTER(docid));
 
 		if (!ti)
 			g_printerr ("no ti for %u\n", docid);

src/mu-msg-iter.h

@@ -99,15 +99,13 @@ void		 mu_msg_iter_destroy           (MuMsgIter *iter);
 /**
  * get the corresponding MuMsg for this iter; this instance is owned
  * by MuMsgIter, and becomes invalid after either mu_msg_iter_destroy
- * or mu_msg_iter_next. _do not_ unref it.
+ * or mu_msg_iter_next. _do not_ unref it; it's a floating reference.
  *
- * @param iter a valid MuMsgIter instance 
+ * @param iter a valid MuMsgIter instance*
- * @param err which receives error info or NULL. err is only filled
- * when the function returns NULL
  *
  * @return a MuMsg instance, or NULL in case of error
  */
-MuMsg* mu_msg_iter_get_msg (MuMsgIter *iter, GError **err)
+MuMsg* mu_msg_iter_get_msg_floating (MuMsgIter *iter)
           G_GNUC_MALLOC G_GNUC_WARN_UNUSED_RESULT;
 
 
@@ -156,27 +154,9 @@ typedef struct _MuMsgIterThreadInfo MuMsgIterThreadInfo;
  */
 const MuMsgIterThreadInfo* mu_msg_iter_get_thread_info (MuMsgIter *iter);
 
-/**
+/* FIXME */
- * get some message field
+const char* mu_msg_iter_get_path (MuMsgIter *iter);
- * 
- * @param iter a valid MuMsgIter iterator
- * @param field the string field to retrieve
- * 
- * @return the field value, or NULL
- */
-const gchar*     mu_msg_iter_get_field         (MuMsgIter *iter, 
-						MuMsgFieldId mfid);
 
-/**
- * get some numeric message field
- * 
- * @param iter a valid MuMsgIter iterator
- * @param field the numeric field to retrieve
- * 
- * @return the field value, or -1 in case of error
- */
-gint64           mu_msg_iter_get_field_numeric     (MuMsgIter *iter, 
-						    MuMsgFieldId mfid);
 G_END_DECLS
 
 #endif /*__MU_MSG_ITER_H__*/