Thread

mozilla/ mailnews/ db/ msgdb/ src/ nsMsgDatabase.cpp

 nsresult nsMsgDatabase::ThreadNewHdr(nsMsgHdr* newHdr, PRBool &newThread)
 {
     nsresult result=NS_ERROR_UNEXPECTED;
     nsCOMPtr <nsIMsgThread> thread;
     nsCOMPtr <nsIMsgDBHdr> replyToHdr;
     nsMsgKey threadId = nsMsgKey_None;
 
     if (!newHdr)
         return NS_ERROR_NULL_POINTER;
 
     PRUint16 numReferences = 0;
     PRUint32 newHdrFlags = 0;
 
     newHdr->GetFlags(&newHdrFlags);
     newHdr->GetNumReferences(&numReferences);
 
 #define SUBJ_THREADING 1// try reference threading first
     for (PRInt32 i = numReferences - 1; i >= 0;  i--)
     {
         nsCAutoString reference;
 
         newHdr->GetStringReference(i, reference);
         // first reference we have hdr for is best top-level hdr.
         // but we have to handle case of promoting new header to top-level
         // in case the top-level header comes after a reply.
 
         if (reference.Length() == 0)
             break;
 
         thread = getter_AddRefs(→GetThreadForReference(reference, getter_AddRefs(replyToHdr))) ;
         if (thread)
         {
             thread->GetThreadKey(&threadId);
             newHdr->SetThreadId(threadId);
             result = AddToThread(newHdr, thread, replyToHdr, PR_TRUE);
             break;
         }
     }
 #ifdef SUBJ_THREADING
     // try subject threading if we couldn't find a reference and the subject starts with Re:
     nsXPIDLCString subject;
 
     newHdr->GetSubject(getter_Copies(subject));
     if ((ThreadBySubjectWithoutRe() || (newHdrFlags & MSG_FLAG_HAS_RE)) && (!thread))
     {
         nsCAutoString cSubject(subject);
         thread = getter_AddRefs(GetThreadForSubject(cSubject));
         if(thread)
         {
             thread->GetThreadKey(&threadId);
             newHdr->SetThreadId(threadId);
             //TRACE("threading based on subject %s\n", (const char *) msgHdr->m_subject);
             // if we move this and do subject threading after, ref threading, 
             // don't thread within children, since we know it won't work. But for now, pass TRUE.
             result = AddToThread(newHdr, thread, nsnull, PR_TRUE);     
         }
     }
 #endif // SUBJ_THREADING
 
     if (!thread)
     {
         // couldn't find any parent articles - msgHdr is top-level thread, for now
         result = AddNewThread(newHdr);
         newThread = PR_TRUE;
     }
     else
     {
         newThread = PR_FALSE;
     }
     return result;
 }

 nsIMsgThread *nsMsgDatabase::GetThreadForReference(nsCString &msgID, nsIMsgDBHdr **pMsgHdr)
 {
   nsIMsgDBHdr   *msgHdr = nsnull;
   →GetMsgHdrForMessageID(msgID.get(), &msgHdr);  
   nsIMsgThread *thread = NULL;
   
   if (msgHdr != NULL)
   {
     nsMsgKey threadId;
     if (NS_SUCCEEDED(msgHdr->GetThreadId(&threadId)))
     {
       // find thread header for header whose message id we matched.
       thread = →GetThreadForThreadId(threadId);
     }
     if (pMsgHdr)
       *pMsgHdr = msgHdr;
     else
       msgHdr->Release();
   }
   return thread;
 }

 NS_IMETHODIMP nsMsgDatabase::GetMsgHdrForMessageID(const char *msgID, nsIMsgDBHdr **aHdr)
 {
   NS_ENSURE_ARG_POINTER(aHdr);
   nsIMsgDBHdr   *msgHdr = nsnull;
   nsresult rv = NS_OK;
   mdbYarn   messageIdYarn;
 
   messageIdYarn.mYarn_Buf = (void *) msgID;
   messageIdYarn.mYarn_Fill = PL_strlen(msgID);
   messageIdYarn.mYarn_Form = 0;
   messageIdYarn.mYarn_Size = messageIdYarn.mYarn_Fill;
 
   nsIMdbRow *hdrRow;
   mdbOid        outRowId;
   mdb_err result = GetStore()->FindRow(GetEnv(), m_hdrRowScopeToken,
       m_messageIdColumnToken, &messageIdYarn,  &outRowId, 
       &hdrRow);
   if (NS_SUCCEEDED(result) && hdrRow)
   {
       //Get key from row
       mdbOid outOid;
       nsMsgKey key=0;
       if (hdrRow->GetOid(GetEnv(), &outOid) == NS_OK)
           key = outOid.mOid_Id;
       rv = GetHdrFromUseCache(key, &msgHdr);
       if (NS_SUCCEEDED(rv) && msgHdr)
           hdrRow->Release();
       else
           rv = CreateMsgHdr(hdrRow, key, &msgHdr);
   }
   NS_IF_ADDREF(*aHdr = msgHdr);
   return NS_OK; // it's not an error not to find a msg hdr.
 }

 // caller needs to unrefer.
 nsIMsgThread *  nsMsgDatabase::GetThreadForThreadId(nsMsgKey threadId)
 {
   
   if (threadId == m_cachedThreadId && m_cachedThread)
   {
     nsIMsgThread *retThread = m_cachedThread;
     NS_ADDREF(retThread);
     return retThread;
   }
   nsMsgThread *pThread = nsnull;
   if (m_mdbStore)
   {
     mdbOid tableId;
     tableId.mOid_Id = threadId;
     tableId.mOid_Scope = m_hdrRowScopeToken;
     
     nsIMdbTable *threadTable;
     mdb_err res = m_mdbStore->GetTable(GetEnv(), &tableId, &threadTable);
     
     if (NS_SUCCEEDED(res) && threadTable)
     {
       pThread = new nsMsgThread(this, threadTable);
       if(pThread)
       {
         NS_ADDREF(pThread);
         m_cachedThread = pThread;
         m_cachedThreadId = threadId;
       }
     }
   }
   return pThread;
 }

 // make the passed in header a thread header
 nsresult nsMsgDatabase::AddNewThread(nsMsgHdr *msgHdr)
 {
   
   if (!msgHdr)
     return NS_ERROR_NULL_POINTER;
   
   nsMsgThread *threadHdr = nsnull;
   
   nsXPIDLCString subject;
   nsMsgKey threadKey = msgHdr->m_messageKey;
   // can't have a thread with key 1 since that's the table id of the all msg hdr table,
   // so give it kTableKeyForThreadOne (0xfffffffe).
   if (threadKey == 1)
     threadKey = kTableKeyForThreadOne;
 
   nsresult err = msgHdr->GetSubject(getter_Copies(subject));
   
   err = CreateNewThread(threadKey, subject, &threadHdr);
   msgHdr->SetThreadId(threadKey);
   if (threadHdr)
   {
     //      nsCString subject;
     
     threadHdr->AddRef();
     //      err = msgHdr->GetSubject(subject);
     //      threadHdr->SetThreadKey(msgHdr->m_messageKey);
     //      threadHdr->SetSubject(subject.get());
     
     // need to add the thread table to the db.
     AddToThread(msgHdr, threadHdr, nsnull, PR_FALSE);
     
     threadHdr->Release();
   }
   return err;
 }

 nsresult nsMsgDatabase::CreateNewThread(nsMsgKey threadId, const char *subject, nsMsgThread **pnewThread)
 {
   nsresult  err = NS_OK;
   nsIMdbTable       *threadTable;
   struct mdbOid threadTableOID;
   struct mdbOid allThreadsTableOID;
   
   if (!pnewThread || !m_mdbStore)
     return NS_ERROR_NULL_POINTER;
   
   threadTableOID.mOid_Scope = m_hdrRowScopeToken;
   threadTableOID.mOid_Id = threadId;
   
   err  = GetStore()->NewTableWithOid(GetEnv(), &threadTableOID, m_threadTableKindToken, 
     PR_FALSE, nsnull, &threadTable);
   if (NS_FAILED(err)) 
     return err;
   
   allThreadsTableOID.mOid_Scope = m_threadRowScopeToken;
   allThreadsTableOID.mOid_Id = threadId;    
   
   // add a row for this thread in the table of all threads that we'll use
   // to do our mapping between subject strings and threads.
   nsIMdbRow *threadRow = nsnull;
   
   err = m_mdbStore->GetRow(GetEnv(), &allThreadsTableOID, &threadRow);
   if (!threadRow)   
   {
     err  = m_mdbStore->NewRowWithOid(GetEnv(), &allThreadsTableOID, &threadRow);
     if (NS_SUCCEEDED(err) && threadRow)
     {
       if (m_mdbAllThreadsTable)
         m_mdbAllThreadsTable->AddRow(GetEnv(), threadRow);
       err = CharPtrToRowCellColumn(threadRow, m_threadSubjectColumnToken, subject);
       threadRow->Release();
     }
   }
   
   *pnewThread = new nsMsgThread(this, threadTable);
   if (*pnewThread)
     (*pnewThread)->SetThreadKey(threadId);
   return err;
 }