Frage zu Namespaces

[butze]

hi!

Für eine Logger Klasse, die mit mehreren Scopes (GUI, XML etc.) arbeitet, möchte ich aus Bequemlichkeitsgründen in den entsprechenden Klassen eine Logmitteilung mit dem Befehl LOG::Info oder Log::Warning hinzufügen. Je nach zuvor gesetztem Namespace werden die entsprechenden Funktionen ausgeführt (wenn keine namespaces gesetzt sind, dann soll die Klasse "Log" alleine genommen werden.

Klingt gerade etwas kompliziert. Daher ein Beispiel, wie ich es benutzen möchte:


In Klasse GUI, die den Namespace GUILog benutzt, kommt der Aufruf:

Log::Info("strgui");

Dabei automatisch die Logklasse im Namespace "GUILog" gewählt und darin die die Methode Logger::info("strgui", GUI) aufgerufen



In Klasse XML, die den Namespace XMLLog benutzt, kommt der Aufruf:

Log::Info("strxml);

Dabei automatisch die Logklasse im Namespace "XMLLog" gewählt und darin die die Methode Logger::info("strgui", XML) aufgerufen.



In der Klasse xyz wird kein namespace gesetzt.

Log::Info("strxyz);

ruft Log::info("strxyz, GENERAL) auf




...soweit die Theorie: in der Praxis werden die Namespaces nicht erkannt. Ich hab schon alles ausprobiert mit using namespace XMLLog (XMLLog::Log ...). Es klappt nur, wenn ich ohne den Namespace einzubinden GUILOG::LOG::INFO("text"); bzw. XMLLog::LOG::INFO("str"); schreibe.




enumerations.h

Code: Alles auswählen

enum LogScope {GENERAL=0, XML=1, GUI=2,  PLOT=3};
enum LogType {INFO=0, WARNING=1, DEBUG=2, FATAL=3};

Log.h

Code: Alles auswählen

#ifndef LOG_H_
#define LOG_H_

#include <QList>
#include <QString>
#include <QObject>

#include "enumatations.h"



class Logger : public QObject
{
    Q_OBJECT
public:

    ~Logger();
    static Logger* instance();

    static void info(QString str, LogScope scope);
    static void debug(QString str, LogScope scope);
    static void warning(QString str, LogScope scope);
    static void fatal(QString str,  LogScope scope);

    void getLog();

signals:
    void newLog(HLog);
    void completeLog(QList <HLog>);


private:
    Logger();
    static Logger* m_instance;

    void append(HLog log);
    QList<HLog> logList;
};



class Log
{
public:
    static void info(QString str);
    static void debug(QString str);
    static void warning(QString str);
    static void fatal(QString str);
};

namespace GUILog
{
class Log
{
public:
    static void info(QString str);
    static void debug(QString str);
    static void warning(QString str);
    static void fatal(QString str);
};
}
; //end namespace GUILOG


namespace XMLLog
{
class Log
{
public:
    static void info(QString str);
    static void debug(QString str);
    static void warning(QString str);
    static void fatal(QString str);
};
}
; //end namespace XMLLog


#endif /* LOG_H_ */

Log.cpp:

Code: Alles auswählen

#include "Log.h"


Logger* Logger::m_instance = 0; // initial no object created

///public
Logger::~Logger()
{
    std::cout << "Log Destruktor \n";
}


/// public static
Logger* Logger::instance()
{
    if (!m_instance)
    {
        m_instance = new Logger();
    }
    return m_instance;
}

void Logger::info(QString str, LogScope scope)
{
    HLog log;
    log.scope = scope;
    log.type = INFO;
    log.timeStamp = QTime::currentTime();
    log.msg = str;
    instance()->append(log);
}

void Logger::debug(QString str, LogScope scope)
{
    HLog log;
    log.scope = scope;
    log.type = DEBUG;
    log.timeStamp = QTime::currentTime();
    log.msg = str;
    instance()->append(log);
}

void Logger::warning(QString str, LogScope scope)
{
    HLog log;
    log.scope = scope;
    log.type = WARNING;
    log.timeStamp = QTime::currentTime();
    log.msg = str;
    instance()->append(log);
}

void Logger::fatal(QString str, LogScope scope)
{
    HLog log;
    log.scope = scope;
    log.type = FATAL;
    log.timeStamp = QTime::currentTime();
    log.msg = str;
    instance()->append(log);
}

void Logger::getLog()
{
    emit completeLog(logList);
}

//private
Logger::Logger()
{
    //std::cout << "Log Konstruktor \n";
}


void Logger::append(HLog log)
{
    //    std::cout <<
    //    "Log::append " <<
    //    "Logscope = " << log.scope <<
    //    "LogType = "  << log.type <<
    //    "TimeStamp = " << log.timeStamp.toString("hh:mm:ss").toStdString() <<
    //    "Msg = " << log.msg.toStdString() <<
    //    "\n";

    emit newLog(log);
}


void Log::info(QString str)
{
    //std::cout << "GENERALLog::info(QString str) \n";
    Logger::info(str, GENERAL);
}
void Log::debug(QString str)
{
    //std::cout << "GENERALLog::debug(QString str) \n";
    Logger::debug(str, GENERAL);
}
void Log::warning(QString str)
{
    //std::cout << "GENERALLog::warning(QString str) \n";
    Logger::warning(str, GENERAL);
}
void Log::fatal(QString str)
{
    //std::cout << "GENERALLog::fatal(QString str) \n";
    Logger::fatal(str, GENERAL);
}




namespace GUILog
{
void Log::info(QString str)
{
    //std::cout << "GUILog::info(QString str) \n";
    Logger::info(str, GUI);
}
void Log::debug(QString str)
{
    //std::cout << "GUILog::debug(QString str) \n";
    Logger::debug(str, GUI);
}
void Log::warning(QString str)
{
    //std::cout << "GUILog::warning(QString str) \n";
    Logger::warning(str, GUI);
}
void Log::fatal(QString str)
{
    //std::cout << "GUILog::fatal(QString str) \n";
    Logger::fatal(str, GUI);
}
}
;  //end namespace GUILog


namespace XMLLog
{
void Log::info(QString str)
{
    //std::cout << "XMLLog::info(QString str) \n";
    Logger::info(str, XML);
}
void Log::debug(QString str)
{
    //std::cout << "XMLLog::debug(QString str) \n";
    Logger::debug(str, XML);
}
void Log::warning(QString str)
{
    //std::cout << "XMLLog::warning(QString str) \n";
    Logger::warning(str, XML);
}
void Log::fatal(QString str)
{
    //std::cout << "XMLLog::fatal(QString str) \n";
    Logger::fatal(str, XML);
}
}
;  //end namespace XMLLog

..die ganze Lösung ist in meinen Augen noch ziemlich schauderhaft. Habt ihr da bessere Lösungsvorschläge?