Logger.h

Go to the documentation of this file.

#ifndef __LOGGER
#define __LOGGER

#include <ishtar/settings.h>
#include <ostream>
#include <fstream>
#include <vector>

namespace Teem
{
    class Logger
    {
    public:
    
        Logger(const char* fileName) : logFile(fileName), inited(false) { }
        virtual ~Logger();
        
        template<typename T> void addVariable(const std::string &label, const T &ref) { add(label, new LoggableVariable<T>(ref)); }
        
        template<typename T> void addIshtarVariable(const std::string &label, const char* id) { add(label, new LoggableIshtarVariable<T>(id)); }
        
        template<typename ForwardIterator> void addVariables(const std::string &label, ForwardIterator from, ForwardIterator to) { while(from != to) { addVariable(label, *from); ++from; } }
        
        void step();
    
    protected:
    
        class Loggable
        {
        public:
            virtual ~Loggable() { }
            virtual void print(std::ostream &s) const = 0;
        };
        
        template<typename T> class LoggableVariable : public Loggable
        {
        public:
            LoggableVariable(const T &r) : ref(r) { }
            virtual void print(std::ostream &s) const { s << ref; }
        protected:
            const T& ref; 
        };
        
        template<typename T> class LoggableIshtarVariable :  public Loggable
        {
        public:
            LoggableIshtarVariable(const char* id) : variable(id) { }
            virtual void print(std::ostream &s) const { s << variable; }
        protected:
            Ishtar::Variable<T> variable; 
        };
        
        friend std::ostream& operator<< (std::ostream &os, const Logger::Loggable &loggable);
    
        typedef std::map<std::string, std::vector<Loggable*> > LoggableMap;
        std::ofstream logFile; 
        bool inited; 
        LoggableMap loggables; 
        
        void add(const std::string &label, Loggable* loggable);
        
        virtual void initLog(std::ostream &log) = 0;
        virtual void dumpSnapshot(std::ostream &log) = 0;
    };
    
    class OctaveLogger : public Logger
    {
    public:
        OctaveLogger(const char* fileName, bool matlab = false) : Logger(fileName), matlabMode(matlab) { }
        virtual ~OctaveLogger() { }
    
    protected:
    
        const bool matlabMode; 
    
        virtual void initLog(std::ostream &log);
        virtual void dumpSnapshot(std::ostream &log);
    };
    
    inline std::ostream& operator<< (std::ostream &os, const Logger::Loggable &loggable)
    {
        loggable.print(os);
        return os;
    }
}

#endif

---