message.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2017-2018, 2020 Sadie Powell <[email protected]>
 *   Copyright (C) 2017-2018 Attila Molnar <[email protected]>
 *
 * This file is part of InspIRCd.  InspIRCd 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, version 2.
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */
 
 
#pragma once
 
enum MessageType
{
        MSG_PRIVMSG,
 
        MSG_NOTICE
};
 
class CoreExport MessageDetails
{
 public:
        bool echo;
 
        /* Whether to send the original message back to clients with echo-message support. */
        bool echo_original;
 
        bool update_idle;
 
        CUList exemptions;
 
        /* The original message as sent by the user. */
        const std::string original_text;
 
        const ClientProtocol::TagMap tags_in;
 
        ClientProtocol::TagMap tags_out;
 
        std::string text;
 
        MessageType type;
 
        virtual bool IsCTCP(std::string& name, std::string& body) const = 0;
 
        virtual bool IsCTCP(std::string& name) const = 0;
 
        virtual bool IsCTCP() const = 0;
 
 protected:
        MessageDetails(MessageType mt, const std::string& msg, const ClientProtocol::TagMap& tags)
                : echo(true)
                , echo_original(false)
                , update_idle(true)
                , original_text(msg)
                , tags_in(tags)
                , text(msg)
                , type(mt)
        {
        }
};
 
class CoreExport MessageTarget
{
 public:
        enum TargetType
        {
                TYPE_USER,
 
                TYPE_CHANNEL,
 
                TYPE_SERVER
        };
 
 private:
        void* dest;
 
 public:
        char status;
 
        MessageTarget::TargetType type;
 
        MessageTarget(Channel* channel, char statuschar)
                : dest(channel)
                , status(statuschar)
                , type(TYPE_CHANNEL)
        {
        }
 
        MessageTarget(User* user)
                : dest(user)
                , status(0)
                , type(TYPE_USER)
        {
        }
 
        MessageTarget(std::string* server)
                : dest(server)
                , status(0)
                , type(TYPE_SERVER)
        {
        }
 
        template<typename T>
        T* Get() const
        {
                return static_cast<T*>(dest);
        }
 
        const std::string& GetName() const
        {
                switch (type)
                {
                        case TYPE_CHANNEL:
                                return Get<Channel>()->name;
                        case TYPE_USER:
                                return Get<User>()->nick;
                        case TYPE_SERVER:
                                return *Get<std::string>();
                }
 
                // We should never reach this point during a normal execution but
                // handle it just in case.
                static const std::string target = "*";
                return target;
        }
};