wilderjds
/
kconfig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

REVIEW: 118039

Browse Source 
Simplify KConfigGroup::readEntry/writeEntry.

KConfigGroup::readCheck/writeCheck caused some compilers to complain
since they were private functions that were being reimplemented outside
the class definition.

Updated KCONFIGGROUP_DECLARE_ENUM_QOBJECT/
deprecated global functions created in KDE4 times.
wilder
Thomas Braxton 12 years ago
parent 70193760af
commit 5f4dc2973f
2 changed files with 54 additions and 71 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      autotests/kconfigtest.cpp
  2. 93
      src/core/kconfiggroup.h

16
autotests/kconfigtest.cpp
Unescape View File

@ -165,10 +165,10 @@ void KConfigTest::initTestCase()
cg.writePathEntry("homepathescape", HOMEPATHESCAPE); cg.writePathEntry("homepathescape", HOMEPATHESCAPE);
cg = KConfigGroup(&sc, "Enum Types"); cg = KConfigGroup(&sc, "Enum Types");
writeEntry(cg, "enum-10", Tens); cg.writeEntry("enum-10", Tens);
writeEntry(cg, "enum-100", Hundreds); cg.writeEntry("enum-100", Hundreds);
writeEntry(cg, "flags-bit0", Flags(bit0)); cg.writeEntry("flags-bit0", Flags(bit0));
writeEntry(cg, "flags-bit0-bit1", Flags(bit0 | bit1)); cg.writeEntry("flags-bit0-bit1", Flags(bit0 | bit1));
cg = KConfigGroup(&sc, "ParentGroup"); cg = KConfigGroup(&sc, "ParentGroup");
KConfigGroup cg1(&cg, "SubGroup1"); KConfigGroup cg1(&cg, "SubGroup1");
@ -563,11 +563,11 @@ void KConfigTest::testEnums()
KConfigGroup sc3(&sc, "Enum Types"); KConfigGroup sc3(&sc, "Enum Types");
QCOMPARE(sc3.readEntry("enum-10"), QString("Tens")); QCOMPARE(sc3.readEntry("enum-10"), QString("Tens"));
QVERIFY(readEntry(sc3, "enum-100", Ones) != Ones); QVERIFY(sc3.readEntry("enum-100", Ones) != Ones);
QVERIFY(readEntry(sc3, "enum-100", Ones) != Tens); QVERIFY(sc3.readEntry("enum-100", Ones) != Tens);
QCOMPARE(sc3.readEntry("flags-bit0"), QString("bit0")); QCOMPARE(sc3.readEntry("flags-bit0"), QString("bit0"));
QVERIFY(readEntry(sc3, "flags-bit0", Flags()) == bit0); QVERIFY(sc3.readEntry("flags-bit0", Flags()) == bit0);
int eid = staticMetaObject.indexOfEnumerator("Flags"); int eid = staticMetaObject.indexOfEnumerator("Flags");
QVERIFY(eid != -1); QVERIFY(eid != -1);
@ -575,7 +575,7 @@ void KConfigTest::testEnums()
Flags bitfield = bit0 | bit1; Flags bitfield = bit0 | bit1;
QCOMPARE(sc3.readEntry("flags-bit0-bit1"), QString(me.valueToKeys(bitfield))); QCOMPARE(sc3.readEntry("flags-bit0-bit1"), QString(me.valueToKeys(bitfield)));
QVERIFY(readEntry(sc3, "flags-bit0-bit1", Flags()) == bitfield); QVERIFY(sc3.readEntry("flags-bit0-bit1", Flags()) == bitfield);
} }
void KConfigTest::testEntryMap() void KConfigTest::testEntryMap()

93
src/core/kconfiggroup.h
Unescape View File

@ -243,16 +243,13 @@ public:
* @see writeEntry(), deleteEntry(), hasKey() * @see writeEntry(), deleteEntry(), hasKey()
*/ */
template <typename T> template <typename T>
inline T readEntry(const QString &key, const T &aDefault) const T readEntry(const QString &key, const T &aDefault) const
{ {
return readCheck(key.toUtf8().constData(), aDefault); return readEntry(key.toUtf8().constData(), aDefault);
} }
/** Overload for readEntry(const QString&, const T&) const */ /** Overload for readEntry(const QString&, const T&) const */
template <typename T> template <typename T>
inline T readEntry(const char *key, const T &aDefault) const T readEntry(const char *key, const T &aDefault) const;
{
return readCheck(key, aDefault);
}
/** /**
* Reads the value of an entry specified by @p key in the current group * Reads the value of an entry specified by @p key in the current group
@ -322,16 +319,13 @@ public:
* @see readXdgListEntry(), writeEntry(), deleteEntry(), hasKey() * @see readXdgListEntry(), writeEntry(), deleteEntry(), hasKey()
*/ */
template<typename T> template<typename T>
inline QList<T> readEntry(const QString &key, const QList<T> &aDefault) const QList<T> readEntry(const QString &key, const QList<T> &aDefault) const
{ {
return readListCheck(key.toUtf8().constData(), aDefault); return readEntry(key.toUtf8().constData(), aDefault);
} }
/** Overload for readEntry(const QString&, const QList<T>&) */ /** Overload for readEntry(const QString&, const QList<T>&) */
template<typename T> template<typename T>
inline QList<T> readEntry(const char *key, const QList<T> &aDefault) const QList<T> readEntry(const char *key, const QList<T> &aDefault) const;
{
return readListCheck(key, aDefault);
}
/** /**
* Reads a list of strings from the config object, following XDG * Reads a list of strings from the config object, following XDG
@ -428,15 +422,12 @@ public:
/** Overload for writeEntry(const QString&, const QVariant&, WriteConfigFlags) */ /** Overload for writeEntry(const QString&, const QVariant&, WriteConfigFlags) */
template <typename T> template <typename T>
inline void writeEntry(const char *key, const T &value, WriteConfigFlags pFlags = Normal) void writeEntry(const char *key, const T &value, WriteConfigFlags pFlags = Normal);
{
writeCheck(key, value, pFlags);
}
/** Overload for writeEntry(const QString&, const QVariant&, WriteConfigFlags) */ /** Overload for writeEntry(const QString&, const QVariant&, WriteConfigFlags) */
template <typename T> template <typename T>
inline void writeEntry(const QString &key, const T &value, WriteConfigFlags pFlags = Normal) void writeEntry(const QString &key, const T &value, WriteConfigFlags pFlags = Normal)
{ {
writeCheck(key.toUtf8().constData(), value, pFlags); writeEntry(key.toUtf8().constData(), value, pFlags);
} }
/** Overload for writeEntry(const QString&, const QVariant&, WriteConfigFlags) */ /** Overload for writeEntry(const QString&, const QVariant&, WriteConfigFlags) */
@ -455,16 +446,13 @@ public:
/** Overload for writeEntry(const QString&, const QVariant&, WriteConfigFlags) */ /** Overload for writeEntry(const QString&, const QVariant&, WriteConfigFlags) */
template <typename T> template <typename T>
inline void writeEntry(const QString &key, const QList<T> &value, WriteConfigFlags pFlags = Normal) void writeEntry(const QString &key, const QList<T> &value, WriteConfigFlags pFlags = Normal)
{ {
writeListCheck(key.toUtf8().constData(), value, pFlags); writeEntry(key.toUtf8().constData(), value, pFlags);
} }
/** Overload for writeEntry(const QString&, const QVariant&, WriteConfigFlags) */ /** Overload for writeEntry(const QString&, const QVariant&, WriteConfigFlags) */
template <typename T> template <typename T>
inline void writeEntry(const char *key, const QList<T> &value, WriteConfigFlags pFlags = Normal) void writeEntry(const char *key, const QList<T> &value, WriteConfigFlags pFlags = Normal);
{
writeListCheck(key, value, pFlags);
}
/** /**
* Writes a list of strings to the config object, following XDG * Writes a list of strings to the config object, following XDG
@ -645,18 +633,6 @@ protected:
private: private:
QExplicitlySharedDataPointer<KConfigGroupPrivate> d; QExplicitlySharedDataPointer<KConfigGroupPrivate> d;
template<typename T>
inline T readCheck(const char *key, const T &defaultValue) const;
template<typename T>
inline QList<T> readListCheck(const char *key, const QList<T> &defaultValue) const;
template<typename T>
inline void writeCheck(const char *key, const T &value, WriteConfigFlags pFlags);
template<typename T>
inline void writeListCheck(const char *key, const QList<T> &value, WriteConfigFlags pFlags);
friend class KConfigGroupPrivate; friend class KConfigGroupPrivate;
/** /**
@ -683,63 +659,72 @@ private:
* use the macro * use the macro
* <code>KCONFIGGROUP_DECLARE_ENUM_QOBJECT(MyClass, MyEnum)</code> * <code>KCONFIGGROUP_DECLARE_ENUM_QOBJECT(MyClass, MyEnum)</code>
* *
* After that, you can use readEntry(group, key, value) and writeEntry(group, key, value[, flags]).
* Note that those are global functions, NOT member functions of KConfigGroup.
*
*/ */
#define KCONFIGGROUP_DECLARE_ENUM_QOBJECT(Class, Enum) \ #define KCONFIGGROUP_DECLARE_ENUM_QOBJECT(Class, Enum) \
inline Class::Enum readEntry(const KConfigGroup& group, const char* key, const Class::Enum& def) \ template<> \
Class::Enum KConfigGroup::readEntry(const char* key, const Class::Enum& def) const\
{ \ { \
const QMetaObject* M_obj = &Class::staticMetaObject; \ const QMetaObject* M_obj = &Class::staticMetaObject; \
const int M_index = M_obj->indexOfEnumerator(#Enum); \ const int M_index = M_obj->indexOfEnumerator(#Enum); \
if(M_index == -1) qFatal(KCONFIGGROUP_ENUMERATOR_ERROR(#Enum)); \ if(M_index == -1) qFatal(KCONFIGGROUP_ENUMERATOR_ERROR(#Enum)); \
const QMetaEnum M_enum = M_obj->enumerator(M_index); \ const QMetaEnum M_enum = M_obj->enumerator(M_index); \
const QByteArray M_data = group.readEntry(key, QByteArray(M_enum.valueToKey(def)));\ const QByteArray M_data = readEntry(key, QByteArray(M_enum.valueToKey(def)));\
return static_cast<Class::Enum>(M_enum.keyToValue(M_data.constData())); \ return static_cast<Class::Enum>(M_enum.keyToValue(M_data.constData())); \
} \ } \
inline void writeEntry(KConfigGroup& group, const char* key, const Class::Enum& value, KConfigBase::WriteConfigFlags flags = KConfigBase::Normal)\ inline Class::Enum Q_DECL_DEPRECATED readEntry(const KConfigGroup& group, const char* key, const Class::Enum& def)\
{ return group.readEntry(key, def); } \
template<> \
void KConfigGroup::writeEntry(const char* key, const Class::Enum& value, KConfigBase::WriteConfigFlags flags)\
{ \ { \
const QMetaObject* M_obj = &Class::staticMetaObject; \ const QMetaObject* M_obj = &Class::staticMetaObject; \
const int M_index = M_obj->indexOfEnumerator(#Enum); \ const int M_index = M_obj->indexOfEnumerator(#Enum); \
if(M_index == -1) qFatal(KCONFIGGROUP_ENUMERATOR_ERROR(#Enum)); \ if(M_index == -1) qFatal(KCONFIGGROUP_ENUMERATOR_ERROR(#Enum)); \
const QMetaEnum M_enum = M_obj->enumerator(M_index); \ const QMetaEnum M_enum = M_obj->enumerator(M_index); \
group.writeEntry(key, QByteArray(M_enum.valueToKey(value)), flags); \ writeEntry(key, QByteArray(M_enum.valueToKey(value)), flags); \
} } \
inline void Q_DECL_DEPRECATED writeEntry(KConfigGroup& group, const char* key, const Class::Enum& value, KConfigBase::WriteConfigFlags flags = KConfigBase::Normal)\
{ group.writeEntry(key, value, flags); }
/** /**
* Similar to KCONFIGGROUP_DECLARE_ENUM_QOBJECT but for flags declared with Q_FLAGS() * Similar to KCONFIGGROUP_DECLARE_ENUM_QOBJECT but for flags declared with Q_FLAGS()
* (where multiple values can be set at the same time) * (where multiple values can be set at the same time)
*/ */
#define KCONFIGGROUP_DECLARE_FLAGS_QOBJECT(Class, Flags) \ #define KCONFIGGROUP_DECLARE_FLAGS_QOBJECT(Class, Flags) \
inline Class::Flags readEntry(const KConfigGroup& group, const char* key, const Class::Flags& def) \ template<> \
Class::Flags KConfigGroup::readEntry(const char* key, const Class::Flags& def) const\
{ \ { \
const QMetaObject* M_obj = &Class::staticMetaObject; \ const QMetaObject* M_obj = &Class::staticMetaObject; \
const int M_index = M_obj->indexOfEnumerator(#Flags); \ const int M_index = M_obj->indexOfEnumerator(#Flags); \
if(M_index == -1) qFatal(KCONFIGGROUP_ENUMERATOR_ERROR(#Flags)); \ if(M_index == -1) qFatal(KCONFIGGROUP_ENUMERATOR_ERROR(#Flags)); \
const QMetaEnum M_enum = M_obj->enumerator(M_index); \ const QMetaEnum M_enum = M_obj->enumerator(M_index); \
const QByteArray M_data = group.readEntry(key, QByteArray(M_enum.valueToKeys(def)));\ const QByteArray M_data = readEntry(key, QByteArray(M_enum.valueToKeys(def)));\
return static_cast<Class::Flags>(M_enum.keysToValue(M_data.constData())); \ return static_cast<Class::Flags>(M_enum.keysToValue(M_data.constData())); \
} \ } \
inline void writeEntry(KConfigGroup& group, const char* key, const Class::Flags& value, KConfigBase::WriteConfigFlags flags = KConfigBase::Normal)\ inline Class::Flags Q_DECL_DEPRECATED readEntry(const KConfigGroup& group, const char* key, const Class::Flags& def)\
{ return group.readEntry(key, def);} \
template<> \
void KConfigGroup::writeEntry(const char* key, const Class::Flags& value, KConfigBase::WriteConfigFlags flags)\
{ \ { \
const QMetaObject* M_obj = &Class::staticMetaObject; \ const QMetaObject* M_obj = &Class::staticMetaObject; \
const int M_index = M_obj->indexOfEnumerator(#Flags); \ const int M_index = M_obj->indexOfEnumerator(#Flags); \
if(M_index == -1) qFatal(KCONFIGGROUP_ENUMERATOR_ERROR(#Flags)); \ if(M_index == -1) qFatal(KCONFIGGROUP_ENUMERATOR_ERROR(#Flags)); \
const QMetaEnum M_enum = M_obj->enumerator(M_index); \ const QMetaEnum M_enum = M_obj->enumerator(M_index); \
group.writeEntry(key, QByteArray(M_enum.valueToKeys(value)), flags); \ writeEntry(key, QByteArray(M_enum.valueToKeys(value)), flags); \
} } \
inline void Q_DECL_DEPRECATED writeEntry(KConfigGroup& group, const char* key, const Class::Flags& value, KConfigBase::WriteConfigFlags flags = KConfigBase::Normal)\
{ group.writeEntry(key, value, flags); }
#include "conversioncheck.h" #include "conversioncheck.h"
template <typename T> template <typename T>
T KConfigGroup::readCheck(const char *key, const T &defaultValue) const T KConfigGroup::readEntry(const char *key, const T &defaultValue) const
{ {
ConversionCheck::to_QVariant<T>(); ConversionCheck::to_QVariant<T>();
return qvariant_cast<T>(readEntry(key, qVariantFromValue(defaultValue))); return qvariant_cast<T>(readEntry(key, qVariantFromValue(defaultValue)));
} }
template <typename T> template <typename T>
QList<T> KConfigGroup::readListCheck(const char *key, const QList<T> &defaultValue) const QList<T> KConfigGroup::readEntry(const char *key, const QList<T> &defaultValue) const
{ {
ConversionCheck::to_QVariant<T>(); ConversionCheck::to_QVariant<T>();
ConversionCheck::to_QString<T>(); ConversionCheck::to_QString<T>();
@ -760,16 +745,14 @@ QList<T> KConfigGroup::readListCheck(const char *key, const QList<T> &defaultVal
} }
template <typename T> template <typename T>
void KConfigGroup::writeCheck(const char *key, const T &value, void KConfigGroup::writeEntry(const char *key, const T &value, WriteConfigFlags pFlags)
WriteConfigFlags pFlags)
{ {
ConversionCheck::to_QVariant<T>(); ConversionCheck::to_QVariant<T>();
writeEntry(key, qVariantFromValue(value), pFlags); writeEntry(key, qVariantFromValue(value), pFlags);
} }
template <typename T> template <typename T>
void KConfigGroup::writeListCheck(const char *key, const QList<T> &list, void KConfigGroup::writeEntry(const char *key, const QList<T> &list, WriteConfigFlags pFlags)
WriteConfigFlags pFlags)
{ {
ConversionCheck::to_QVariant<T>(); ConversionCheck::to_QVariant<T>();
ConversionCheck::to_QString<T>(); ConversionCheck::to_QString<T>();

Write Preview
Loading…
Cancel
Save