imapinfo.h

#ifndef _IMAPINFO_H
#define _IMAPINFO_H
/**********************************************************************
 *
 *   imapinfo.h  - IMAP4rev1 SELECT / EXAMINE handler
 *   Copyright (C) 2000 Sven Carstens <s.carstens@gmx.de>
 *
 *   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
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *   Send comments and bug fixes to
 *
 *********************************************************************/
 
#include <tqstringlist.h>
#include <tqstring.h>
 
//class handling the info we get on EXAMINE and SELECT
class imapInfo
{
public:
 
 
  enum MessageAttribute
  {
    Seen = 1 << 0,
    Answered = 1 << 1,
    Flagged = 1 << 2,
    Deleted = 1 << 3,
    Draft = 1 << 4,
    Recent = 1 << 5,
    User = 1 << 6,
    // non standard flags
    Forwarded = 1 << 7,
    Todo = 1 << 8,
    Watched = 1 << 9,
    Ignored = 1 << 10
  };
 
 
    imapInfo ();
    imapInfo (const TQStringList &);
    imapInfo (const imapInfo &);
    imapInfo & operator = (const imapInfo &);
 
  static ulong _flags (const TQCString &);
 
  void setCount (ulong l)
  {
    countAvailable_ = true;
    count_ = l;
  }
 
  void setRecent (ulong l)
  {
    recentAvailable_ = true;
    recent_ = l;
  }
 
  void setUnseen (ulong l)
  {
    unseenAvailable_ = true;
    unseen_ = l;
  }
 
  void setUidValidity (ulong l)
  {
    uidValidityAvailable_ = true;
    uidValidity_ = l;
  }
 
  void setUidNext (ulong l)
  {
    uidNextAvailable_ = true;
    uidNext_ = l;
  }
 
  void setFlags (ulong l)
  {
    flagsAvailable_ = true;
    flags_ = l;
  }
 
  void setFlags (const TQCString & inFlag)
  {
    flagsAvailable_ = true;
    flags_ = _flags (inFlag);
  }
 
  void setPermanentFlags (ulong l)
  {
    permanentFlagsAvailable_ = true;
    permanentFlags_ = l;
  }
 
  void setPermanentFlags (const TQCString & inFlag)
  {
    permanentFlagsAvailable_ = true;
    permanentFlags_ = _flags (inFlag);
  }
 
  void setReadWrite (bool b)
  {
    readWriteAvailable_ = true;
    readWrite_ = b;
  }
 
  void setAlert( const char* cstr )
  {
    alert_ = cstr;
  }
 
  ulong count () const
  {
    return count_;
  }
 
  ulong recent () const
  {
    return recent_;
  }
 
  ulong unseen () const
  {
    return unseen_;
  }
 
  ulong uidValidity () const
  {
    return uidValidity_;
  }
 
  ulong uidNext () const
  {
    return uidNext_;
  }
 
  ulong flags () const
  {
    return flags_;
  }
 
  ulong permanentFlags () const
  {
    return permanentFlags_;
  }
 
  bool readWrite () const
  {
    return readWrite_;
  }
 
  ulong countAvailable () const
  {
    return countAvailable_;
  }
 
  ulong recentAvailable () const
  {
    return recentAvailable_;
  }
 
  ulong unseenAvailable () const
  {
    return unseenAvailable_;
  }
 
  ulong uidValidityAvailable () const
  {
    return uidValidityAvailable_;
  }
 
  ulong uidNextAvailable () const
  {
    return uidNextAvailable_;
  }
 
  ulong flagsAvailable () const
  {
    return flagsAvailable_;
  }
 
  ulong permanentFlagsAvailable () const
  {
    return permanentFlagsAvailable_;
  }
 
  bool readWriteAvailable () const
  {
    return readWriteAvailable_;
  }
 
  TQCString alert() const
  {
    return alert_;
  }
 
private:
 
  TQCString alert_;
 
  ulong count_;
  ulong recent_;
  ulong unseen_;
  ulong uidValidity_;
  ulong uidNext_;
  ulong flags_;
  ulong permanentFlags_;
  bool readWrite_;
 
  bool countAvailable_;
  bool recentAvailable_;
  bool unseenAvailable_;
  bool uidValidityAvailable_;
  bool uidNextAvailable_;
  bool flagsAvailable_;
  bool permanentFlagsAvailable_;
  bool readWriteAvailable_;
};
 
#endif