DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (2a29ee0adb31)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */

/**
 * @defgroup msgdb Mailnews message database
 * This module is the access point to locally-stored databases.
 *
 * These databases are stored in .msf files. Each file contains useful cached
 * information, like the message id or references, as well as the cc header or
 * tag information. This cached information is encapsulated in nsIMsgDBHdr.
 *
 * Also included is threading information, mostly encapsulated in nsIMsgThread.
 * The final component is the database folder info, which contains information
 * on the view and basic information also stored in the folder cache such as the
 * name or most recent update.
 *
 * What this module does not do is access individual messages. Access is
 * strictly controlled by the nsIMsgFolder objects and their backends.
 * @{
 */
#include "nsISupports.idl"
#include "nsIDBChangeAnnouncer.idl"

%{C++
#include "nsTArray.h"
%}

interface nsIMutableArray;
interface nsIMsgDatabase;
interface nsIMsgDBView;
interface nsIDBChangeListener;
interface nsIMsgDBHdr;
interface nsISimpleEnumerator;
interface nsIMsgThread;
interface nsIDBFolderInfo;
interface nsIMsgOfflineImapOperation;
interface nsIMsgFolder;
interface nsIMsgKeyArray;
interface nsIFile;
interface nsIArray;

typedef unsigned long nsMsgRetainByPreference;


[scriptable, uuid(fe8b7cec-eec8-4bcd-82ff-d8bb23cef3da)]

interface nsIMsgRetentionSettings : nsISupports
{
  const unsigned long nsMsgRetainAll = 1;
  const unsigned long nsMsgRetainByAge = 2;
  const unsigned long nsMsgRetainByNumHeaders = 3;

  attribute boolean useServerDefaults;
  attribute nsMsgRetainByPreference retainByPreference;
  attribute unsigned long daysToKeepHdrs;
  attribute unsigned long numHeadersToKeep;

  // this is for keeping offline bodies.
  attribute boolean cleanupBodiesByDays;
  attribute unsigned long daysToKeepBodies;

  /**
   * Should retention settings be applied to flagged/starred messages?
   * If false, flagged messages are never automatically deleted.
   */
  attribute boolean applyToFlaggedMessages;
};

[scriptable, uuid(86a9da90-14f1-11d5-a5c0-0060b0fc04b7)]
interface nsIMsgDownloadSettings : nsISupports
{
  attribute boolean useServerDefaults;
  attribute boolean downloadByDate;
  attribute boolean downloadUnreadOnly;
  attribute unsigned long ageLimitOfMsgsToDownload;
};

typedef long nsMsgDBCommit;

[scriptable, uuid(15431853-e448-45dc-8978-9958bf74d9b7)]

interface nsMsgDBCommitType
{
  const long kLargeCommit = 1;
  const long kSessionCommit = 2;
  const long kCompressCommit = 3;
};

[ref] native nsMsgKeyArrayRef(nsTArray<nsMsgKey>);
[ptr] native nsMsgKeyArrayPtr(nsTArray<nsMsgKey>);

/**
 * A service to open mail databases and manipulate listeners automatically.
 *
 * The contract ID for this component is
 * <tt>\@mozilla.org/msgDatabase/msgDBService;1</tt>.
 */
[scriptable, uuid(4cbbf024-3760-402d-89f3-6ababafeb07d)]
interface nsIMsgDBService : nsISupports
{
  /**
   * Opens a database for a given folder.
   *
   * This method is preferred over nsIMsgDBService::openMailDBFromFile if the
   * caller has an actual nsIMsgFolder around. If the database detects that it
   * is unreadable or out of date (using nsIMsgDatabase::outOfDate) it will
   * destroy itself and prepare to be rebuilt, unless aLeaveInvalidDB is true.
   *
   * If one gets a NS_MSG_ERROR_FOLDER_SUMMARY_MISSING message, then one
   * should call nsIMsgDBService::createNewDB to create the new database.
   *
   * @param aFolder         The folder whose database should be returned.
   * @param aLeaveInvalidDB Whether or not the database should be deleted if it
   *                        is invalid.
   * @return                A new nsIMsgDatabase object representing the folder
   *                        database that was opened.
   * @exception NS_ERROR_FILE_TARGET_DOES_NOT_EXIST
   *                        The file could not be created.
   * @exception NS_MSG_ERROR_FOLDER_SUMMARY_OUT_OF_DATE
   *                        The database is present (and was opened), but the
   *                        summary file is out of date.
   * @exception NS_MSG_ERROR_FOLDER_SUMMARY_MISSING
   *                        The database is present, but the summary file is
   *                        missing.
   * @see nsIMsgDatabase::Open
   * @see nsIMsgDBService::createNewDB
   */
  nsIMsgDatabase openFolderDB(in nsIMsgFolder aFolder,
                              in boolean aLeaveInvalidDB);

  /**
   * This is the same as a synchronous open in terms of params and errors.
   * But to finish opening the db, the caller must call
   * nsIMsgDBService::OpenMore repeatedly until the open is finished.
   * @see nsIMsgDBService::openFolderDB
   * @see nsIMsgDBService::openMore
   */
  nsIMsgDatabase asyncOpenFolderDB(in nsIMsgFolder aFolder,
                                   in boolean aLeaveInvalidDB);

  /**
   * Continues the open process for a db opened with
   * nsIMsgDBService::asyncOpenFolderDB. Returns true if the db is ready
   * to use, false if openMore needs to be called again.
   * This will throw the same kinds of exceptions as openFolderDB.
   * @param aTimeHint approximate number of milliseconds to spend
   *                  before returning. This is more of a floor than
                      a ceiling, since we can't guarantee that there
                      won't be one big chunk that we can't interrupt.
   * @return true if db is ready to use, false if openMore needs to
   *         be called again.
   * @see nsIMsgDBService::openFolderDB
   */
  boolean openMore(in nsIMsgDatabase aDB, in unsigned long aTimeHint);

  /**
   * Creates a new database for the given folder.
   *
   * If the database already exists, it will return the database, emit a
   * warning, but not fully initialize it. For this reason, it should only be
   * used when it is known that the database does not exist, such as when
   * nsIMsgDBService::openFolderDB throws an error.
   *
   * @see nsIMsgDBService::openFolderDB
   */
  nsIMsgDatabase createNewDB(in nsIMsgFolder aFolder);

  /**
   * Opens or creates a database for a given file.
   *
   * This method should only be used if the caller does not have a folder
   * instance, because the resulting db and message headers retrieved from the
   * database would not know their owning folder, which limits their usefulness.
   * For this reason, one should use nsIMsgDBService::openFolderDB instead
   * except under special circumstances.
   *
   * Unlike nsIMsgDBService::openFolderDB, there is no corresponding method to
   * create a new database if opening the database failed. However, this method
   * will never throw NS_MSG_ERROR_FOLDER_SUMMARY_MISSING, so no corresponding
   * method is needed.
   *
   * @param aFile           The file for which the database should be returned.
   * @param aFolder         Folder the db corresponds to (may be null)
   * @param aCreate         Whether or not the file should be created.
   * @param aLeaveInvalidDB Whether or not the database should be deleted if it
   *                        is invalid.
   * @return                A new nsIMsgDatabase object encapsulating the file
   *                        passed in.
   * @exception NS_ERROR_FILE_TARGET_DOES_NOT_EXIST
   *                        The file could not be created.
   * @see nsIMsgDBService::openFolderDB
   * @see nsIMsgDatabase::Open
   */
  nsIMsgDatabase openMailDBFromFile(in nsIFile aFile,
                                    in nsIMsgFolder aFolder,
                                    in boolean aCreate,
                                    in boolean aLeaveInvalidDB);
  /**
   * Adds the given listener to the listener set for the folder.
   *
   * Since the message database will likely be opened and closed many times, by
   * registering using this method, one will be guaranteed to see all subsequent
   * modifications. This will also add the listener to the database if it is
   * already opened.
   *
   * @param aFolder         The folder to add a listener to.
   * @param aListener       The listener to add the folder to.
   */
  void registerPendingListener(in nsIMsgFolder aFolder,
                               in nsIDBChangeListener aListener);
  /**
   * Removes the listener from all folder listener sets.
   *
   * @param aListener       The listener to remove.
   * @exception NS_ERROR_FAILURE
   *                        The listener is not registered.
   */
  void unregisterPendingListener(in nsIDBChangeListener aListener);

  /**
   * Get the db for a folder, if already open.
   *
   * @param aFolder   The folder to get the cached (open) db for.
   *
   * @returns         null if the db isn't open, otherwise the db.
   */
  nsIMsgDatabase cachedDBForFolder(in nsIMsgFolder aFolder);

  /**
   * Close the db for a folder, if already open.
   *
   * @param aFolder   The folder to close the cached (open) db for.
   */
  void forceFolderDBClosed(in nsIMsgFolder aFolder);

  /// an enumerator to iterate over the open dbs.
  readonly attribute nsIArray openDBs;
};

[scriptable, uuid(b64e66f8-4717-423a-be42-482658fb2199)]
interface nsIMsgDatabase : nsIDBChangeAnnouncer {
  void Close(in boolean aForceCommit);

  void Commit(in nsMsgDBCommit commitType);
  // Force closed is evil, and we should see if we can do without it.
  // In 4.x, it was mainly used to remove corrupted databases.
  void ForceClosed();
  void clearCachedHdrs();
  void resetHdrCacheSize(in unsigned long size);

  readonly attribute nsIDBFolderInfo  dBFolderInfo;

  /// Size of the database file in bytes.
  readonly attribute long long databaseSize;

  /// Folder this db was opened on.
  readonly attribute nsIMsgFolder folder;

  /**
   * This is used when deciding which db's to close to free up memory
   * and other resources in an LRU manner. It doesn't track every operation
   * on every object from the db, but high level things like open, commit,
   * and perhaps some of the list methods. Commit should be a proxy for all
   * the mutation methods.
   *
   * I'm allowing clients to set the last use time as well, so that
   * nsIMsgFolder.msgDatabase can set the last use time.
   */
  attribute PRTime lastUseTime;

  // get a message header for the given key. Caller must release()!

  nsIMsgDBHdr GetMsgHdrForKey(in nsMsgKey key);
  nsIMsgDBHdr getMsgHdrForMessageID(in string messageID);

  /**
   * get a message header for a Gmail message with the given X-GM-MSGID.
   */
  nsIMsgDBHdr GetMsgHdrForGMMsgID(in string aGmailMessageID);
  //Returns whether or not this database contains the given key
  boolean ContainsKey(in nsMsgKey key);

/**
 * Must call AddNewHdrToDB after creating. The idea is that you create
 * a new header, fill in its properties, and then call AddNewHdrToDB.
 * AddNewHdrToDB will send notifications to any listeners.
 *
 * @param aKey msgKey for the new header. If aKey is nsMsgKey_None,
 *             we will auto-assign a new key.
 */
  nsIMsgDBHdr CreateNewHdr(in nsMsgKey aKey);

  void AddNewHdrToDB(in nsIMsgDBHdr newHdr, in boolean notify);

  nsIMsgDBHdr CopyHdrFromExistingHdr(in nsMsgKey key, in nsIMsgDBHdr existingHdr, in boolean addHdrToDB);

  /**
   * Returns all message keys stored in the database.
   * Keys are returned in the order as stored in the database.
   * The caller should sort them if it needs to.
   */
  void ListAllKeys(in nsIMsgKeyArray array);

  nsISimpleEnumerator EnumerateMessages();
  nsISimpleEnumerator ReverseEnumerateMessages();
  nsISimpleEnumerator EnumerateThreads();

  /**
   * Get an enumerator for use with nextMatchingHdrs. The enumerator
   * will only return messages that match the passed-in search terms.
   *
   * @param     searchTerms       array of search terms to evaluate.
   * @param     reverse           start at the end, defaults to false.
   *
   * @returns   an enumerator for passing into nextMatchingHdrs
   */
  nsISimpleEnumerator getFilterEnumerator(in nsIArray searchTerms,
                                          [optional] in boolean reverse);

  /**
   * Get the next N matching headers using a filter enumerator
   * obtained by calling getFilterEnumerator.
   *
   * @param     enumerator -      This *must* be a filter enumerator
   * @param     numHdrsToLookAt   if non 0, the number of hdrs to advance the
   *                              enumerator before returning.
   * @param     maxResults        if non 0, the max results to return.
   * @param     matchingHdrs      if non null, array of matching hdrs.
   * @param     numMatches        if non null, the number of matching hdrs.
   *
   * @returns   false, if done, true if more hdrs to look at.
   */
  boolean nextMatchingHdrs(in nsISimpleEnumerator enumerator,
                           in long numHdrsToLookAt,
                           in long maxResults,
                           in nsIMutableArray matchingHdrs,
                           out long numMatches);


  // count the total and unread msgs, and adjust global count if needed
  void syncCounts();

  nsIMsgThread GetThreadContainingMsgHdr(in nsIMsgDBHdr msgHdr) ;

  // helpers for user command functions like delete, mark read, etc.

  void MarkHdrRead(in nsIMsgDBHdr msgHdr, in boolean bRead,
                         in nsIDBChangeListener instigator);

  void MarkHdrReplied(in nsIMsgDBHdr msgHdr, in boolean bReplied,
                         in nsIDBChangeListener instigator);

  void MarkHdrMarked(in nsIMsgDBHdr msgHdr, in boolean mark,
                         in nsIDBChangeListener instigator);
  /**
   * Remove the new status from a message.
   *
   * @param aMsgHdr        The database reference header for the message
   * @param aInstigator    Reference to original calling object
   */
  void MarkHdrNotNew(in nsIMsgDBHdr aMsgHdr,
                     in nsIDBChangeListener aInstigator);

  // MDN support
  void MarkMDNNeeded(in nsMsgKey key, in boolean bNeeded,
                           in nsIDBChangeListener instigator);

  // MarkMDNneeded only used when mail server is a POP3 server
  // or when the IMAP server does not support user defined
  // PERMANENTFLAGS
  boolean IsMDNNeeded(in nsMsgKey key);

  void MarkMDNSent(in nsMsgKey key, in boolean bNeeded,
                         in nsIDBChangeListener instigator);
  boolean IsMDNSent(in nsMsgKey key);

// methods to get and set docsets for ids.
  void MarkRead(in nsMsgKey key, in boolean bRead,
                      in nsIDBChangeListener instigator);

  void MarkReplied(in nsMsgKey key, in boolean bReplied,
                         in nsIDBChangeListener instigator);

  void MarkForwarded(in nsMsgKey key, in boolean bForwarded,
                           in nsIDBChangeListener instigator);

  void MarkHasAttachments(in nsMsgKey key, in boolean bHasAttachments,
                                in nsIDBChangeListener instigator);

  void MarkThreadRead(in nsIMsgThread thread, in nsIDBChangeListener instigator,
                      out unsigned long aCount,
                      [array, size_is(aCount)] out nsMsgKey aKeys);

  /// Mark the specified thread ignored.
  void MarkThreadIgnored(in nsIMsgThread thread, in nsMsgKey threadKey,
                         in boolean bIgnored,
                         in nsIDBChangeListener instigator);

  /// Mark the specified thread watched.
  void MarkThreadWatched(in nsIMsgThread thread, in nsMsgKey threadKey,
                         in boolean bWatched,
                         in nsIDBChangeListener instigator);

  /// Mark the specified subthread ignored.
  void MarkHeaderKilled(in nsIMsgDBHdr msg, in boolean bIgnored,
                        in nsIDBChangeListener instigator);

  /// Is the message read.
  boolean IsRead(in nsMsgKey key);
  /// Is the message part of an ignored thread.
  boolean IsIgnored(in nsMsgKey key);
  /// Is the message part of a watched thread.
  boolean IsWatched(in nsMsgKey key);
  /// Is the message flagged/starred.
  boolean IsMarked(in nsMsgKey key);
  /// Does the message have attachments.
  boolean HasAttachments(in nsMsgKey key);

  void MarkAllRead(out unsigned long aCount,
                   [array, size_is(aCount)] out nsMsgKey aKeys);

  void deleteMessages(in unsigned long aNumKeys,
                      [array, size_is(aNumKeys)] in nsMsgKey nsMsgKeys,
                      in nsIDBChangeListener instigator);
  void DeleteMessage(in nsMsgKey key,
                           in nsIDBChangeListener instigator,
                           in boolean commit);
  void DeleteHeader(in nsIMsgDBHdr msgHdr, in nsIDBChangeListener instigator,
                          in boolean commit, in boolean notify);

  // lower level routine that doesn't remove hdr from thread or adjust counts
  void RemoveHeaderMdbRow(in nsIMsgDBHdr msgHdr);

  void UndoDelete(in nsIMsgDBHdr msgHdr);

  void MarkMarked(in nsMsgKey key, in boolean mark,
                        in nsIDBChangeListener instigator);
  void MarkOffline(in nsMsgKey key, in boolean offline,
                         in nsIDBChangeListener instigator);
  void SetLabel(in nsMsgKey key, in nsMsgLabelValue label);
  void setStringProperty(in nsMsgKey aKey, in string aProperty, in string aValue);
  /**
   * Set the value of a string property in a message header
   *
   * @param msgHdr    Header of the message whose property will be changed
   * @param aProperty the property to change
   * @param aValue    new value for the property
   */
  void setStringPropertyByHdr(in nsIMsgDBHdr msgHdr, in string aProperty, in string aValue);

  /**
   * Set the value of a uint32 property in a message header.
   *
   * @param aMsgHdr   header of the message whose property will be changed
   * @param aProperty the property to change
   * @param aValue    new value for the property
   */
  void setUint32PropertyByHdr(in nsIMsgDBHdr aMsgHdr,
                              in string aProperty, in unsigned long aValue);

  void MarkImapDeleted(in nsMsgKey key, in boolean deleted,
                             in nsIDBChangeListener instigator);

  readonly attribute nsMsgKey FirstNew;

  attribute nsIMsgRetentionSettings msgRetentionSettings;
  // purge unwanted message headers and/or bodies. If deleteViaFolder is
  // true, we'll call nsIMsgFolder::DeleteMessages to delete the messages.
  // Otherwise, we'll just delete them from the db.
  void applyRetentionSettings(in nsIMsgRetentionSettings aMsgRetentionSettings,
                              in boolean aDeleteViaFolder);

  attribute nsIMsgDownloadSettings msgDownloadSettings;

  boolean HasNew();
  void ClearNewList(in boolean notify);
  void AddToNewList(in nsMsgKey key);

  // used mainly to force the timestamp of a local mail folder db to
  // match the time stamp of the corresponding berkeley mail folder,
  // but also useful to tell the summary to mark itself invalid
  // Also, if a local folder is being reparsed, summary will be invalid
  // until the reparsing is done.
  attribute boolean summaryValid;

  // offline operations - we could move these into an offline operation interface
  // but it would have to be in nsMailDatabase, since local folders can be move destinations
  nsIMsgOfflineImapOperation GetOfflineOpForKey(in nsMsgKey messageKey, in boolean create);
  void  RemoveOfflineOp(in nsIMsgOfflineImapOperation op);
  nsISimpleEnumerator EnumerateOfflineOps();
  [noscript] void ListAllOfflineOpIds(in nsMsgKeyArrayPtr offlineOpIds);
  [noscript] void ListAllOfflineDeletes(in nsMsgKeyArrayPtr offlineDeletes);
  void ListAllOfflineMsgs(in nsIMsgKeyArray aKeys);

  void setAttributeOnPendingHdr(in nsIMsgDBHdr pendingHdr, in string property,
                                  in string propertyVal);

  void setUint32AttributeOnPendingHdr(in nsIMsgDBHdr pendingHdr, in string property,
                                  in unsigned long propertyVal);

  /**
   * Sets a pending 64 bit attribute, which tells the DB that when a message
   * which looks like the pendingHdr (e.g., same message-id) is added to the
   * db, set the passed in property and value on the new header. This is
   * usually because we've copied an imap message to a different folder, and
   * want to carry forward attributes from the original message to the copy,
   * but don't have the message hdr for the copy yet so we can't set
   * attributes directly.
   *
   * @param aPendingHdr usually the source of the copy.
   * @param aProperty name of property to set.
   * @param aPropertyVal 64 bit value of property to set.
   */
  void setUint64AttributeOnPendingHdr(in nsIMsgDBHdr aPendingHdr,
                                      in string aProperty,
                                      in unsigned long long aPropertyVal);

  /**
   * Given a message header with its message-id set, update any pending
   *  attributes on the header.
   *
   * @param aNewHdr a new header that may have pending attributes.
   */
  void updatePendingAttributes(in nsIMsgDBHdr aNewHdr);

  readonly attribute nsMsgKey lowWaterArticleNum;
  readonly attribute nsMsgKey highWaterArticleNum;
  attribute nsMsgKey nextPseudoMsgKey;   //for undo-redo of move pop->imap
  readonly attribute nsMsgKey nextFakeOfflineMsgKey; // for saving "fake" offline msg hdrs
  // for sorting
  void createCollationKey(in AString sourceString, out unsigned long aCount,
                          [array, size_is(aCount)] out octet aKey);
  long compareCollationKeys(in unsigned long aLen1,
                            [array, size_is(aLen1)] in octet key1,
                            in unsigned long aLen2,
                            [array, size_is(aLen2)] in octet key2);

  // when creating a view, the default sort order and view flags
  // use these for the default.  (this allows news to override, so that
  // news can be threaded by default)
  readonly attribute nsMsgViewFlagsTypeValue defaultViewFlags;
  readonly attribute nsMsgViewSortTypeValue  defaultSortType;
  readonly attribute nsMsgViewSortOrderValue defaultSortOrder;

  // for msg hdr hash table allocation. controllable by caller to improve folder loading performance.
  attribute unsigned long msgHdrCacheSize;

  /**
   * The list of messages currently in the NEW state.
   *
   * If there are no such messages, a null pointer may be returned.
   * the caller should free when done using free.
   */
  void getNewList(out unsigned long count, [array, size_is(count)] out nsMsgKey newKeys);

  // These are used for caching search hits in a db, to speed up saved search folders.
  nsISimpleEnumerator getCachedHits(in string aSearchFolderUri);
  void refreshCache(in string aSearchFolderUri, in unsigned long aNumKeys, [array, size_is (aNumKeys)] in nsMsgKey aNewHits,
     out unsigned long aNumBadHits, [array, size_is(aNumBadHits)] out nsMsgKey aStaleHits);
  void updateHdrInCache(in string aSearchFolderUri, in nsIMsgDBHdr aHdr, in boolean aAdd);
  boolean hdrIsInCache(in string aSearchFolderUri, in nsIMsgDBHdr aHdr);

};
/** @} */