ResourcePoolEventObserver.hh

//********************************************************************
//*** ResourcePool/ResourcePoolEventObserver.hh
//*** Copyright (c) 2003-2009 by Markus Winand <mws@fatalmind.com>
//*** $Id: ResourcePoolEventObserver.hh,v 1.18 2009-03-14 13:43:43 mws Exp $
//********************************************************************
/*
This file is part of ResourcePool.

ResourcePool 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; either version 2 of 
the License, or (at your option) any later version.

ResourcePool 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 ResourcePool; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307  USA */

#ifndef RESOURCEPOOL_LOGINTERFACE_HH
#define RESOURCEPOOL_LOGINTERFACE_HH

#include <map>
#include <algorithm>
#include <sstream>
#include "util/Clone.hh"
#include "mm/gc_ptr.hh"
#include "ResourcePool/Command.hh"

namespace fatalmind {

class EventReader; // Fwd decl
class ResourcePoolEventObserver: public Clone {
    public:
        typedef unsigned int event_t;
        static const std::string NoResourceID;

        ResourcePoolEventObserver();

        virtual void event(event_t eventID,  const std::string& resourceID = NoResourceID, const std::string& message ="");

        bool isEvent(event_t eventID) {
            return ((logevents & eventID) != 0);
        }

        static struct Events {
            static const event_t INCREMENT_POOL;
            static const event_t DOWNSIZE_POOL;
            static const event_t FAIL_RESOURCE;
            static const event_t GET_RESOURCE_FAIL;
            static const event_t EXECUTE_NFE;
            static const event_t EXECUTE_FAIL;

            static const event_t TIME_HIRES;

            static const event_t FAIL;
            static const event_t ALL;
            static const event_t NONE;
        } Event;

        // returns references to the members in the map, they become invalid
        // after destruction.
        const std::string& getEventName(const event_t event) const;

        const event_t getEvent(const std::string& value) const;

        const event_t registerEvent(const std::string& value) ;

        const event_t getEventMask(const std::string& value) const;

        inline event_t setLogEvents(event_t events) {
            event_t rv = logevents;
            logevents = events;
            return rv;
        }
        void setDefaultEventMask();

        gc_ptr<EventReader> getReader(const event_t event, const std::string& r);
        
    protected:

        event_t logevents;
        virtual Clone* DoClone() const;

    private:
        typedef std::map<event_t, std::string> namemap_t;
        namemap_t names;
        int nextEventBit;

        static const std::string INVALID;
};

class EventReader: public usg_cnt_t<DefaultThreadedModel>, public std::ostringstream {
        typedef std::ostringstream super;
    private:
        // todo, could be destructed, would prefere gc_ptr/weak_ptr
        EventReader(ResourcePoolEventObserver& observer, ResourcePoolEventObserver::event_t e, std::string resource);
    friend  class ResourcePoolEventObserver;
    public:
        //EventReader(const EventReader& rho);
        // the d-tor actually loggs
        ~EventReader();

/*
        template<typename T>
        inline
        EventReader& operator<< (const std::string& val) {
            if (observer.isEvent(event)) {
                *((super*)this)<<val;
            }
            return *this;
        }
*/

        template<typename T>
        inline
        EventReader& operator<< (const T& val) {
            if (observer.isEvent(event)) {
                super& s = *((super*)this);
                s <<val;
            }
            return *this;
        }

/*
        template<class T>
        EventReader& operator<< (const fatalmind::Command<T>& rho) {
                if (observer.isEvent(event)) {
                        rho.outputoperator(*this);
                }
                return *this;
        }
*/
    private:
        ResourcePoolEventObserver& observer;
        ResourcePoolEventObserver::event_t event;
        std::string resource;
//      std::ostringstream os;
};

} // namespace fatalmind
#endif

---