src/log4qt/helpers/initialisationhelper.h

Go to the documentation of this file.

/******************************************************************************
 *
 * package:     Log4Qt
 * file:        initialisationhelper.h
 * created:     September 2007
 * author:      Martin Heinrich
 *
 *
 * changes:     Sep 2008, Martin Heinrich:
 *              - Replaced usage of q_atomic_test_and_set_ptr with
 *                QBasicAtomicPointer
 *
 *
 * Copyright 2007 - 2008 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_HELPERS_INITIALISATIONHELPER_H
#define LOG4QT_HELPERS_INITIALISATIONHELPER_H


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

#include <QtCore/QAtomicPointer>
#include <QtCore/QHash>

#if QT_VERSION >= QT_VERSION_CHECK(4, 4, 0)
#   ifndef Q_ATOMIC_POINTER_TEST_AND_SET_IS_ALWAYS_NATIVE
#       warning "QAtomicPointer test and set is not native. The macros Log4Qt::LOG4QT_GLOBAL_STATIC and Log4Qt::LOG4QT_IMPLEMENT_INSTANCE are not thread-safe."
#   endif
#endif


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

class QMutex;

namespace Log4Qt
{
#if QT_VERSION < QT_VERSION_CHECK(4, 4, 0)
    #define LOG4QT_GLOBAL_STATIC(TYPE, FUNCTION)                              \
        static volatile TYPE *sp_global_static_##FUNCTION = 0;                \
        TYPE *FUNCTION()                                                      \
        {                                                                     \
            if (!sp_global_static_##FUNCTION)                                 \
            {                                                                 \
                TYPE *p_temp = new TYPE;                                      \
                if (!q_atomic_test_and_set_ptr(&sp_global_static_##FUNCTION,  \
                                               0, p_temp))                    \
                    delete p_temp;                                            \
            }                                                                 \
            return const_cast<TYPE *>(sp_global_static_##FUNCTION);           \
        }
#else
    #define LOG4QT_GLOBAL_STATIC(TYPE, FUNCTION)                              \
        static QBasicAtomicPointer<TYPE > sp_global_static_##FUNCTION =       \
            Q_BASIC_ATOMIC_INITIALIZER(0);                                    \
        TYPE *FUNCTION()                                                      \
        {                                                                     \
            if (!sp_global_static_##FUNCTION)                                 \
            {                                                                 \
                TYPE *p_temp = new TYPE;                                      \
                if (!sp_global_static_##FUNCTION.testAndSetOrdered(0,         \
                                                                   p_temp))   \
                    delete p_temp;                                            \
            }                                                                 \
            return sp_global_static_##FUNCTION;                               \
        }
#endif

#if QT_VERSION < QT_VERSION_CHECK(4, 4, 0)
    #define LOG4QT_IMPLEMENT_INSTANCE(TYPE)                                   \
        static TYPE *sp_singleton_##TYPE = 0;                                 \
        TYPE *TYPE::instance()                                                \
        {                                                                     \
            if (!sp_singleton_##TYPE)                                         \
            {                                                                 \
                TYPE *p_temp = new TYPE;                                      \
                if (!q_atomic_test_and_set_ptr(&sp_singleton_##TYPE,          \
                                               0, p_temp))                    \
                     delete p_temp;                                           \
            }                                                                 \
            return sp_singleton_##TYPE;                                       \
        }
#else
    #define LOG4QT_IMPLEMENT_INSTANCE(TYPE)                                   \
        static QBasicAtomicPointer<TYPE > sp_singleton_##TYPE =               \
            Q_BASIC_ATOMIC_INITIALIZER(0);                                    \
        TYPE *TYPE::instance()                                                \
        {                                                                     \
            if (!sp_singleton_##TYPE)                                         \
            {                                                                 \
                TYPE *p_temp = new TYPE;                                      \
                if (!sp_singleton_##TYPE.testAndSetOrdered(0, p_temp))        \
                    delete p_temp;                                            \
            }                                                                 \
            return sp_singleton_##TYPE;                                       \
        }
#endif

    class InitialisationHelper
    {
    private:
        InitialisationHelper();
        InitialisationHelper(const InitialisationHelper &rOther); // Not implemented
        virtual ~InitialisationHelper();
        InitialisationHelper &operator=(const InitialisationHelper &rOther); // Not implemented

    public:

        static QHash<QString, QString> environmentSettings();

        static InitialisationHelper *instance();

        static QString setting(const QString &rKey,
                               const QString &rDefault = QString());

        static qint64 startTime();

    private:
        void doInitialiseEnvironmentSettings();
        void doRegisterTypes();
        QString doSetting(const QString &rKey,
                          const QString &rDefault) const;
        static bool shutdown();
        static bool staticInitialisation();

    private:
        // QMutex mObjectGuard;
        const qint64 mStartTime;
        QHash <QString, QString> mEnvironmentSettings;
        static bool msStaticInitialisation;

#ifndef QT_NO_DEBUG_STREAM
        // Needs to be friend to access details
        friend QDebug operator<<(QDebug debug,
                                 const InitialisationHelper &rInitialisationHelper);
#endif // QT_NO_DEBUG_STREAM
    };


    /**************************************************************************
     * Operators, Helper
     **************************************************************************/

#ifndef QT_NO_DEBUG_STREAM

    QDebug operator<<(QDebug debug,
                      const InitialisationHelper &rInitialisationHelper);
#endif // QT_NO_DEBUG_STREAM


    /**************************************************************************
     * Inline
     **************************************************************************/

    inline QHash<QString, QString> InitialisationHelper::environmentSettings()
    {   // QMutexLocker locker(&instance()->mObjectGuard); // Constant for object lifetime
        return instance()->mEnvironmentSettings;  }

    inline QString InitialisationHelper::setting(const QString &rKey,
                                                 const QString &rDefault)
    {   // QMutexLocker locker(&instance()->mObjectGuard); // Reentrant and const
        return instance()->doSetting(rKey, rDefault);  }

    inline qint64 InitialisationHelper::startTime()
    {   // QMutexLocker locker(&instance()->mObjectGuard); // Constant for object lifetime
        return instance()->mStartTime;  }

} // namespace Log4Qt


// Q_DECLARE_TYPEINFO(Log4Qt::InitialisationHelper, Q_COMPLEX_TYPE); // use default


#endif // LOG4QT_HELPERS_INITIALISATIONHELPER_H

---