From 80ad529d5a33b6ece71bd27107b4b30540447497 Mon Sep 17 00:00:00 2001 From: Vincent Richard Date: Thu, 25 Nov 2021 21:23:50 +0100 Subject: [PATCH] #268 Code style fixes + moved specific bits to IMAP namespace --- src/vmime/dateTime.cpp | 8 - src/vmime/dateTime.hpp | 2 - src/vmime/net/folder.hpp | 31 -- src/vmime/net/imap/IMAPCommand.hpp | 2 +- src/vmime/net/imap/IMAPFolder.cpp | 9 +- src/vmime/net/imap/IMAPFolder.hpp | 31 +- src/vmime/net/imap/IMAPSearchAttributes.cpp | 574 ++++++++++++++++++++ src/vmime/net/imap/IMAPSearchAttributes.hpp | 150 +++++ src/vmime/net/imap/IMAPUtils.cpp | 29 +- src/vmime/net/imap/IMAPUtils.hpp | 7 + src/vmime/net/maildir/maildirFolder.cpp | 14 - src/vmime/net/maildir/maildirFolder.hpp | 10 - src/vmime/net/pop3/POP3Folder.cpp | 15 - src/vmime/net/pop3/POP3Folder.hpp | 10 - src/vmime/net/searchAttributes.cpp | 440 --------------- src/vmime/net/searchAttributes.hpp | 139 ----- 16 files changed, 787 insertions(+), 684 deletions(-) create mode 100644 src/vmime/net/imap/IMAPSearchAttributes.cpp create mode 100644 src/vmime/net/imap/IMAPSearchAttributes.hpp delete mode 100644 src/vmime/net/searchAttributes.cpp delete mode 100644 src/vmime/net/searchAttributes.hpp diff --git a/src/vmime/dateTime.cpp b/src/vmime/dateTime.cpp index 1caa2641..84a5ba3f 100644 --- a/src/vmime/dateTime.cpp +++ b/src/vmime/dateTime.cpp @@ -775,14 +775,6 @@ void datetime::getDate(int& year, int& month, int& day) const { } -string datetime::getDate() const { - - std::ostringstream date; - date << m_day << "-" << monthNames[m_month - 1] << "-" << m_year; - return date.str(); -} - - void datetime::setTime( const int hour, const int minute, diff --git a/src/vmime/dateTime.hpp b/src/vmime/dateTime.hpp index 311e60c1..64e8dad4 100644 --- a/src/vmime/dateTime.hpp +++ b/src/vmime/dateTime.hpp @@ -216,8 +216,6 @@ class VMIME_EXPORT datetime : public headerFieldValue { void getTime(int& hour, int& minute, int& second) const; void getDate(int& year, int& month, int& day) const; - string getDate() const; - // Set void setYear(const int year); void setMonth(const int month); diff --git a/src/vmime/net/folder.hpp b/src/vmime/net/folder.hpp index 8eaf49c1..4d5cf6ef 100644 --- a/src/vmime/net/folder.hpp +++ b/src/vmime/net/folder.hpp @@ -43,7 +43,6 @@ #include "vmime/net/folderStatus.hpp" #include "vmime/net/fetchAttributes.hpp" #include "vmime/net/folderAttributes.hpp" -#include "vmime/net/searchAttributes.hpp" #include "vmime/utility/path.hpp" #include "vmime/utility/stream.hpp" @@ -407,36 +406,6 @@ class VMIME_EXPORT folder : public object, public enable_shared_from_this getMessageNumbersStartingOnUID(const message::uid& uid) = 0; - /** Return the sequence numbers of messages matching the searchAttributes. - * - * @param sa the searchAttributes containing search tokens to match messages to - * @param charset optional charset name, the string tokens are assumed to be encoded - * in the provided encoding OR need to be in US-ASCII if no charset is provided - * @throw exceptions::net_exception if an error occurs - * - * Quirks: some servers will not accept any encoding other than US-ASCII, - * other servers will accept UTF-8 but will fail utf-8 - */ - virtual std::vector getMessageNumbersMatchingSearchAttributes( - const searchAttributes& sa, - const vmime::charset* charset = nullptr - ) = 0; - - /** Return the UIDs of messages matching the searchAttributes. - * - * @param sa the searchAttributes containing search tokens to match messages to - * @param charset optional charset name, the string tokens are assumed to be encoded - * in the provided encoding OR need to be in US-ASCII if no charset is provided - * @throw exceptions::net_exception if an error occurs - * - * Quirks: some servers will not accept any encoding other than US-ASCII, - * other servers will accept UTF-8 but will fail utf-8 - */ - virtual std::vector getMessageUIDsMatchingSearchAttributes( - const searchAttributes& sa, - const vmime::charset* charset = nullptr - ) = 0; - // Event listeners void addMessageChangedListener(events::messageChangedListener* l); void removeMessageChangedListener(events::messageChangedListener* l); diff --git a/src/vmime/net/imap/IMAPCommand.hpp b/src/vmime/net/imap/IMAPCommand.hpp index a04e9ff5..9801ff8d 100644 --- a/src/vmime/net/imap/IMAPCommand.hpp +++ b/src/vmime/net/imap/IMAPCommand.hpp @@ -66,7 +66,7 @@ class VMIME_EXPORT IMAPCommand : public object, public enable_shared_from_this < static shared_ptr APPEND(const string& mailboxName, const std::vector & flags, vmime::datetime* date, const size_t size); static shared_ptr COPY(const messageSet& msgs, const string& mailboxName); static shared_ptr SEARCH(const std::vector & keys, const vmime::charset* charset); - static shared_ptr UIDSEARCH(const std::vector & keys, const vmime::charset* charset); + static shared_ptr UIDSEARCH(const std::vector & keys, const vmime::charset* charset); static shared_ptr STARTTLS(); static shared_ptr CAPABILITY(); static shared_ptr NOOP(); diff --git a/src/vmime/net/imap/IMAPFolder.cpp b/src/vmime/net/imap/IMAPFolder.cpp index bc3e907f..34da36d7 100644 --- a/src/vmime/net/imap/IMAPFolder.cpp +++ b/src/vmime/net/imap/IMAPFolder.cpp @@ -1501,8 +1501,9 @@ std::vector IMAPFolder::getMessageNumbersStartingOnUID(const message::u return seqNumbers; } + std::vector IMAPFolder::getMessageNumbersMatchingSearchAttributes( - const searchAttributes& sa, + const IMAPSearchAttributes& sa, const vmime::charset* charset ) { @@ -1548,8 +1549,9 @@ std::vector IMAPFolder::getMessageNumbersMatchingSearchAttributes( return seqNumbers; } + std::vector IMAPFolder::getMessageUIDsMatchingSearchAttributes( - const searchAttributes& sa, + const IMAPSearchAttributes& sa, const vmime::charset* charset ) { @@ -1593,7 +1595,8 @@ std::vector IMAPFolder::getMessageUIDsMatchingSearchAttributes( processStatusUpdate(resp.get()); return uidNumbers; - } +} + void IMAPFolder::processStatusUpdate(const IMAPParser::response* resp) { diff --git a/src/vmime/net/imap/IMAPFolder.hpp b/src/vmime/net/imap/IMAPFolder.hpp index a3319eac..ef547193 100644 --- a/src/vmime/net/imap/IMAPFolder.hpp +++ b/src/vmime/net/imap/IMAPFolder.hpp @@ -39,6 +39,7 @@ #include "vmime/net/folder.hpp" #include "vmime/net/imap/IMAPParser.hpp" +#include "vmime/net/imap/IMAPSearchAttributes.hpp" namespace vmime { @@ -94,16 +95,36 @@ class VMIME_EXPORT IMAPFolder : public folder { std::vector > getMessages(const messageSet& msgs); std::vector getMessageNumbersStartingOnUID(const message::uid& uid); - + + /** Return the sequence numbers of messages matching the searchAttributes. + * + * @param sa the searchAttributes containing search tokens to match messages to + * @param charset optional charset name, the string tokens are assumed to be encoded + * in the provided encoding OR need to be in US-ASCII if no charset is provided + * @throw exceptions::net_exception if an error occurs + * + * Quirks: some servers will not accept any encoding other than US-ASCII, + * other servers will accept UTF-8 but will fail utf-8 + */ std::vector getMessageNumbersMatchingSearchAttributes( - const searchAttributes& sa, + const IMAPSearchAttributes& sa, const vmime::charset* charset = nullptr - ) override; + ); + /** Return the UIDs of messages matching the searchAttributes. + * + * @param sa the searchAttributes containing search tokens to match messages to + * @param charset optional charset name, the string tokens are assumed to be encoded + * in the provided encoding OR need to be in US-ASCII if no charset is provided + * @throw exceptions::net_exception if an error occurs + * + * Quirks: some servers will not accept any encoding other than US-ASCII, + * other servers will accept UTF-8 but will fail utf-8 + */ std::vector getMessageUIDsMatchingSearchAttributes( - const searchAttributes& sa, + const IMAPSearchAttributes& sa, const vmime::charset* charset = nullptr - ) override; + ); size_t getMessageCount(); diff --git a/src/vmime/net/imap/IMAPSearchAttributes.cpp b/src/vmime/net/imap/IMAPSearchAttributes.cpp new file mode 100644 index 00000000..7675f3e1 --- /dev/null +++ b/src/vmime/net/imap/IMAPSearchAttributes.cpp @@ -0,0 +1,574 @@ +#include "vmime/net/imap/IMAPSearchAttributes.hpp" + +#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP + + +#include "vmime/net/imap/IMAPUtils.hpp" + + +namespace vmime { +namespace net { +namespace imap { + +namespace helpers { + + +class keylessToken : public IMAPSearchToken { + +public: + + keylessToken(const char* token) + : IMAPSearchToken(token) { + } + + void generate(std::ostringstream& out) const { + + out << m_token; + } +}; + + +template +class typedSearchToken : public IMAPSearchToken { + +public: + + typedSearchToken(const char* token, const TYPE& keyword) + : IMAPSearchToken(token) + , m_keyword(keyword) { + + } + + typedSearchToken(const char* token, const TYPE&& keyword) + : IMAPSearchToken(token) + , m_keyword(std::move(keyword)) { + + } + +protected: + + TYPE m_keyword; +}; + + +// Represents a string search token with the search string quoted +class stringToken : public typedSearchToken { + +public: + + stringToken(const char* token, const string& keyword) + : typedSearchToken(token, keyword) { + + } + + void generate(std::ostringstream& out) const override { + + out << m_token << " \"" << m_keyword << "\""; + }; +}; + + +class headerToken : public typedSearchToken { + +public: + + headerToken(const char* token, const char* header) + : typedSearchToken(token, header) { + + } + + headerToken(const char* token, const char* header, const string& headerKeyword) + : typedSearchToken(token, header) + , m_headerKeyword(headerKeyword) { + + } + + void generate(std::ostringstream& out) const override { + + out << m_token << " " << m_keyword << " \"" << m_headerKeyword << "\""; + }; + +protected: + + string m_headerKeyword; +}; + + +class dateToken : public typedSearchToken { + +public: + + dateToken(const char* token, const vmime::datetime& date) + : typedSearchToken(token, date) { + + } + + // RFC claims that we need to disregard time information + void generate(std::ostringstream& out) const override { + + out << m_token << " " << IMAPUtils::searchDate(m_keyword); + }; +}; + + +class numberToken : public typedSearchToken< int > { + +public: + + numberToken(const char* token, uint32_t keyword) + : typedSearchToken(token, keyword) { + + } + + void generate(std::ostringstream& out) const override { + + out << m_token << " " << m_keyword; + }; +}; + + +class flagToken : public typedSearchToken { + +public: + + flagToken(const char* token, vmime::net::message::Flags keyword) + : typedSearchToken(token, keyword) { + + } + + void generate(std::ostringstream& out) const override { + + out << m_token << " "; + + switch (m_keyword) { + case vmime::net::message::Flags::FLAG_SEEN: out << "Seen"; break; + case vmime::net::message::Flags::FLAG_REPLIED: out << "Answered"; break; + case vmime::net::message::Flags::FLAG_MARKED: out << "Flagged"; break; + case vmime::net::message::Flags::FLAG_DRAFT: out << "Draft"; break; + case vmime::net::message::Flags::FLAG_DELETED: out << "Deleted"; break; + default: throw exceptions::operation_not_supported(); + } + }; +}; + + +class tokenMessageSetEnumerator : public messageSetEnumerator { + +public: + + tokenMessageSetEnumerator() + : m_first(true) { + + m_oss.imbue(std::locale::classic()); + } + + void enumerateNumberMessageRange(const vmime::net::numberMessageRange& range) { + + if (!m_first) { + m_oss << ","; + } + + if (range.getFirst() == range.getLast()) { + m_oss << range.getFirst(); + } else if (range.getLast() == size_t(-1)) { + m_oss << range.getFirst() << ":*"; + } else { + m_oss << range.getFirst() << ":" << range.getLast(); + } + + m_first = false; + } + + void enumerateUIDMessageRange(const vmime::net::UIDMessageRange& range) { + + if (!m_first) { + m_oss << ","; + } + + if (range.getFirst() == range.getLast()) { + m_oss << range.getFirst(); + } else if (range.getLast() == size_t(-1)) { + m_oss << range.getFirst() << ":*"; + } else { + m_oss << range.getFirst() << ":" << range.getLast(); + } + + m_first = false; + } + + const std::string str() const { + + return m_oss.str(); + } + +private: + + std::ostringstream m_oss; + bool m_first; +}; + + +class messageSetToken : public typedSearchToken { + +public: + + messageSetToken(const char *token, const vmime::net::messageSet& keyword) + : typedSearchToken(token, keyword) { + + } + + messageSetToken(const char *token, const vmime::net::messageSet&& keyword) + : typedSearchToken(token, std::move(keyword)) { + + } + + void generate(std::ostringstream& out) const override { + + if (*m_token) { + out << m_token << " ("; + } + else { + out << "("; + } + tokenMessageSetEnumerator enu; + m_keyword.enumerate(enu); + out << enu.str(); + out << ")"; + } +}; + + +// Contains a list of tokens which the server will interpret as AND +class tokenVectorToken : public typedSearchToken >> { + +public: + + tokenVectorToken(const char* token, const std::vector >& tokensAndKeywords) + : typedSearchToken(token, tokensAndKeywords) { + + if (0 == m_keyword.size()) { + throw exceptions::invalid_argument(); + } + } + + tokenVectorToken(const char* token, const std::vector >&& tokensAndKeywords) + : typedSearchToken(token, tokensAndKeywords) { + + if (0 == m_keyword.size()) { + throw exceptions::invalid_argument(); + } + } + + void generate(std::ostringstream& out) const override { + + out << m_token; + + if (*m_token) { + out << " ("; + } else { + out << "("; + } + + m_keyword[0]->generate(out); + + for (size_t i = 1; i < m_keyword.size(); i++) { + out << " "; + m_keyword[i]->generate(out); + } + + out << ")"; + }; +}; + + +// A pair of tokens, used with OR +class tokenPairToken : public typedSearchToken , vmime::shared_ptr >> { + +public: + + tokenPairToken(const char* token, const std::pair , vmime::shared_ptr >& pair) + : typedSearchToken(token, pair) { + + } + + void generate(std::ostringstream& out) const override { + + out << m_token << " "; + m_keyword.first->generate(out); + out << " "; + m_keyword.second->generate(out); + }; +}; + + +} // helpers + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::AND(const std::vector &&keywords) { + + return vmime::make_shared ("", std::move(keywords)); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::ANSWERED() { + + return vmime::make_shared ("ANSWERED"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::BCC(const string& keyword) { + + return vmime::make_shared ("BCC", keyword); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::BEFORE(const datetime& keyword) { + + return vmime::make_shared ("BEFORE", keyword); +} + +IMAPSearchTokenPtr IMAPSearchTokenFactory::BODY(const string& keyword) { + + return vmime::make_shared ("BODY", keyword); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::CC(const string& keyword) { + + return vmime::make_shared ("CC", keyword); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::DELETED() { + + return vmime::make_shared ("DELETED"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::DRAFT() { + + return vmime::make_shared ("DRAFT"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::FLAGGED() { + + return vmime::make_shared ("FLAGGED"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::FROM(const string& keyword) { + + return vmime::make_shared ("FROM", keyword); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::HEADER(const char* fieldName) { + + return vmime::make_shared ("HEADER", fieldName); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::HEADER(const char* fieldName, const string& fieldContents) { + + return vmime::make_shared ("HEADER", fieldName, fieldContents); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::KEYWORD(vmime::net::message::Flags flag) { + + return vmime::make_shared ("KEYWORD", flag); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::LARGER(uint32_t size) { + + return vmime::make_shared ("LARGER", size); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::MESSAGESET(const vmime::net::messageSet& set) { + + return vmime::make_shared ("", set); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::MESSAGESET(const vmime::net::messageSet&& set) { + + return vmime::make_shared ("", std::move(set)); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::NEW() { + + return vmime::make_shared ("NEW"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::NOT(const IMAPSearchTokenPtr& token) { + + return vmime::make_shared ("NOT", std::vector >({token})); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::OLD() { + + return vmime::make_shared ("OLD"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::ON(const datetime& date) { + + return vmime::make_shared ("ON", date); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::OR(const IMAPSearchTokenPtr& tokenA, const IMAPSearchTokenPtr& tokenB) { + + return vmime::make_shared ("OR", std::make_pair(tokenA, tokenB)); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::RECENT() { + + return vmime::make_shared ("RECENT"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::SEEN() { + + return vmime::make_shared ("SEEN"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::SENTBEFORE(const datetime& date) { + + return vmime::make_shared ("SENTBEFORE", date); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::SENTON(const datetime& date) { + + return vmime::make_shared ("SENTON", date); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::SENTSINCE(const datetime& date) { + + return vmime::make_shared ("SENTSINCE", date); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::SINCE(const datetime& date) { + + return vmime::make_shared ("SINCE", date); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::SMALLER(uint32_t size) { + + return vmime::make_shared ("SMALLER", size); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::SUBJECT(const string& keyword) { + + return vmime::make_shared ("SUBJECT", keyword); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::TEXT(const string& keyword) { + + return vmime::make_shared ("TEXT", keyword); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::TO(const string& keyword) { + + return vmime::make_shared ("TO", keyword); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::UID(const vmime::net::messageSet& set) { + + return vmime::make_shared ("UID", set); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::UID(const vmime::net::messageSet&& set) { + + return vmime::make_shared ("UID", std::move(set)); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::UNANSWERED() { + + return vmime::make_shared ("UNANSWERED"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::UNDELETED() { + + return vmime::make_shared ("UNDELETED"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::UNDRAFT() { + + return vmime::make_shared ("UNDRAFT"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::UNFLAGGED() { + + return vmime::make_shared ("UNFLAGGED"); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::UNKEYWORD(vmime::net::message::Flags flag) { + + return vmime::make_shared ("UNKEYWORD", flag); +} + + +IMAPSearchTokenPtr IMAPSearchTokenFactory::UNSEEN() { + + return vmime::make_shared ("UNSEEN"); +} + + +IMAPSearchAttributes::IMAPSearchAttributes(std::vector >&& tokens) + : m_andTokens(std::move(tokens)) { +} + + +void IMAPSearchAttributes::add(const vmime::shared_ptr & token) { + + m_andTokens.push_back(token); +} + + +std::vector IMAPSearchAttributes::generate() const { + + std::vector< string > keys; + + for (auto& token : m_andTokens) { + + std::ostringstream key; + key.imbue(std::locale::classic()); + + token->generate(key); + + keys.push_back(key.str()); + } + + return keys; +} + + +} // imap +} // net +} // vmime + + +#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP diff --git a/src/vmime/net/imap/IMAPSearchAttributes.hpp b/src/vmime/net/imap/IMAPSearchAttributes.hpp new file mode 100644 index 00000000..5e96f56c --- /dev/null +++ b/src/vmime/net/imap/IMAPSearchAttributes.hpp @@ -0,0 +1,150 @@ +// +// VMime library (http://www.vmime.org) +// Copyright (C) 2002 Vincent Richard +// +// 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 3 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. +// +// Linking this library statically or dynamically with other modules is making +// a combined work based on this library. Thus, the terms and conditions of +// the GNU General Public License cover the whole combination. +// + +#ifndef VMIME_NET_IMAP_IMAPSEARCHATTRIBUTES_HPP_INCLUDED +#define VMIME_NET_IMAP_IMAPSEARCHATTRIBUTES_HPP_INCLUDED + + +#include "vmime/config.hpp" + + +#if VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP + + +#include + +#include "vmime/types.hpp" +#include "vmime/utility/stringUtils.hpp" +#include "vmime/dateTime.hpp" +#include "vmime/net/message.hpp" +#include "vmime/net/messageSet.hpp" + + +namespace vmime { +namespace net { +namespace imap { + + +class IMAPSearchToken : public object { + +public: + + IMAPSearchToken(const char* token) + : m_token(token) { + + if (nullptr == m_token) { + throw exceptions::invalid_argument(); + } + } + + virtual void generate(std::ostringstream& out) const = 0; + +protected: + + const char* m_token; +}; + + +typedef vmime::shared_ptr IMAPSearchTokenPtr; + + +class IMAPSearchTokenFactory : public object { + +public: + + static IMAPSearchTokenPtr AND(const std::vector &); + static IMAPSearchTokenPtr AND(const std::vector &&); + static IMAPSearchTokenPtr ANSWERED(); + static IMAPSearchTokenPtr BCC(const string&); + static IMAPSearchTokenPtr BEFORE(const datetime&); + static IMAPSearchTokenPtr BODY(const string&); + static IMAPSearchTokenPtr CC(const string&); + static IMAPSearchTokenPtr DELETED(); + static IMAPSearchTokenPtr DRAFT(); + static IMAPSearchTokenPtr FLAGGED(); + static IMAPSearchTokenPtr FROM(const string&); + static IMAPSearchTokenPtr HEADER(const char* fieldName); + static IMAPSearchTokenPtr HEADER(const char* filedName, const string& fieldContents); + static IMAPSearchTokenPtr KEYWORD(vmime::net::message::Flags); + static IMAPSearchTokenPtr LARGER(uint32_t); + static IMAPSearchTokenPtr MESSAGESET(const vmime::net::messageSet&); + static IMAPSearchTokenPtr MESSAGESET(const vmime::net::messageSet&&); + static IMAPSearchTokenPtr NEW(); + static IMAPSearchTokenPtr NOT(const IMAPSearchTokenPtr&); + static IMAPSearchTokenPtr OLD(); + static IMAPSearchTokenPtr ON(const datetime&); + static IMAPSearchTokenPtr OR(const IMAPSearchTokenPtr&, const IMAPSearchTokenPtr&); + static IMAPSearchTokenPtr RECENT(); + static IMAPSearchTokenPtr SEEN(); + static IMAPSearchTokenPtr SENTBEFORE(const datetime&); + static IMAPSearchTokenPtr SENTON(const datetime&); + static IMAPSearchTokenPtr SENTSINCE(const datetime&); + static IMAPSearchTokenPtr SINCE(const datetime&); + static IMAPSearchTokenPtr SMALLER(uint32_t); + static IMAPSearchTokenPtr SUBJECT(const string&); + static IMAPSearchTokenPtr TEXT(const string&); + static IMAPSearchTokenPtr TO(const string&); + static IMAPSearchTokenPtr UID(const vmime::net::messageSet&); + static IMAPSearchTokenPtr UID(const vmime::net::messageSet&&); + static IMAPSearchTokenPtr UNANSWERED(); + static IMAPSearchTokenPtr UNDELETED(); + static IMAPSearchTokenPtr UNDRAFT(); + static IMAPSearchTokenPtr UNFLAGGED(); + static IMAPSearchTokenPtr UNKEYWORD(vmime::net::message::Flags); + static IMAPSearchTokenPtr UNSEEN(); +}; + + +/** Holds a set of attributes to match messages against when searching folder contents. + */ +class VMIME_EXPORT IMAPSearchAttributes : public object { + +public: + + IMAPSearchAttributes() = default; + IMAPSearchAttributes(std::vector >&&); + + /** Adds a new search token that will be used to match messages against. Multiple tokens are + * treated as an AND operation. + * + * @param token the search token to add + */ + void add(const vmime::shared_ptr & token); + + std::vector generate() const; + +protected: + + std::vector > m_andTokens; +}; + + +} // imap +} // net +} // vmime + + +#endif // VMIME_HAVE_MESSAGING_FEATURES && VMIME_HAVE_MESSAGING_PROTO_IMAP + + +#endif // VMIME_NET_IMAP_IMAPSEARCHATTRIBUTES_HPP_INCLUDED diff --git a/src/vmime/net/imap/IMAPUtils.cpp b/src/vmime/net/imap/IMAPUtils.cpp index 8c055356..80e84874 100644 --- a/src/vmime/net/imap/IMAPUtils.cpp +++ b/src/vmime/net/imap/IMAPUtils.cpp @@ -43,6 +43,12 @@ namespace net { namespace imap { +static const char* IMAP_MONTH_NAMES[12] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" +}; + + // static const string IMAPUtils::quoteString(const string& text) { @@ -545,6 +551,22 @@ const std::vector IMAPUtils::messageFlagList(const int flags) { } +// static +const string IMAPUtils::searchDate(const vmime::datetime& date) { + + std::ostringstream res; + res.imbue(std::locale::classic()); + + res << date.getDay(); + res << '-'; + res << IMAP_MONTH_NAMES[std::min(std::max(date.getMonth() - 1, 0), 11)]; + res << '-'; + res << date.getYear(); + + return res.str(); +} + + // static const string IMAPUtils::dateTime(const vmime::datetime& date) { @@ -567,12 +589,7 @@ const string IMAPUtils::dateTime(const vmime::datetime& date) { res << '-'; - static const char* monthNames[12] = { - "Jan", "Feb", "Mar", "Apr", "May", "Jun", - "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" - }; - - res << monthNames[std::min(std::max(date.getMonth() - 1, 0), 11)]; + res << IMAP_MONTH_NAMES[std::min(std::max(date.getMonth() - 1, 0), 11)]; res << '-'; diff --git a/src/vmime/net/imap/IMAPUtils.hpp b/src/vmime/net/imap/IMAPUtils.hpp index d4bd1356..e64b2683 100644 --- a/src/vmime/net/imap/IMAPUtils.hpp +++ b/src/vmime/net/imap/IMAPUtils.hpp @@ -85,6 +85,13 @@ class VMIME_EXPORT IMAPUtils static const std::vector messageFlagList(const int flags); + /** Format a date to IMAP SEARCH date format (eg. 25-Nov-2021). + * + * @param date date to format + * @return IMAP SEARCH-formatted date + */ + static const string searchDate(const vmime::datetime& date); + /** Format a date/time to IMAP date/time format. * * @param date date/time to format diff --git a/src/vmime/net/maildir/maildirFolder.cpp b/src/vmime/net/maildir/maildirFolder.cpp index ff256c48..44857679 100644 --- a/src/vmime/net/maildir/maildirFolder.cpp +++ b/src/vmime/net/maildir/maildirFolder.cpp @@ -1355,21 +1355,7 @@ std::vector maildirFolder::getMessageNumbersStartingOnUID(const message throw exceptions::operation_not_supported(); } -std::vector maildirFolder::getMessageNumbersMatchingSearchAttributes( - const searchAttributes&, - const vmime::charset* -) { - - throw exceptions::operation_not_supported(); -} -std::vector maildirFolder::getMessageUIDsMatchingSearchAttributes( - const searchAttributes&, - const vmime::charset* -) { - - throw exceptions::operation_not_supported(); -} } // maildir } // net diff --git a/src/vmime/net/maildir/maildirFolder.hpp b/src/vmime/net/maildir/maildirFolder.hpp index 3e611908..24f2bf86 100644 --- a/src/vmime/net/maildir/maildirFolder.hpp +++ b/src/vmime/net/maildir/maildirFolder.hpp @@ -147,16 +147,6 @@ class VMIME_EXPORT maildirFolder : public folder { std::vector getMessageNumbersStartingOnUID(const message::uid& uid); - std::vector getMessageNumbersMatchingSearchAttributes( - const searchAttributes& sa, - const vmime::charset* charset = nullptr - ) override; - - std::vector getMessageUIDsMatchingSearchAttributes( - const searchAttributes& sa, - const vmime::charset* charset = nullptr - ) override; - private: void scanFolder(); diff --git a/src/vmime/net/pop3/POP3Folder.cpp b/src/vmime/net/pop3/POP3Folder.cpp index ded2e09c..b69a483d 100644 --- a/src/vmime/net/pop3/POP3Folder.cpp +++ b/src/vmime/net/pop3/POP3Folder.cpp @@ -812,21 +812,6 @@ std::vector POP3Folder::getMessageNumbersStartingOnUID(const message::u throw exceptions::operation_not_supported(); } -std::vector POP3Folder::getMessageNumbersMatchingSearchAttributes( - const searchAttributes&, - const vmime::charset* -) { - - throw exceptions::operation_not_supported(); -} - -std::vector POP3Folder::getMessageUIDsMatchingSearchAttributes( - const searchAttributes&, - const vmime::charset* -) { - - throw exceptions::operation_not_supported(); -} } // pop3 } // net diff --git a/src/vmime/net/pop3/POP3Folder.hpp b/src/vmime/net/pop3/POP3Folder.hpp index 1aa4da87..73e29f99 100644 --- a/src/vmime/net/pop3/POP3Folder.hpp +++ b/src/vmime/net/pop3/POP3Folder.hpp @@ -144,16 +144,6 @@ class VMIME_EXPORT POP3Folder : public folder { std::vector getMessageNumbersStartingOnUID(const message::uid& uid); - std::vector getMessageNumbersMatchingSearchAttributes( - const searchAttributes& sa, - const vmime::charset* charset = nullptr - ) override; - - std::vector getMessageUIDsMatchingSearchAttributes( - const searchAttributes& sa, - const vmime::charset* charset = nullptr - ) override; - private: void registerMessage(POP3Message* msg); diff --git a/src/vmime/net/searchAttributes.cpp b/src/vmime/net/searchAttributes.cpp deleted file mode 100644 index 20639ae4..00000000 --- a/src/vmime/net/searchAttributes.cpp +++ /dev/null @@ -1,440 +0,0 @@ -#include "vmime/net/searchAttributes.hpp" - -#if VMIME_HAVE_MESSAGING_FEATURES - -namespace vmime { -namespace net { - -namespace helpers { - -class keylessToken : public searchToken { - -public: - keylessToken(const char* token) - : searchToken(token) { - } - - void generate(std::ostringstream& out) const { - out << m_token; - } -}; - -template < class TYPE > -class typedSearchToken : public searchToken { - -public: - typedSearchToken(const char* token, const TYPE& keyword) - : searchToken(token) - , m_keyword(keyword) { - } - - typedSearchToken(const char* token, const TYPE&& keyword) - : searchToken(token) - , m_keyword(std::move(keyword)) { - } - - -protected: - TYPE m_keyword; -}; - -// Represents a string search token with the search string quoted -class stringToken : public typedSearchToken< string > { - -public: - stringToken(const char* token, const string& keyword) - : typedSearchToken(token, keyword) { - } - - void generate(std::ostringstream& out) const override { - out << m_token << " \"" << m_keyword << "\""; - }; -}; - -class headerToken : public typedSearchToken< const char* > { - -public: - headerToken(const char* token, const char* header) - : typedSearchToken(token, header) { - } - - headerToken(const char* token, const char* header, const string& headerKeyword) - : typedSearchToken(token, header) - , m_headerKeyword(headerKeyword) { - } - - void generate(std::ostringstream& out) const override { - out << m_token << " " << m_keyword << " \"" << m_headerKeyword << "\""; - }; - -protected: - string m_headerKeyword; -}; - -class dateToken : public typedSearchToken< vmime::datetime > { - -public: - dateToken(const char* token, const vmime::datetime& date) - : typedSearchToken(token, date) { - } - - // RFC claims that we need to disregard time information - void generate(std::ostringstream& out) const override { - out << m_token << " " << m_keyword.getDate(); - }; -}; - -class numberToken : public typedSearchToken< int > { - -public: - numberToken(const char* token, uint32_t keyword) - : typedSearchToken(token, keyword) { - } - - void generate(std::ostringstream& out) const override { - out << m_token << " " << m_keyword; - }; -}; - -class flagToken : public typedSearchToken< vmime::net::message::Flags > { - -public: - flagToken(const char* token, vmime::net::message::Flags keyword) - : typedSearchToken(token, keyword) { - } - - void generate(std::ostringstream& out) const override { - out << m_token << " "; - switch (m_keyword) { - case vmime::net::message::Flags::FLAG_SEEN: out << "Seen"; break; - case vmime::net::message::Flags::FLAG_REPLIED: out << "Answered"; break; - case vmime::net::message::Flags::FLAG_MARKED: out << "Flagged"; break; - case vmime::net::message::Flags::FLAG_DRAFT: out << "Draft"; break; - case vmime::net::message::Flags::FLAG_DELETED: out << "Deleted"; break; - default: throw exceptions::operation_not_supported(); - } - }; -}; - -class tokenMessageSetEnumerator : public messageSetEnumerator { - -public: - - tokenMessageSetEnumerator() - : m_first(true) { - - m_oss.imbue(std::locale::classic()); - } - - void enumerateNumberMessageRange(const vmime::net::numberMessageRange& range) { - - if (!m_first) { - m_oss << ","; - } - - if (range.getFirst() == range.getLast()) { - m_oss << range.getFirst(); - } else if (range.getLast() == size_t(-1)) { - m_oss << range.getFirst() << ":*"; - } else { - m_oss << range.getFirst() << ":" << range.getLast(); - } - - m_first = false; - } - - void enumerateUIDMessageRange(const vmime::net::UIDMessageRange& range) { - - if (!m_first) { - m_oss << ","; - } - - if (range.getFirst() == range.getLast()) { - m_oss << range.getFirst(); - } else if (range.getLast() == size_t(-1)) { - m_oss << range.getFirst() << ":*"; - } else { - m_oss << range.getFirst() << ":" << range.getLast(); - } - - m_first = false; - } - - const std::string str() const { - - return m_oss.str(); - } - -private: - - std::ostringstream m_oss; - bool m_first; -}; - - -class messageSetToken : public typedSearchToken< vmime::net::messageSet > { - -public: - messageSetToken(const char *token, const vmime::net::messageSet& keyword) - : typedSearchToken(token, keyword) { - } - - messageSetToken(const char *token, const vmime::net::messageSet&& keyword) - : typedSearchToken(token, std::move(keyword)) { - } - - void generate(std::ostringstream& out) const override { - if (*m_token) { - out << m_token << " ("; - } - else { - out << "("; - } - tokenMessageSetEnumerator enu; - m_keyword.enumerate(enu); - out << enu.str(); - out << ")"; - } -}; - -// Contains a list of tokens which the server will interpret as AND -class tokenVectorToken : public typedSearchToken< std::vector< vmime::shared_ptr< const searchToken > > > { - -public: - tokenVectorToken(const char* token, const std::vector< vmime::shared_ptr< const searchToken > >& tokensAndKeywords) - : typedSearchToken(token, tokensAndKeywords) { - - if (0 == m_keyword.size()) { - throw exceptions::invalid_argument(); - } - } - - tokenVectorToken(const char* token, const std::vector< vmime::shared_ptr< const searchToken > >&& tokensAndKeywords) - : typedSearchToken(token, tokensAndKeywords) { - - if (0 == m_keyword.size()) { - throw exceptions::invalid_argument(); - } - } - - void generate(std::ostringstream& out) const override { - out << m_token; - if (*m_token) - out << " ("; - else - out << "("; - - m_keyword[0]->generate(out); - for (size_t i = 1; i < m_keyword.size(); i++) { - out << " "; - m_keyword[i]->generate(out); - } - - out << ")"; - }; -}; - -// A pair of tokens, used with OR -class tokenPairToken : public typedSearchToken< std::pair< vmime::shared_ptr< const searchToken >, vmime::shared_ptr< const searchToken > > > { - -public: - tokenPairToken(const char* token, const std::pair< vmime::shared_ptr< const searchToken >, vmime::shared_ptr< const searchToken > >& pair) - : typedSearchToken(token, pair) { - } - - void generate(std::ostringstream& out) const override { - out << m_token << " "; - m_keyword.first->generate(out); - out << " "; - m_keyword.second->generate(out); - }; -}; - -} // namespace helpers - -searchTokenPtr searchTokenFactory::AND(const std::vector< searchTokenPtr >&&keywords) { - return vmime::make_shared("", std::move(keywords)); -} - -searchTokenPtr searchTokenFactory::ANSWERED() { - return vmime::make_shared("ANSWERED"); -} - -searchTokenPtr searchTokenFactory::BCC(const string& keyword) { - return vmime::make_shared("BCC", keyword); -} - -searchTokenPtr searchTokenFactory::BEFORE(const datetime& keyword) { - return vmime::make_shared("BEFORE", keyword); -} - -searchTokenPtr searchTokenFactory::BODY(const string& keyword) { - return vmime::make_shared("BODY", keyword); -} - -searchTokenPtr searchTokenFactory::CC(const string& keyword) { - return vmime::make_shared("CC", keyword); -} - -searchTokenPtr searchTokenFactory::DELETED() { - return vmime::make_shared("DELETED"); -} - -searchTokenPtr searchTokenFactory::DRAFT() { - return vmime::make_shared("DRAFT"); -} - -searchTokenPtr searchTokenFactory::FLAGGED() { - return vmime::make_shared("FLAGGED"); -} - -searchTokenPtr searchTokenFactory::FROM(const string& keyword) { - return vmime::make_shared("FROM", keyword); -} - -searchTokenPtr searchTokenFactory::HEADER(const char* fieldName) { - return vmime::make_shared("HEADER", fieldName); -} - -searchTokenPtr searchTokenFactory::HEADER(const char* fieldName, const string& fieldContents) { - return vmime::make_shared("HEADER", fieldName, fieldContents); -} - -searchTokenPtr searchTokenFactory::KEYWORD(vmime::net::message::Flags flag) { - return vmime::make_shared("KEYWORD", flag); -} - -searchTokenPtr searchTokenFactory::LARGER(uint32_t size) { - return vmime::make_shared("LARGER", size); -} - -searchTokenPtr searchTokenFactory::MESSAGESET(const vmime::net::messageSet& set) { - return vmime::make_shared("", set); -} - -searchTokenPtr searchTokenFactory::MESSAGESET(const vmime::net::messageSet&& set) { - return vmime::make_shared("", std::move(set)); -} - -searchTokenPtr searchTokenFactory::NEW() { - return vmime::make_shared("NEW"); -} - -searchTokenPtr searchTokenFactory::NOT(const searchTokenPtr& token) { - return vmime::make_shared("NOT", std::vector< vmime::shared_ptr< const searchToken > >({token})); -} - -searchTokenPtr searchTokenFactory::OLD() { - return vmime::make_shared("OLD"); -} - -searchTokenPtr searchTokenFactory::ON(const datetime& date) { - return vmime::make_shared("ON", date); -} - -searchTokenPtr searchTokenFactory::OR(const searchTokenPtr& tokenA, const searchTokenPtr& tokenB) { - return vmime::make_shared("OR", std::make_pair(tokenA, tokenB)); -} - -searchTokenPtr searchTokenFactory::RECENT() { - return vmime::make_shared("RECENT"); -} - -searchTokenPtr searchTokenFactory::SEEN() { - return vmime::make_shared("SEEN"); -} - -searchTokenPtr searchTokenFactory::SENTBEFORE(const datetime& date) { - return vmime::make_shared("SENTBEFORE", date); -} - -searchTokenPtr searchTokenFactory::SENTON(const datetime& date) { - return vmime::make_shared("SENTON", date); -} - -searchTokenPtr searchTokenFactory::SENTSINCE(const datetime& date) { - return vmime::make_shared("SENTSINCE", date); -} - -searchTokenPtr searchTokenFactory::SINCE(const datetime& date) { - return vmime::make_shared("SINCE", date); -} - -searchTokenPtr searchTokenFactory::SMALLER(uint32_t size) { - return vmime::make_shared("SMALLER", size); -} - -searchTokenPtr searchTokenFactory::SUBJECT(const string& keyword) { - return vmime::make_shared("SUBJECT", keyword); -} - -searchTokenPtr searchTokenFactory::TEXT(const string& keyword) { - return vmime::make_shared("TEXT", keyword); -} - -searchTokenPtr searchTokenFactory::TO(const string& keyword) { - return vmime::make_shared("TO", keyword); -} - -searchTokenPtr searchTokenFactory::UID(const vmime::net::messageSet& set) { - return vmime::make_shared("UID", set); -} - -searchTokenPtr searchTokenFactory::UID(const vmime::net::messageSet&& set) { - return vmime::make_shared("UID", std::move(set)); -} - -searchTokenPtr searchTokenFactory::UNANSWERED() { - return vmime::make_shared("UNANSWERED"); -} - -searchTokenPtr searchTokenFactory::UNDELETED() { - return vmime::make_shared("UNDELETED"); -} - -searchTokenPtr searchTokenFactory::UNDRAFT() { - return vmime::make_shared("UNDRAFT"); -} - -searchTokenPtr searchTokenFactory::UNFLAGGED() { - return vmime::make_shared("UNFLAGGED"); -} - -searchTokenPtr searchTokenFactory::UNKEYWORD(vmime::net::message::Flags flag) { - return vmime::make_shared("UNKEYWORD", flag); -} - -searchTokenPtr searchTokenFactory::UNSEEN() { - return vmime::make_shared("UNSEEN"); -} - -searchAttributes::searchAttributes(std::vector< vmime::shared_ptr< const searchToken > >&& tokens) - : m_andTokens(std::move(tokens)) { -} - -void searchAttributes::add(const vmime::shared_ptr< const searchToken >& token) { - m_andTokens.push_back(token); -} - -std::vector< string > searchAttributes::generate() const { - - std::vector< string > keys; - - for (auto& token : m_andTokens) { - std::ostringstream key; - key.imbue(std::locale::classic()); - - token->generate(key); - - keys.push_back(key.str()); - } - - return keys; -} - - -} // net -} // vmime - - -#endif // VMIME_HAVE_MESSAGING_FEATURES diff --git a/src/vmime/net/searchAttributes.hpp b/src/vmime/net/searchAttributes.hpp deleted file mode 100644 index 4bd0b1c7..00000000 --- a/src/vmime/net/searchAttributes.hpp +++ /dev/null @@ -1,139 +0,0 @@ -// -// VMime library (http://www.vmime.org) -// Copyright (C) 2002 Vincent Richard -// -// 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 3 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. -// -// Linking this library statically or dynamically with other modules is making -// a combined work based on this library. Thus, the terms and conditions of -// the GNU General Public License cover the whole combination. -// - -#ifndef VMIME_NET_SEARCHATTRIBUTES_HPP_INCLUDED -#define VMIME_NET_SEARCHATTRIBUTES_HPP_INCLUDED - - -#include "vmime/config.hpp" - - -#if VMIME_HAVE_MESSAGING_FEATURES - - -#include - -#include "vmime/types.hpp" -#include "vmime/utility/stringUtils.hpp" -#include "vmime/dateTime.hpp" -#include "vmime/net/message.hpp" -#include "vmime/net/messageSet.hpp" - -namespace vmime { -namespace net { - -class searchToken : public object { - -public: - searchToken(const char* token) - : m_token(token) { - - if (nullptr == m_token) { - throw exceptions::invalid_argument(); - } - } - - virtual void generate(std::ostringstream& out) const = 0; - -protected: - const char* m_token; -}; - -typedef vmime::shared_ptr< const searchToken> searchTokenPtr; - -class searchTokenFactory : public object { - -public: - static searchTokenPtr AND(const std::vector< searchTokenPtr >&); - static searchTokenPtr AND(const std::vector< searchTokenPtr >&&); - static searchTokenPtr ANSWERED(); - static searchTokenPtr BCC(const string&); - static searchTokenPtr BEFORE(const datetime&); - static searchTokenPtr BODY(const string&); - static searchTokenPtr CC(const string&); - static searchTokenPtr DELETED(); - static searchTokenPtr DRAFT(); - static searchTokenPtr FLAGGED(); - static searchTokenPtr FROM(const string&); - static searchTokenPtr HEADER(const char* fieldName); - static searchTokenPtr HEADER(const char* filedName, const string& fieldContents); - static searchTokenPtr KEYWORD(vmime::net::message::Flags); - static searchTokenPtr LARGER(uint32_t); - static searchTokenPtr MESSAGESET(const vmime::net::messageSet&); - static searchTokenPtr MESSAGESET(const vmime::net::messageSet&&); - static searchTokenPtr NEW(); - static searchTokenPtr NOT(const searchTokenPtr&); - static searchTokenPtr OLD(); - static searchTokenPtr ON(const datetime&); - static searchTokenPtr OR(const searchTokenPtr&, const searchTokenPtr&); - static searchTokenPtr RECENT(); - static searchTokenPtr SEEN(); - static searchTokenPtr SENTBEFORE(const datetime&); - static searchTokenPtr SENTON(const datetime&); - static searchTokenPtr SENTSINCE(const datetime&); - static searchTokenPtr SINCE(const datetime&); - static searchTokenPtr SMALLER(uint32_t); - static searchTokenPtr SUBJECT(const string&); - static searchTokenPtr TEXT(const string&); - static searchTokenPtr TO(const string&); - static searchTokenPtr UID(const vmime::net::messageSet&); - static searchTokenPtr UID(const vmime::net::messageSet&&); - static searchTokenPtr UNANSWERED(); - static searchTokenPtr UNDELETED(); - static searchTokenPtr UNDRAFT(); - static searchTokenPtr UNFLAGGED(); - static searchTokenPtr UNKEYWORD(vmime::net::message::Flags); - static searchTokenPtr UNSEEN(); -}; - -/** Holds a set of attributes to match messages against when searching folder contents. - */ -class VMIME_EXPORT searchAttributes : public object { - -public: - searchAttributes() = default; - searchAttributes(std::vector< vmime::shared_ptr< const searchToken > >&&); - - /** Adds a new search token that will be used to match messages against. Multiple tokens are - * treated as an AND operation. - * - * @param token the search token to add - */ - void add(const vmime::shared_ptr< const searchToken >& token); - - std::vector< string > generate() const; - -protected: - - std::vector< vmime::shared_ptr< const searchToken > > m_andTokens; -}; - - -} // net -} // vmime - - -#endif // VMIME_HAVE_MESSAGING_FEATURES - - -#endif // VMIME_NET_SEARCHATTRIBUTES_HPP_INCLUDED