Log4SX.h

#ifndef _LOG4SX_LOG4SX_H_
#define _LOG4SX_LOG4SX_H_

#include <export/Export.h>
#include <sx/Exception.h>
#include <string>
#include <fstream>
#include <vector>
#include <map>
#include <boost/timer.hpp>
using namespace std;

namespace sx {

    enum LogLevel {
        L_HARMLESS = 0,
        L_WARNING = 1,
        L_ERROR = 2,
        L_FATAL_ERROR = 3,
        L_NONE = 4
    };

    class Level {
    private:

        LogLevel level;

    public:

        EXL Level(LogLevel level);

        EXL Level(const Level &l);

        EXL Level &operator = (const Level &l);

        EXL LogLevel getLevel() const;
    };

    class LogMarkup {
    protected:

        string message;

    public:

        EXL LogMarkup(string message);

        EXL LogMarkup(const LogMarkup &lm);

        EXL LogMarkup &operator = (const LogMarkup &lm);

        EXL virtual ~LogMarkup();

        EXL string getMessage() const;

    };

    class Annotation {
    private:

        string annotation;

    public:

        EXL Annotation(string annotation);
        
        EXL Annotation(const Annotation &a);

        EXL Annotation &operator = (const Annotation &a);

        EXL string getAnnotation() const;

    };

    class Logger {
    private:

        static map<string,Logger *> loggers;

        static Logger *defaultLogger;

        static Logger *initDefaultLogger();

        Logger(const Logger &);

        Logger &operator = (const Logger &);

    protected:

        LogLevel minLevel;

        LogLevel level;

        EXL Logger();

        bool takeMessage() const;

    public:

        EXL static string newLine();

        EXL static void addLogger(string ID, Logger *logger);

        EXL static void setDefaultLogger(string ID);

        EXL static Logger & get();

        EXL static void deleteLogger(string ID);

        EXL virtual ~Logger();

        EXL void setMinLevel(LogLevel level);

        EXL LogLevel getMinLevel() const;

        EXL LogLevel getLevel() const;

        EXL virtual Logger & operator << (const Level l);

        EXL virtual Logger & operator << (const LogMarkup m) = 0;

        EXL virtual Logger & operator << (const Annotation a) = 0;

        EXL virtual Logger & operator << (char value) = 0;

        EXL virtual Logger & operator << (unsigned char value) = 0;

        EXL virtual Logger & operator << (short value) = 0;

        EXL virtual Logger & operator << (unsigned short value) = 0;

        EXL virtual Logger & operator << (int value) = 0;

        EXL virtual Logger & operator << (unsigned int value) = 0;

        EXL virtual Logger & operator << (long value) = 0;

        EXL virtual Logger & operator << (unsigned long value) = 0;

        EXL virtual Logger & operator << (float value) = 0;

        EXL virtual Logger & operator << (double value) = 0;

        EXL virtual Logger & operator << (string value) = 0;

    };

    class ConsoleLogger: public Logger {
    private:

        ConsoleLogger(const ConsoleLogger &);

        ConsoleLogger &operator = (const ConsoleLogger &);


    public:

        EXL ConsoleLogger();

        EXL ~ConsoleLogger();

        EXL Logger &operator << (const Level level);

        EXL Logger & operator << (const LogMarkup m);

        EXL Logger & operator << (const Annotation a);

        EXL Logger & operator << (char value);

        EXL Logger & operator << (unsigned char value);

        EXL Logger & operator << (short value);

        EXL Logger & operator << (unsigned short value);

        EXL Logger & operator << (int value);

        EXL Logger & operator << (unsigned int value);

        EXL Logger & operator << (long value);

        EXL Logger & operator << (unsigned long value);

        EXL Logger & operator << (float value);

        EXL Logger & operator << (double value);

        EXL Logger & operator << (string value);
    };

    class ListMarkup: public LogMarkup {
    private:

        vector<char> chars;

        vector<unsigned char> uchars;

        vector<short> shorts;

        vector<unsigned short> ushorts;

        vector<int> ints;

        vector<unsigned int> uints;

        vector<long> longs;

        vector<unsigned long> ulongs;

        vector<float> floats;

        vector<double> doubles;

        vector<string> strings;

        vector<Annotation> annotations;

    public:

        EXL ListMarkup(string message);

        EXL ListMarkup(const ListMarkup &m);

        EXL ListMarkup &operator = (const ListMarkup &m);

        EXL ~ListMarkup();

        EXL vector<char> & getChars();

        EXL vector<unsigned char> & getUchars();

        EXL vector<short> & getShorts();

        EXL vector<unsigned short> & getUshorts();

        EXL vector<int> & getInts();

        EXL vector<unsigned int> & getUints();

        EXL vector<long> & getLongs();

        EXL vector<unsigned long> & getUlongs();

        EXL vector<float> & getFloats();

        EXL vector<double> & getDoubles();

        EXL vector<string> & getStrings();

        EXL vector<Annotation> & getAnnotations();

    };

    class ListLogger: public Logger {
    private:

        ListMarkup *defaultMarkup;

        map<string,ListMarkup> markups;

        ListLogger(const ListLogger &);

        ListLogger &operator = (const ListLogger &);

    public:

        EXL ListLogger();

        EXL ~ListLogger();

        EXL Logger &operator << (const Level level);

        EXL Logger & operator << (const LogMarkup m);

        EXL Logger & operator << (const Annotation a);

        EXL Logger & operator << (char value);

        EXL Logger & operator << (unsigned char value);

        EXL Logger & operator << (short value);

        EXL Logger & operator << (unsigned short value);

        EXL Logger & operator << (int value);

        EXL Logger & operator << (unsigned int value);

        EXL Logger & operator << (long value);

        EXL Logger & operator << (unsigned long value);

        EXL Logger & operator << (float value);

        EXL Logger & operator << (double value);

        EXL Logger & operator << (string value);

        EXL map<string,ListMarkup> & getMarkups();

        EXL Annotation getAnnotationEntry(string ID, unsigned int index);

        EXL char getCharEntry(string ID, unsigned int index);

        EXL unsigned char getUcharEntry(string ID, unsigned int index);

        EXL short getShortEntry(string ID, unsigned int index);

        EXL unsigned short getUshortEntry(string ID, unsigned int index);

        EXL int getIntEntry(string ID, unsigned int index);

        EXL unsigned int getUintEntry(string ID, unsigned int index);

        EXL long getLongEntry(string ID, unsigned int index);

        EXL unsigned long getUlongEntry(string ID, unsigned int index);

        EXL float getFloatEntry(string ID, unsigned int index);

        EXL double getDoubleEntry(string ID, unsigned int index);

        EXL string getStringEntry(string ID, unsigned int index);

    };

    enum FileLoggerState {

        FIRST_TABLE,

        COLLECT_ANNOTATIONS,

        COLLECT_MESSAGES,

    };

    class FileLogger: public Logger {
    private:

        ofstream file;

        bool errorbit;

        FileLoggerState state;

        boost::timer timeMeasurement;

        string INTERNAL_TABLE_PRINT_FUNCTION();
        string INTERNAL_SEPARATE_ANNOTATION();
        string INTERNAL_FINISH_TABLE();

        FileLogger(const FileLogger &);

        FileLogger &operator = (const FileLogger &);

    public:

        EXL FileLogger(string filename);

        EXL ~FileLogger();

        EXL bool hasErrors() const;

        EXL void close();

        EXL Logger &operator << (const Level level);

        EXL Logger & operator << (const LogMarkup m);

        EXL Logger & operator << (const Annotation a);

        EXL Logger & operator << (char value);

        EXL Logger & operator << (unsigned char value);

        EXL Logger & operator << (short value);

        EXL Logger & operator << (unsigned short value);

        EXL Logger & operator << (int value);

        EXL Logger & operator << (unsigned int value);

        EXL Logger & operator << (long value);

        EXL Logger & operator << (unsigned long value);

        EXL Logger & operator << (float value);

        EXL Logger & operator << (double value);

        EXL Logger & operator << (string value);
    };

}

#ifdef _IS_LOGGING_
    #define SXout(MSG) sx::Logger::get() << MSG;
#else
    #define SXout(MSG)
#endif

#endif