File indexing completed on 2024-04-21 04:40:36

 /* This file is part of the KDE project
    Copyright (C) 2003-2016 Jarosław Staniek <staniek@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program 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
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KDbResult.h"
 #include "KDbMessageHandler.h"
 #include "kdb_debug.h"
 #include "KDb_p.h"
 
 #if 0 // needed by lupdate to avoid "Qualifying with unknown namespace/class" because header is generated
 class KDbResult { Q_DECLARE_TR_FUNCTIONS(KDbResult) };
 class KDbResultable {};
 #endif
 
 #define ERRMSG(a) \
     { if (m_msgHandler) m_msgHandler->showErrorMessage(a); }
 
 #define STORE_PREV_ERR \
 
 KDbResult::KDbResult(int code, const QString& message)
     : d(new Data)
 {
     init(code, message);
 }
 
 KDbResult::KDbResult(const QString& message)
     : d(new Data)
 {
     init(ERR_OTHER, message);
 }
 
 KDbResult::~KDbResult()
 {
 }
 
 void KDbResult::init(int code, const QString& message)
 {
     d->code = code;
     d->errorSql = d->sql;
     if (d->code == ERR_OTHER && message.isEmpty())
         d->message = tr("Unspecified error encountered");
     else
         d->message = message;
 //! @todo
 /*    if (m_hasError)
         ERRMSG(this);*/
 }
 
 bool KDbResult::isError() const
 {
     return d->code != ERR_NONE
             || d->serverErrorCodeSet
             || !d->message.isEmpty()
             || !d->messageTitle.isEmpty()
             || !d->errorSql.isEmpty()
             || !d->serverMessage.isEmpty();
 }
 
 void KDbResult::setServerErrorCode(int errorCode)
 {
     d->serverErrorCode = errorCode;
     d->serverErrorCodeSet = true;
 }
 
 void KDbResult::prependMessage(int code, const QString& message)
 {
     if (d->code == ERR_NONE) {
         if (code == ERR_NONE)
             d->code = ERR_OTHER;
         else
             d->code = code;
     }
     if (!message.isEmpty()) {
         if (d->message.isEmpty())
             d->message = message;
         else
             d->message = message + QLatin1Char(' ') + d->message;
     }
 //    if (m_hasError)
 //! @todo IMPORTANT: ERRMSG(this);
 }
 
 void KDbResult::prependMessage(const QString& message)
 {
     prependMessage(ERR_NONE, message);
 }
 
 QDebug operator<<(QDebug dbg, const KDbResult& result)
 {
     if (result.isError()) {
         dbg.nospace() << "KDbResult:";
         dbg.nospace() << " CODE=" << result.code();
         if (!result.message().isEmpty())
             dbg.nospace() << " MESSAGE=" << result.message();
         if (!result.messageTitle().isEmpty())
             dbg.nospace() << " TITLE=" << result.messageTitle();
         if (!result.sql().isEmpty())
             dbg.nospace() << " SQL=" << result.sql();
         if (!result.errorSql().isEmpty())
             dbg.nospace() << " ERR_SQL=" << result.errorSql();
         dbg.nospace() << " SERVER_ERROR_CODE=" << result.serverErrorCode() /*<< "NAME:" << result.serverResultName()*/;
         if (!result.serverMessage().isEmpty())
             dbg.nospace() << " SERVER_MESSAGE=" << result.serverMessage();
     } else {
         dbg.nospace() << "KDbResult: OK";
     }
     return dbg;
 }
 /*
 KDbMessageHandler::ButtonCode KDbObject::askQuestion(
     KDbMessageHandler::QuestionType messageType,
     const QString& message,
     const QString &caption,
     KDbMessageHandler::ButtonCode defaultResult,
     const KDbGuiItem &buttonYes,
     const KDbGuiItem &buttonNo,
     const QString &dontShowAskAgainName,
     KDbMessageHandler::Options options,
     KDbMessageHandler* msgHandler)
 {
     if (msgHandler)
         return msgHandler->askQuestion(messageType, message, caption, defaultResult, buttonYes, buttonNo,
                                        dontShowAskAgainName, options);
 
     if (m_msgHandler)
         return m_msgHandler->askQuestionInternal(messageType, message, caption, defaultResult, buttonYes, buttonNo,
                                                  dontShowAskAgainName, options);
 
     return defaultResult;
 }*/
 
 /*
 void KDbResultable::storePreviousError()
 {
     m_previousServerResultCode = m_previousServerResultCode2;
     m_previousServerResultName = m_previousServerResultName2;
     m_previousServerResultCode2 = m_serverResultCode;
     m_previousServerResultName2 = m_serverResultName;
     kdbDebug() << "Object ERROR:" << m_previousServerResultCode2 << ":" << m_previousServerResultName2;
 }*/
 
 class Q_DECL_HIDDEN KDbResultable::Private
 {
 public:
     Private() : messageHandler(nullptr)
     {
     }
     Private(const Private &other) {
         copy(other);
     }
 #define KDbResultablePrivateArgs(o) std::tie(o.messageHandler)
     void copy(const Private &other) {
         KDbResultablePrivateArgs((*this)) = KDbResultablePrivateArgs(other);
     }
     bool operator==(const Private &other) const {
         return KDbResultablePrivateArgs((*this)) == KDbResultablePrivateArgs(other);
     }
     KDbMessageHandler* messageHandler;
 };
 
 KDbResultable::KDbResultable()
  : d(new Private)
 {
 }
 
 KDbResultable::KDbResultable(const KDbResultable &other)
     : m_result(other.m_result)
     , d(new Private(*other.d))
 {
 }
 
 KDbResultable::~KDbResultable()
 {
     delete d;
 }
 
 KDbResultable& KDbResultable::operator=(const KDbResultable &other)
 {
     d->messageHandler = other.messageHandler();
     m_result = other.m_result;
     return *this;
 }
 
 KDbResult KDbResultable::result() const
 {
     return m_result;
 }
 
 void KDbResultable::clearResult()
 {
     m_result = KDbResult();
 }
 
 QString KDbResultable::serverResultName() const
 {
     return QString();
 }
 
 void KDbResultable::setMessageHandler(KDbMessageHandler *handler)
 {
     d->messageHandler = handler;
 }
 
 KDbMessageHandler* KDbResultable::messageHandler() const
 {
     return d->messageHandler;
 }
 
 void KDbResultable::showMessage()
 {
     if (d->messageHandler && m_result.isError()) {
         d->messageHandler->showErrorMessage(m_result);
     }
 }
 
 QDebug operator<<(QDebug dbg, const KDbResultInfo &info)
 {
     dbg.nospace() << "ResultInfo(";
     dbg.space() << "success:" << info.success
                 << "allowToDiscardChanges:" << info.allowToDiscardChanges
                 << "message:" << info.message
                 << "description:" << info.description
                 << "column:" << info.column;
     dbg.nospace() << ")";
     return dbg.space();
 }
 
 void KDbResultInfo::clear()
 {
     success = true;
     allowToDiscardChanges = false;
     column = -1;
     message.clear();
     description.clear();
 }