@acalcutt/maplibre-gl-native-test 5.0.1-pre.16 → 5.0.2-pre.1

package/platform/qt/src/mbgl/run_loop_impl.hpp

@@ -1,39 +0,0 @@
-#pragma once
-
-#include <mbgl/util/logging.hpp>
-#include <mbgl/util/async_task.hpp>
-#include <mbgl/util/run_loop.hpp>
-
-#include <QEventLoop>
-#include <QObject>
-#include <QSocketNotifier>
-
-#include <unordered_map>
-
-namespace mbgl {
-namespace util {
-
-using WatchCallback = std::function<void(int, RunLoop::Event)>;
-using WatchPair = std::pair<std::unique_ptr<QSocketNotifier>, WatchCallback>;
-
-class RunLoop::Impl : public QObject {
-    Q_OBJECT
-
-public:
-    Impl() = default;
-
-    RunLoop::Type type;
-
-    std::unique_ptr<QEventLoop> loop;
-    std::unique_ptr<AsyncTask> async;
-
-    std::unordered_map<int, WatchPair> readPoll;
-    std::unordered_map<int, WatchPair> writePoll;
-
-public slots:
-    void onReadEvent(int fd);
-    void onWriteEvent(int fd);
-};
-
-} // namespace util
-} // namespace mbgl

package/platform/qt/src/mbgl/sqlite3.cpp

@@ -1,475 +0,0 @@
-#include <mbgl/storage/sqlite3.hpp>
-
-#include <QSqlDatabase>
-#include <QSqlError>
-#include <QSqlQuery>
-#include <QStringList>
-#include <QThread>
-#include <QVariant>
-#include <QAtomicInt>
-
-#include <cassert>
-#include <cstring>
-#include <cstdio>
-#include <chrono>
-#include <limits>
-
-#include <mbgl/util/chrono.hpp>
-#include <mbgl/util/logging.hpp>
-#include <mbgl/util/optional.hpp>
-#include <mbgl/util/string.hpp>
-#include <mbgl/util/traits.hpp>
-
-namespace mapbox {
-namespace sqlite {
-
-void checkQueryError(const QSqlQuery& query) {
-    QSqlError lastError = query.lastError();
-    if (lastError.type() != QSqlError::NoError) {
-        throw Exception { lastError.nativeErrorCode().toInt(), lastError.databaseText().toStdString() };
-    }
-}
-
-void checkDatabaseError(const QSqlDatabase &db) {
-    QSqlError lastError = db.lastError();
-    if (lastError.type() != QSqlError::NoError) {
-        throw Exception { lastError.nativeErrorCode().toInt(), lastError.databaseText().toStdString() };
-    }
-}
-
-namespace {
-    QString incrementCounter() {
-        static QAtomicInt count = 0;
-        return QString::number(count.fetchAndAddAcquire(1));
-    }
-}
-
-class DatabaseImpl {
-public:
-    DatabaseImpl(QString connectionName_)
-        : connectionName(std::move(connectionName_))
-    {
-    }
-
-    ~DatabaseImpl() {
-        auto db = QSqlDatabase::database(connectionName);
-        db.close();
-        checkDatabaseError(db);
-    }
-
-    void setBusyTimeout(std::chrono::milliseconds timeout);
-    void exec(const std::string& sql);
-
-    QString connectionName;
-};
-
-class StatementImpl {
-public:
-    StatementImpl(const QString& sql, const QSqlDatabase& db) : query(db) {
-        if (!query.prepare(sql)) {
-            checkQueryError(query);
-        }
-    }
-
-    ~StatementImpl() {
-        query.clear();
-    }
-
-    QSqlQuery query;
-    int64_t lastInsertRowId = 0;
-    int64_t changes = 0;
-};
-
-template <typename T>
-using optional = std::experimental::optional<T>;
-
-mapbox::util::variant<Database, Exception> Database::tryOpen(const std::string &filename, int flags) {
-    if (!QSqlDatabase::drivers().contains("QSQLITE")) {
-        return Exception { ResultCode::CantOpen, "SQLite driver not found." };
-    }
-
-    QString connectionName = QString::number(uint64_t(QThread::currentThread())) + incrementCounter();
-
-    assert(!QSqlDatabase::contains(connectionName));
-    auto db = QSqlDatabase::addDatabase("QSQLITE", connectionName);
-
-    QString connectOptions = db.connectOptions();
-    if (flags & OpenFlag::ReadOnly) {
-        if (!connectOptions.isEmpty()) connectOptions.append(';');
-        connectOptions.append("QSQLITE_OPEN_READONLY");
-    }
-
-    if (filename.compare(0, 5, "file:") == 0) {
-        if (!connectOptions.isEmpty()) connectOptions.append(';');
-        connectOptions.append("QSQLITE_OPEN_URI");
-    }
-
-    db.setConnectOptions(connectOptions);
-    db.setDatabaseName(QString(filename.c_str()));
-
-    if (!db.open()) {
-        // Assume every error when opening the data as CANTOPEN. Qt
-        // always returns -1 for `nativeErrorCode()` on database errors.
-        return Exception { ResultCode::CantOpen, "Error opening the database." };
-    }
-
-    return Database(std::make_unique<DatabaseImpl>(connectionName));
-}
-
-Database Database::open(const std::string &filename, int flags) {
-    auto result = tryOpen(filename, flags);
-    if (result.is<Exception>()) {
-        throw result.get<Exception>();
-    } else {
-        return std::move(result.get<Database>());
-    }
-}
-
-Database::Database(std::unique_ptr<DatabaseImpl> impl_)
-    : impl(std::move(impl_))
-{}
-
-Database::Database(Database &&other) noexcept
-        : impl(std::move(other.impl)) {
-    assert(impl);
-}
-
-Database &Database::operator=(Database &&other) noexcept {
-    std::swap(impl, other.impl);
-    assert(impl);
-    return *this;
-}
-
-Database::~Database() {
-}
-
-void Database::setBusyTimeout(std::chrono::milliseconds timeout) {
-    assert(impl);
-    impl->setBusyTimeout(timeout);
-}
-
-void DatabaseImpl::setBusyTimeout(std::chrono::milliseconds timeout) {
-    // std::chrono::milliseconds.count() is a long and Qt will cast
-    // internally to int, so we need to make sure the limits apply.
-    std::string timeoutStr = mbgl::util::toString(timeout.count() & INT_MAX);
-
-    auto db = QSqlDatabase::database(connectionName);
-    QString connectOptions = db.connectOptions();
-    if (connectOptions.isEmpty()) {
-        if (!connectOptions.isEmpty()) connectOptions.append(';');
-        connectOptions.append("QSQLITE_BUSY_TIMEOUT=").append(QString::fromStdString(timeoutStr));
-    }
-    if (db.isOpen()) {
-        db.close();
-    }
-    db.setConnectOptions(connectOptions);
-    if (!db.open()) {
-        // Assume every error when opening the data as CANTOPEN. Qt
-        // always returns -1 for `nativeErrorCode()` on database errors.
-        throw Exception { ResultCode::CantOpen, "Error opening the database." };
-    }
-}
-
-void Database::exec(const std::string &sql) {
-    assert(impl);
-    impl->exec(sql);
-}
-
-void DatabaseImpl::exec(const std::string& sql) {
-#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
-    QStringList statements = QString::fromStdString(sql).split(';', Qt::SkipEmptyParts);
-#else
-    QStringList statements = QString::fromStdString(sql).split(';', QString::SkipEmptyParts);
-#endif
-    statements.removeAll("\n");
-    for (QString statement : statements) {
-        if (!statement.endsWith(';')) {
-            statement.append(';');
-        }
-        QSqlQuery query(QSqlDatabase::database(connectionName));
-        query.prepare(statement);
-
-        if (!query.exec()) {
-            checkQueryError(query);
-        }
-    }
-}
-
-Statement::Statement(Database& db, const char* sql)
-    : impl(std::make_unique<StatementImpl>(QString(sql),
-                                           QSqlDatabase::database(db.impl->connectionName))) {
-    assert(impl);
-}
-
-Statement::~Statement() {
-#ifndef NDEBUG
-    // Crash if we're destructing this object while we know a Query object references this.
-    assert(!used);
-#endif
-}
-
-Query::Query(Statement& stmt_) : stmt(stmt_) {
-    assert(stmt.impl);
-
-#ifndef NDEBUG
-    assert(!stmt.used);
-    stmt.used = true;
-#endif
-}
-
-Query::~Query() {
-    reset();
-    clearBindings();
-
-#ifndef NDEBUG
-    stmt.used = false;
-#endif
-}
-
-template void Query::bind(int, int64_t);
-
-template <typename T>
-void Query::bind(int offset, T value) {
-    assert(stmt.impl);
-    // Field numbering starts at 0.
-    stmt.impl->query.bindValue(offset - 1, QVariant::fromValue<T>(value), QSql::In);
-    checkQueryError(stmt.impl->query);
-}
-
-template <>
-void Query::bind(int offset, std::nullptr_t) {
-    assert(stmt.impl);
-    // Field numbering starts at 0.
-#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
-    stmt.impl->query.bindValue(offset - 1, QVariant(), QSql::In);
-#else
-    stmt.impl->query.bindValue(offset - 1, QVariant(QVariant::Invalid), QSql::In);
-#endif
-    checkQueryError(stmt.impl->query);
-}
-
-template <>
-void Query::bind(int offset, int32_t value) {
-    bind(offset, static_cast<int64_t>(value));
-}
-
-template <>
-void Query::bind(int offset, bool value) {
-    bind(offset, static_cast<int>(value));
-}
-
-template <>
-void Query::bind(int offset, int8_t value) {
-    bind(offset, static_cast<int64_t>(value));
-}
-
-template <>
-void Query::bind(int offset, uint8_t value) {
-    bind(offset, static_cast<int64_t>(value));
-}
-
-template <>
-void Query::bind(int offset, mbgl::Timestamp value) {
-    bind(offset, std::chrono::system_clock::to_time_t(value));
-}
-
-template <>
-void Query::bind(int offset, optional<std::string> value) {
-    if (value) {
-        bind(offset, *value);
-    } else {
-        bind(offset, nullptr);
-    }
-}
-
-template <>
-void Query::bind(int offset, optional<mbgl::Timestamp> value) {
-    if (value) {
-        bind(offset, *value);
-    } else {
-        bind(offset, nullptr);
-    }
-}
-
-void Query::bind(int offset, const char* value, std::size_t length, bool /* retain */) {
-    assert(stmt.impl);
-    if (length > std::numeric_limits<int>::max()) {
-        // Kept for consistence with the default implementation.
-        throw std::range_error("value too long");
-    }
-
-    // Field numbering starts at 0.
-    stmt.impl->query.bindValue(offset - 1, QString(QByteArray(value, static_cast<int>(length))), QSql::In);
-
-    checkQueryError(stmt.impl->query);
-}
-
-void Query::bind(int offset, const std::string& value, bool retain) {
-    bind(offset, value.data(), value.size(), retain);
-}
-
-void Query::bindBlob(int offset, const void* value_, std::size_t length, bool retain) {
-    assert(stmt.impl);
-    const char* value = reinterpret_cast<const char*>(value_);
-    if (length > std::numeric_limits<int>::max()) {
-        // Kept for consistence with the default implementation.
-        throw std::range_error("value too long");
-    }
-
-    // Field numbering starts at 0.
-    stmt.impl->query.bindValue(offset - 1, retain ? QByteArray(value, static_cast<int>(length)) :
-            QByteArray::fromRawData(value, static_cast<int>(length)), QSql::In | QSql::Binary);
-
-    checkQueryError(stmt.impl->query);
-}
-
-void Query::bindBlob(int offset, const std::vector<uint8_t>& value, bool retain) {
-    bindBlob(offset, value.data(), value.size(), retain);
-}
-
-bool Query::run() {
-    assert(stmt.impl);
-
-    if (!stmt.impl->query.isValid()) {
-       if (stmt.impl->query.exec()) {
-           stmt.impl->lastInsertRowId = stmt.impl->query.lastInsertId().value<int64_t>();
-           stmt.impl->changes = stmt.impl->query.numRowsAffected();
-       } else {
-           checkQueryError(stmt.impl->query);
-       }
-    }
-
-    const bool hasNext = stmt.impl->query.next();
-    if (!hasNext) stmt.impl->query.finish();
-
-    return hasNext;
-}
-
-template bool Query::get(int);
-template int Query::get(int);
-template int64_t Query::get(int);
-template double Query::get(int);
-
-template <typename T> T Query::get(int offset) {
-    assert(stmt.impl && stmt.impl->query.isValid());
-    QVariant value = stmt.impl->query.value(offset);
-    checkQueryError(stmt.impl->query);
-    return value.value<T>();
-}
-
-template <> std::vector<uint8_t> Query::get(int offset) {
-    assert(stmt.impl && stmt.impl->query.isValid());
-    QByteArray byteArray = stmt.impl->query.value(offset).toByteArray();
-    checkQueryError(stmt.impl->query);
-    std::vector<uint8_t> blob(byteArray.begin(), byteArray.end());
-    return blob;
-}
-
-template <> mbgl::Timestamp Query::get(int offset) {
-    assert(stmt.impl && stmt.impl->query.isValid());
-    QVariant value = stmt.impl->query.value(offset);
-    checkQueryError(stmt.impl->query);
-    return std::chrono::time_point_cast<std::chrono::seconds>(
-        std::chrono::system_clock::from_time_t(value.value<::time_t>()));
-}
-
-template <> optional<int64_t> Query::get(int offset) {
-    assert(stmt.impl && stmt.impl->query.isValid());
-    QVariant value = stmt.impl->query.value(offset);
-    checkQueryError(stmt.impl->query);
-    if (value.isNull())
-        return {};
-    return { value.value<int64_t>() };
-}
-
-template <> optional<double> Query::get(int offset) {
-    assert(stmt.impl && stmt.impl->query.isValid());
-    QVariant value = stmt.impl->query.value(offset);
-    checkQueryError(stmt.impl->query);
-    if (value.isNull())
-        return {};
-    return { value.value<double>() };
-}
-
-template <> std::string Query::get(int offset) {
-    assert(stmt.impl && stmt.impl->query.isValid());
-    QByteArray value = stmt.impl->query.value(offset).toByteArray();
-    checkQueryError(stmt.impl->query);
-    return std::string(value.constData(), value.size());
-}
-
-template <> optional<std::string> Query::get(int offset) {
-    assert(stmt.impl && stmt.impl->query.isValid());
-    QByteArray value = stmt.impl->query.value(offset).toByteArray();
-    checkQueryError(stmt.impl->query);
-    if (value.isNull())
-        return {};
-    return { std::string(value.constData(), value.size()) };
-}
-
-template <> optional<mbgl::Timestamp> Query::get(int offset) {
-    assert(stmt.impl && stmt.impl->query.isValid());
-    QVariant value = stmt.impl->query.value(offset);
-    checkQueryError(stmt.impl->query);
-    if (value.isNull())
-        return {};
-    return { std::chrono::time_point_cast<mbgl::Seconds>(
-        std::chrono::system_clock::from_time_t(value.value<::time_t>())) };
-}
-
-void Query::reset() {
-    assert(stmt.impl);
-    stmt.impl->query.finish();
-}
-
-void Query::clearBindings() {
-    // no-op
-}
-
-int64_t Query::lastInsertRowId() const {
-    assert(stmt.impl);
-    return stmt.impl->lastInsertRowId;
-}
-
-uint64_t Query::changes() const {
-    assert(stmt.impl);
-    return (stmt.impl->changes < 0 ? 0 : stmt.impl->changes);
-}
-
-Transaction::Transaction(Database& db_, Mode mode)
-    : dbImpl(*db_.impl) {
-    switch (mode) {
-    case Deferred:
-        dbImpl.exec("BEGIN DEFERRED TRANSACTION");
-        break;
-    case Immediate:
-        dbImpl.exec("BEGIN IMMEDIATE TRANSACTION");
-        break;
-    case Exclusive:
-        dbImpl.exec("BEGIN EXCLUSIVE TRANSACTION");
-        break;
-    }
-}
-
-Transaction::~Transaction() {
-    if (needRollback) {
-        try {
-            rollback();
-        } catch (...) {
-            // Ignore failed rollbacks in destructor.
-        }
-    }
-}
-
-void Transaction::commit() {
-    needRollback = false;
-    dbImpl.exec("COMMIT TRANSACTION");
-}
-
-void Transaction::rollback() {
-    needRollback = false;
-    dbImpl.exec("ROLLBACK TRANSACTION");
-}
-
-} // namespace sqlite
-} // namespace mapbox

package/platform/qt/src/mbgl/string_stdlib.cpp

@@ -1,24 +0,0 @@
-#include <mbgl/util/platform.hpp>
-
-#include <QByteArray>
-#include <QString>
-
-#include <string>
-
-namespace mbgl {
-namespace platform {
-
-std::string uppercase(const std::string& str) {
-    auto upper = QString::fromUtf8(str.data(), static_cast<int>(str.length())).toUpper().toUtf8();
-
-    return std::string(upper.constData(), upper.size());
-}
-
-std::string lowercase(const std::string& str) {
-    auto lower = QString::fromUtf8(str.data(), static_cast<int>(str.length())).toLower().toUtf8();
-
-    return std::string(lower.constData(), lower.size());
-}
-
-} // namespace platform
-} // namespace mbgl

package/platform/qt/src/mbgl/thread.cpp

@@ -1,28 +0,0 @@
-#include <mbgl/util/platform.hpp>
-#include <mbgl/platform/thread.hpp>
-
-#include <string>
-
-namespace mbgl {
-namespace platform {
-
-std::string getCurrentThreadName() {
-    return "unknown";
-}
-
-void setCurrentThreadName(const std::string&) {
-}
-
-void makeThreadLowPriority() {
-}
-
-void setCurrentThreadPriority(double) {}
-
-void attachThread() {
-}
-
-void detachThread() {
-}
-
-} // namespace platform
-} // namespace mbgl

package/platform/qt/src/mbgl/thread_local.cpp

@@ -1,39 +0,0 @@
-#include <mbgl/util/thread_local.hpp>
-
-#include <array>
-#include <cassert>
-
-#include <QThreadStorage>
-
-namespace mbgl {
-namespace util {
-namespace impl {
-
-// QThreadStorage tries to be smart and take ownership of the data, which we don't want. So we're
-// wrapping it in another type which doesn't own the pointer it contains.
-using StorageType = QThreadStorage<std::array<void*, 1>>;
-
-ThreadLocalBase::ThreadLocalBase() {
-    static_assert(sizeof(storage) >= sizeof(StorageType), "storage is too small");
-    static_assert(alignof(decltype(storage)) % alignof(StorageType) == 0, "storage is incorrectly aligned");
-    new (&reinterpret_cast<StorageType&>(storage)) QThreadStorage<void*>();
-}
-
-ThreadLocalBase::~ThreadLocalBase() {
-    // ThreadLocal will not take ownership of the pointer it is managing. The pointer
-    // needs to be explicitly cleared before we destroy this object.
-    assert(!get());
-    reinterpret_cast<StorageType&>(storage).~QThreadStorage();
-}
-
-void* ThreadLocalBase::get() {
-    return reinterpret_cast<StorageType&>(storage).localData()[0];
-}
-
-void ThreadLocalBase::set(void* ptr) {
-    reinterpret_cast<StorageType&>(storage).setLocalData({{ ptr }});
-}
-
-} // namespace impl
-} // namespace util
-} // namespace mbgl

package/platform/qt/src/mbgl/timer.cpp

@@ -1,62 +0,0 @@
-#include "timer_impl.hpp"
-
-#include <mbgl/util/run_loop.hpp>
-#include <mbgl/util/timer.hpp>
-
-#include <memory>
-
-namespace mbgl {
-namespace util {
-
-Timer::Impl::Impl() {
-    timer.setTimerType(Qt::PreciseTimer);
-    connect(&timer, &QTimer::timeout, this, &Timer::Impl::timerFired);
-}
-
-void Timer::Impl::start(uint64_t timeout, uint64_t repeat_, std::function<void ()>&& cb) {
-    repeat = repeat_;
-    callback = std::move(cb);
-
-    timer.setSingleShot(true);
-#if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
-    timer.start(static_cast<std::chrono::milliseconds>(timeout));
-#else
-    timer.start(static_cast<int>(timeout));
-#endif
-}
-
-void Timer::Impl::stop() {
-    timer.stop();
-}
-
-void Timer::Impl::timerFired() {
-    if (repeat) {
-        timer.setSingleShot(false);
-#if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
-        timer.start(static_cast<std::chrono::milliseconds>(repeat));
-#else
-        timer.start(static_cast<int>(repeat));
-#endif
-    }
-
-    callback();
-}
-
-Timer::Timer()
-    : impl(std::make_unique<Impl>()) {
-}
-
-Timer::~Timer() = default;
-
-void Timer::start(Duration timeout, Duration repeat, std::function<void()>&& cb) {
-    impl->start(std::chrono::duration_cast<std::chrono::milliseconds>(timeout).count(),
-                std::chrono::duration_cast<std::chrono::milliseconds>(repeat).count(),
-                std::move(cb));
-}
-
-void Timer::stop() {
-    impl->stop();
-}
-
-}
-}

package/platform/qt/src/mbgl/timer_impl.hpp

@@ -1,31 +0,0 @@
-#pragma once
-
-#include <mbgl/util/timer.hpp>
-
-#include <QObject>
-#include <QTimer>
-
-namespace mbgl {
-namespace util {
-
-class Timer::Impl : public QObject {
-    Q_OBJECT
-
-public:
-    Impl();
-
-    void start(uint64_t timeout, uint64_t repeat, std::function<void ()> &&);
-    void stop();
-
-public slots:
-    void timerFired();
-
-private:
-    uint64_t repeat;
-    std::function<void()> callback;
-
-    QTimer timer;
-};
-
-} // namespace util
-} // namespace mbgl