zglobal.h

Go to the documentation of this file.

/*
 * Zuble - A run-time system for QML/Javascript applications
 * Copyright (C) 2013, 2014  Bob Dinitto
 *
 * zglobal.h
 *
 *  Created on: 15-Feb, 2013
 *      Author: Bob Dinitto   bob@ninzo.com
 *
 * Zuble is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
*/

#ifndef ZGLOBAL_H
#define ZGLOBAL_H

#include <QtCore/qglobal.h>
#include <QSharedPointer>
#include <QThread>
#include "ZblException.h"
#include "ZblThreadErr.h"
#include "ZblLogCategory.h"

class QFile;
class QIODevice;
class QByteArray;
class QSqlQuery;
class QProcess;


namespace Zbl
{

#define cStr(qStr) qStr.toUtf8().constData()

#define ptrStr(ptr) ptrToString(static_cast<void*>(ptr))

inline QString ptrToString(void* ptr)
{
    return QString::asprintf("%p", ptr);
}

inline bool fromLiterallyTrue(const QString& value)
{
    const QString lc = value.toLower();

    if(lc == "true")
        return true;
    else
        return false;
}

inline QString toLiterallyTrue(bool value)
{
    if(value)
        return QString("true");
    else
        return QString("false");
}

// TDB: make object name user definable ie: m_log



#define ZBL_DECLARE_LOGGED_CATEGORY(category) static ZblLogCategory category;

#define ZBL_DECLARE_LOGGED_OBJECT ZBL_DECLARE_LOGGED_CATEGORY(m_log)

#define ZBL_DEFINE_LOGGED_CATEGORY(category_name, variable_name) \
    ZblLogCategory variable_name(#category_name);

#define ZBL_DEFINE_LOGGED_OBJECT(class_name) \
    ZblLogCategory class_name::m_log(#class_name);

#define ZBL_REGISTER_LOGGED_CATEGORY(variable_name) variable_name.registerCategory();

#define ZBL_REGISTER_LOGGED_OBJECT ZBL_REGISTER_LOGGED_CATEGORY(m_log)


#define zCWarning(category) qCWarning(category())
#define zCCritical(category) qCCritical(category())
#define zCDebug(category) qCDebug(category())

#define zWarning() zCWarning(m_log)
#define zCritical() zCCritical(m_log)
#define zDebug() zCDebug(m_log)

#define LOCK_ZLOGCATEGORIES \
    QStringList& zLogCategories(ZblLogCategory::m_categories); \
    QMutexLocker categoryLock(&ZblLogCategory::m_categorylock);

#define Z_FAC_JS ZJS

#define ZBL_SLOT_BEGIN_TRY try{zThreadErr.clearError();

#define ZBL_SLOT_END_VOID(facility,code,error_message) \
}catch(Zbl::ZblException ze){ \
QString msg(#error_message); \
msg.append(", source exception: ").append(ze.what( )); \
zThreadErr.raiseError(#facility,#code,msg);} \
catch(...){zThreadErr.raiseError(#facility,#code,#error_message);}

#define ZBL_SLOT_END_RETURN(return_success,return_failed,facility,code,error_message) \
    return return_success; \
    ZBL_SLOT_END_VOID(facility,code,error_message) \
    return return_failed;

#define Z_CONSTANT_DEF(propName, dataType) \
    Q_PROPERTY(dataType propName READ propName CONSTANT) \
    dataType propName();

#define Z_CONSTANT_IMPL(className, readMethodName, dataType, constantExp) \
dataType className::readMethodName(){return constantExp;}

#define Z_PROPGET_DEF(propName, propType) \
    Q_PROPERTY(propType propName READ propName) \
    propType propName();

#define Z_PROPGET_IMPL(className, propName, propType, failedValue) \
propType className::propName(){ \
    ZBL_SLOT_BEGIN_TRY \
    ZBL_SLOT_END_RETURN(m_fi.at(m_i).propName(),  failedValue, \
        Z_FAC_JS, className::propName, propName failed) \

typedef QSharedPointer<QFile> ZqFilePtr;
typedef QSharedPointer<QIODevice> ZqIODevicePtr;
typedef QSharedPointer<QString> ZqStringPtr;
typedef QSharedPointer<QByteArray> ZqByteArrayPtr;
typedef QSharedPointer<QProcess> ZqProcessPtr;

typedef QList<QString> zMetaRow;
typedef QList<QList<QString> > zStringTable;
typedef QList<QList<QVariant> > zVariantTable;

inline bool inObjectThread(const QObject& object)
{
    //return QThread::currentThread() == object.thread();

    QThread* objThread = object.thread();

    QThread* thisThread = QThread::currentThread();

    return objThread == thisThread ? true : false;
}

inline bool inObjectThread(const QObject* object)
{
    if(!object)
        return false;
    else
        return inObjectThread(*object);
}

#if 1
// save text instead
typedef enum logFileFormat
{
    LogFormatText = 0,
    LogFormatXML = 1,
    LogFormatJSON = 2
} LogFileFormat;
#endif

enum textSearchType
{
    SearchCaseSensitive = 0,
    SearchCaseInsensitive
};

inline textSearchType zValidateSearchType(int searchType)
{
    if(searchType < SearchCaseSensitive || searchType > SearchCaseInsensitive)
        return SearchCaseInsensitive;
    else
        return static_cast<textSearchType>(searchType);
}


} // Zbl


#endif // ZGLOBAL_H