[prev in list] [next in list] [prev in thread] [next in thread] 

List:       kde-commits
Subject:    [kdb] src: Improve KDb::cstringToVariant()
From:       Jaroslaw Staniek <staniek () kde ! org>
Date:       2015-06-30 22:09:07
Message-ID: E1ZA3iF-00042Q-Rj () scm ! kde ! org
[Download RAW message or body]

Git commit 3eed88bb098e3c42760ea7b0c4e364126e48d3c8 by Jaroslaw Staniek.
Committed on 30/06/2015 at 16:51.
Pushed by staniek into branch 'master'.

Improve KDb::cstringToVariant()

- add signedness support for integers
- extend the docs
- add more sanity checks
- fail on unsupported types (Null, etc.) or if data is 0
- set result in the ok OUT arg
- much better convert integers (check limits)

+Add KDb::iif helper

M  +57   -15   src/KDb.cpp
M  +25   -3    src/KDb.h

http://commits.kde.org/kdb/3eed88bb098e3c42760ea7b0c4e364126e48d3c8

diff --git a/src/KDb.cpp b/src/KDb.cpp
index cb716cb..6338880 100644
--- a/src/KDb.cpp
+++ b/src/KDb.cpp
@@ -43,6 +43,7 @@
 #include <QApplication>
 #include <QDir>
 #include <QProcess>
+#include <QtDebug>
 
 #include <memory>
 
@@ -1552,30 +1553,71 @@ QString KDb::defaultFileBasedDriverId()
     return QLatin1String("org.kde.kdb.sqlite");
 }
 
-/*! @return QVariant value converted from null-terminated @a data string.
- In case of BLOB type, @a data is not null terminated, so passing length is needed. */
-QVariant KDb::cstringToVariant(const char* data, KDbField* f, int length)
+// Try to convert from string to type T
+template <typename T>
+QVariant convert(T (QString::*ConvertToT)(bool*,int) const, const char *data, int size,
+                 qlonglong minValue, qlonglong maxValue, bool *ok)
 {
-    if (!data)
+    T v = (QString::fromLatin1(data, size).*ConvertToT)(ok, 10);
+    if (*ok) {
+        *ok = minValue <= v && v <= maxValue;
+    }
+    return KDb::iif(*ok, QVariant(v));
+}
+
+QVariant KDb::cstringToVariant(const char* data, KDbField::Type type, bool *ok, int length,
+                               KDb::Signedness signedness)
+{
+    bool tempOk;
+    bool *thisOk = ok ? ok : &tempOk;
+    if (!data || type > KDbField::LastType) {
+        *thisOk = false;
         return QVariant();
+    }
     // from most to least frequently used types:
 
-    if (!f || f->isTextType())
+    if (KDbField::isTextType(type)) {
+        *thisOk = true;
+        //! @todo use KDbDriverBehaviour::TEXT_TYPE_MAX_LENGTH for Text type?
         return QString::fromUtf8(data, length);
-    if (f->isIntegerType()) {
-        if (f->type() == KDbField::BigInteger)
-            return QVariant(QString::fromLatin1(data, length).toLongLong());
-        return QVariant(QString::fromLatin1(data, length).toInt());
-    }
-    if (f->isFPNumericType())
-        return QString::fromLatin1(data, length).toDouble();
-    if (f->type() == KDbField::BLOB)
-        return QByteArray(data, length);
+    }
+    if (KDbField::isIntegerType(type)) {
+        qlonglong minValue, maxValue;
+        const bool isUnsigned = signedness == KDb::Unsigned;
+        KDb::getLimitsForFieldType(type, &minValue, &maxValue, signedness);
+        switch (type) {
+        case KDbField::Byte: // Byte here too, minValue/maxValue will take care of limits
+        case KDbField::ShortInteger:
+            return isUnsigned ?
+                convert(&QString::toUShort, data, length, minValue, maxValue, thisOk)
+                : convert(&QString::toShort, data, length, minValue, maxValue, thisOk);
+        case KDbField::Integer:
+            return isUnsigned ?
+                convert(&QString::toUInt, data, length, minValue, maxValue, thisOk)
+                : convert(&QString::toInt, data, length, minValue, maxValue, thisOk);
+        case KDbField::BigInteger:
+            return isUnsigned ?
+                convert(&QString::toULongLong, data, length, minValue, maxValue, thisOk)
+                : convert(&QString::toLongLong, data, length, minValue, maxValue, thisOk);
+        default:
+            qFatal("Unsupported integer type %d", type);
+        }
+    }
+    if (KDbField::isFPNumericType(type)) {
+        return KDb::iif(*thisOk, QVariant(QString::fromLatin1(data, length).toDouble(thisOk)));
+    }
+    if (type == KDbField::BLOB) {
+        *thisOk = length >= 0;
+        return *thisOk ? QVariant(QByteArray(data, length)) : QVariant();
+    }
     // the default
 //! @todo date/time?
     QVariant result(QString::fromUtf8(data, length));
-    if (!result.convert(KDbField::variantType(f->type())))
+    if (!result.convert(KDbField::variantType(type))) {
+        *thisOk = false;
         return QVariant();
+    }
+    *thisOk = true;
     return result;
 }
 
diff --git a/src/KDb.h b/src/KDb.h
index 7835464..f064247 100644
--- a/src/KDb.h
+++ b/src/KDb.h
@@ -418,9 +418,21 @@ KDB_EXPORT void getLimitsForFieldType(KDbField::Type type, qlonglong *minValue,
  of 100 * 100 exceeds the range of Byte. */
 KDB_EXPORT KDbField::Type maximumForIntegerFieldTypes(KDbField::Type t1, KDbField::Type t2);
 
-/*! @return QVariant value converted from null-terminated @a data string.
- In case of BLOB type, @a data is not null terminated, so passing length is needed. */
-KDB_EXPORT QVariant cstringToVariant(const char* data, KDbField* f, int length = -1);
+//! @return QVariant value converted from a @a data string
+/*! Conversion is based on the information about type @a type.
+ @a type has to be an element from KDbField::Type, not greater than KDbField::LastType.
+ For unsupported type this function fails. @a length value controls number of characters
+ used in the conversion. It is optional value for all cases but for the BLOB type because
+ for it @a data is not null-terminated so the length cannot be measured.
+ The value of @a signedness controls the conversion in case of integer types; numbers can be
+ limited to unsigned or not.
+ If @a ok is not 0 *ok is set to false on failure and to true on success. On failure a null
+ QVariant is returned. The function fails if @a data is 0.
+ For rules of conversion to the boolean type see the documentation of @ref QVariant::toBool(),
+ QVariant::toDate() for date type, QVariant::toDateTime() for date+time type,
+ QVariant::toTime() for time type. */
+KDB_EXPORT QVariant cstringToVariant(const char* data, KDbField::Type type, bool *ok, int length = -1,
+                                     KDb::Signedness signedness = KDb::Signed);
 
 /*! @return default file-based driver MIME type
  (typically something like "application/x-kexiproject-sqlite") */
@@ -489,6 +501,16 @@ T iifNotEmpty(const T &string, const QByteArray &stringIfEmpty)
     return iifNotEmpty(string, QString(stringIfEmpty));
 }
 
+//! @return @a value if @a ok is true, else returns default value T().
+template<typename T>
+T iif(bool ok, const T &value)
+{
+    if (ok) {
+        return value;
+    }
+    return T();
+}
+
 /*! @return a list of paths that KDb will search when dynamically loading libraries (plugins)
  This is basicaly list of directories returned QCoreApplication::libraryPaths() that have readable
  subdirectory "kdb".

[prev in list] [next in list] [prev in thread] [next in thread]