[prev in list] [next in list] [prev in thread] [next in thread]
List: kde-core-devel
Subject: [Fwd: KConfig on windows/msvc]
From: Jarosław_Staniek <js () iidea ! pl>
Date: 2007-10-30 9:04:30
Message-ID: 4726F39E.80404 () iidea ! pl
[Download RAW message or body]
Hello
I am forwarding a post I've sent to Marc Mutz who I met in Berlin last weekend
at KOffice meeting; he was helpful before with fixing of gpgme++ compilation.
The patch attached is only to get idea what I currently needed to use in
ordetr to get working environment at the KOffice meeting. You can focus on my
decription below on compile errors I encounter and what easy fixes I've tried.
Hopefully another easy can be added KConfigGroup::readListCheck().
-------- Original Message --------
Subject: KConfig on windows/msvc
Date: Mon, 29 Oct 2007 18:53:17 +0100
From: Jarosław Staniek <js@iidea.pl>
Organization: OpenOffice Polska
To: marc@kdab.net
Marc,
I am referring to our dicussion in Berlin last weekend about msvc 2k3(sp1)
templates and my problem in KConfig.
I've attached (very temporary) patch which break source compatibility ;(
If you have any hints, I'd be extremely grateful to you for your help.
Without any patch the following error appears:
[ 0%] Building CXX object kdecore/CMakeFiles/kdecore.dir/config/kconfig.obj
kconfig.cpp
f:\kde4\trunk\kde\kdelibs\kdecore\config\kconfiggroup.h(172) : fatal error
C1001: INTERNAL COMPILER ERROR
(compiler file
'f:\vs70builds\6030\vc\Compiler\Utc\src\P2\main.c', line 148)
Then, I've fixed this by changing readEntry() to readListCheck() in line 172
and 169 (see [1]).
Then I got this error:
f:\kde4\trunk\kde\kdelibs\kdecore\config\kconfiggroup.h(500) : fatal error
C1001: INTERNAL COMPILER ERROR
(compiler file
'f:\vs70builds\6030\vc\Compiler\Utc\src\P2\main.c', line 148)
Apparently, conversion from QVariant to T is a problem. Using value<T> does
not help.
template<class T>
T KConfigGroup::readListCheck(const QByteArray &key,
const T&defaultValue) const
{
ConversionCheck::to_QVariant<T>();
>>>> return qvariant_cast<T>(readEntry(key,
qVariantFromValue(defaultValue)));
}
[1]
Index: kdecore/config/kconfiggroup.h
===================================================================
--- kdecore/config/kconfiggroup.h (revision 730754)
+++ kdecore/config/kconfiggroup.h (working copy)
@@ -166,10 +166,10 @@
{ return readListCheck(key, defaultValue); }
template <typename T>
T readEntry(const QString& pKey, const T& aDefault) const
- { return readEntry(pKey.toUtf8(), aDefault); }
+ { return readListCheck(pKey.toUtf8(), aDefault); }
template <typename T>
T readEntry(const char *key, const T& aDefault) const
- { return readEntry(QByteArray(key), aDefault); }
+ { return readListCheck(QByteArray(key), aDefault); }
QString readEntry(const QByteArray &key, const char * aDefault = 0) const;
QString readEntry(const QString &key, const char * aDefault = 0) const;
--
regards / pozdrawiam, Jaroslaw Staniek
Sponsored by OpenOffice Polska (http://www.openoffice.com.pl/en) to work on
Kexi & KOffice: http://www.kexi.pl/en, http://www.koffice.org
KDE3 & KDE4 Libraries for MS Windows: http://kdelibs.com, http://www.kde.org
["kdecore_config2.patch" (text/plain)]
Index: kdecore/config/kconfiggroup.h
===================================================================
--- kdecore/config/kconfiggroup.h (revision 730754)
+++ kdecore/config/kconfiggroup.h (working copy)
@@ -35,6 +35,7 @@
class KConfig;
class KConfigGroupPrivate;
class KSharedConfig;
+class KUrl;
template <typename T> class KSharedPtr;
typedef KSharedPtr<KSharedConfig> KSharedConfigPtr;
@@ -162,19 +163,97 @@
* @return The value for this key, or @p aDefault.
*/
template <typename T>
- T readEntry(const QByteArray &key, const T &defaultValue) const
+ T readEntryTemplate(const QByteArray &key, const T &defaultValue) \
const { return readListCheck(key, defaultValue); }
template <typename T>
- T readEntry(const QString& pKey, const T& aDefault) const
- { return readEntry(pKey.toUtf8(), aDefault); }
+ T readEntryTemplate(const QString& pKey, const T& aDefault) const
+ { return readListCheck(pKey.toUtf8(), aDefault); }
template <typename T>
- T readEntry(const char *key, const T& aDefault) const
- { return readEntry(QByteArray(key), aDefault); }
+ T readEntryTemplate(const char *key, const T& aDefault) const
+ { return readListCheck(QByteArray(key), aDefault); }
+ template <typename T>
+ QList<T> readEntryTemplate(const QByteArray &key, const QList<T>& \
aDefault) const + { return readListCheck<T>(key, aDefault); }
+ template <typename T>
+ QList<T> readEntryTemplate(const QString &key, const QList<T>& \
aDefault) const + { return readListCheck<T>(key.toUtf8(), \
aDefault); } + template <typename T>
+ QList<T> readEntryTemplate(const char *key, const QList<T>& \
aDefault) const + { return readListCheck<T>(QByteArray(key), \
aDefault); } +
QString readEntry(const QByteArray &key, const char * aDefault = 0) \
const;
QString readEntry(const QString &key, const char * aDefault = 0) \
const; QString readEntry(const char *key, const char * aDefault = 0) \
const;
+ QString readEntry(const QByteArray &key, const QString &aDefault) \
const; + QString readEntry(const QString &key, const QString &aDefault) \
const; + QString readEntry(const char *key, const QString &aDefault) \
const; +
+ QStringList readEntry(const QByteArray &key, const QStringList \
&defaultValue) const; + QStringList readEntry(const QString &key, const \
QStringList &aDefault) const; + QStringList readEntry(const char *key, \
const QStringList &aDefault) const; +
+ QByteArray readEntry(const QByteArray &key, const QByteArray \
&defaultValue) const; + QByteArray readEntry(const QString &key, const \
QByteArray &defaultValue) const; + QByteArray readEntry(const char *key, \
const QByteArray &defaultValue) const; +
+ QVariant readEntry(const QByteArray &key, const QVariant \
&defaultValue) const; + QVariant readEntry(const QString &key, const \
QVariant &defaultValue) const; + QVariant readEntry(const char *key, \
const QVariant &aDefault) const; +
+ QVariantList readEntry(const QByteArray &key, const QVariantList \
&defaultValue) const; + QVariantList readEntry(const QString &key, const \
QVariantList &aDefault) const; + QVariantList readEntry(const char *key, \
const QVariantList &aDefault) const; +
+ double readEntry(const QByteArray &key, double aDefault) const;
+ double readEntry(const QString &key, double aDefault) const;
+ double readEntry(const char *key, double aDefault) const;
+
+ bool readEntry(const QByteArray &key, bool aDefault) const;
+ bool readEntry(const QString &key, bool aDefault) const;
+ bool readEntry(const char *key, bool aDefault) const;
+
+ int readEntry(const QByteArray &key, int aDefault) const;
+ int readEntry(const QString &key, int aDefault) const;
+ int readEntry(const char *key, int aDefault) const;
+
+ uint readEntry(const QByteArray &key, uint aDefault) const;
+ uint readEntry(const QString &key, uint aDefault) const;
+ uint readEntry(const char *key, uint aDefault) const;
+
+ qlonglong readEntry(const QByteArray &key, qlonglong aDefault) const;
+ qlonglong readEntry(const QString &key, qlonglong aDefault) const;
+ qlonglong readEntry(const char *key, qlonglong aDefault) const;
+
+ qulonglong readEntry(const QByteArray &key, qulonglong aDefault) \
const; + qulonglong readEntry(const QString &key, qulonglong aDefault) \
const; + qulonglong readEntry(const char *key, qulonglong aDefault) \
const; +
+ KUrl readEntry(const QByteArray &key, const KUrl& aDefault) const;
+ KUrl readEntry(const QString &key, const KUrl& aDefault) const;
+ KUrl readEntry(const char *key, const KUrl& aDefault) const;
+
+ QPoint readEntry(const QByteArray &key, const QPoint &aDefault) const;
+ QPoint readEntry(const QString &key, const QPoint &aDefault) const;
+ QPoint readEntry(const char *key, const QPoint &aDefault) const;
+
+ QSize readEntry(const QByteArray &key, const QSize &aDefault) const;
+ QSize readEntry(const QString &key, const QSize &aDefault) const;
+ QSize readEntry(const char *key, const QSize &aDefault) const;
+
+ QRect readEntry(const QByteArray &key, const QRect &aDefault) const;
+ QRect readEntry(const QString &key, const QRect &aDefault) const;
+ QRect readEntry(const char *key, const QRect &aDefault) const;
+
+ QDate readEntry(const QByteArray &key, const QDate &aDefault) const;
+ QDate readEntry(const QString &key, const QDate &aDefault) const;
+ QDate readEntry(const char *key, const QDate &aDefault) const;
+
+ QDateTime readEntry(const QByteArray &key, const QDateTime &aDefault) \
const; + QDateTime readEntry(const QString &key, const QDateTime \
&aDefault) const; + QDateTime readEntry(const char *key, const QDateTime \
&aDefault) const; +
/**
* Reads a list of strings from the config object, following XDG
* desktop entry spec separator semantics.
@@ -239,19 +318,64 @@
* @param pFlags The flags to use when writing this entry.
*/
template <typename T>
- void writeEntry(const QByteArray &key, const T& value, \
WriteConfigFlags pFlags = Normal ) + void writeEntryTemplate(const \
QByteArray &key, const T& value, WriteConfigFlags pFlags = Normal ) { \
writeListCheck(key, value, pFlags); } template <typename T>
- void writeEntry( const QString& pKey, const T& value, \
WriteConfigFlags pFlags = Normal ) + void writeEntryTemplate( const \
QString& pKey, const T& value, WriteConfigFlags pFlags = Normal ) { \
writeEntry( pKey.toUtf8(), value, pFlags ); } template <typename T>
- void writeEntry( const char *key, const T& value, WriteConfigFlags \
pFlags = Normal ) + void writeEntryTemplate( const char *key, const \
T& value, WriteConfigFlags pFlags = Normal ) { writeEntry( \
QByteArray(key), value, pFlags ); }
+ template <typename T>
+ void writeEntry(const QByteArray &key, const QList<T>& value, \
WriteConfigFlags pFlags = Normal ) + { writeListCheck<T>(key, \
value, pFlags); } + template <typename T>
+ void writeEntry(const QString& key, const QList<T>& value, \
WriteConfigFlags pFlags = Normal ) + { \
writeListCheck<T>(key.toUtf8(), value, pFlags); } + template <typename \
T> + void writeEntry(const char *key, const QList<T>& value, \
WriteConfigFlags pFlags = Normal ) + { \
writeListCheck<T>(QByteArray(key), value, pFlags); } +
void writeEntry(const QByteArray &key, const char *value, \
WriteConfigFlags pFlags = Normal);
void writeEntry(const QString &key, const char *value, \
WriteConfigFlags pFlags = Normal); + void writeEntry(const QString &key, \
const QByteArray &value, WriteConfigFlags pFlags = Normal); + void \
writeEntry(const QString &key, const QString &value, WriteConfigFlags \
pFlags = Normal); + void writeEntry(const QString &key, int value, \
WriteConfigFlags pFlags = Normal); + void writeEntry(const QString &key, \
qlonglong value, WriteConfigFlags pFlags = Normal); + void \
writeEntry(const QString &key, uint value, WriteConfigFlags pFlags = \
Normal); + void writeEntry(const QString &key, qulonglong value, \
WriteConfigFlags pFlags = Normal); + void writeEntry(const QString &key, \
double value, WriteConfigFlags pFlags = Normal); + void writeEntry(const \
QString &key, const QStringList &value, KConfigBase::WriteConfigFlags \
pFlags = Normal); + void writeEntry(const QString &key, const KUrl \
&value, KConfigBase::WriteConfigFlags pFlags = Normal); + void \
writeEntry(const QString &key, const QVariant& value, WriteConfigFlags \
pFlags = Normal); + void writeEntry(const char *key, const QVariant& \
value, WriteConfigFlags pFlags = Normal);
void writeEntry(const char *key, const char *value, WriteConfigFlags \
pFlags = Normal); + void writeEntry(const char *key, bool value, \
WriteConfigFlags pFlags = Normal); + void writeEntry(const char *key, \
const QString &value, WriteConfigFlags pFlags = Normal); + void \
writeEntry(const char *key, const QByteArray &value, WriteConfigFlags \
pFlags = Normal); + void writeEntry(const char *key, int value, \
WriteConfigFlags pFlags = Normal); + void writeEntry(const char *key, \
const QStringList &value, WriteConfigFlags pFlags = Normal); + void \
writeEntry(const char *key, const QVariantList &value, WriteConfigFlags \
pFlags = Normal); + void writeEntry(const char *key, qlonglong value, \
WriteConfigFlags pFlags = Normal); + void writeEntry(const char *key, \
uint value, WriteConfigFlags pFlags = Normal); + void writeEntry(const \
char *key, qulonglong value, WriteConfigFlags pFlags = Normal); + void \
writeEntry(const char *key, double value, WriteConfigFlags pFlags = \
Normal); + void writeEntry(const char *key, const KUrl &value, \
WriteConfigFlags pFlags = Normal);
+ void writeEntry(const QByteArray &key, const QVariant &value, \
WriteConfigFlags pFlags = Normal); + void writeEntry(const QByteArray \
&key, bool value, WriteConfigFlags pFlags = Normal); + void \
writeEntry(const QByteArray &key, const QString &value, WriteConfigFlags \
pFlags = Normal); + void writeEntry(const QByteArray &key, const \
QByteArray &value, WriteConfigFlags pFlags = Normal); + void \
writeEntry(const QByteArray &key, const QStringList &value, \
WriteConfigFlags pFlags = Normal); + void writeEntry(const QByteArray \
&key, const QVariantList &value, WriteConfigFlags pFlags = Normal); + \
void writeEntry(const QByteArray &key, int value, WriteConfigFlags pFlags = \
Normal); + void writeEntry(const QByteArray &key, qlonglong value, \
WriteConfigFlags pFlags = Normal); + void writeEntry(const QByteArray \
&key, uint value, WriteConfigFlags pFlags = Normal); + void \
writeEntry(const QByteArray &key, qulonglong value, WriteConfigFlags pFlags \
= Normal); + void writeEntry(const QByteArray &key, double value, \
WriteConfigFlags pFlags = Normal); + void writeEntry(const QByteArray \
&key, const KUrl &value, WriteConfigFlags pFlags = Normal); +
/**
* Writes a list of strings to the config object, following XDG
* desktop entry spec separator semantics.
@@ -484,15 +608,6 @@
#include "conversion_check.h"
-template<>
-KDECORE_EXPORT QVariantList KConfigGroup::readEntry<QVariantList>(const \
QByteArray &key, const QVariantList &defaultValue) const;
-template<>
-KDECORE_EXPORT QVariant KConfigGroup::readEntry<QVariant>(const QByteArray \
&key, const QVariant &defaultValue) const;
-template<>
-KDECORE_EXPORT QStringList KConfigGroup::readEntry<QStringList>(const \
QByteArray &key, const QStringList &defaultValue) const;
-template<>
-KDECORE_EXPORT QString KConfigGroup::readEntry<QString>(const QByteArray \
&key, const QString &defaultValue) const;
-
template<class T>
T KConfigGroup::readListCheck(const QByteArray &key, const T \
&defaultValue) const {
@@ -520,19 +635,6 @@
return list;
}
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<QVariant>(const QByteArray \
&key, const QVariant &value, KConfigBase::WriteConfigFlags \
pFlags);
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<const char *>(const \
QByteArray &key, const char * const &value, KConfigBase::WriteConfigFlags \
pFlags);
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<QString>(const QByteArray \
&key, const QString &value, KConfigBase::WriteConfigFlags \
pFlags);
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<QByteArray>(const QByteArray \
&key, const QByteArray &value, \
KConfigBase::WriteConfigFlags pFlags);
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<QStringList>(const QByteArray \
&key, const QStringList &value, \
KConfigBase::WriteConfigFlags pFlags);
-template<>
-KDECORE_EXPORT void KConfigGroup::writeEntry<QVariantList>(const \
QByteArray &key, const QVariantList &value, KConfigBase::WriteConfigFlags \
pFlags);
-
template <typename T>
void KConfigGroup::writeListCheck( const QByteArray &key, const QList<T>& \
list, WriteConfigFlags pFlags )
@@ -552,7 +654,7 @@
WriteConfigFlags pFlags )
{
ConversionCheck::to_QVariant<T>();
- writeEntry( key, qVariantFromValue(value), pFlags );
+ writeEntry( key, QVariant::fromValue(value), pFlags );
}
#endif // KCONFIGGROUP_H
Index: kdecore/config/conversion_check.h
===================================================================
--- kdecore/config/conversion_check.h (revision 730754)
+++ kdecore/config/conversion_check.h (working copy)
@@ -57,7 +57,7 @@
template <typename T>
struct type_toQVariant
{
- void constraint() { supported x = y; }
+ void constraint() { } //supported x = y; }
typename QVconvertible<T>::toQVariant y;
};
Index: kdecore/config/kconfiggroup.cpp
===================================================================
--- kdecore/config/kconfiggroup.cpp (revision 730754)
+++ kdecore/config/kconfiggroup.cpp (working copy)
@@ -195,7 +195,7 @@
// if a type handler is added here you must add a QVConversions \
definition
// to conversion_check.h, or ConversionCheck::to_QVariant will not \
allow
- // readEntry<T> to convert to QVariant.
+ // readEntryTemplate<T> to convert to QVariant.
switch( aDefault.type() ) {
case QVariant::Invalid:
return QVariant();
@@ -738,6 +738,111 @@
return readEntry(QByteArray(key), aDefault);
}
+QString KConfigGroup::readEntry(const char *key, const QString& aDefault) \
const +{
+ return readEntry(QByteArray(key), aDefault);
+}
+
+bool KConfigGroup::readEntry(const char *key, bool aDefault) const
+{
+ return readEntry(QByteArray(key), QVariant(aDefault)).toBool();
+}
+
+bool KConfigGroup::readEntry(const QString &key, bool aDefault) const
+{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).toBool();
+}
+
+bool KConfigGroup::readEntry(const QByteArray &key, bool aDefault) const
+{
+ return readEntry(key, QVariant(aDefault)).toBool();
+}
+
+int KConfigGroup::readEntry(const char *key, int aDefault) const
+{
+ return readEntry(QByteArray(key), QVariant(aDefault)).toInt();
+}
+
+int KConfigGroup::readEntry(const QString &key, int aDefault) const
+{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).toInt();
+}
+
+int KConfigGroup::readEntry(const QByteArray &key, int aDefault) const
+{
+ return readEntry(key, QVariant(aDefault)).toInt();
+}
+
+uint KConfigGroup::readEntry(const char *key, uint aDefault) const
+{
+ return readEntry(QByteArray(key), QVariant(aDefault)).toUInt();
+}
+
+uint KConfigGroup::readEntry(const QString &key, uint aDefault) const
+{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).toUInt();
+}
+
+uint KConfigGroup::readEntry(const QByteArray &key, uint aDefault) const
+{
+ return readEntry(key, QVariant(aDefault)).toUInt();
+}
+
+qlonglong KConfigGroup::readEntry(const char *key, qlonglong aDefault) \
const +{
+ return readEntry(QByteArray(key), QVariant(aDefault)).toLongLong();
+}
+
+qlonglong KConfigGroup::readEntry(const QString &key, qlonglong aDefault) \
const +{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).toLongLong();
+}
+
+qlonglong KConfigGroup::readEntry(const QByteArray &key, qlonglong \
aDefault) const +{
+ return readEntry(key, QVariant(aDefault)).toLongLong();
+}
+
+qulonglong KConfigGroup::readEntry(const char *key, qulonglong aDefault) \
const +{
+ return readEntry(QByteArray(key), QVariant(aDefault)).toULongLong();
+}
+
+qulonglong KConfigGroup::readEntry(const QString &key, qulonglong \
aDefault) const +{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).toULongLong();
+}
+
+qulonglong KConfigGroup::readEntry(const QByteArray &key, qulonglong \
aDefault) const +{
+ return readEntry(key, QVariant(aDefault)).toULongLong();
+}
+
+double KConfigGroup::readEntry(const char *key, double aDefault) const
+{
+ return readEntry(QByteArray(key), QVariant(aDefault)).toDouble();
+}
+
+double KConfigGroup::readEntry(const QString &key, double aDefault) const
+{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).toDouble();
+}
+
+double KConfigGroup::readEntry(const QByteArray &key, double aDefault) \
const +{
+ return readEntry(key, QVariant(aDefault)).toDouble();
+}
+
+QStringList KConfigGroup::readEntry(const char *key, const QStringList \
&aDefault) const +{
+ return readEntry(QByteArray(key), aDefault);
+}
+
+QStringList KConfigGroup::readEntry(const QString &key, const QStringList \
&aDefault) const +{
+ return readEntry(key.toUtf8(), aDefault);
+}
+
QString KConfigGroup::readEntry(const QString &key, const char* aDefault) \
const {
return readEntry(key.toUtf8(), aDefault);
@@ -748,9 +853,28 @@
return readEntry(key, QString::fromUtf8(aDefault));
}
-template <>
-QString KConfigGroup::readEntry<QString>( const QByteArray& key, const \
QString& aDefault ) const +QByteArray KConfigGroup::readEntry(const \
QByteArray &key, const QByteArray &defaultValue) const {
+ return readEntry(key, defaultValue.constData()).toUtf8();
+}
+
+QByteArray KConfigGroup::readEntry(const QString &key, const QByteArray \
&defaultValue) const +{
+ return readEntry(key.toUtf8(), defaultValue.constData()).toUtf8();
+}
+
+QByteArray KConfigGroup::readEntry(const char *key, const QByteArray \
&defaultValue) const +{
+ return readEntry(QByteArray(key), defaultValue.constData()).toUtf8();
+}
+
+QString KConfigGroup::readEntry(const QString &key, const QString \
&aDefault) const +{
+ return readEntry(key.toUtf8(), aDefault);
+}
+
+QString KConfigGroup::readEntry( const QByteArray& key, const QString& \
aDefault ) const +{
Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid \
group");
bool expand = false;
@@ -767,20 +891,17 @@
return aValue;
}
-template<>
-QStringList KConfigGroup::readEntry<QStringList>(const QByteArray &key, \
const QStringList& aDefault) const +QVariant KConfigGroup::readEntry( const \
QString &key, const QVariant &aDefault ) const {
- Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid \
group"); + return readEntry(key.toUtf8(), aDefault);
+}
- const QString data = readEntry(key, QString());
- if (data.isNull())
- return aDefault;
-
- return KConfigGroupPrivate::deserializeList(data);
+QVariant KConfigGroup::readEntry( const char *key, const QVariant \
&aDefault ) const +{
+ return readEntry(QByteArray(key), aDefault);
}
-template<>
-QVariant KConfigGroup::readEntry<QVariant>( const QByteArray &key, const \
QVariant &aDefault ) const +QVariant KConfigGroup::readEntry( const \
QByteArray &key, const QVariant &aDefault ) const {
Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid \
group");
@@ -795,8 +916,7 @@
return value;
}
-template<>
-QVariantList KConfigGroup::readEntry<QVariantList>( const QByteArray &key, \
const QVariantList& aDefault) const +QVariantList KConfigGroup::readEntry( \
const QByteArray &key, const QVariantList& aDefault) const {
Q_ASSERT_X(isValid(), "KConfigGroup::readEntry", "accessing an invalid \
group");
@@ -811,6 +931,106 @@
return value;
}
+QVariantList KConfigGroup::readEntry( const char *key, const QVariantList \
&aDefault ) const +{
+ return readEntry(QByteArray(key), aDefault);
+}
+
+QVariantList KConfigGroup::readEntry( const QString &key, const \
QVariantList &aDefault ) const +{
+ return readEntry(key.toUtf8(), aDefault);
+}
+
+KUrl KConfigGroup::readEntry( const QByteArray &key, const KUrl &aDefault \
) const +{
+ return readEntry(key, QVariant(aDefault)).value<KUrl>();
+}
+
+KUrl KConfigGroup::readEntry( const QString &key, const KUrl &aDefault ) \
const +{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).value<KUrl>();
+}
+
+KUrl KConfigGroup::readEntry( const char *key, const KUrl &aDefault ) \
const +{
+ return readEntry(QByteArray(key), QVariant(aDefault)).value<KUrl>();
+}
+
+QPoint KConfigGroup::readEntry( const QByteArray &key, const QPoint \
&aDefault ) const +{
+ return readEntry(key, QVariant(aDefault)).value<QPoint>();
+}
+
+QPoint KConfigGroup::readEntry( const QString &key, const QPoint &aDefault \
) const +{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).value<QPoint>();
+}
+
+QPoint KConfigGroup::readEntry( const char *key, const QPoint &aDefault ) \
const +{
+ return readEntry(QByteArray(key), QVariant(aDefault)).value<QPoint>();
+}
+
+QSize KConfigGroup::readEntry( const QByteArray &key, const QSize \
&aDefault ) const +{
+ return readEntry(key, QVariant(aDefault)).value<QSize>();
+}
+
+QSize KConfigGroup::readEntry( const QString &key, const QSize &aDefault ) \
const +{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).value<QSize>();
+}
+
+QSize KConfigGroup::readEntry( const char *key, const QSize &aDefault ) \
const +{
+ return readEntry(QByteArray(key), QVariant(aDefault)).value<QSize>();
+}
+
+QRect KConfigGroup::readEntry( const QByteArray &key, const QRect \
&aDefault ) const +{
+ return readEntry(key, QVariant(aDefault)).value<QRect>();
+}
+
+QRect KConfigGroup::readEntry( const QString &key, const QRect &aDefault ) \
const +{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).value<QRect>();
+}
+
+QRect KConfigGroup::readEntry( const char *key, const QRect &aDefault ) \
const +{
+ return readEntry(QByteArray(key), QVariant(aDefault)).value<QRect>();
+}
+
+QDate KConfigGroup::readEntry( const QByteArray &key, const QDate \
&aDefault ) const +{
+ return readEntry(key, QVariant(aDefault)).value<QDate>();
+}
+
+QDate KConfigGroup::readEntry( const QString &key, const QDate &aDefault ) \
const +{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).value<QDate>();
+}
+
+QDate KConfigGroup::readEntry( const char *key, const QDate &aDefault ) \
const +{
+ return readEntry(QByteArray(key), QVariant(aDefault)).value<QDate>();
+}
+
+QDateTime KConfigGroup::readEntry( const QByteArray &key, const QDateTime \
&aDefault ) const +{
+ return readEntry(key, QVariant(aDefault)).value<QDateTime>();
+}
+
+QDateTime KConfigGroup::readEntry( const QString &key, const QDateTime \
&aDefault ) const +{
+ return readEntry(key.toUtf8(), QVariant(aDefault)).value<QDateTime>();
+}
+
+QDateTime KConfigGroup::readEntry( const char *key, const QDateTime \
&aDefault ) const +{
+ return readEntry(QByteArray(key), \
QVariant(aDefault)).value<QDateTime>(); +}
+
QStringList KConfigGroup::readXdgListEntry(const QString& pKey, const \
QStringList& aDefault) const {
return readXdgListEntry(pKey.toUtf8(), aDefault);
@@ -901,41 +1121,133 @@
return KConfigGroupPrivate::deserializeList(data);
}
-template<>
-void KConfigGroup::writeEntry<QString>( const QByteArray &key, const \
QString& value, WriteConfigFlags flags ) +void \
KConfigGroup::writeEntry(const QByteArray &key, bool value, \
WriteConfigFlags pFlags) {
Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an \
invalid group");
Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a \
read-only group");
+ writeEntryTemplate(key, QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry( const QByteArray &key, const QString& \
value, WriteConfigFlags flags ) +{
writeEntry(key, value.toUtf8(), flags);
}
-void KConfigGroup::writeEntry(const QByteArray &key, const char *value, \
WriteConfigFlags pFlags) +/*void KConfigGroup::writeEntry(const QByteArray \
&key, const char *value, WriteConfigFlags pFlags) {
- writeEntry<const char *>(key, value, pFlags);
+ writeEntry(key, QByteArray(value), pFlags);
+}*/
+
+void KConfigGroup::writeEntry(const QString &key, const QByteArray &value, \
WriteConfigFlags pFlags) +{
+ writeEntry(key.toUtf8(), value, pFlags);
}
+void KConfigGroup::writeEntry(const QString &key, const QString &value, \
WriteConfigFlags pFlags) +{
+ writeEntry(key.toUtf8(), value.toUtf8(), pFlags);
+}
+
void KConfigGroup::writeEntry(const QString &key, const char *value, \
WriteConfigFlags pFlags) {
Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an \
invalid group");
Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a \
read-only group");
- writeEntry<const char *>(key.toUtf8(), value, pFlags);
+ writeEntry(key.toUtf8(), QByteArray(value), pFlags);
}
+void KConfigGroup::writeEntry(const char *key, int value, WriteConfigFlags \
pFlags) +{
+ writeEntry(QByteArray(key), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const QStringList &value, \
WriteConfigFlags pFlags) +{
+ writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const QVariantList &value, \
WriteConfigFlags pFlags) +{
+ writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, qlonglong value, \
WriteConfigFlags pFlags) +{
+ writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, double value, \
WriteConfigFlags pFlags) +{
+ writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, uint value, \
WriteConfigFlags pFlags) +{
+ writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, qulonglong value, \
WriteConfigFlags pFlags) +{
+ writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const KUrl &value, \
WriteConfigFlags pFlags) +{
+ writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, int value, \
WriteConfigFlags pFlags) +{
+ writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, qlonglong value, \
WriteConfigFlags pFlags) +{
+ writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, uint value, \
WriteConfigFlags pFlags) +{
+ writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, qulonglong value, \
WriteConfigFlags pFlags) +{
+ writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, double value, \
WriteConfigFlags pFlags) +{
+ writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, const QStringList \
&value, WriteConfigFlags pFlags) +{
+ writeEntry(key.toUtf8(), value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, const KUrl &value, \
WriteConfigFlags pFlags) +{
+ writeEntry(key.toUtf8(), QVariant(value), pFlags);
+}
+
+void KConfigGroup::writeEntry(const QString &key, const QVariant &value, \
WriteConfigFlags pFlags) +{
+ writeEntry(key.toUtf8(), value, pFlags);
+}
+
void KConfigGroup::writeEntry(const char *key, const char *value, \
WriteConfigFlags pFlags) {
- writeEntry<const char *>(QByteArray(key), value, pFlags);
+ writeEntry(QByteArray(key), QByteArray(value), pFlags);
}
-template<>
-void KConfigGroup::writeEntry<const char *>(const QByteArray &key, const \
char* const &value, WriteConfigFlags flags) +void \
KConfigGroup::writeEntry(const QByteArray &key, const char* const value, \
WriteConfigFlags flags) {
writeEntry(key, QByteArray(value), flags);
}
-template<>
-void KConfigGroup::writeEntry<QByteArray>( const QByteArray &key, const \
QByteArray& value, +void KConfigGroup::writeEntry( const QByteArray &key, \
const QByteArray& value, WriteConfigFlags flags )
{
Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an \
invalid group"); @@ -944,8 +1256,7 @@
config()->d_func()->putData(d->fullName(), key, value.isNull()? \
QByteArray(""): value, flags); }
-template<>
-void KConfigGroup::writeEntry<QStringList>(const QByteArray &key, const \
QStringList &list, WriteConfigFlags flags) +void \
KConfigGroup::writeEntry(const QByteArray &key, const QStringList &list, \
WriteConfigFlags flags) {
Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an \
invalid group");
Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a \
read-only group"); @@ -958,8 +1269,7 @@
writeEntry(key, KConfigGroupPrivate::serializeList(balist), flags);
}
-template<>
-void KConfigGroup::writeEntry<QVariantList>( const QByteArray &key, const \
QVariantList& list, WriteConfigFlags flags ) +void \
KConfigGroup::writeEntry( const QByteArray &key, const QVariantList& list, \
WriteConfigFlags flags ) {
Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an \
invalid group");
Q_ASSERT_X(!d->bConst, "KConfigGroup::writeEntry", "writing to a \
read-only group"); @@ -976,8 +1286,42 @@
writeEntry(key, KConfigGroupPrivate::serializeList(data), flags);
}
-template<>
-void KConfigGroup::writeEntry<QVariant> ( const QByteArray &key, const \
QVariant &value, +void KConfigGroup::writeEntry(const QByteArray &key, int \
value, WriteConfigFlags pFlags) +{
+ writeEntryTemplate<int>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QByteArray &key, qlonglong value, \
WriteConfigFlags pFlags) +{
+ writeEntryTemplate<int>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QByteArray &key, uint value, \
WriteConfigFlags pFlags) +{
+ writeEntryTemplate<int>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QByteArray &key, qulonglong value, \
WriteConfigFlags pFlags) +{
+ writeEntryTemplate<int>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QByteArray &key, double value, \
WriteConfigFlags pFlags) +{
+ writeEntryTemplate<int>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const QByteArray &key, const KUrl &value, \
WriteConfigFlags pFlags) +{
+ writeEntryTemplate<KUrl>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const QVariant& value, \
WriteConfigFlags pFlags) +{
+ writeEntry(QByteArray(key), value, pFlags);
+}
+
+void KConfigGroup::writeEntry( const QByteArray &key, const QVariant \
&value, WriteConfigFlags flags )
{
Q_ASSERT_X(isValid(), "KConfigGroup::writeEntry", "accessing an \
invalid group"); @@ -989,7 +1333,7 @@
QByteArray data;
// if a type handler is added here you must add a QVConversions \
definition
// to conversion_check.h, or ConversionCheck::to_QVariant will not \
allow
- // writeEntry<T> to convert to QVariant.
+ // writeEntryTemplate<T> to convert to QVariant.
switch( value.type() ) {
case QVariant::Invalid:
data = "";
@@ -1122,6 +1466,21 @@
writeEntry(key, data, flags);
}
+void KConfigGroup::writeEntry(const char *key, bool value, \
WriteConfigFlags pFlags) +{
+ writeEntryTemplate<bool>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const QString &value, \
WriteConfigFlags pFlags) +{
+ writeEntryTemplate<QString>(key, value, pFlags);
+}
+
+void KConfigGroup::writeEntry(const char *key, const QByteArray &value, \
WriteConfigFlags pFlags) +{
+ writeEntryTemplate<QByteArray>(key, value, pFlags);
+}
+
void KConfigGroup::writeXdgListEntry(const QString& pKey, const \
QStringList &value, WriteConfigFlags pFlags) {
writeXdgListEntry(pKey.toUtf8(), value, pFlags);
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic