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;
}

}

#endif // CUTELYSTMEMCACHED_H