channels.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2013-2016, 2018 Attila Molnar <[email protected]>
 *   Copyright (C) 2012-2013, 2017-2020 Sadie Powell <[email protected]>
 *   Copyright (C) 2012 Robby <[email protected]>
 *   Copyright (C) 2009 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2007-2008 Robin Burchell <[email protected].net>
 *   Copyright (C) 2007, 2009 Dennis Friis <[email protected]>
 *   Copyright (C) 2003-2006, 2008, 2010 Craig Edwards <[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
 
#include "membership.h"
#include "mode.h"
#include "parammode.h"
 
class CoreExport Channel : public Extensible
{
 public:
        typedef std::map<User*, insp::aligned_storage<Membership> > MemberMap;
 
 private:
        void SetDefaultModes();
 
        std::bitset<ModeParser::MODEID_MAX> modes;
 
        void DelUser(const MemberMap::iterator& membiter);
 
 public:
        Channel(const std::string &name, time_t ts);
 
        void CheckDestroy();
 
        std::string name;
 
        time_t age;
 
        MemberMap userlist;
 
        std::string topic;
 
        time_t topicset;
 
        std::string setby; /* 128 */
 
        void SetMode(ModeHandler* mode, bool value);
 
        bool IsModeSet(ModeHandler* mode) { return ((mode->GetId() != ModeParser::MODEID_MAX) && (modes[mode->GetId()])); }
        bool IsModeSet(ModeHandler& mode) { return IsModeSet(&mode); }
        bool IsModeSet(ChanModeReference& mode);
 
        std::string GetModeParameter(ModeHandler* mode);
        std::string GetModeParameter(ChanModeReference& mode);
        std::string GetModeParameter(ParamModeBase* pm);
 
        void SetTopic(User* user, const std::string& topic, time_t topicts, const std::string* setter = NULL);
 
        size_t GetUserCounter() const { return userlist.size(); }
 
        Membership* AddUser(User* user);
 
        void DelUser(User* user);
 
        const MemberMap& GetUsers() const { return userlist; }
 
        bool HasUser(User* user);
 
        Membership* GetUser(User* user);
 
        void KickUser(User* src, const MemberMap::iterator& victimiter, const std::string& reason);
 
        void KickUser(User* src, User* user, const std::string& reason)
        {
                MemberMap::iterator it = userlist.find(user);
                if (it != userlist.end())
                        KickUser(src, it, reason);
        }
 
        bool PartUser(User* user, std::string& reason);
 
        static Channel* JoinUser(LocalUser* user, std::string channame, bool override = false, const std::string& key = "");
 
        Membership* ForceJoin(User* user, const std::string* privs = NULL, bool bursting = false, bool created_by_local = false);
 
        void Write(ClientProtocol::Event& protoev, char status = 0, const CUList& except_list = CUList());
 
        void Write(ClientProtocol::EventProvider& protoevprov, ClientProtocol::Message& msg, char status = 0, const CUList& except_list = CUList());
 
        const char* ChanModes(bool showsecret);
 
        unsigned int GetPrefixValue(User* user);
 
        bool IsBanned(User* user);
 
        bool CheckBan(User* user, const std::string& banmask);
 
        ModResult GetExtBanStatus(User *u, char type);
 
        void WriteNotice(const std::string& text, char status = 0);
        void WriteRemoteNotice(const std::string& text, char status = 0);
};
 
inline bool Channel::HasUser(User* user)
{
        return (userlist.find(user) != userlist.end());
}
 
inline std::string Channel::GetModeParameter(ChanModeReference& mode)
{
        if (!mode)
                return "";
        return GetModeParameter(*mode);
}
 
inline std::string Channel::GetModeParameter(ModeHandler* mh)
{
        std::string out;
        ParamModeBase* pm = mh->IsParameterMode();
        if (pm && this->IsModeSet(pm))
                pm->GetParameter(this, out);
        return out;
}
 
inline std::string Channel::GetModeParameter(ParamModeBase* pm)
{
        std::string out;
        if (this->IsModeSet(pm))
                pm->GetParameter(this, out);
        return out;
}
 
inline bool Channel::IsModeSet(ChanModeReference& mode)
{
        if (!mode)
                return false;
        return IsModeSet(*mode);
}