Clean up implementation of UpdateResolver.

include/QtxUpdate

@@ -5,7 +5,7 @@
 #include "../src/update/abstractupdatechecker.h"
 #include "../src/update/abstractupdatefilter.h"
 #include "../src/update/abstractversioncomparator.h"
-#include "../src/update/appcastminsystemupdatefilter.h"
+#include "../src/update/appcastminsysupdatefilter.h"
 #include "../src/update/appcastupdatechecker.h"
 #include "../src/update/semversortupdatefilter.h"
 #include "../src/update/semverversioncomparator.h"

src/update/updateresolver.cpp

@@ -8,15 +8,37 @@
 QTX_BEGIN_NAMESPACE
 
 
+class UpdateResolverPrivate
+{
+public:
+    UpdateResolverPrivate(UpdateResolver *q);
+    virtual ~UpdateResolverPrivate();
+
+public:
+    UpdateResolver *q_ptr;
+    Q_DECLARE_PUBLIC(UpdateResolver);
+
+    QString version;
+    AbstractUpdateChecker *checker;
+    QList<AbstractUpdateFilter *> filters;
+    AbstractVersionComparator *comparator;
+
+    QString errorString;
+};
+
+
 UpdateResolver::UpdateResolver(QObject *parent /* = 0 */)
-  : QObject(parent),
-    mChecker(0),
-    mComparator(0)
+    : QObject(parent),
+      d_ptr(new UpdateResolverPrivate(this))
 {
 }
 
 UpdateResolver::~UpdateResolver()
 {
+    if (d_ptr) {
+        delete d_ptr;
+        d_ptr = 0;
+    }
 }
 
 void UpdateResolver::resolve()
@@ -29,40 +51,40 @@ void UpdateResolver::resolve()
 
 void UpdateResolver::resolve(const QString & version)
 {
-    if (!mChecker) {
+    if (!d_ptr->checker) {
         emit error(InvalidCheckerError);
         return;
     }
 
-    mVersion = version;
-    mChecker->check();
+    d_ptr->version = version;
+    d_ptr->checker->check();
 }
 
 Update *UpdateResolver::updateFrom(const QString & version)
 {
     if (version.isEmpty()) {
         return 0;
     }
-    if (!mChecker) { 
+    if (!d_ptr->checker) { 
         return 0;
     }
 
-    if (!mComparator) {
-        mComparator = new SemVerVersionComparator(this);
+    if (!d_ptr->comparator) {
+        d_ptr->comparator = new SemVerVersionComparator(this);
     }
 
     // The checker is expected to build a list of available updates.  The
     // server that is queried for updates may filter this list based on
     // compatiblity information ascertained from the request (for example,
     // by inspecting a `User-Agent` header).
-    QList<Update *> candidates = mChecker->updates();
+    QList<Update *> candidates = d_ptr->checker->updates();
 
     // Filter the list of candidates.  Filters are typically used to inspect
     // candidates, ensuring they satisfy minimum system requirements and
     // runtime compatibility.  If the server applied its own filtering, these
     // filters further refine the list of candidates based on information known
     // only by the client system.
-    foreach (AbstractUpdateFilter *filter, mFilters) {
+    foreach (AbstractUpdateFilter *filter, d_ptr->filters) {
         candidates = filter->filter(candidates);
     }
 
@@ -75,7 +97,7 @@ Update *UpdateResolver::updateFrom(const QString & version)
     // recent than the given version.  If so, and update is available;
     // otherwise, no update is available.
     Update *update = candidates.at(0);
-    int rv = mComparator->compare(update->version(), version);
+    int rv = d_ptr->comparator->compare(update->version(), version);
     if (rv == 1) {
         return update;
     }
@@ -84,38 +106,48 @@ Update *UpdateResolver::updateFrom(const QString & version)
 
 void UpdateResolver::setUpdateChecker(AbstractUpdateChecker *checker)
 {
-    if (mChecker) {
-        mChecker->disconnect(this);
-        mChecker->deleteLater();
+    if (d_ptr->checker) {
+        d_ptr->checker->disconnect(this);
+        d_ptr->checker->deleteLater();
     }
 
     checker->setParent(this);
-    mChecker = checker;
-    connect(mChecker, SIGNAL(finished()), SLOT(onCheckerFinished()));
-    connect(mChecker, SIGNAL(error(qint32)), SLOT(onCheckerError(qint32)));
+    d_ptr->checker = checker;
+    connect(d_ptr->checker, SIGNAL(finished()), SLOT(onCheckerFinished()));
+    connect(d_ptr->checker, SIGNAL(error(qint32)), SLOT(onCheckerError(qint32)));
 }
 
 void UpdateResolver::addUpdateFilter(AbstractUpdateFilter *filter)
 {
     filter->setParent(this);
-    mFilters.append(filter);
+    d_ptr->filters.append(filter);
 }
 
 void UpdateResolver::setVersionComparator(AbstractVersionComparator *comparator)
 {
-    if (mComparator) {
-        mComparator->deleteLater();
+    if (d_ptr->comparator) {
+        d_ptr->comparator->deleteLater();
     }
 
     comparator->setParent(this);
-    mComparator = comparator;
+    d_ptr->comparator = comparator;
+}
+
+QString UpdateResolver::errorString() const
+{
+    return d_ptr->errorString;
+}
+
+void UpdateResolver::setErrorString(const QString & str)
+{
+    d_ptr->errorString = str;
 }
 
 void UpdateResolver::onCheckerFinished()
 {
-    mChecker->disconnect(this);
+    d_ptr->checker->disconnect(this);
 
-    Update *update = updateFrom(mVersion);
+    Update *update = updateFrom(d_ptr->version);
     if (update) {
         emit updateAvailable(update);
     } else {
@@ -125,10 +157,25 @@ void UpdateResolver::onCheckerFinished()
 
 void UpdateResolver::onCheckerError(qint32 code)
 {
-    mChecker->disconnect(this);
+    Q_UNUSED(code);
+
+    d_ptr->checker->disconnect(this);
 
+    setErrorString(d_ptr->checker->errorString());
     emit error(UnknownCheckError);
 }
 
 
+UpdateResolverPrivate::UpdateResolverPrivate(UpdateResolver *q)
+    : q_ptr(q),
+      checker(0),
+      comparator(0)
+{
+}
+
+UpdateResolverPrivate::~UpdateResolverPrivate()
+{
+}
+
+
 QTX_END_NAMESPACE

src/update/updateresolver.h

@@ -11,6 +11,7 @@ class AbstractUpdateChecker;
 class AbstractVersionComparator;
 class AbstractUpdateFilter;
 class Update;
+class UpdateResolverPrivate;
 
 class UpdateResolver : public QObject
 {
@@ -35,21 +36,24 @@ class UpdateResolver : public QObject
     void addUpdateFilter(AbstractUpdateFilter *filter);
     void setVersionComparator(AbstractVersionComparator *comparator);
 
+    QString errorString() const;
+
 signals:
     void updateAvailable(Update *);
     void noUpdateAvailable();
     void error(UpdateResolver::Error code);
 
+protected:
+    void setErrorString(const QString & str);
+
 private slots:
     void onCheckerFinished();
     void onCheckerError(qint32 code);
-
-private:
-    QString mVersion;
 
-    AbstractUpdateChecker *mChecker;
-    AbstractVersionComparator *mComparator;
-    QList<AbstractUpdateFilter *> mFilters;
+protected:
+    UpdateResolverPrivate *d_ptr;
+private:
+    Q_DECLARE_PRIVATE(UpdateResolver);
 };