Changeset 372 for cpp/frams/mhandlers


Ignore:
Timestamp:
04/22/15 04:14:59 (10 years ago)
Author:
sz
Message:

Renamed some classes and functions to make their purpose more obvious:

All MessageHandlers? must now be given the explicit "Enable" argument if you want them to automatically become active. This makes side effects clearly visible.

Location:
cpp/frams/mhandlers
Files:
4 deleted
1 edited
4 copied
1 moved

Legend:

Unmodified
Added
Removed

  • cpp/frams/mhandlers/mhandlers.cpp

    r371 r372  
    33// See LICENSE.txt for details.
    44
    5 #include "errmanager.h"
     5#include "mhandlers.h"
    66#include <common/stl-util.h>
    77
    8 void _FramMessageSingleLine(const char *o, const char *m, const char *txt, int w)
     8void _HmessageSingleLine(const char *o, const char *m, const char *txt, int w)
    99{
    10         tlsGetRef(errmgr_instance).send(o, m, txt, w);
     10        tlsGetRef(message_handler_manager_instance).send(o, m, txt, w);
    1111}
    1212
    13 THREAD_LOCAL_DEF(ErrorManager, errmgr_instance);
     13THREAD_LOCAL_DEF(MessageHandlerManager, message_handler_manager_instance);
    1414
    15 void ErrorManager::send(int level, const char *o, const char *m, const char *bl, int w)
     15void MessageHandlerManager::send(int level, const char *o, const char *m, const char *bl, int w)
    1616{
    1717        if (level >= handlers.size()) level = handlers.size() - 1;
    … …  
    1919        for (int i = level; i >= 0; i--)
    2020        {
    21                 ErrorHandlerBase *r = handlers(i);
    22                 if ((!(r->options & ErrorHandlerBase::Paused)) &&
    23                         ((!blocked) || (r->options & ErrorHandlerBase::CannotBeBlocked)))
     21                MessageHandlerBase *r = handlers(i);
     22                if ((!(r->options & MessageHandlerBase::Paused)) &&
     23                        ((!blocked) || (r->options & MessageHandlerBase::CannotBeBlocked)))
    2424                {
    2525                        r->handle(o, m, bl, w);
    26                         if (!(r->options & ErrorHandlerBase::DontBlock)) blocked = 1;
     26                        if (!(r->options & MessageHandlerBase::DontBlock)) blocked = 1;
    2727                }
    2828        }
    2929}
    3030
    31 int ErrorManager::add(ErrorHandlerBase *h)
     31int MessageHandlerManager::add(MessageHandlerBase *h)
    3232{
    3333        h->mgr = this;
    … …  
    3636}
    3737
    38 void ErrorManager::remove(int i)
     38void MessageHandlerManager::remove(int i)
    3939{
    40         ErrorHandlerBase *h = handlers(i);
     40        MessageHandlerBase *h = handlers(i);
    4141        h->mgr = 0;
    4242        handlers.remove(i);
    4343}
    4444
    45 void ErrorManager::remove(ErrorHandlerBase *h)
     45void MessageHandlerManager::remove(MessageHandlerBase *h)
    4646{
    4747        int i;
    … …  
    5050}
    5151
    52 void ErrorManager::removeAll()
     52void MessageHandlerManager::removeAll()
    5353{
    5454        while (handlers.size() > 0)
    … …  
    5858//////////////////////////////////
    5959
    60 void ErrorHandlerBase::send(const char *o, const char *m, const char *bl, int w)
     60void MessageHandlerBase::send(const char *o, const char *m, const char *bl, int w)
    6161{
    6262        if (!isEnabled()) return;
    … …  
    6565}
    6666
    67 void ErrorHandlerBase::FMprintf(const char *o, const char *m, int w, const char *bl, ...)
     67void MessageHandlerBase::Hprintf(const char *o, const char *m, int w, const char *bl, ...)
    6868{
    6969        if (!isEnabled()) return;
    … …  
    7777
    7878
    79 void ErrorHandlerBase::enable()
     79void MessageHandlerBase::enable()
    8080{
    8181        if (isEnabled()) return;
    82         tlsGetRef(errmgr_instance).add(this);
     82        tlsGetRef(message_handler_manager_instance).add(this);
    8383}
    8484
    85 void ErrorHandlerBase::disable()
     85void MessageHandlerBase::disable()
    8686{
    8787        if (!isEnabled()) return;
    88         tlsGetRef(errmgr_instance).remove(this);
     88        tlsGetRef(message_handler_manager_instance).remove(this);
    8989}
    9090
    91 void ErrorHandlerBase::pause()
     91void MessageHandlerBase::pause()
    9292{
    9393        if (isPaused()) return;
    … …  
    9595}
    9696
    97 void ErrorHandlerBase::resume()
     97void MessageHandlerBase::resume()
    9898{
    9999        if (!isPaused()) return;
    … …  
    103103/////////////////////////////////
    104104
    105 void ErrorHandler::handle(const char *o, const char *m, const char *bl, int w)
     105void MessageHandlerToMemory::handle(const char *o, const char *m, const char *bl, int w)
    106106{
    107107        if (w > maxlevel) maxlevel = w;
    108         if (w >= FMLV_INFO) infocount++;
    109         if (w >= FMLV_WARN) warncount++;
    110         if (w >= FMLV_ERROR) errcount++;
     108        if (w >= HMLV_INFO) infocount++;
     109        if (w >= HMLV_WARN) warncount++;
     110        if (w >= HMLV_ERROR) errcount++;
    111111
    112112        if (w >= storlevel)

  • cpp/frams/mhandlers/mhandlers.h

    r371 r372  
    33// See LICENSE.txt for details.
    44
    5 #ifndef _ERRMANAGER_H_
    6 #define _ERRMANAGER_H_
     5#ifndef _MHANDLERS_H_
     6#define _MHANDLERS_H_
    77
    88#include <frams/util/list.h>
    99#include <frams/util/sstring.h>
    10 #include <common/framsg.h>
     10#include <common/hmessage.h>
    1111#include <common/threads.h>
    1212
    13 class ErrorHandlerBase;
     13class MessageHandlerBase;
    1414
    15 class ErrorManager
     15class MessageHandlerManager
    1616{
    17         friend class ErrorHandlerBase;
    18         SListTempl<ErrorHandlerBase*> handlers;
     17        friend class MessageHandlerBase;
     18        SListTempl<MessageHandlerBase*> handlers;
    1919        void send(int level, const char *o, const char *m, const char *bl, int w);
    2020public:
    21         int find(ErrorHandlerBase *r) { return handlers.find(r); }
    22         int add(ErrorHandlerBase *r);
     21        int find(MessageHandlerBase *r) { return handlers.find(r); }
     22        int add(MessageHandlerBase *r);
    2323        void remove(int i);
    24         void remove(ErrorHandlerBase *r);
     24        void remove(MessageHandlerBase *r);
    2525        void removeAll();
    2626        void send(const char *o, const char *m, const char *bl, int w)
    … …  
    2828                send(handlers.size() - 1, o, m, bl, w);
    2929        }
    30         ~ErrorManager() { removeAll(); }
     30        ~MessageHandlerManager() { removeAll(); }
    3131};
    3232
    33 extern THREAD_LOCAL_DECL(ErrorManager, errmgr_instance);
     33extern THREAD_LOCAL_DECL(MessageHandlerManager, message_handler_manager_instance);
    3434
    3535////////////////////////////////////////
    3636
    37 class ErrorHandlerBase
     37class MessageHandlerBase
    3838{
    39         friend class ErrorManager;
     39        friend class MessageHandlerManager;
    4040protected:
    41         ErrorManager* mgr;
     41        MessageHandlerManager* mgr;
    4242        int options;
    4343
    … …  
    4646        enum HandlerOptions
    4747        {
    48                 DontBlock = 1, CannotBeBlocked = 2, DontEnable = 4, Paused = 8
     48                DontBlock = 1, CannotBeBlocked = 2, Enable = 4, Paused = 8
    4949        };
    5050
    51         void FMprintf(const char *o, const char *m, int w, const char *bl, ...);
     51        void Hprintf(const char *o, const char *m, int w, const char *bl, ...);
    5252        void send(const char *o, const char *m, const char *bl, int w);
    5353
    … …  
    5959        void resume();
    6060
    61         ErrorHandlerBase(int opts = 0) :mgr(0), options(opts)
     61        MessageHandlerBase(int opts = 0) :mgr(0), options(opts)
    6262        {
    63                 if (!(options&DontEnable)) enable();
     63                if (options&Enable) enable();
    6464        }
    65         virtual ~ErrorHandlerBase()
     65        virtual ~MessageHandlerBase()
    6666        {
    6767                disable();
    … …  
    7373///////////////////////////////////////////
    7474
    75 class ErrorHandler : public ErrorHandlerBase
     75class MessageHandlerToMemory : public MessageHandlerBase
    7676{
    7777protected:
    … …  
    8181public:
    8282
    83         void reset() { maxlevel = FMLV_INFO - 1; errcount = warncount = storcount = infocount = 0; msgs = 0; }
     83        void reset() { maxlevel = HMLV_INFO - 1; errcount = warncount = storcount = infocount = 0; msgs = 0; }
    8484
    8585        enum Options2
    … …  
    9595        const SString& getMessages() { return msgs; }
    9696
    97         ErrorHandler(int opts = 0, int store = FMLV_ERROR) :ErrorHandlerBase(opts), storlevel(store)
     97        MessageHandlerToMemory(int opts = 0, int minimal_level_to_store = HMLV_ERROR) :MessageHandlerBase(opts), storlevel(minimal_level_to_store)
    9898        {
    9999                reset();
    … …  
    103103};
    104104
    105 class ErrorRedirector : public ErrorHandlerBase
     105class RedirectingMessageHandler : public MessageHandlerBase
    106106{
    107         ErrorManager *other_mgr;
     107        MessageHandlerManager *other_mgr;
    108108public:
    109         ErrorRedirector(ErrorManager *om)
    110                 :ErrorHandlerBase(), other_mgr(om) {}
     109        RedirectingMessageHandler(MessageHandlerManager *om,int opts=0)
     110                :MessageHandlerBase(opts), other_mgr(om) {}
    111111
    112112        void handle(const char *o, const char *m, const char *bl, int w)

  • cpp/frams/mhandlers/stderrors.cpp

    r348 r372  
    55#include "stderrors.h"
    66#include <frams/util/sstringutils.h>
    7 #include <common/framsg.h>
     7#include <common/hmessage.h>
    88
    99bool listIndexCheck(SList* list,int index,const char* msgobj,const char* msgfun)
    … …  
    1313        {
    1414        if (size>0)
    15                 FMprintf(msgobj,msgfun,FMLV_ERROR,"Invalid index %d (allowed range is 0..%d)",index,size-1);
     15                Hprintf(msgobj,msgfun,HMLV_ERROR,"Invalid index %d (allowed range is 0..%d)",index,size-1);
    1616        else
    17                 FMprintf(msgobj,msgfun,FMLV_ERROR,"Invalid index %d (this list is empty)",index);
     17                Hprintf(msgobj,msgfun,HMLV_ERROR,"Invalid index %d (this list is empty)",index);
    1818        return 0;
    1919        }
    … …  
    2929        {
    3030        SString msg2=SString(msg)+": \"%s\" (adjusted to \"%s\")";
    31         FMprintf(msgobj,msgfun,FMLV_WARN,msg2.c_str(),in.c_str(),corrected.c_str());
     31        Hprintf(msgobj,msgfun,HMLV_WARN,msg2.c_str(),in.c_str(),corrected.c_str());
    3232        }
    3333return corrected;

  • cpp/frams/mhandlers/stdouthandler.cpp

    r371 r372  
    33// See LICENSE.txt for details.
    44
    5 #include "stdouterr.h"
     5#include "stdouthandler.h"
    66#ifdef SHP
    77#include <FBaseSys.h> //AppLog
    … …  
    1010#endif
    1111
    12 void StdoutErrorHandler::handle(const char *o, const char *m, const char *bl, int w)
     12void MessageHandlerToStdout::handle(const char *o, const char *m, const char *bl, int w)
    1313{
    1414        if (w < -1) w = -1; else if (w>3) w = 3;
    1515#ifdef SHP
    16         AppLog(FRAMSG_FORMAT "\n",MSG_LEVEL[w+1],o,m,bl);
     16        AppLog(HMSG_FORMAT "\n",HMSG_LEVEL[w+1],o,m,bl);
    1717#else
    1818        if (file)
    19                 file->printf(FRAMSG_FORMAT "\n", MSG_LEVEL[w + 1], o, m, bl);
     19                file->printf(HMSG_FORMAT "\n", HMSG_LEVEL[w + 1], o, m, bl);
    2020        else
    21                 printf(FRAMSG_FORMAT "\n", MSG_LEVEL[w + 1], o, m, bl);
     21                printf(HMSG_FORMAT "\n", HMSG_LEVEL[w + 1], o, m, bl);
    2222#endif
    2323}

  • cpp/frams/mhandlers/stdouthandler.h

    r371 r372  
    33// See LICENSE.txt for details.
    44
    5 #ifndef _STDOUTERRORHANDLER_H_
    6 #define _STDOUTERRORHANDLER_H_
     5#ifndef _STDOUTHANDLER_H_
     6#define _STDOUTHANDLER_H_
    77
    8 #include "errmanager.h"
     8#include "mhandlers.h"
    99#include <frams/virtfile/virtfile.h>
    1010
    11 class StdoutErrorHandler : public ErrorHandlerBase
     11class MessageHandlerToStdout : public MessageHandlerBase
    1212{
    1313        VirtFILE *file;
    1414public:
    15         StdoutErrorHandler(int opts = DontBlock, VirtFILE *_file = NULL) :ErrorHandlerBase(opts), file(_file) {}
     15        MessageHandlerToStdout(int opts = 0, VirtFILE *_file = NULL) :MessageHandlerBase(opts), file(_file) {}
    1616        void handle(const char *o, const char *m, const char *bl, int w);
    1717};
Note: See TracChangeset for help on using the changeset viewer.