smtp_message.hpp

Go to the documentation of this file.

 
#ifndef JOIN_SERVICES_SMTP_MESSAGE_HPP
#define JOIN_SERVICES_SMTP_MESSAGE_HPP
 
// libjoin.
#include <join/version.hpp>
#include <join/error.hpp>
 
// C++.
#include <iostream>
#include <vector>
 
namespace join
{
    class SmtpSender
    {
    public:
        SmtpSender () = default;
 
        SmtpSender (const std::string& address);
 
        SmtpSender (const std::string& address, const std::string& name);
 
        SmtpSender (const SmtpSender& other);
 
        SmtpSender& operator= (const SmtpSender& other);
 
        SmtpSender (SmtpSender&& other);
 
        SmtpSender& operator= (SmtpSender&& other);
 
        virtual ~SmtpSender () = default;
 
        void address (const std::string& addr);
 
        const std::string& address () const;
 
        void realName (const std::string& name);
 
        const std::string& realName () const;
 
        bool empty () const;
 
    protected:
        std::string _address;
 
        std::string _name;
    };
 
    std::ostream& operator<< (std::ostream& out, const SmtpSender& sender);
 
    class SmtpRecipient : public SmtpSender
    {
    public:
        enum Type
        {
            Recipient,    
            CCRecipient,  
            BCCRecipient, 
        };
 
        SmtpRecipient () = default;
 
        SmtpRecipient (const std::string& address, Type t = Recipient);
 
        SmtpRecipient (const std::string& address, const std::string& name, Type t = Recipient);
 
        SmtpRecipient (const SmtpRecipient& other);
 
        SmtpRecipient& operator= (const SmtpRecipient& other);
 
        SmtpRecipient (SmtpRecipient&& other);
 
        SmtpRecipient& operator= (SmtpRecipient&& other);
 
        virtual ~SmtpRecipient () = default;
 
        void type (Type t);
 
        Type type () const;
 
    protected:
        Type _type = Recipient;
    };
 
    using SmtpRecipients = std::vector<SmtpRecipient>;
 
    class SmtpMessage
    {
    public:
        SmtpMessage () = default;
 
        SmtpMessage (const SmtpMessage& other);
 
        SmtpMessage& operator= (const SmtpMessage& other);
 
        SmtpMessage (SmtpMessage&& other);
 
        SmtpMessage& operator= (SmtpMessage&& other);
 
        virtual ~SmtpMessage () = default;
 
        void sender (const SmtpSender& from);
 
        const SmtpSender& sender () const;
 
        void addRecipient (const SmtpRecipient& to);
 
        void addRecipient (SmtpRecipient&& to);
 
        const SmtpRecipients& recipients () const;
 
        void subject (const std::string& subj);
 
        const std::string& subject () const;
 
        void content (const std::string& message);
 
        const std::string& content () const;
 
        int writeHeaders (std::ostream& out) const;
 
        int writeContent (std::ostream& out) const;
 
    protected:
        SmtpSender _sender;
 
        SmtpRecipients _recipients;
 
        std::string _subject;
 
        std::string _content;
    };
}
 
#endif