nsMsgSearchAdapter.h

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef _nsMsgSearchAdapter_H_

#define _nsMsgSearchAdapter_H_

#include "nsMsgSearchCore.h"

#include "nsCOMPtr.h"

#include "nsString.h"

#include "nsIMsgSearchAdapter.h"

#include "nsIMsgSearchValidityTable.h"

#include "nsIMsgSearchValidityManager.h"

#include "nsIMsgSearchTerm.h"

#include "nsINntpIncomingServer.h"

class nsIMsgSearchScopeTerm;

//-----------------------------------------------------------------------------

// These Adapter classes contain the smarts to convert search criteria from

// the canonical structures in msg_srch.h into whatever format is required

// by their protocol.

//

// There is a separate Adapter class for area (pop, imap, nntp, ldap) to contain

// the special smarts for that protocol.

//-----------------------------------------------------------------------------

class nsMsgSearchAdapter : public nsIMsgSearchAdapter {

 public:

  nsMsgSearchAdapter(nsIMsgSearchScopeTerm*,

                     nsTArray<RefPtr<nsIMsgSearchTerm>> const&);

  NS_DECL_ISUPPORTS

  NS_DECL_NSIMSGSEARCHADAPTER

  nsIMsgSearchScopeTerm* m_scope;

  nsTArray<RefPtr<nsIMsgSearchTerm>>

      m_searchTerms; /* linked list of criteria terms */

  nsString m_defaultCharset = u"UTF-8"_ns;

  static nsresult EncodeImap(

      char** ppEncoding, nsTArray<RefPtr<nsIMsgSearchTerm>> const& searchTerms,

      const char16_t* srcCharset, const char16_t* destCharset,

      bool reallyDredd = false);

  static nsresult EncodeImapValue(char* encoding, const char* value,

                                  bool useQuotes, bool reallyDredd);

  static char* GetImapCharsetParam(const char16_t* destCharset);

  static char16_t* EscapeSearchUrl(const char16_t* nntpCommand);

  static char16_t* EscapeImapSearchProtocol(const char16_t* imapCommand);

  static char16_t* EscapeQuoteImapSearchProtocol(const char16_t* imapCommand);

  static char* UnEscapeSearchUrl(const char* commandSpecificData);

  // This stuff lives in the base class because the IMAP search syntax

  // is used by the Dredd SEARCH command as well as IMAP itself

  static const char* m_kImapBefore;

  static const char* m_kImapBody;

  static const char* m_kImapCC;

  static const char* m_kImapFrom;

  static const char* m_kImapNot;

  static const char* m_kImapOr;

  static const char* m_kImapSince;

  static const char* m_kImapSubject;

  static const char* m_kImapTo;

  static const char* m_kImapHeader;

  static const char* m_kImapAnyText;

  static const char* m_kImapKeyword;

  static const char* m_kNntpKeywords;

  static const char* m_kImapSentOn;

  static const char* m_kImapSeen;

  static const char* m_kImapAnswered;

  static const char* m_kImapNotSeen;

  static const char* m_kImapNotAnswered;

  static const char* m_kImapCharset;

  static const char* m_kImapUnDeleted;

  static const char* m_kImapSizeSmaller;

  static const char* m_kImapSizeLarger;

  static const char* m_kImapNew;

  static const char* m_kImapNotNew;

  static const char* m_kImapFlagged;

  static const char* m_kImapNotFlagged;

 protected:

  virtual ~nsMsgSearchAdapter();

  typedef enum _msg_TransformType {

    kOverwrite, /* "John Doe" -> "John*Doe",   simple contains   */

    kInsert,    /* "John Doe" -> "John* Doe",  name completion   */

    kSurround   /* "John Doe" -> "John* *Doe", advanced contains */

  } msg_TransformType;

  char* TransformSpacesToStars(const char*, msg_TransformType transformType);

  nsresult OpenNewsResultInUnknownGroup(nsMsgResultElement*);

  static nsresult EncodeImapTerm(nsIMsgSearchTerm*, bool reallyDredd,

                                 const char16_t* srcCharset,

                                 const char16_t* destCharset, char** ppOutTerm);

};

//-----------------------------------------------------------------------------

// Validity checking for attrib/op pairs. We need to know what operations are

// legal in three places:

//   1. when the FE brings up the dialog box and needs to know how to build

//      the menus and enable their items

//   2. when the FE fires off a search, we need to check their lists for

//      correctness

//   3. for on-the-fly capability negotiation e.g. with XSEARCH-capable news

//      servers

//-----------------------------------------------------------------------------

class nsMsgSearchValidityTable final : public nsIMsgSearchValidityTable {

 public:

  nsMsgSearchValidityTable();

  NS_DECL_NSIMSGSEARCHVALIDITYTABLE

  NS_DECL_ISUPPORTS

 protected:

  int m_numAvailAttribs;  // number of rows with at least one available operator

  typedef struct vtBits {

    uint16_t bitEnabled : 1;

    uint16_t bitAvailable : 1;

    uint16_t bitValidButNotShown : 1;

  } vtBits;

  vtBits m_table[nsMsgSearchAttrib::kNumMsgSearchAttributes]

                [nsMsgSearchOp::kNumMsgSearchOperators];

 private:

  ~nsMsgSearchValidityTable() {}

  nsMsgSearchAttribValue m_defaultAttrib;

};

// Using getters and setters seems a little nicer then dumping the 2-D array

// syntax all over the code

#define CHECK_AO                                                           \

  if (a < 0 || a >= nsMsgSearchAttrib::kNumMsgSearchAttributes || o < 0 || \

      o >= nsMsgSearchOp::kNumMsgSearchOperators)                          \

    return NS_ERROR_ILLEGAL_VALUE;

inline nsresult nsMsgSearchValidityTable::SetAvailable(int a, int o, bool b) {

  CHECK_AO;

  m_table[a][o].bitAvailable = b;

  return NS_OK;

inline nsresult nsMsgSearchValidityTable::SetEnabled(int a, int o, bool b) {

  CHECK_AO;

  m_table[a][o].bitEnabled = b;

  return NS_OK;

inline nsresult nsMsgSearchValidityTable::SetValidButNotShown(int a, int o,

                                                              bool b) {

  CHECK_AO;

  m_table[a][o].bitValidButNotShown = b;

  return NS_OK;

inline nsresult nsMsgSearchValidityTable::GetAvailable(int a, int o,

                                                       bool* aResult) {

  CHECK_AO;

  *aResult = m_table[a][o].bitAvailable;

  return NS_OK;

inline nsresult nsMsgSearchValidityTable::GetEnabled(int a, int o,

                                                     bool* aResult) {

  CHECK_AO;

  *aResult = m_table[a][o].bitEnabled;

  return NS_OK;

inline nsresult nsMsgSearchValidityTable::GetValidButNotShown(int a, int o,

                                                              bool* aResult) {

  CHECK_AO;

  *aResult = m_table[a][o].bitValidButNotShown;

  return NS_OK;

#undef CHECK_AO

class nsMsgSearchValidityManager : public nsIMsgSearchValidityManager {

 public:

  nsMsgSearchValidityManager();

 protected:

  virtual ~nsMsgSearchValidityManager();

 public:

  NS_DECL_NSIMSGSEARCHVALIDITYMANAGER

  NS_DECL_ISUPPORTS

  nsresult GetTable(int, nsMsgSearchValidityTable**);

 protected:

  // There's one global validity manager that everyone uses. You *could* do

  // this with static members of the adapter classes, but having a dedicated

  // object makes cleanup of these tables (at shutdown-time) automagic.

  nsCOMPtr<nsIMsgSearchValidityTable> m_offlineMailTable;

  nsCOMPtr<nsIMsgSearchValidityTable> m_offlineMailFilterTable;

  nsCOMPtr<nsIMsgSearchValidityTable> m_onlineMailTable;

  nsCOMPtr<nsIMsgSearchValidityTable> m_onlineMailFilterTable;

  nsCOMPtr<nsIMsgSearchValidityTable> m_onlineManualFilterTable;

  nsCOMPtr<nsIMsgSearchValidityTable> m_newsTable;  // online news

  // Local news tables, used for local news searching or offline.

  nsCOMPtr<nsIMsgSearchValidityTable> m_localNewsTable;      // base table

  nsCOMPtr<nsIMsgSearchValidityTable> m_localNewsJunkTable;  // base + junk

  nsCOMPtr<nsIMsgSearchValidityTable> m_localNewsBodyTable;  // base + body

  nsCOMPtr<nsIMsgSearchValidityTable>

      m_localNewsJunkBodyTable;  // base + junk + body

  nsCOMPtr<nsIMsgSearchValidityTable> m_ldapTable;

  nsCOMPtr<nsIMsgSearchValidityTable> m_ldapAndTable;

  nsCOMPtr<nsIMsgSearchValidityTable> m_localABTable;

  nsCOMPtr<nsIMsgSearchValidityTable> m_localABAndTable;

  nsCOMPtr<nsIMsgSearchValidityTable> m_newsFilterTable;

  nsresult NewTable(nsIMsgSearchValidityTable**);

  nsresult InitOfflineMailTable();

  nsresult InitOfflineMailFilterTable();

  nsresult InitOnlineMailTable();

  nsresult InitOnlineMailFilterTable();

  nsresult InitOnlineManualFilterTable();

  nsresult InitNewsTable();

  nsresult InitLocalNewsTable();

  nsresult InitLocalNewsJunkTable();

  nsresult InitLocalNewsBodyTable();

  nsresult InitLocalNewsJunkBodyTable();

  nsresult InitNewsFilterTable();

  // set the custom headers in the table, changes whenever

  // "mailnews.customHeaders" pref changes.

  nsresult SetOtherHeadersInTable(nsIMsgSearchValidityTable* table,

                                  const char* customHeaders);

  nsresult InitLdapTable();

  nsresult InitLdapAndTable();

  nsresult InitLocalABTable();

  nsresult InitLocalABAndTable();

  nsresult SetUpABTable(nsIMsgSearchValidityTable* aTable, bool isOrTable);

  nsresult EnableDirectoryAttribute(nsIMsgSearchValidityTable* table,

                                    nsMsgSearchAttribValue aSearchAttrib);

};

#endif

Revision control

Copy as Markdown

Other Tools