event.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2018-2020 Sadie Powell <[email protected]>
 *   Copyright (C) 2015, 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
 
namespace Events
{
        class ModuleEventListener;
        class ModuleEventProvider;
}
 
class Events::ModuleEventProvider : public ServiceProvider, private dynamic_reference_base::CaptureHook
{
 public:
        struct Comp
        {
                bool operator()(ModuleEventListener* lhs, ModuleEventListener* rhs) const;
        };
 
        struct ElementComp
        {
                bool operator()(ModuleEventListener* lhs, ModuleEventListener* rhs) const;
        };
 
        typedef insp::flat_multiset<ModuleEventListener*, Comp, ElementComp> SubscriberList;
 
        ModuleEventProvider(Module* mod, const std::string& eventid)
                : ServiceProvider(mod, eventid, SERVICE_DATA)
                , prov(mod, eventid)
        {
                prov.SetCaptureHook(this);
        }
 
        const SubscriberList& GetSubscribers() const { return prov->subscribers; }
 
        void Subscribe(ModuleEventListener* subscriber)
        {
                subscribers.insert(subscriber);
                OnSubscribe(subscriber);
        }
 
        void Unsubscribe(ModuleEventListener* subscriber)
        {
                subscribers.erase(subscriber);
                OnUnsubscribe(subscriber);
        }
 
 private:
        void OnCapture() CXX11_OVERRIDE
        {
                // If someone else holds the list from now on, clear mine. See below for more info.
                if (*prov != this)
                        subscribers.clear();
        }
 
        virtual void OnSubscribe(ModuleEventListener* subscriber) { }
 
        virtual void OnUnsubscribe(ModuleEventListener* subscriber) { }
 
        dynamic_reference_nocheck<ModuleEventProvider> prov;
 
        SubscriberList subscribers;
};
 
class Events::ModuleEventListener : private dynamic_reference_base::CaptureHook
{
        dynamic_reference_nocheck<ModuleEventProvider> prov;
 
        const unsigned int eventpriority;
 
        void OnCapture() CXX11_OVERRIDE
        {
                prov->Subscribe(this);
        }
 
 public:
        static const unsigned int DefaultPriority = 100;
 
        ModuleEventListener(Module* mod, const std::string& eventid, unsigned int eventprio = DefaultPriority)
                : prov(mod, eventid)
                , eventpriority(eventprio)
        {
                prov.SetCaptureHook(this);
                // If the dynamic_reference resolved at construction our capture handler wasn't called
                if (prov)
                        ModuleEventListener::OnCapture();
        }
 
        ~ModuleEventListener()
        {
                if (prov)
                        prov->Unsubscribe(this);
        }
 
        const Module* GetModule() const { return prov.creator; }
 
        unsigned int GetPriority() const { return eventpriority; }
};
 
inline bool Events::ModuleEventProvider::Comp::operator()(Events::ModuleEventListener* lhs, Events::ModuleEventListener* rhs) const
{
        return (lhs->GetPriority() < rhs->GetPriority());
}
 
inline bool Events::ModuleEventProvider::ElementComp::operator()(Events::ModuleEventListener* lhs, Events::ModuleEventListener* rhs) const
{
        if (lhs->GetPriority() < rhs->GetPriority())
                return true;
        if (lhs->GetPriority() > rhs->GetPriority())
                return false;
        return std::less<ModuleEventListener*>()(lhs, rhs);
}
 
#define FOREACH_MOD_CUSTOM(prov, listenerclass, func, params) do { \
        const ::Events::ModuleEventProvider::SubscriberList& _handlers = (prov).GetSubscribers(); \
        for (::Events::ModuleEventProvider::SubscriberList::const_iterator _i = _handlers.begin(); _i != _handlers.end(); ++_i) \
        { \
                listenerclass* _t = static_cast<listenerclass*>(*_i); \
                const Module* _m = _t->GetModule(); \
                if (_m && !_m->dying) \
                        _t->func params ; \
        } \
} while (0);
 
#define FIRST_MOD_RESULT_CUSTOM(prov, listenerclass, func, result, params) do { \
        result = MOD_RES_PASSTHRU; \
        const ::Events::ModuleEventProvider::SubscriberList& _handlers = (prov).GetSubscribers(); \
        for (::Events::ModuleEventProvider::SubscriberList::const_iterator _i = _handlers.begin(); _i != _handlers.end(); ++_i) \
        { \
                listenerclass* _t = static_cast<listenerclass*>(*_i); \
                const Module* _m = _t->GetModule(); \
                if (!_m || _m->dying) \
                        continue; \
                result = _t->func params ; \
                if (result != MOD_RES_PASSTHRU) \
                        break; \
        } \
} while (0);