433 lines
14 KiB
C++
433 lines
14 KiB
C++
/******************************************************************************
|
|
*
|
|
* This file is part of Log4Qt library.
|
|
*
|
|
* Copyright (C) 2007 - 2020 Log4Qt contributors
|
|
*
|
|
* 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
|
|
|
|
#include "log4qt/log4qtshared.h"
|
|
|
|
#include <QHash>
|
|
#include <QMutex>
|
|
#include <QStringList>
|
|
|
|
class QObject;
|
|
class QMetaProperty;
|
|
|
|
namespace Log4Qt
|
|
{
|
|
|
|
class Appender;
|
|
class Filter;
|
|
class Layout;
|
|
|
|
/*!
|
|
* \brief The class Factory provides factories for Appender, Filter and
|
|
* Layout objects.
|
|
*
|
|
* The functions createAppender(), createFilter() and createLayout()
|
|
* allow to create objects by specifying their class names. By default
|
|
* all classes of the package are recognised with their Log4j and Log4Qt
|
|
* classanmes. For example an object of the class FileAppender can be
|
|
* craeted using "org.apache.log4j.FileAppender" or "Log4Qt::FileAppender".
|
|
* Additional classes can be registered using registerAppender(),
|
|
* registerFilter() and registerLayout().
|
|
*
|
|
* An QObject property can be set from a string value with
|
|
* setObjectProperty(). The function handles the required error checking
|
|
* and type conversion.
|
|
*
|
|
* \note All the functions declared in this class are thread-safe.
|
|
*
|
|
* \sa PropertyConfigurator
|
|
*/
|
|
class LOG4QT_EXPORT Factory
|
|
{
|
|
public:
|
|
/*!
|
|
* Prototype for an Appender factory function. The function creates
|
|
* an Appender object on the heap and returns a pointer to it.
|
|
*
|
|
* \sa registerAppender(), createAppender()
|
|
*/
|
|
typedef Appender *(*AppenderFactoryFunc)();
|
|
|
|
/*!
|
|
* Prototype for a Filter factory function. The function creates
|
|
* a Filter object on the heap and returns a pointer to it.
|
|
*
|
|
* \sa registerFilter(), createFilter()
|
|
*/
|
|
typedef Filter *(*FilterFactoryFunc)();
|
|
|
|
/*!
|
|
* Prototype for a Layout factory function. The function creates
|
|
* a Layout object on the heap and returns a pointer to it.
|
|
*
|
|
* \sa registerLayout(), createLayout()
|
|
*/
|
|
typedef Layout *(*LayoutFactoryFunc)();
|
|
|
|
private:
|
|
Factory();
|
|
Q_DISABLE_COPY(Factory)
|
|
|
|
public:
|
|
/*!
|
|
* Creates an object for the class \a appenderClassName on the heap
|
|
* and returns a pointer to it. If the class has no registered factory
|
|
* function a null pointer is returned.
|
|
*
|
|
* \sa registerAppender(), unregisterAppender(), registeredAppenders()
|
|
*/
|
|
static Appender *createAppender(const QString &appenderClassName);
|
|
|
|
/*!
|
|
* This is an overloaded member function, provided for convenience.
|
|
*/
|
|
static Appender *createAppender(const char *appenderClassName);
|
|
|
|
/*!
|
|
* Creates an object for the class \a filterClassName on the heap
|
|
* and returns a pointer to it. If the class has no registered factory
|
|
* function a null pointer is returned.
|
|
*
|
|
* \sa registerFilter(), unregisterFilter(), registeredFilters()
|
|
*/
|
|
static Filter *createFilter(const QString &filterClassName);
|
|
|
|
/*!
|
|
* This is an overloaded member function, provided for convenience.
|
|
*/
|
|
static Filter *createFilter(const char *filterClassName);
|
|
|
|
/*!
|
|
* Creates an object for the class \a layoutClassName on the heap
|
|
* and returns a pointer to it. If the class has no registered factory
|
|
* function a null pointer is returned.
|
|
*
|
|
* \sa registerLayout(), unregisterLayout(), registeredLayouts()
|
|
*/
|
|
static Layout *createLayout(const QString &layoutClassName);
|
|
|
|
/*!
|
|
* This is an overloaded member function, provided for convenience.
|
|
*/
|
|
static Layout *createLayout(const char *layoutClassName);
|
|
|
|
/*!
|
|
* Returns the Factory instance.
|
|
*/
|
|
static Factory *instance();
|
|
|
|
/*!
|
|
* Registers the Appender factory function \a appenderFactoryFunc
|
|
* for the class \a appenderClassName. If a registered factory
|
|
* function exists for the class, it is replaced with
|
|
* \a appenderFactoryFunc.
|
|
*
|
|
* \sa unregisterAppender(), registeredAppenders(), createAppender()
|
|
*/
|
|
static void registerAppender(const QString &appenderClassName,
|
|
AppenderFactoryFunc appenderFactoryFunc);
|
|
|
|
/*!
|
|
* This is an overloaded member function, provided for convenience.
|
|
*/
|
|
static void registerAppender(const char *appenderClassName,
|
|
AppenderFactoryFunc appenderFactoryFunc);
|
|
|
|
/*!
|
|
* Registers the Filter factory function \a filterFactoryFunc
|
|
* for the class \a filterClassName. If a registered factory
|
|
* function exists for the class, it is replaced with
|
|
* \a filterFactoryFunc.
|
|
*
|
|
* \sa unregisterFilter(), registeredFilters(), createFilter()
|
|
*/
|
|
static void registerFilter(const QString &filterClassName,
|
|
FilterFactoryFunc filterFactoryFunc);
|
|
|
|
/*!
|
|
* This is an overloaded member function, provided for convenience.
|
|
*/
|
|
static void registerFilter(const char *filterClassName,
|
|
FilterFactoryFunc filterFactoryFunc);
|
|
|
|
/*!
|
|
* Registers the Layout factory function \a layoutFactoryFunc
|
|
* for the class \a filterClassName. If a registered factory
|
|
* function exists for the class, it is replaced with
|
|
* \a layoutFactoryFunc.
|
|
*
|
|
* \sa unregisterLayout(), registeredLayout(), createLayout()
|
|
*/
|
|
static void registerLayout(const QString &layoutClassName,
|
|
LayoutFactoryFunc layoutFactoryFunc);
|
|
|
|
/*!
|
|
* This is an overloaded member function, provided for convenience.
|
|
*/
|
|
static void registerLayout(const char *layoutClassName,
|
|
LayoutFactoryFunc layoutFactoryFunc);
|
|
|
|
/*!
|
|
* Returns a list of the class names for registered Appender factory
|
|
* functions.
|
|
*
|
|
* \sa registerAppender(), unregisterAppender()
|
|
*/
|
|
static QStringList registeredAppenders();
|
|
|
|
/*!
|
|
* Returns a list of the class names for registered Filter factory
|
|
* functions.
|
|
*
|
|
* \sa registerFilter(), unregisterFilter()
|
|
*/
|
|
static QStringList registeredFilters();
|
|
|
|
/*!
|
|
* Returns a list of the class names for registered Layout factory
|
|
* functions.
|
|
*
|
|
* \sa registerLayout(), unregisterLayout()
|
|
*/
|
|
static QStringList registeredLayouts();
|
|
|
|
/*!
|
|
* Sets the property \a rProperty of the object \a pObject to the
|
|
* value \a rValue. The function will test that the property
|
|
* \a rProperty is writeable and of a type the function can convert to.
|
|
* The types bool, int, Level and QString are supported.
|
|
*
|
|
* \sa OptionConverter
|
|
*/
|
|
static void setObjectProperty(QObject *object,
|
|
const QString &property,
|
|
const QString &value);
|
|
|
|
/*!
|
|
* This is an overloaded member function, provided for convenience.
|
|
*/
|
|
static void setObjectProperty(QObject *object,
|
|
const char *property,
|
|
const QString &value);
|
|
|
|
/*!
|
|
* Unregisters the Appender factory function for the class
|
|
* \a rAppenderClassName.
|
|
*
|
|
* \sa registerAppender(), registeredAppenders()
|
|
*/
|
|
static void unregisterAppender(const QString &appenderClassName);
|
|
|
|
/*!
|
|
* This is an overloaded member function, provided for convenience.
|
|
*/
|
|
static void unregisterAppender(const char *appenderClassName);
|
|
|
|
/*!
|
|
* Unregisters the Filter factory function for the class
|
|
* \a filterClassName.
|
|
*
|
|
* \sa registerFilter(), registeredFilters()
|
|
*/
|
|
static void unregisterFilter(const QString &filterClassName);
|
|
|
|
/*!
|
|
* This is an overloaded member function, provided for convenience.
|
|
*/
|
|
static void unregisterFilter(const char *filterClassName);
|
|
|
|
/*!
|
|
* Unregisters the Layout factory function for the class
|
|
* \a filterClassName.
|
|
*
|
|
* \sa registerLayout(), registeredLayouts()
|
|
*/
|
|
static void unregisterLayout(const QString &filterClassName);
|
|
|
|
/*!
|
|
* This is an overloaded member function, provided for convenience.
|
|
*/
|
|
static void unregisterLayout(const char *layoutClassName);
|
|
|
|
private:
|
|
Appender *doCreateAppender(const QString &appenderClassName);
|
|
Filter *doCreateFilter(const QString &filterClassName);
|
|
Layout *doCreateLayout(const QString &layoutClassName);
|
|
void doRegisterAppender(const QString &appenderClassName,
|
|
AppenderFactoryFunc appenderFactoryFunc);
|
|
void doRegisterFilter(const QString &filterClassName,
|
|
FilterFactoryFunc filterFactoryFunc);
|
|
void doRegisterLayout(const QString &filterClassName,
|
|
LayoutFactoryFunc layoutFactoryFunc);
|
|
void doSetObjectProperty(QObject *object,
|
|
const QString &property,
|
|
const QString &value);
|
|
void doUnregisterAppender(const QString &appenderClassName);
|
|
void doUnregisterFilter(const QString &filterClassName);
|
|
void doUnregisterLayout(const QString &filterClassName);
|
|
void registerDefaultAppenders();
|
|
void registerDefaultFilters();
|
|
void registerDefaultLayouts();
|
|
bool validateObjectProperty(QMetaProperty &metaProperty,
|
|
const QString &property,
|
|
QObject *object);
|
|
|
|
private:
|
|
mutable QMutex mObjectGuard;
|
|
QHash<QString, AppenderFactoryFunc> mAppenderRegistry;
|
|
QHash<QString, FilterFactoryFunc> mFilterRegistry;
|
|
QHash<QString, LayoutFactoryFunc> mLayoutRegistry;
|
|
};
|
|
|
|
inline Appender *Factory::createAppender(const QString &appenderClassName)
|
|
{
|
|
return instance()->doCreateAppender(appenderClassName);
|
|
}
|
|
|
|
inline Appender *Factory::createAppender(const char *appenderClassName)
|
|
{
|
|
return instance()->doCreateAppender(QLatin1String(appenderClassName));
|
|
}
|
|
|
|
inline Filter *Factory::createFilter(const QString &filterClassName)
|
|
{
|
|
return instance()->doCreateFilter(filterClassName);
|
|
}
|
|
|
|
inline Filter *Factory::createFilter(const char *layoutClassName)
|
|
{
|
|
return instance()->doCreateFilter(QLatin1String(layoutClassName));
|
|
}
|
|
|
|
inline Layout *Factory::createLayout(const QString &layoutClassName)
|
|
{
|
|
return instance()->doCreateLayout(layoutClassName);
|
|
}
|
|
|
|
inline Layout *Factory::createLayout(const char *layoutClassName)
|
|
{
|
|
return instance()->doCreateLayout(QLatin1String(layoutClassName));
|
|
}
|
|
|
|
inline void Factory::registerAppender(const QString &appenderClassName,
|
|
AppenderFactoryFunc appenderFactoryFunc)
|
|
{
|
|
instance()->doRegisterAppender(appenderClassName, appenderFactoryFunc);
|
|
}
|
|
|
|
inline void Factory::registerAppender(const char *appenderClassName,
|
|
AppenderFactoryFunc appenderFactoryFunc)
|
|
{
|
|
instance()->doRegisterAppender(QLatin1String(appenderClassName), appenderFactoryFunc);
|
|
}
|
|
|
|
inline void Factory::registerFilter(const QString &filterClassName,
|
|
FilterFactoryFunc filterFactoryFunc)
|
|
{
|
|
instance()->doRegisterFilter(filterClassName, filterFactoryFunc);
|
|
}
|
|
|
|
inline void Factory::registerFilter(const char *filterClassName,
|
|
FilterFactoryFunc filterFactoryFunc)
|
|
{
|
|
instance()->doRegisterFilter(QLatin1String(filterClassName), filterFactoryFunc);
|
|
}
|
|
|
|
inline void Factory::registerLayout(const QString &filterClassName,
|
|
LayoutFactoryFunc layoutFactoryFunc)
|
|
{
|
|
instance()->doRegisterLayout(filterClassName, layoutFactoryFunc);
|
|
}
|
|
|
|
inline void Factory::registerLayout(const char *layoutClassName,
|
|
LayoutFactoryFunc layoutFactoryFunc)
|
|
{
|
|
instance()->doRegisterLayout(QLatin1String(layoutClassName), layoutFactoryFunc);
|
|
}
|
|
|
|
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 *object,
|
|
const QString &property,
|
|
const QString &value)
|
|
{
|
|
instance()->doSetObjectProperty(object, property, value);
|
|
}
|
|
|
|
inline void Factory::setObjectProperty(QObject *object,
|
|
const char *property,
|
|
const QString &value)
|
|
{
|
|
instance()->doSetObjectProperty(object, QLatin1String(property), value);
|
|
}
|
|
|
|
inline void Factory::unregisterAppender(const QString &appenderClassName)
|
|
{
|
|
instance()->doUnregisterAppender(appenderClassName);
|
|
}
|
|
|
|
inline void Factory::unregisterAppender(const char *appenderClassName)
|
|
{
|
|
instance()->doUnregisterAppender(QLatin1String(appenderClassName));
|
|
}
|
|
|
|
inline void Factory::unregisterFilter(const QString &filterClassName)
|
|
{
|
|
instance()->doUnregisterFilter(filterClassName);
|
|
}
|
|
|
|
inline void Factory::unregisterFilter(const char *filterClassName)
|
|
{
|
|
instance()->doUnregisterFilter(QLatin1String(filterClassName));
|
|
}
|
|
|
|
inline void Factory::unregisterLayout(const QString &filterClassName)
|
|
{
|
|
instance()->doUnregisterLayout(filterClassName);
|
|
}
|
|
|
|
inline void Factory::unregisterLayout(const char *layoutClassName)
|
|
{
|
|
instance()->doUnregisterLayout(QLatin1String(layoutClassName));
|
|
}
|
|
|
|
} // namespace Log4Qt
|
|
|
|
#endif // LOG4QT_HELPERS_FACTORY_H
|