src/log4qt/helpers/factory.h

Go to the documentation of this file.

/******************************************************************************
 *
 * package:     Log4Qt
 * file:        factory.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_HELPERS_FACTORY_H
#define LOG4QT_HELPERS_FACTORY_H


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

#include <QtCore/QHash>
#include <QtCore/QMutex>
#include <QtCore/QStringList>


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

namespace Log4Qt
{
    
    class Appender;
    class Filter;
    class Layout;
        
    class Factory
    {
    public:
        typedef Appender *(*AppenderFactoryFunc)();
        
        typedef Filter *(*FilterFactoryFunc)();
        
        typedef Layout *(*LayoutFactoryFunc)();
        
    private:
        Factory();
        Factory(const Factory &rOther); // Not implemented
        // virtual ~Factory(); // Use compiler default
        Factory &operator=(const Factory &rOther); // Not implemented
    
    public:
        static Appender *createAppender(const QString &rAppenderClassName);
        
        static Appender *createAppender(const char *pAppenderClassName);
    
        static Filter *createFilter(const QString &rFilterClassName);
        
        static Filter *createFilter(const char *pFilterClassName);
        
        static Layout *createLayout(const QString &rLayoutClassName);
        
        static Layout *createLayout(const char *pLayoutClassName);
        
        static Factory *instance();
        
        static void registerAppender(const QString &rAppenderClassName,
                                     AppenderFactoryFunc pAppenderFactoryFunc);
        
        static void registerAppender(const char *pAppenderClassName,
                                     AppenderFactoryFunc pAppenderFactoryFunc);
        
        static void registerFilter(const QString &rFilterClassName,
                                   FilterFactoryFunc pFilterFactoryFunc);
        
        static void registerFilter(const char *pFilterClassName,
                                   FilterFactoryFunc pFilterFactoryFunc);
        
        static void registerLayout(const QString &rLayoutClassName,
                                   LayoutFactoryFunc pLayoutFactoryFunc);
        
        static void registerLayout(const char *pLayoutClassName,
                                   LayoutFactoryFunc pLayoutFactoryFunc);
        
        static QStringList registeredAppenders();
        
        static QStringList registeredFilters();
        
        static QStringList registeredLayouts();
        
        static void setObjectProperty(QObject *pObject, 
                                      const QString &rProperty,
                                      const QString &rValue);
        
        static void setObjectProperty(QObject *pObject, 
                                      const char *pProperty, 
                                      const QString &rValue);

        static void unregisterAppender(const QString &rAppenderClassName);
        
        static void unregisterAppender(const char *pAppenderClassName);
        
        static void unregisterFilter(const QString &rFilterClassName);
        
        static void unregisterFilter(const char *pFilterClassName);
        
        static void unregisterLayout(const QString &rLayoutClassName);
        
        static void unregisterLayout(const char *pLayoutClassName);

    private:
        Appender *doCreateAppender(const QString &rAppenderClassName);
        Filter *doCreateFilter(const QString &rFilterClassName);
        Layout *doCreateLayout(const QString &rLayoutClassName);
        void doRegisterAppender(const QString &rAppenderClassName,
                                AppenderFactoryFunc pAppenderFactoryFunc);
        void doRegisterFilter(const QString &rFilterClassName,
                              FilterFactoryFunc pFilterFactoryFunc);
        void doRegisterLayout(const QString &rLayoutClassName,
                              LayoutFactoryFunc pLayoutFactoryFunc);
        void doSetObjectProperty(QObject *pObject, 
                                 const QString &rProperty, 
                                 const QString &rValue);
        void doUnregisterAppender(const QString &rAppenderClassName);
        void doUnregisterFilter(const QString &rFilterClassName);
        void doUnregisterLayout(const QString &rLayoutClassName);
        void registerDefaultAppenders();
        void registerDefaultFilters();
        void registerDefaultLayouts();
        bool validateObjectProperty(QMetaProperty &rMetaProperty, 
                                    const QString &rProperty,
                                    QObject *pObject);
        
    private:
        mutable QMutex mObjectGuard;
        QHash<QString, AppenderFactoryFunc> mAppenderRegistry;
        QHash<QString, FilterFactoryFunc> mFilterRegistry;
        QHash<QString, LayoutFactoryFunc> mLayoutRegistry;
    };
    
    
    /**************************************************************************
     * Operators, Helper
     **************************************************************************/

#ifndef QT_NO_DEBUG_STREAM

    QDebug operator<<(QDebug debug, 
                      const Factory &rFactory);
#endif // QT_NO_DEBUG_STREAM

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

    inline Appender *Factory::createAppender(const QString &rAppenderClassName)
    {   return instance()->doCreateAppender(rAppenderClassName);    }
    
    inline Appender *Factory::createAppender(const char *pAppenderClassName)
    {   return instance()->doCreateAppender(QLatin1String(pAppenderClassName)); }

    inline Filter *Factory::createFilter(const QString &rFilterClassName)
    {   return instance()->doCreateFilter(rFilterClassName);    }

    inline Filter *Factory::createFilter(const char *pFilterClassName)
    {   return instance()->doCreateFilter(QLatin1String(pFilterClassName)); }
    
    inline Layout *Factory::createLayout(const QString &rLayoutClassName)
    {   return instance()->doCreateLayout(rLayoutClassName);   }
    
    inline Layout *Factory::createLayout(const char *pLayoutClassName)
    {   return instance()->doCreateLayout(QLatin1String(pLayoutClassName)); }
   
    inline void Factory::registerAppender(const QString &rAppenderClassName,
                                          AppenderFactoryFunc pAppenderFactoryFunc)
    {   instance()->doRegisterAppender(rAppenderClassName, pAppenderFactoryFunc);  }

    inline void Factory::registerAppender(const char *pAppenderClassName,
                                          AppenderFactoryFunc pAppenderFactoryFunc)
    {   instance()->doRegisterAppender(QLatin1String(pAppenderClassName), pAppenderFactoryFunc);    }
    
    inline void Factory::registerFilter(const QString &rFilterClassName,
                                 FilterFactoryFunc pFilterFactoryFunc)
    {   instance()->doRegisterFilter(rFilterClassName, pFilterFactoryFunc);   }
    
    inline void Factory::registerFilter(const char *pFilterClassName,
                                        FilterFactoryFunc pFilterFactoryFunc)
    {   instance()->doRegisterFilter(QLatin1String(pFilterClassName), pFilterFactoryFunc);  }
    
    inline void Factory::registerLayout(const QString &rLayoutClassName,
                                 LayoutFactoryFunc pLayoutFactoryFunc)
    {   instance()->doRegisterLayout(rLayoutClassName, pLayoutFactoryFunc);    }
    
    inline void Factory::registerLayout(const char *pLayoutClassName,
                                        LayoutFactoryFunc pLayoutFactoryFunc)
    {   instance()->doRegisterLayout(QLatin1String(pLayoutClassName), pLayoutFactoryFunc);  }

    inline QStringList Factory::registeredAppenders()
    {   QMutexLocker locker(&instance()->mObjectGuard);
        return instance()->mAppenderRegistry.keys();    }
    
    inline QStringList Factory::registeredFilters()
    {   QMutexLocker locker(&instance()->mObjectGuard);
        return instance()->mFilterRegistry.keys();  }
    
    inline QStringList Factory::registeredLayouts()
    {   QMutexLocker locker(&instance()->mObjectGuard);
        return instance()->mLayoutRegistry.keys();  }
    
    inline void Factory::setObjectProperty(QObject *pObject, 
                                           const QString &rProperty, 
                                           const QString &rValue)
    {   instance()->doSetObjectProperty(pObject, rProperty, rValue); }
    
    inline void Factory::setObjectProperty(QObject *pObject, 
                                           const char *pProperty, 
                                           const QString &rValue)
    {   instance()->doSetObjectProperty(pObject, QLatin1String(pProperty), rValue);  }
    
    inline void Factory::unregisterAppender(const QString &rAppenderClassName)
    {   instance()->doUnregisterAppender(rAppenderClassName);  }
    
    inline void Factory::unregisterAppender(const char *pAppenderClassName)
    {   instance()->doUnregisterAppender(QLatin1String(pAppenderClassName));    }
    
    inline void Factory::unregisterFilter(const QString &rFilterClassName)
    {   instance()->doUnregisterFilter(rFilterClassName);  }
    
    inline void Factory::unregisterFilter(const char *pFilterClassName)
    {   instance()->doUnregisterFilter(QLatin1String(pFilterClassName));    }
    
    inline void Factory::unregisterLayout(const QString &rLayoutClassName)
    {   instance()->doUnregisterLayout(rLayoutClassName);  }
    
    inline void Factory::unregisterLayout(const char *pLayoutClassName)
    {   instance()->doUnregisterLayout(QLatin1String(pLayoutClassName));    }
    
} // namespace Log4Qt   


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


#endif // LOG4QT_HELPERS_FACTORY_H

---