source: cpp/frams/mhandlers/mhandlers.h @ 373

// This file is a part of Framsticks SDK.  http://www.framsticks.com/
// Copyright (C) 1999-2015  Maciej Komosinski and Szymon Ulatowski.
// See LICENSE.txt for details.

#ifndef _MHANDLERS_H_
#define _MHANDLERS_H_

#include <frams/util/list.h>
#include <frams/util/sstring.h>
#include <common/hmessage.h>
#include <common/threads.h>

class MessageHandlerBase;

class MessageHandlerManager
{
        friend class MessageHandlerBase;
        SListTempl<MessageHandlerBase*> handlers;
        void send(int level, const char *o, const char *m, const char *bl, int w);
public:
        int find(MessageHandlerBase *r) { return handlers.find(r); }
        int add(MessageHandlerBase *r);
        void remove(int i);
        void remove(MessageHandlerBase *r);
        void removeAll();
        void send(const char *o, const char *m, const char *bl, int w)
        {
                send(handlers.size() - 1, o, m, bl, w);
        }
        ~MessageHandlerManager() { removeAll(); }
};

extern THREAD_LOCAL_DECL(MessageHandlerManager, message_handler_manager_instance);

////////////////////////////////////////

class MessageHandlerBase
{
        friend class MessageHandlerManager;
protected:
        MessageHandlerManager* manager;
        int options;

public:

        enum HandlerOptions
        {
                DontBlock = 1, CannotBeBlocked = 2, Enable = 4, Paused = 8
        };

        void Hprintf(const char *o, const char *m, int w, const char *bl, ...);
        void send(const char *o, const char *m, const char *bl, int w);

        bool isEnabled() { return manager ? true : false; }
        void enable();
        void disable();
        bool isPaused() { return (options & Paused) != 0; }
        void pause();
        void resume();

        MessageHandlerBase(int opts = 0) :manager(NULL), options(opts)
        {
                if (options&Enable) enable();
        }
        virtual ~MessageHandlerBase()
        {
                disable();
        }

        virtual void handle(const char *o, const char *m, const char *bl, int w) {}
};

///////////////////////////////////////////

class MessageHandlerToMemory : public MessageHandlerBase
{
protected:
        int maxlevel, minleveltostore, errcount, warncount, storedcount, infocount;
        SString msgs;

public:

        void reset() { maxlevel = HMLV_INFO - 1; errcount = warncount = storedcount = infocount = 0; msgs = 0; }

        enum Options2
        {
                StoreFirstMessage = 16, StoreAllMessages = 32
        };

        int getErrorCount()       { return errcount; }
        int getWarningCount()     { return warncount; }
        int getInfoCount()        { return infocount; }
        int getStoredCount()      { return storedcount; }
        int getErrorLevel()       { return maxlevel; }
        const SString& getMessages() { return msgs; }

        MessageHandlerToMemory(int opts = 0, int minimal_level_to_store = HMLV_ERROR) :MessageHandlerBase(opts), minleveltostore(minimal_level_to_store)
        {
                reset();
        }

        void handle(const char *o, const char *m, const char *bl, int w);
};

class RedirectingMessageHandler : public MessageHandlerBase
{
        MessageHandlerManager *other_manager;
public:
        RedirectingMessageHandler(MessageHandlerManager *other_mgr,int opts=0)
                :MessageHandlerBase(opts), other_manager(other_mgr) {}

        void handle(const char *o, const char *m, const char *bl, int w)
        {
                other_manager->send(o, m, bl, w);
        }
};

#endif