memcached.h

/*
 * SPDX-FileCopyrightText: (C) 2017-2022 Matthias Fehring <mf@huessenbergnetz.de>
 * SPDX-License-Identifier: BSD-3-Clause
 */

#ifndef CUTELYSTMEMCACHED_H
#define CUTELYSTMEMCACHED_H

#include <Cutelyst/cutelyst_global.h>
#include <Cutelyst/plugin.h>

#include <QDataStream>
#include <QVersionNumber>

namespace Cutelyst {

class Context;
class MemcachedPrivate;

class CUTELYST_PLUGIN_MEMCACHED_EXPORT Memcached : public Plugin
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(Memcached)
public:
    Memcached(Application *parent);

    virtual ~Memcached() override;

    enum MemcachedReturnType {
        Success,           
        Failure,           
        HostLookupFailure, 
        ConnectionFailure, 
        WriteFailure,      
        ReadFailure,       
        UnknownReadFailure, 
        ProtocolError,      
        ClientError,        
        ServerError,        
        Error,              
        DataExists,         
        DataDoesNotExist,   
        NotStored,          
        Stored,             
        NotFound,           
        MemoryAllocationFailure, 
        PartialRead,             
        SomeErrors,   
        NoServers,    
        End,          
        Deleted,      
        Stat,         
        Errno,        
        NotSupported, 
        FetchNotFinished, 
        Timeout,          
        Buffered,         
        BadKeyProvided,   
        InvalidHostProtocol, 
        ServerMarkedDead,    
        UnknownStatKey,   
        E2Big,            
        InvalidArguments, 
        KeyTooBig,        
        AuthProblem,      
        AuthFailure,      
        AuthContinue,     
        ParseError, 
        ParseUserError, 
        Deprecated,     
        InProgress,
        ServerTemporaryDisabled,
        ServerMemoryAllocationFailure,
        MaximumReturn,
        PluginNotRegisterd 
    };
    Q_ENUM(MemcachedReturnType)

    
    void setDefaultConfig(const QVariantMap &defaultConfig);

    static bool set(const QString &key,
                    const QByteArray &value,
                    time_t expiration,
                    MemcachedReturnType *returnType = nullptr);

    template <typename T>
    static bool set(const QString &key,
                    const T &value,
                    time_t expiration,
                    MemcachedReturnType *returnType = nullptr);

    static bool setByKey(const QString &groupKey,
                         const QString &key,
                         const QByteArray &value,
                         time_t expiration,
                         MemcachedReturnType *returnType = nullptr);

    template <typename T>
    static bool setByKey(const QString &groupKey,
                         const QString &key,
                         const T &value,
                         time_t expiration,
                         MemcachedReturnType *returnType = nullptr);

    static bool add(const QString &key,
                    const QByteArray &value,
                    time_t expiration,
                    MemcachedReturnType *returnType = nullptr);

    template <typename T>
    static bool add(const QString &key,
                    const T &value,
                    time_t expiration,
                    MemcachedReturnType *returnType = nullptr);

    static bool addByKey(const QString &groupKey,
                         const QString &key,
                         const QByteArray &value,
                         time_t expiration,
                         MemcachedReturnType *returnType = nullptr);

    template <typename T>
    static bool addByKey(const QString &groupKey,
                         const QString &key,
                         const T &value,
                         time_t expiration,
                         MemcachedReturnType *returnType = nullptr);

    static bool replace(const QString &key,
                        const QByteArray &value,
                        time_t expiration,
                        MemcachedReturnType *returnType = nullptr);

    template <typename T>
    static bool replace(const QString &key,
                        const T &value,
                        time_t expiration,
                        MemcachedReturnType *returnType = nullptr);

    static bool replaceByKey(const QString &groupKey,
                             const QString &key,
                             const QByteArray &value,
                             time_t expiration,
                             MemcachedReturnType *returnType = nullptr);

    template <typename T>
    static bool replaceByKey(const QString &groupKey,
                             const QString &key,
                             const T &value,
                             time_t expiration,
                             MemcachedReturnType *returnType = nullptr);

    static QByteArray
        get(const QString &key, uint64_t *cas = nullptr, MemcachedReturnType *returnType = nullptr);

    template <typename T>
    static T
        get(const QString &key, uint64_t *cas = nullptr, MemcachedReturnType *returnType = nullptr);

    static QByteArray getByKey(const QString &groupKey,
                               const QString &key,
                               uint64_t *cas                   = nullptr,
                               MemcachedReturnType *returnType = nullptr);

    template <typename T>
    static T getByKey(const QString &groupKey,
                      const QString &key,
                      uint64_t *cas                   = nullptr,
                      MemcachedReturnType *returnType = nullptr);

    static bool remove(const QString &key, MemcachedReturnType *returnType = nullptr);

    static bool removeByKey(const QString &groupKey,
                            const QString &key,
                            MemcachedReturnType *returnType = nullptr);

    static bool exist(const QString &key, MemcachedReturnType *returnType = nullptr);

    static bool existByKey(const QString &groupKey,
                           const QString &key,
                           MemcachedReturnType *returnType = nullptr);

    static const time_t expirationNotAdd;

    static bool increment(const QString &key,
                          uint32_t offset,
                          uint64_t *value                 = nullptr,
                          MemcachedReturnType *returnType = nullptr);

    static bool incrementByKey(const QString &groupKey,
                               const QString &key,
                               uint64_t offset,
                               uint64_t *value                 = nullptr,
                               MemcachedReturnType *returnType = nullptr);

    static bool incrementWithInitial(const QString &key,
                                     uint64_t offset,
                                     uint64_t initial,
                                     time_t expiration,
                                     uint64_t *value                 = nullptr,
                                     MemcachedReturnType *returnType = nullptr);

    static bool incrementWithInitialByKey(const QString &groupKey,
                                          const QString &key,
                                          uint64_t offset,
                                          uint64_t initial,
                                          time_t expiration,
                                          uint64_t *value                 = nullptr,
                                          MemcachedReturnType *returnType = nullptr);

    static bool decrement(const QString &key,
                          uint32_t offset,
                          uint64_t *value                 = nullptr,
                          MemcachedReturnType *returnType = nullptr);

    static bool decrementByKey(const QString &groupKey,
                               const QString &key,
                               uint64_t offset,
                               uint64_t *value                 = nullptr,
                               MemcachedReturnType *returnType = nullptr);

    static bool decrementWithInitial(const QString &key,
                                     uint64_t offset,
                                     uint64_t initial,
                                     time_t expiration,
                                     uint64_t *value                 = nullptr,
                                     MemcachedReturnType *returnType = nullptr);

    static bool decrementWithInitialByKey(const QString &groupKey,
                                          const QString &key,
                                          uint64_t offset,
                                          uint64_t initial,
                                          time_t expiration,
                                          uint64_t *value                 = nullptr,
                                          MemcachedReturnType *returnType = nullptr);

    static bool cas(const QString &key,
                    const QByteArray &value,
                    time_t expiration,
                    uint64_t cas,
                    MemcachedReturnType *returnType = nullptr);

    template <typename T>
    static bool cas(const QString &key,
                    const T &value,
                    time_t expiration,
                    uint64_t cas,
                    MemcachedReturnType *returnType = nullptr);

    static bool casByKey(const QString &groupKey,
                         const QString &key,
                         const QByteArray &value,
                         time_t expiration,
                         uint64_t cas,
                         MemcachedReturnType *returnType = nullptr);

    template <typename T>
    static bool casByKey(const QString &groupKey,
                         const QString &key,
                         const T &value,
                         time_t expiration,
                         uint64_t cas,
                         MemcachedReturnType *returnType = nullptr);

    static bool flushBuffers(MemcachedReturnType *returnType = nullptr);

    static bool flush(time_t expiration, MemcachedReturnType *returnType = nullptr);

    static QHash<QString, QByteArray> mget(const QStringList &keys,
                                           QHash<QString, uint64_t> *casValues = nullptr,
                                           MemcachedReturnType *returnType     = nullptr);

    template <typename T>
    static QHash<QString, T> mget(const QStringList &keys,
                                  QHash<QString, uint64_t> *casValues = nullptr,
                                  MemcachedReturnType *returnType     = nullptr);

    static QHash<QString, QByteArray> mgetByKey(const QString &groupKey,
                                                const QStringList &keys,
                                                QHash<QString, uint64_t> *casValues = nullptr,
                                                MemcachedReturnType *returnType     = nullptr);

    template <typename T>
    static QHash<QString, T> mgetByKey(const QString &groupKey,
                                       const QStringList &keys,
                                       QHash<QString, uint64_t> *casValues = nullptr,
                                       MemcachedReturnType *returnType     = nullptr);

    static bool
        touch(const QString &key, time_t expiration, MemcachedReturnType *returnType = nullptr);

    static bool touchByKey(const QString &groupKey,
                           const QString &key,
                           time_t expiration,
                           MemcachedReturnType *returnType = nullptr);

    static QString errorString(Context *c, MemcachedReturnType rt);

    static QVersionNumber libMemcachedVersion();

protected:
    const QScopedPointer<MemcachedPrivate> d_ptr;

    virtual bool setup(Application *app) override;
};

template <typename T>
bool Memcached::set(const QString &key,
                    const T &value,
                    time_t expiration,
                    MemcachedReturnType *returnType)
{
    QByteArray data;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QDataStream out(&data, QIODevice::WriteOnly);
#else
    QDataStream out(&data, QIODeviceBase::WriteOnly);
#endif
    out << value;
    return Memcached::set(key, data, expiration, returnType);
}

template <typename T>
bool Memcached::setByKey(const QString &groupKey,
                         const QString &key,
                         const T &value,
                         time_t expiration,
                         MemcachedReturnType *returnType)
{
    QByteArray data;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QDataStream out(&data, QIODevice::WriteOnly);
#else
    QDataStream out(&data, QIODeviceBase::WriteOnly);
#endif
    out << value;
    return Memcached::setByKey(groupKey, key, data, expiration, returnType);
}

template <typename T>
bool Memcached::add(const QString &key,
                    const T &value,
                    time_t expiration,
                    MemcachedReturnType *returnType)
{
    QByteArray data;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QDataStream out(&data, QIODevice::WriteOnly);
#else
    QDataStream out(&data, QIODeviceBase::WriteOnly);
#endif
    out << value;
    return Memcached::add(key, data, expiration, returnType);
}

template <typename T>
bool Memcached::addByKey(const QString &groupKey,
                         const QString &key,
                         const T &value,
                         time_t expiration,
                         MemcachedReturnType *returnType)
{
    QByteArray data;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QDataStream out(&data, QIODevice::WriteOnly);
#else
    QDataStream out(&data, QIODeviceBase::WriteOnly);
#endif
    out << value;
    return Memcached::addByKey(groupKey, key, data, expiration, returnType);
}

template <typename T>
bool Memcached::replace(const QString &key,
                        const T &value,
                        time_t expiration,
                        MemcachedReturnType *returnType)
{
    QByteArray data;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QDataStream out(&data, QIODevice::WriteOnly);
#else
    QDataStream out(&data, QIODeviceBase::WriteOnly);
#endif
    out << value;
    return Memcached::replace(key, data, expiration, returnType);
}

template <typename T>
bool Memcached::replaceByKey(const QString &groupKey,
                             const QString &key,
                             const T &value,
                             time_t expiration,
                             MemcachedReturnType *returnType)
{
    QByteArray data;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QDataStream out(&data, QIODevice::WriteOnly);
#else
    QDataStream out(&data, QIODeviceBase::WriteOnly);
#endif
    out << value;
    return Memcached::replaceByKey(groupKey, key, data, expiration, returnType);
}

template <typename T>
T Memcached::get(const QString &key, uint64_t *cas, MemcachedReturnType *returnType)
{
    T retVal;
    QByteArray ba = Memcached::get(key, cas, returnType);
    if (!ba.isEmpty()) {
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
        QDataStream in(&ba, QIODevice::ReadOnly);
#else
        QDataStream in(&ba, QIODeviceBase::ReadOnly);
#endif
        in >> retVal;
    }
    return retVal;
}

template <typename T>
T Memcached::getByKey(const QString &groupKey,
                      const QString &key,
                      uint64_t *cas,
                      MemcachedReturnType *returnType)
{
    T retVal;
    QByteArray ba = Memcached::getByKey(groupKey, key, cas, returnType);
    if (!ba.isEmpty()) {
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
        QDataStream in(&ba, QIODevice::ReadOnly);
#else
        QDataStream in(&ba, QIODeviceBase::ReadOnly);
#endif
        in >> retVal;
    }
    return retVal;
}

template <typename T>
bool Memcached::cas(const QString &key,
                    const T &value,
                    time_t expiration,
                    uint64_t cas,
                    MemcachedReturnType *returnType)
{
    QByteArray data;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QDataStream out(&data, QIODevice::WriteOnly);
#else
    QDataStream out(&data, QIODeviceBase::WriteOnly);
#endif
    out << value;
    return Memcached::cas(key, data, expiration, cas, returnType);
}

template <typename T>
bool Memcached::casByKey(const QString &groupKey,
                         const QString &key,
                         const T &value,
                         time_t expiration,
                         uint64_t cas,
                         MemcachedReturnType *returnType)
{
    QByteArray data;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QDataStream out(&data, QIODevice::WriteOnly);
#else
    QDataStream out(&data, QIODeviceBase::WriteOnly);
#endif
    out << value;
    return Memcached::casByKey(groupKey, key, data, expiration, cas, returnType);
}

template <typename T>
QHash<QString, T> Memcached::mget(const QStringList &keys,
                                  QHash<QString, uint64_t> *casValues,
                                  MemcachedReturnType *returnType)
{
    QHash<QString, T> hash;
    QHash<QString, QByteArray> _data = Memcached::mget(keys, casValues, returnType);
    if (!_data.empty()) {
        auto i = _data.constBegin();
        while (i != _data.constEnd()) {
            T retVal;
            QDataStream in(i.value());
            in >> retVal;
            hash.insert(i.key(), retVal);
            ++i;
        }
    }
    return hash;
}

template <typename T>
QHash<QString, T> Memcached::mgetByKey(const QString &groupKey,
                                       const QStringList &keys,
                                       QHash<QString, uint64_t> *casValues,
                                       MemcachedReturnType *returnType)
{
    QHash<QString, T> hash;
    QHash<QString, QByteArray> _data = Memcached::mgetByKey(groupKey, keys, casValues, returnType);
    if (!_data.empty()) {
        auto i = _data.constBegin();
        while (i != _data.constEnd()) {
            T retVal;
            QDataStream in(i.value());
            in >> retVal;
            hash.insert(i.key(), retVal);
            ++i;
        }
    }
    return hash;
}

} // namespace Cutelyst

#endif // CUTELYSTMEMCACHED_H