memcached.cpp

/*
 * SPDX-FileCopyrightText: (C) 2017-2022 Matthias Fehring <mf@huessenbergnetz.de>
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#include "memcached_p.h"
 
#include <Cutelyst/Application>
#include <Cutelyst/Context>
#include <Cutelyst/Engine>
#include <utility>
 
#include <QLoggingCategory>
#include <QStringList>
 
Q_LOGGING_CATEGORY(C_MEMCACHED, "cutelyst.plugin.memcached", QtWarningMsg)
 
using namespace Cutelyst;
 
static thread_local Memcached *mcd       = nullptr;
const time_t Memcached::expirationNotAdd = MEMCACHED_EXPIRATION_NOT_ADD;
 
Memcached::Memcached(Application *parent)
    : Plugin(parent)
    , d_ptr(new MemcachedPrivate)
{
}
 
Memcached::~Memcached()
{
}
 
void Memcached::setDefaultConfig(const QVariantMap &defaultConfig)
{
    Q_D(Memcached);
    d->defaultConfig = defaultConfig;
}
 
bool Memcached::setup(Application *app)
{
    Q_D(Memcached);
 
    const QVariantMap map = app->engine()->config(QStringLiteral("Cutelyst_Memcached_Plugin"));
    QStringList config;
 
    const QStringList serverList =
        map.value(QStringLiteral("servers"), d->defaultConfig.value(QStringLiteral("servers")))
            .toString()
            .split(u';');
 
    if (serverList.empty()) {
        config.push_back(QStringLiteral("--SERVER=localhost"));
    }
 
    for (const QString &flag : {
             QStringLiteral("verify_key"),
             QStringLiteral("remove_failed_servers"),
             QStringLiteral("binary_protocol"),
             QStringLiteral("buffer_requests"),
             QStringLiteral("hash_with_namespace"),
             QStringLiteral("noreply"),
             QStringLiteral("randomize_replica_read"),
             QStringLiteral("sort_hosts"),
             QStringLiteral("support_cas"),
             QStringLiteral("use_udp"),
             QStringLiteral("tcp_nodelay"),
             QStringLiteral("tcp_keepalive"),
         }) {
        if (map.value(flag, d->defaultConfig.value(flag, false)).toBool()) {
            const QString flagStr = u"--" + flag.toUpper().replace(u'_', u'-');
            config.push_back(flagStr);
        }
    }
 
    const bool useUDP = map.value(QStringLiteral("use_udp"),
                                  d->defaultConfig.value(QStringLiteral("use_udp"), false))
                            .toBool();
 
    for (const QString &opt : {
             QStringLiteral("connect_timeout"),
             QStringLiteral("distribution"),
             QStringLiteral("hash"),
             QStringLiteral("number_of_replicas"),
             QStringLiteral("namespace"),
             QStringLiteral("retry_timeout"),
             QStringLiteral("server_failure_limit"),
             QStringLiteral("snd_timeout"),
             QStringLiteral("socket_recv_size"),
             QStringLiteral("socket_send_size"),
             QStringLiteral("poll_timeout"),
             QStringLiteral("io_bytes_watermark"),
             QStringLiteral("io_key_prefetch"),
             QStringLiteral("io_msg_watermark"),
             QStringLiteral("rcv_timeout"),
         }) {
        const QString _val = map.value(opt, d->defaultConfig.value(opt)).toString();
        if (!_val.isEmpty()) {
            const QString optStr = u"--" + opt.toUpper().replace(u'_', u'-') + u'=' + _val;
            config.push_back(optStr); // clazy:exclude=reserve-candidates
        }
    }
 
    const QByteArray configString = config.join(u' ').toUtf8();
 
    bool ok = false;
 
    qCInfo(C_MEMCACHED,
           "Setting up connection to memcached servers using libmemcached %s with the following "
           "configuration string: \"%s\"",
           memcached_lib_version(),
           configString.constData());
 
    memcached_st *new_memc = memcached(configString.constData(), configString.size());
 
    if (new_memc) {
 
        if (!serverList.empty()) {
            for (const QString &server : serverList) {
                const auto serverParts = QStringView(server).split(u',');
                QString name;
                uint port       = 11211;
                uint32_t weight = 1;
                bool isSocket   = false;
                if (!serverParts.empty()) {
                    const auto part0 = serverParts.at(0);
                    if (!part0.isEmpty()) {
                        name     = part0.toString();
                        isSocket = name.startsWith(u'/');
                    }
                    if (serverParts.size() > 1) {
                        const auto part1 = serverParts.at(1);
                        if (!part1.isEmpty()) {
                            if (isSocket) {
                                weight = part1.toUInt();
                            } else {
                                port = part1.toUInt();
                            }
                        }
                        if (!isSocket && (serverParts.size() > 2)) {
                            const auto part2 = serverParts.at(2);
                            if (!part2.isEmpty()) {
                                weight = part2.toUInt();
                            }
                        }
                    }
                }
                if (!name.isEmpty()) {
                    memcached_return_t rc;
                    if (isSocket) {
                        rc = memcached_server_add_unix_socket_with_weight(
                            new_memc, name.toUtf8().constData(), weight);
                        if (Q_LIKELY(memcached_success(rc))) {
                            qCInfo(C_MEMCACHED,
                                   "Added memcached server on socket %s with weight %u.",
                                   qPrintable(name),
                                   weight);
                        } else {
                            qCWarning(
                                C_MEMCACHED,
                                "Failed to add memcached server on socket %s with weight %u: %s",
                                qPrintable(name),
                                weight,
                                memcached_strerror(new_memc, rc));
                        }
                    } else {
                        if (useUDP) {
                            rc = memcached_server_add_udp_with_weight(
                                new_memc, name.toUtf8().constData(), port, weight);
                        } else {
                            rc = memcached_server_add_with_weight(
                                new_memc, name.toUtf8().constData(), port, weight);
                        }
                        if (Q_LIKELY(memcached_success(rc))) {
                            qCInfo(C_MEMCACHED,
                                   "Added memcached server on host %s:%u with weight %u.",
                                   qPrintable(name),
                                   port,
                                   weight);
                        } else {
                            qCWarning(
                                C_MEMCACHED,
                                "Failed to add memcached server on host %s:%u with weight %u: %s",
                                qPrintable(name),
                                port,
                                weight,
                                memcached_strerror(new_memc, rc));
                        }
                    }
                }
            }
 
            if (Q_UNLIKELY(memcached_server_count(new_memc) == 0)) {
                qCWarning(C_MEMCACHED,
                          "Failed to add any memcached server. Adding default server on localhost "
                          "port 11211.");
                memcached_return_t rc = memcached_server_add(new_memc, "localhost", 11211);
                if (Q_UNLIKELY(!memcached_success(rc))) {
                    qCCritical(C_MEMCACHED,
                               "Failed to add default memcached server. Memcached plugin will not "
                               "work without a configured server! %s",
                               memcached_strerror(new_memc, rc));
                    memcached_free(new_memc);
                    return false;
                }
            }
        }
 
        d->compression = map.value(QStringLiteral("compression"),
                                   d->defaultConfig.value(QStringLiteral("compression"), false))
                             .toBool();
        d->compressionLevel =
            map.value(QStringLiteral("compression_level"),
                      d->defaultConfig.value(QStringLiteral("compression_level"), -1))
                .toInt();
        d->compressionThreshold =
            map.value(QStringLiteral("compression_threshold"),
                      d->defaultConfig.value(QStringLiteral("compression_threshold"), 100))
                .toInt();
        if (d->compression) {
            qCInfo(C_MEMCACHED,
                   "Compression: enabled (Compression level: %i, Compression threshold: %i bytes)",
                   d->compressionLevel,
                   d->compressionThreshold);
        } else {
            qCInfo(C_MEMCACHED, "Compression: disabled");
        }
 
        const QString encKey = map.value(QStringLiteral("encryption_key")).toString();
        if (!encKey.isEmpty()) {
            const QByteArray encKeyBa = encKey.toUtf8();
            const memcached_return_t rt =
                memcached_set_encoding_key(new_memc, encKeyBa.constData(), encKeyBa.size());
            if (Q_LIKELY(memcached_success(rt))) {
                qCInfo(C_MEMCACHED, "Encryption: enabled");
            } else {
                qCWarning(C_MEMCACHED,
                          "Failed to enable encryption: %s",
                          memcached_strerror(new_memc, rt));
            }
        } else {
            qCInfo(C_MEMCACHED, "Encryption: disabled");
        }
 
#ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
#    if LIBMEMCACHED_WITH_SASL_SUPPORT == 1
        const QString saslUser = map.value(QStringLiteral("sasl_user")).toString();
        const QString saslPass = map.value(QStringLiteral("sasl_password")).toString();
        if (!saslUser.isEmpty() && !saslPass.isEmpty()) {
            const memcached_return_t rt = memcached_set_sasl_auth_data(
                new_memc, saslUser.toUtf8().constData(), saslPass.toUtf8().constData());
            if (Q_LIKELY(memcached_success(rt))) {
                qCInfo(C_MEMCACHED, "SASL authentication: enabled");
                d->saslEnabled = true;
            } else {
                qCWarning(C_MEMCACHED,
                          "Failed to enable SASL authentication: %s",
                          memcached_strerror(new_memc, rt));
            }
        } else {
            qCInfo(C_MEMCACHED, "SASL authentication: disabled");
        }
#    endif
#endif
 
        if (d->memc) {
            memcached_free(d->memc);
        }
        d->memc = new_memc;
        ok      = true;
    }
 
    if (ok) {
        connect(app, &Application::postForked, this, [=] { mcd = this; });
        app->loadTranslations(QStringLiteral("plugin_memcached"));
    } else {
        qCCritical(C_MEMCACHED) << "Failed to configure the connection to the memcached server(s)";
    }
 
    return ok;
}
 
bool Memcached::set(const QString &key,
                    const QByteArray &value,
                    time_t expiration,
                    Cutelyst::Memcached::MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key = key.toUtf8();
 
    MemcachedPrivate::Flags flags;
    QByteArray _value = value;
 
    if (mcd->d_ptr->compression && (_value.size() > mcd->d_ptr->compressionThreshold)) {
        flags |= MemcachedPrivate::Compressed;
        _value = qCompress(value, mcd->d_ptr->compressionLevel);
    }
 
    const memcached_return_t rt = memcached_set(mcd->d_ptr->memc,
                                                _key.constData(),
                                                _key.size(),
                                                _value.constData(),
                                                _value.size(),
                                                expiration,
                                                flags);
 
    const bool ok = memcached_success(rt);
 
    if (!ok) {
        qCWarning(C_MEMCACHED,
                  "Failed to store key \"%s\": %s",
                  _key.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::setByKey(const QString &groupKey,
                         const QString &key,
                         const QByteArray &value,
                         time_t expiration,
                         MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key      = key.toUtf8();
    const QByteArray _groupKey = groupKey.toUtf8();
 
    MemcachedPrivate::Flags flags;
    QByteArray _value = value;
 
    if (mcd->d_ptr->compression && (_value.size() > mcd->d_ptr->compressionThreshold)) {
        flags |= MemcachedPrivate::Compressed;
        _value = qCompress(value, mcd->d_ptr->compressionLevel);
    }
 
    const memcached_return_t rt = memcached_set_by_key(mcd->d_ptr->memc,
                                                       _groupKey.constData(),
                                                       _groupKey.size(),
                                                       _key.constData(),
                                                       _key.size(),
                                                       _value.constData(),
                                                       _value.size(),
                                                       expiration,
                                                       flags);
 
    const bool ok = memcached_success(rt);
 
    if (!ok) {
        qCWarning(C_MEMCACHED,
                  "Failed to store key \"%s\" on group \"%s\": %s",
                  _key.constData(),
                  _groupKey.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::add(const QString &key,
                    const QByteArray &value,
                    time_t expiration,
                    MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key = key.toUtf8();
 
    MemcachedPrivate::Flags flags;
    QByteArray _value = value;
 
    if (mcd->d_ptr->compression && (_value.size() > mcd->d_ptr->compressionThreshold)) {
        flags |= MemcachedPrivate::Compressed;
        _value = qCompress(value, mcd->d_ptr->compressionLevel);
    }
 
    const memcached_return_t rt = memcached_add(mcd->d_ptr->memc,
                                                _key.constData(),
                                                _key.size(),
                                                _value.constData(),
                                                _value.size(),
                                                expiration,
                                                flags);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTSTORED)) {
        qCWarning(C_MEMCACHED,
                  "Failed to add key \"%s\": %s",
                  _key.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::addByKey(const QString &groupKey,
                         const QString &key,
                         const QByteArray &value,
                         time_t expiration,
                         MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key      = key.toUtf8();
    const QByteArray _groupKey = groupKey.toUtf8();
 
    MemcachedPrivate::Flags flags;
    QByteArray _value = value;
 
    if (mcd->d_ptr->compression && (_value.size() > mcd->d_ptr->compressionThreshold)) {
        flags |= MemcachedPrivate::Compressed;
        _value = qCompress(value, mcd->d_ptr->compressionLevel);
    }
 
    const memcached_return_t rt = memcached_add_by_key(mcd->d_ptr->memc,
                                                       _groupKey.constData(),
                                                       _groupKey.size(),
                                                       _key.constData(),
                                                       _key.size(),
                                                       _value.constData(),
                                                       _value.size(),
                                                       expiration,
                                                       flags);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTSTORED)) {
        qCWarning(C_MEMCACHED,
                  "Failed to add key \"%s\" on group \"%s\": %s",
                  _key.constData(),
                  _groupKey.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::replace(const QString &key,
                        const QByteArray &value,
                        time_t expiration,
                        MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key = key.toUtf8();
 
    MemcachedPrivate::Flags flags;
    QByteArray _value = value;
 
    if (mcd->d_ptr->compression && (_value.size() > mcd->d_ptr->compressionThreshold)) {
        flags |= MemcachedPrivate::Compressed;
        _value = qCompress(value, mcd->d_ptr->compressionLevel);
    }
 
    const memcached_return_t rt = memcached_replace(mcd->d_ptr->memc,
                                                    _key.constData(),
                                                    _key.size(),
                                                    _value.constData(),
                                                    _value.size(),
                                                    expiration,
                                                    flags);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTSTORED)) {
        qCWarning(C_MEMCACHED,
                  "Failed to replace key \"%s\": %s",
                  _key.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::replaceByKey(const QString &groupKey,
                             const QString &key,
                             const QByteArray &value,
                             time_t expiration,
                             MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _groupKey = groupKey.toUtf8();
    const QByteArray _key      = key.toUtf8();
 
    MemcachedPrivate::Flags flags;
    QByteArray _value = value;
 
    if (mcd->d_ptr->compression && (_value.size() > mcd->d_ptr->compressionThreshold)) {
        flags |= MemcachedPrivate::Compressed;
        _value = qCompress(value, mcd->d_ptr->compressionLevel);
    }
 
    const memcached_return_t rt = memcached_replace_by_key(mcd->d_ptr->memc,
                                                           _groupKey.constData(),
                                                           _groupKey.size(),
                                                           _key.constData(),
                                                           _key.size(),
                                                           _value.constData(),
                                                           _value.size(),
                                                           expiration,
                                                           flags);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTSTORED)) {
        qCWarning(C_MEMCACHED,
                  "Failed to replace key \"%s\" on group \"%s\": %s",
                  _key.constData(),
                  _groupKey.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
QByteArray Memcached::get(const QString &key,
                          uint64_t *cas,
                          Cutelyst::Memcached::MemcachedReturnType *returnType)
{
    QByteArray retData;
 
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return retData;
    }
 
    memcached_return_t rt;
    const QByteArray _key = key.toUtf8();
    bool ok               = false;
 
    std::vector<const char *> keys;
    std::vector<size_t> sizes;
    keys.push_back(_key.constData());
    sizes.push_back(_key.size());
    rt = memcached_mget(mcd->d_ptr->memc, &keys[0], &sizes[0], keys.size());
 
    if (memcached_success(rt)) {
        memcached_result_st *result = memcached_fetch_result(mcd->d_ptr->memc, NULL, &rt);
        if (result) {
            retData = QByteArray(memcached_result_value(result), memcached_result_length(result));
            if (cas) {
                *cas = memcached_result_cas(result);
            }
            MemcachedPrivate::Flags flags = MemcachedPrivate::Flags(memcached_result_flags(result));
            if (flags.testFlag(MemcachedPrivate::Compressed)) {
                retData = qUncompress(retData);
            }
            ok = true;
            // fetch another result even if there is no one to get
            // a NULL for the internal of libmemcached
            memcached_fetch_result(mcd->d_ptr->memc, NULL, NULL);
        }
        memcached_result_free(result);
    }
 
    if (!ok && (rt != MEMCACHED_NOTFOUND)) {
        qCWarning(C_MEMCACHED,
                  "Failed to get data for key \"%s\": %s",
                  _key.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return retData;
}
 
QByteArray Memcached::getByKey(const QString &groupKey,
                               const QString &key,
                               uint64_t *cas,
                               MemcachedReturnType *returnType)
{
    QByteArray retData;
 
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return retData;
    }
 
    memcached_return_t rt;
    const QByteArray _groupKey = groupKey.toUtf8();
    const QByteArray _key      = key.toUtf8();
    bool ok                    = false;
 
    std::vector<const char *> keys;
    std::vector<size_t> sizes;
    keys.push_back(_key.constData());
    sizes.push_back(_key.size());
    rt = memcached_mget_by_key(mcd->d_ptr->memc,
                               _groupKey.constData(),
                               _groupKey.size(),
                               &keys[0],
                               &sizes[0],
                               keys.size());
 
    if (memcached_success(rt)) {
        memcached_result_st *result = memcached_fetch_result(mcd->d_ptr->memc, NULL, &rt);
        if (result) {
            retData = QByteArray(memcached_result_value(result), memcached_result_length(result));
            if (cas) {
                *cas = memcached_result_cas(result);
            }
            MemcachedPrivate::Flags flags = MemcachedPrivate::Flags(memcached_result_flags(result));
            if (flags.testFlag(MemcachedPrivate::Compressed)) {
                retData = qUncompress(retData);
            }
            ok = true;
            // fetch another result even if there is no one to get
            // a NULL for the internal of libmemcached
            memcached_fetch_result(mcd->d_ptr->memc, NULL, NULL);
        }
        memcached_result_free(result);
    }
 
    if (!ok && (rt != MEMCACHED_NOTFOUND)) {
        qCWarning(C_MEMCACHED,
                  "Failed to get data for key \"%s\" on group \"%s\": %s",
                  _key.constData(),
                  _groupKey.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return retData;
}
 
bool Memcached::remove(const QString &key, MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key = key.toUtf8();
 
    const memcached_return_t rt =
        memcached_delete(mcd->d_ptr->memc, _key.constData(), _key.size(), 0);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTFOUND)) {
        qCWarning(C_MEMCACHED,
                  "Failed to remove data for key \"%s\": %s",
                  _key.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::removeByKey(const QString &groupKey,
                            const QString &key,
                            MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _groupKey = groupKey.toUtf8();
    const QByteArray _key      = key.toUtf8();
 
    const memcached_return_t rt = memcached_delete_by_key(mcd->d_ptr->memc,
                                                          _groupKey.constData(),
                                                          _groupKey.size(),
                                                          _key.constData(),
                                                          _key.size(),
                                                          0);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTFOUND)) {
        qCWarning(C_MEMCACHED,
                  "Failed to remove data for key \"%s\" on group \"%s\": %s",
                  _key.constData(),
                  _groupKey.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::exist(const QString &key, MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key = key.toUtf8();
 
    const memcached_return_t rt = memcached_exist(mcd->d_ptr->memc, _key.constData(), _key.size());
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTFOUND)) {
        qCWarning(C_MEMCACHED,
                  "Failed to check existence of key \"%s\": %s",
                  _key.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::existByKey(const QString &groupKey,
                           const QString &key,
                           MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _groupKey = groupKey.toUtf8();
    const QByteArray _key      = key.toUtf8();
 
    const memcached_return_t rt = memcached_exist_by_key(
        mcd->d_ptr->memc, _groupKey.constData(), _groupKey.size(), _key.constData(), _key.size());
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTFOUND)) {
        qCWarning(C_MEMCACHED,
                  "Failed to check existence of key \"%s\" in group \"%s\"",
                  _key.constData(),
                  _groupKey.constData());
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::increment(const QString &key,
                          uint32_t offset,
                          uint64_t *value,
                          MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key = key.toUtf8();
 
    const memcached_return_t rt =
        memcached_increment(mcd->d_ptr->memc, _key.constData(), _key.size(), offset, value);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTFOUND)) {
        qCWarning(C_MEMCACHED,
                  "Failed to increment key \"%s\" by %u: %s",
                  _key.constData(),
                  offset,
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::incrementByKey(const QString &groupKey,
                               const QString &key,
                               uint64_t offset,
                               uint64_t *value,
                               MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _group = groupKey.toUtf8();
    const QByteArray _key   = key.toUtf8();
 
    const memcached_return_t rt = memcached_increment_by_key(mcd->d_ptr->memc,
                                                             _group.constData(),
                                                             _group.size(),
                                                             _key.constData(),
                                                             _key.size(),
                                                             offset,
                                                             value);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTFOUND)) {
        qCWarning(C_MEMCACHED,
                  "Failed to increment \"%s\" key on group \"%s\" by %lu: %s",
                  _key.constData(),
                  _group.constData(),
                  offset,
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::incrementWithInitial(const QString &key,
                                     uint64_t offset,
                                     uint64_t initial,
                                     time_t expiration,
                                     uint64_t *value,
                                     MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key = key.toUtf8();
 
    const memcached_return_t rt = memcached_increment_with_initial(
        mcd->d_ptr->memc, _key.constData(), _key.size(), offset, initial, expiration, value);
 
    const bool ok = memcached_success(rt);
 
    if (!ok) {
        qCWarning(C_MEMCACHED,
                  "Failed to increment or initialize key \"%s\" by offset %lu or initial %lu: %s",
                  _key.constData(),
                  offset,
                  initial,
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::incrementWithInitialByKey(const QString &groupKey,
                                          const QString &key,
                                          uint64_t offset,
                                          uint64_t initial,
                                          time_t expiration,
                                          uint64_t *value,
                                          MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _group = groupKey.toUtf8();
    const QByteArray _key   = key.toUtf8();
 
    const memcached_return_t rt = memcached_increment_with_initial_by_key(mcd->d_ptr->memc,
                                                                          _group.constData(),
                                                                          _group.size(),
                                                                          _key.constData(),
                                                                          _key.size(),
                                                                          offset,
                                                                          initial,
                                                                          expiration,
                                                                          value);
 
    const bool ok = memcached_success(rt);
    if (!ok) {
        qCWarning(C_MEMCACHED,
                  "Failed to increment or initialize key \"%s\" in group \"%s\" by offset %lu or "
                  "initial %lu: %s",
                  _key.constData(),
                  _group.constData(),
                  offset,
                  initial,
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::decrement(const QString &key,
                          uint32_t offset,
                          uint64_t *value,
                          MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key = key.toUtf8();
 
    const memcached_return_t rt =
        memcached_decrement(mcd->d_ptr->memc, _key.constData(), _key.size(), offset, value);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTFOUND)) {
        qCWarning(C_MEMCACHED,
                  "Failed to decrement key \"%s\" by %u: %s",
                  _key.constData(),
                  offset,
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::decrementByKey(const QString &groupKey,
                               const QString &key,
                               uint64_t offset,
                               uint64_t *value,
                               MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _group = groupKey.toUtf8();
    const QByteArray _key   = key.toUtf8();
 
    const memcached_return_t rt = memcached_decrement_by_key(mcd->d_ptr->memc,
                                                             _group.constData(),
                                                             _group.size(),
                                                             _key.constData(),
                                                             _key.size(),
                                                             offset,
                                                             value);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_NOTFOUND)) {
        qCWarning(C_MEMCACHED,
                  "Failed to decrement \"%s\" key on group \"%s\" by %lu: %s",
                  _key.constData(),
                  _group.constData(),
                  offset,
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::decrementWithInitial(const QString &key,
                                     uint64_t offset,
                                     uint64_t initial,
                                     time_t expiration,
                                     uint64_t *value,
                                     MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key = key.toUtf8();
 
    const memcached_return_t rt = memcached_decrement_with_initial(
        mcd->d_ptr->memc, _key.constData(), _key.size(), offset, initial, expiration, value);
 
    const bool ok = memcached_success(rt);
 
    if (!ok) {
        qCWarning(C_MEMCACHED,
                  "Failed to decrement or initialize key \"%s\" by offset %lu or initial %lu: %s",
                  _key.constData(),
                  offset,
                  initial,
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::decrementWithInitialByKey(const QString &groupKey,
                                          const QString &key,
                                          uint64_t offset,
                                          uint64_t initial,
                                          time_t expiration,
                                          uint64_t *value,
                                          MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _group = groupKey.toUtf8();
    const QByteArray _key   = key.toUtf8();
 
    const memcached_return_t rt = memcached_decrement_with_initial_by_key(mcd->d_ptr->memc,
                                                                          _group.constData(),
                                                                          _group.size(),
                                                                          _key.constData(),
                                                                          _key.size(),
                                                                          offset,
                                                                          initial,
                                                                          expiration,
                                                                          value);
 
    const bool ok = memcached_success(rt);
    if (!ok) {
        qCWarning(C_MEMCACHED,
                  "Failed to increment or initialize key \"%s\" in group \"%s\" by offset %lu or "
                  "initial %lu: %s",
                  _key.constData(),
                  _group.constData(),
                  offset,
                  initial,
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::cas(const QString &key,
                    const QByteArray &value,
                    time_t expiration,
                    uint64_t cas,
                    MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key = key.toUtf8();
 
    MemcachedPrivate::Flags flags;
    QByteArray _value = value;
 
    if (mcd->d_ptr->compression && (_value.size() > mcd->d_ptr->compressionThreshold)) {
        flags |= MemcachedPrivate::Compressed;
        _value = qCompress(value, mcd->d_ptr->compressionLevel);
    }
 
    const memcached_return_t rt = memcached_cas(mcd->d_ptr->memc,
                                                _key.constData(),
                                                _key.size(),
                                                _value.constData(),
                                                _value.size(),
                                                expiration,
                                                flags,
                                                cas);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_DATA_EXISTS)) {
        qCWarning(C_MEMCACHED,
                  "Failed to compare and set (cas) key \"%s\": %s",
                  _key.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::casByKey(const QString &groupKey,
                         const QString &key,
                         const QByteArray &value,
                         time_t expiration,
                         uint64_t cas,
                         MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _group = groupKey.toUtf8();
    const QByteArray _key   = key.toUtf8();
 
    MemcachedPrivate::Flags flags;
    QByteArray _value = value;
 
    if (mcd->d_ptr->compression && (_value.size() > mcd->d_ptr->compressionThreshold)) {
        flags |= MemcachedPrivate::Compressed;
        _value = qCompress(value, mcd->d_ptr->compressionLevel);
    }
 
    const memcached_return_t rt = memcached_cas_by_key(mcd->d_ptr->memc,
                                                       _group.constData(),
                                                       _group.size(),
                                                       _key.constData(),
                                                       _key.size(),
                                                       _value.constData(),
                                                       _value.size(),
                                                       expiration,
                                                       flags,
                                                       cas);
 
    const bool ok = memcached_success(rt);
 
    if (!ok && (rt != MEMCACHED_DATA_EXISTS)) {
        qCWarning(C_MEMCACHED,
                  "Failed to compare and set (cas) key \"%s\" in group \"%s\": %s",
                  _key.constData(),
                  _group.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::flushBuffers(MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const memcached_return_t rt = memcached_flush_buffers(mcd->d_ptr->memc);
 
    const bool ok = memcached_success(rt);
 
    if (!ok) {
        qCWarning(
            C_MEMCACHED, "Failed to flush buffers: %s", memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::flush(time_t expiration, MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const memcached_return_t rt = memcached_flush(mcd->d_ptr->memc, expiration);
 
    const bool ok = memcached_success(rt);
 
    if (!ok) {
        qCWarning(C_MEMCACHED,
                  "Failed to wipe clean (flush) server content: %s",
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
QHash<QString, QByteArray> Memcached::mget(const QStringList &keys,
                                           QHash<QString, uint64_t> *casValues,
                                           MemcachedReturnType *returnType)
{
    QHash<QString, QByteArray> ret;
 
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return ret;
    }
 
    if (keys.empty()) {
        qCWarning(C_MEMCACHED, "Can not get multiple values without a list of keys.");
        if (returnType) {
            *returnType = Memcached::BadKeyProvided;
        }
        return ret;
    }
 
    std::vector<char *> _keys;
    _keys.reserve(keys.size());
    std::vector<size_t> _keysSizes;
    _keysSizes.reserve(keys.size());
 
    for (const QString &key : keys) {
        const QByteArray _key = key.toUtf8();
        char *data            = new char[_key.size() + 1];
        qstrcpy(data, _key.data());
        _keys.push_back(data);
        _keysSizes.push_back(_key.size());
    }
 
    memcached_return_t rt;
    bool ok = false;
 
    rt = memcached_mget(mcd->d_ptr->memc, &_keys[0], &_keysSizes[0], _keys.size());
 
    if (memcached_success(rt)) {
        ok = true;
        ret.reserve(keys.size());
        while ((rt != MEMCACHED_END) && (rt != MEMCACHED_NOTFOUND)) {
            memcached_result_st *result = memcached_fetch_result(mcd->d_ptr->memc, NULL, &rt);
            if (result) {
                const QString rk = QString::fromUtf8(memcached_result_key_value(result),
                                                     memcached_result_key_length(result));
                QByteArray rd(memcached_result_value(result), memcached_result_length(result));
                if (casValues) {
                    casValues->insert(rk, memcached_result_cas(result));
                }
                MemcachedPrivate::Flags flags =
                    MemcachedPrivate::Flags(memcached_result_flags(result));
                if (flags.testFlag(MemcachedPrivate::Compressed)) {
                    rd = qUncompress(rd);
                }
                ret.insert(rk, rd);
            }
            memcached_result_free(result);
        }
    }
 
    for (char *c : _keys) {
        delete[] c;
    }
 
    if (!ok) {
        qCWarning(C_MEMCACHED,
                  "Failed to get values for multiple keys: %s",
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ret;
}
 
QHash<QString, QByteArray> Memcached::mgetByKey(const QString &groupKey,
                                                const QStringList &keys,
                                                QHash<QString, uint64_t> *casValues,
                                                MemcachedReturnType *returnType)
{
    QHash<QString, QByteArray> ret;
 
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return ret;
    }
 
    if (groupKey.isEmpty()) {
        qCWarning(C_MEMCACHED,
                  "Can not get multiple values from specific server when groupKey is empty.");
        if (returnType) {
            *returnType = Memcached::BadKeyProvided;
        }
        return ret;
    }
 
    if (keys.empty()) {
        qCWarning(C_MEMCACHED, "Can not get multiple values without a list of keys.");
        if (returnType) {
            *returnType = Memcached::BadKeyProvided;
        }
        return ret;
    }
 
    const QByteArray _group = groupKey.toUtf8();
 
    std::vector<char *> _keys;
    _keys.reserve(keys.size());
    std::vector<size_t> _keysSizes;
    _keysSizes.reserve(keys.size());
 
    for (const QString &key : keys) {
        const QByteArray _key = key.toUtf8();
        char *data            = new char[_key.size() + 1];
        strcpy(data, _key.data());
        _keys.push_back(data);
        _keysSizes.push_back(_key.size());
    }
 
    memcached_return_t rt;
    bool ok = false;
 
    rt = memcached_mget_by_key(mcd->d_ptr->memc,
                               _group.constData(),
                               _group.size(),
                               &_keys[0],
                               &_keysSizes[0],
                               _keys.size());
 
    if (memcached_success(rt)) {
        ok = true;
        ret.reserve(keys.size());
        while ((rt != MEMCACHED_END) && (rt != MEMCACHED_NOTFOUND)) {
            memcached_result_st *result = memcached_fetch_result(mcd->d_ptr->memc, NULL, &rt);
            if (result) {
                const QString rk = QString::fromUtf8(memcached_result_key_value(result),
                                                     memcached_result_key_length(result));
                QByteArray rd(memcached_result_value(result), memcached_result_length(result));
                if (casValues) {
                    casValues->insert(rk, memcached_result_cas(result));
                }
                MemcachedPrivate::Flags flags =
                    MemcachedPrivate::Flags(memcached_result_flags(result));
                if (flags.testFlag(MemcachedPrivate::Compressed)) {
                    rd = qUncompress(rd);
                }
                ret.insert(rk, rd);
            }
            memcached_result_free(result);
        }
    }
 
    for (char *c : _keys) {
        delete[] c;
    }
 
    if (!ok) {
        qCWarning(C_MEMCACHED,
                  "Failed to get values for multiple keys in group \"%s\": %s",
                  _group.constData(),
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ret;
}
 
bool Memcached::touch(const QString &key, time_t expiration, MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _key = key.toUtf8();
 
    const memcached_return_t rt =
        memcached_touch(mcd->d_ptr->memc, _key.constData(), _key.size(), expiration);
 
    const bool ok = memcached_success(rt);
 
    if (!ok) {
        qCWarning(C_MEMCACHED,
                  "Failed to touch key \"%s\" with new expiration time %lu: %s",
                  _key.constData(),
                  expiration,
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
bool Memcached::touchByKey(const QString &groupKey,
                           const QString &key,
                           time_t expiration,
                           MemcachedReturnType *returnType)
{
    if (!mcd) {
        qCCritical(C_MEMCACHED) << "Memcached plugin not registered";
        if (returnType) {
            *returnType = Memcached::PluginNotRegisterd;
        }
        return false;
    }
 
    const QByteArray _group = groupKey.toUtf8();
    const QByteArray _key   = key.toUtf8();
 
    const memcached_return_t rt = memcached_touch_by_key(mcd->d_ptr->memc,
                                                         _group.constData(),
                                                         _group.size(),
                                                         _key.constData(),
                                                         _key.size(),
                                                         expiration);
 
    const bool ok = memcached_success(rt);
 
    if (!ok) {
        qCWarning(C_MEMCACHED,
                  "Failed to touch key \"%s\" in group \"%s\" with new expiration time %lu: %s",
                  _key.constData(),
                  _group.constData(),
                  expiration,
                  memcached_strerror(mcd->d_ptr->memc, rt));
    }
 
    MemcachedPrivate::setReturnType(returnType, rt);
 
    return ok;
}
 
QString Memcached::errorString(Context *c, MemcachedReturnType rt)
{
    switch (rt) {
    case Memcached::Success:
        return c->translate("Cutelyst::Memcached", "The request was successfully executed.");
    case Memcached::Failure:
        return c->translate("Cutelyst::Memcached",
                            "An unknown failure has occurred in the Memcached server.");
    case Memcached::HostLookupFailure:
        return c->translate("Cutelyst::Memcached", "A DNS failure has occurred.");
    case Memcached::ConnectionFailure:
        return c->translate(
            "Cutelyst::Memcached",
            "An unknown error has occurred while trying to connect to a Memcached server.");
    case Memcached::WriteFailure:
        return c->translate("Cutelyst::Memcached",
                            "An error has occurred while trying to write to a Memcached server.");
    case Memcached::ReadFailure:
        return c->translate("Cutelyst::Memcached",
                            "An error has occurred while trying to read from a Memcached server.");
    case Memcached::UnknownReadFailure:
        return c->translate(
            "Cutelyst::Memcached",
            "An unknown error has occurred while trying to read from a Memcached server. This only "
            "occures when either there is a bug in the server, or in rare cases where an ethernet "
            "NIC is reporting dubious information.");
    case Memcached::ProtocolError:
        return c->translate("Cutelyst::Memcached",
                            "An unknown error has occurred in the Memcached protocol.");
    case Memcached::ClientError:
        return c->translate("Cutelyst::Memcached",
                            "An unknown Memcached client error has occurred internally.");
    case Memcached::ServerError:
        return c->translate("Cutelyst::Memcached",
                            "An unknown error has occurred in the Memcached server.");
    case Memcached::Error:
        return c->translate("Cutelyst::Memcached", "A general error occurred.");
    case Memcached::DataExists:
        return c->translate("Cutelyst::Memcached", "The data for the given key alrey exists.");
    case Memcached::DataDoesNotExist:
        return c->translate("Cutelyst::Memcached",
                            "The data requested with the key given was not found.");
    case Memcached::NotStored:
        return c->translate("Cutelyst::Memcached", "The request to store an object failed.");
    case Memcached::Stored:
        return c->translate("Cutelyst::Memcached",
                            "The requested object has been successfully stored on the server.");
    case Memcached::NotFound:
        return c->translate("Cutelyst::Memcached", "The object requested was not found.");
    case Memcached::MemoryAllocationFailure:
        return c->translate("Cutelyst::Memcached",
                            "An error has occurred while trying to allocate memory.");
    case Memcached::PartialRead:
        return c->translate("Cutelyst::Memcached",
                            "The read operation was only partcially successful.");
    case Memcached::SomeErrors:
        return c->translate("Cutelyst::Memcached",
                            "A multi request has been made, and some underterminate number of "
                            "errors have occurred.");
    case Memcached::NoServers:
        return c->translate("Cutelyst::Memcached",
                            "No servers have been added to the Memcached plugin.");
    case Memcached::End:
        return c->translate(
            "Cutelyst::Memcached",
            "The Memcached server has completed returning all of the objects requested.");
    case Memcached::Deleted:
        return c->translate("Cutelyst::Memcached",
                            "The object requested by the key has been deleted.");
    case Memcached::Stat:
        return c->translate("Cutelyst::Memcached",
                            "A “stat” command has been returned in the protocol.");
    case Memcached::Errno:
        return c->translate("Cutelyst::Memcached",
                            "An error has occurred in the driver which has set errno.");
    case Memcached::NotSupported:
        return c->translate("Cutelyst::Memcached",
                            "The given method is not supported in the Memcached server.");
    case Memcached::FetchNotFinished:
        return c->translate("Cutelyst::Memcached",
                            "A request has been made, but the Memcached server has not finished "
                            "the fetch of the last request.");
    case Memcached::Timeout:
        return c->translate("Cutelyst::Memcached", "The operation has timed out.");
    case Memcached::Buffered:
        return c->translate("Cutelyst::Memcached", "The request has been buffered.");
    case Memcached::BadKeyProvided:
        return c->translate("Cutelyst::Memcached", "The key provided is not a valid key.");
    case Memcached::InvalidHostProtocol:
        return c->translate(
            "Cutelyst::Memcached",
            "The Memcached server you are connecting to has an invalid protocol. Most likely you "
            "are connecting to an older server that does not speak the binary protocol.");
    case Memcached::ServerMarkedDead:
        return c->translate("Cutelyst::Memcached",
                            "The requested Memcached server has been marked dead.");
    case Memcached::UnknownStatKey:
        return c->translate("Cutelyst::Memcached",
                            "The Memcached server you are communicating with has a stat key which "
                            "has not be defined in the protocol.");
    case Memcached::E2Big:
        return c->translate("Cutelyst::Memcached",
                            "Item is too large for the Memcached server to store.");
    case Memcached::InvalidArguments:
        return c->translate("Cutelyst::Memcached",
                            "The arguments supplied to the given function were not valid.");
    case Memcached::KeyTooBig:
        return c->translate(
            "Cutelyst::Memcached",
            "The key that has been provided is too large for the given Memcached server.");
    case Memcached::AuthProblem:
        return c->translate("Cutelyst::Memcached",
                            "An unknown issue has occurred during SASL authentication.");
    case Memcached::AuthFailure:
        return c->translate("Cutelyst::Memcached",
                            "The credentials provided are not valid for this Memcached server.");
    case Memcached::AuthContinue:
        return c->translate("Cutelyst::Memcached", "Authentication has been paused.");
    case Memcached::ParseError:
        return c->translate(
            "Cutelyst::Memcached",
            "An error has occurred while trying to parse the configuration string.");
    case Memcached::ParseUserError:
        return c->translate("Cutelyst::Memcached",
                            "An error has occurred in parsing the configuration string.");
    case Memcached::Deprecated:
        return c->translate("Cutelyst::Memcached",
                            "The method that was requested has been deprecated.");
    case Memcached::PluginNotRegisterd:
        return c->translate(
            "Cutelyst::Memcached",
            "The Cutelyst Memcached plugin has not been registered to the application.");
    default:
        return c->translate("Cutelyst::Memcached", "An unknown error has occurred.");
    }
}
 
QVersionNumber Memcached::libMemcachedVersion()
{
    return QVersionNumber::fromString(QLatin1String(memcached_lib_version()));
}
 
// clang-format off
Memcached::MemcachedReturnType MemcachedPrivate::returnTypeConvert(memcached_return_t rt)
{
    switch (rt) {
    case MEMCACHED_SUCCESS:                             return Memcached::Success;
    case MEMCACHED_FAILURE:                             return Memcached::Failure;
    case MEMCACHED_HOST_LOOKUP_FAILURE:                 return Memcached::HostLookupFailure;
    case MEMCACHED_CONNECTION_FAILURE:                  return Memcached::ConnectionFailure;
    case MEMCACHED_CONNECTION_BIND_FAILURE:             return Memcached::HostLookupFailure;
    case MEMCACHED_WRITE_FAILURE:                       return Memcached::WriteFailure;
    case MEMCACHED_READ_FAILURE:                        return Memcached::ReadFailure;
    case MEMCACHED_UNKNOWN_READ_FAILURE:                return Memcached::UnknownReadFailure;
    case MEMCACHED_PROTOCOL_ERROR:                      return Memcached::ProtocolError;
    case MEMCACHED_CLIENT_ERROR:                        return Memcached::ClientError;
    case MEMCACHED_SERVER_ERROR:                        return Memcached::ServerError;
    case MEMCACHED_ERROR:                               return Memcached::Error;
    case MEMCACHED_DATA_EXISTS:                         return Memcached::DataExists;
    case MEMCACHED_DATA_DOES_NOT_EXIST:                 return Memcached::DataDoesNotExist;
    case MEMCACHED_NOTSTORED:                           return Memcached::NotStored;
    case MEMCACHED_STORED:                              return Memcached::Stored;
    case MEMCACHED_NOTFOUND:                            return Memcached::NotFound;
    case MEMCACHED_MEMORY_ALLOCATION_FAILURE:           return Memcached::MemoryAllocationFailure;
    case MEMCACHED_PARTIAL_READ:                        return Memcached::PartialRead;
    case MEMCACHED_SOME_ERRORS:                         return Memcached::SomeErrors;
    case MEMCACHED_NO_SERVERS:                          return Memcached::NoServers;
    case MEMCACHED_END:                                 return Memcached::End;
    case MEMCACHED_DELETED:                             return Memcached::Deleted;
    case MEMCACHED_STAT:                                return Memcached::Stat;
    case MEMCACHED_ERRNO:                               return Memcached::Errno;
    case MEMCACHED_NOT_SUPPORTED:                       return Memcached::NotSupported;
    case MEMCACHED_FETCH_NOTFINISHED:                   return Memcached::FetchNotFinished;
    case MEMCACHED_TIMEOUT:                             return Memcached::Timeout;
    case MEMCACHED_BUFFERED:                            return Memcached::Buffered;
    case MEMCACHED_BAD_KEY_PROVIDED:                    return Memcached::BadKeyProvided;
    case MEMCACHED_INVALID_HOST_PROTOCOL:               return Memcached::InvalidHostProtocol;
    case MEMCACHED_SERVER_MARKED_DEAD:                  return Memcached::ServerMarkedDead;
    case MEMCACHED_UNKNOWN_STAT_KEY:                    return Memcached::UnknownStatKey;
    case MEMCACHED_E2BIG:                               return Memcached::E2Big;
    case MEMCACHED_INVALID_ARGUMENTS:                   return Memcached::InvalidArguments;
    case MEMCACHED_KEY_TOO_BIG:                         return Memcached::KeyTooBig;
    case MEMCACHED_AUTH_PROBLEM:                        return Memcached::AuthProblem;
    case MEMCACHED_AUTH_FAILURE:                        return Memcached::AuthFailure;
    case MEMCACHED_AUTH_CONTINUE:                       return Memcached::AuthContinue;
    case MEMCACHED_PARSE_ERROR:                         return Memcached::ParseError;
    case MEMCACHED_PARSE_USER_ERROR:                    return Memcached::ParseUserError;
    case MEMCACHED_DEPRECATED:                          return Memcached::Deprecated;
    case MEMCACHED_IN_PROGRESS:                         return Memcached::InProgress;
    case MEMCACHED_SERVER_TEMPORARILY_DISABLED:         return Memcached::ServerTemporaryDisabled;
    case MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE:    return Memcached::ServerMemoryAllocationFailure;
    case MEMCACHED_MAXIMUM_RETURN:                      return Memcached::MaximumReturn;
    default:                                            return Memcached::Success;
    }
}
// clang-format on
 
void MemcachedPrivate::setReturnType(Memcached::MemcachedReturnType *rt1, memcached_return_t rt2)
{
    if (rt1) {
        *rt1 = MemcachedPrivate::returnTypeConvert(rt2);
    }
}
 
#include "moc_memcached.cpp"