src/log4qt/helpers/logerror.h

Go to the documentation of this file.

/******************************************************************************
 *
 * package:     Log4Qt
 * file:        logerror.h
 * created:     September 2007
 * author:      Martin Heinrich
 *
 * 
 * Copyright 2007 Martin Heinrich
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
 ******************************************************************************/

#ifndef LOG4QT_LOGERROR_H
#define LOG4QT_LOGERROR_H


/******************************************************************************
 * Dependencies
 ******************************************************************************/

#include <QtCore/QString>
#include <QtCore/QVariant>


/******************************************************************************
 * Declarations
 ******************************************************************************/

namespace Log4Qt
{    
    #define LOG4QT_ERROR(message, code, context)                              \
        LogError(message, code, #code, context)

    #define LOG4QT_QCLASS_ERROR(message, code)                                \
        LogError(message, code, #code, this->metaObject()->className())

    class LogError
    {
    public:
        
        enum Encoding
        {
            LATIN1,
            CODECFORTR,
            UNICODEUTF8,
        };
        Q_ENUMS(Encoding)

        
        LogError();
        
        LogError(const QString &rMessage, 
                 int code = 0,
                 const QString &rSymbol = QString(), 
                 const QString &rContext = QString());
        
        LogError(const char *pMessage, 
                 int code = 0, 
                 const char *pSymbol = 0, 
                 const char *pContext = 0,
                 Encoding encoding = LATIN1);
        
        // LogError(const LogError &rOther); // Use compiler default
        // virtual ~LogError(); // Use compiler default
        // LogError &operator=(const LogError &rOther); // Use compiler default
        
        int code() const;
        
        QString context() const;
        
        QString message() const;
        
        QString symbol() const;
        
        QString translatedMessage() const;

        void setCode(int code);
        
        void setContext(const QString &rClassName);
        
        void setMessage(const QString &rMessage);
        
        void setSymbol(const QString &rSymbol);
        
        static LogError lastError();
        
        static void setLastError(const LogError &rLogError);
        
        LogError &addArg(const QVariant &rArg);
        
        LogError &addArg(int arg);
        
        LogError &addArg(const QString &rArg);
        
        LogError &addCausingError(const LogError &rLogError);
        
        QList<QVariant> args() const;
        
        QList<LogError> causingErrors() const;
        
        void clearArgs();
        
        void clearCausingErrors();
        
        bool isEmpty() const;
        
        QString messageWithArgs() const;
        
        QString translatedMessageWithArgs() const;
        
        LogError &operator<<(const QVariant &rArg);
        
        LogError &operator<<(int arg);
        
        LogError &operator<<(const QString &rArg);
        
        QString toString() const;
    
    private:
        QString insertArgs(const QString &rMessage) const;
        QString cleanMessage(const QString &rMessage);
       
    private:
        int mCode;
        QString  mContext;
        QString  mMessage;
        QString  mSymbol;
        QList<QVariant> mArgs;
        QList<LogError> mCausingErrors;

#ifndef QT_NO_DATASTREAM
        // Needs to be friend to stream objects
        friend QDataStream &operator<<(QDataStream &rStream, 
                                       const LogError &rLogError);
        friend QDataStream &operator>>(QDataStream &rStream, 
                                       LogError &rLogError);
#endif // QT_NO_DATASTREAM
    };
    
    
    /**************************************************************************
     * Operators, Helper
     **************************************************************************/
    
#ifndef QT_NO_DATASTREAM

    QDataStream &operator<<(QDataStream &rStream, 
                            const LogError &rLogError);
    
    QDataStream &operator>>(QDataStream &rStream, 
                            LogError &rLogError);
#endif // QT_NO_DATASTREAM
    
#ifndef QT_NO_DEBUG_STREAM

    QDebug operator<<(QDebug debug, 
                      const LogError &rLogError);
#endif // QT_NO_DEBUG_STREAM
    
    
    /**************************************************************************
     * Inline
     **************************************************************************/
    
    inline int LogError::code() const
    {   return mCode;   }
      
    inline QString LogError::context() const
    {   return mContext;  }
    
    inline QString LogError::message() const
    {   return mMessage;    }
    
    inline QString LogError::symbol() const
    {   return mSymbol;    }
    
    inline void LogError::setCode(int code)
    {   mCode = code;    }
    
    inline void LogError::setContext(const QString &rContext)
    {   mContext = rContext;   }
    
    inline void LogError::setMessage(const QString &rMessage)
    {   mMessage = cleanMessage(rMessage);   }
    
    inline void LogError::setSymbol(const QString &rSymbol)
    {   mSymbol = rSymbol;    }
    
    inline LogError &LogError::addArg(const QVariant &rArg)
    {   mArgs << rArg; return *this; }
    
    inline LogError &LogError::addArg(int arg)
    {   mArgs << QVariant(arg); return *this;   }
    
    inline LogError &LogError::addArg(const QString &rArg)
    {   mArgs << QVariant(rArg); return *this;   }
    
    inline LogError &LogError::addCausingError(const LogError &rLogError)
    {   mCausingErrors << rLogError;  return *this;    }
    
    inline QList<QVariant> LogError::args() const
    {   return mArgs;   }
    
    inline void LogError::clearArgs()
    {   mArgs.clear();  }
    
    inline void LogError::clearCausingErrors()
    {   mCausingErrors.clear(); }
    
    inline QList<LogError> LogError::causingErrors() const
    {   return mCausingErrors;  }
    
    inline bool LogError::isEmpty() const
    {   return mCode || !mMessage.isEmpty(); }
    
    inline QString LogError::messageWithArgs() const
    {   return insertArgs(message());    }
    
    inline QString LogError::translatedMessageWithArgs() const
    {   return insertArgs(translatedMessage());    }
    
    inline LogError &LogError::operator<<(const QVariant &rArg)
    {   return addArg(rArg);  }
    
    inline LogError &LogError::operator<<(int arg)
    {   return addArg(arg);  }
    
    inline LogError &LogError::operator<<(const QString &rArg)
    {   return addArg(rArg);  }
    
    
} // namespace Log4Qt


Q_DECLARE_METATYPE(Log4Qt::LogError)
Q_DECLARE_TYPEINFO(Log4Qt::LogError, Q_MOVABLE_TYPE);


#endif // LOG4QT_ERROR_H

---