memcached.h

/*
 * Copyright (C) 2017-2018 Matthias Fehring <kontakt@buschmann23.de>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#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