memcached.h

/*
 * SPDX-FileCopyrightText: (C) 2017-2022 Matthias Fehring <mf@huessenbergnetz.de>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#pragma once
 
#include <Cutelyst/Plugins/memcached_export.h>
#include <Cutelyst/plugin.h>
#include <chrono>
 
#include <QDataStream>
#include <QVersionNumber>
 
namespace Cutelyst {
 
class Context;
class MemcachedPrivate;

class CUTELYST_PLUGIN_MEMCACHED_EXPORT Memcached // clazy:exclude=ctor-missing-parent-argument
    : public Plugin
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(Memcached) // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
    Q_DISABLE_COPY(Memcached)
public:
    explicit Memcached(Application *parent);

    Memcached(Application *parent, const QVariantMap &defaultConfig);

    ~Memcached() override;

    enum class ReturnType {
        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(Memcached::ReturnType)
 
    
    void setDefaultConfig(const QVariantMap &defaultConfig);

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

    inline static bool set(QByteArrayView key,
                           const QByteArray &value,
                           std::chrono::seconds expiration,
                           ReturnType *returnType = nullptr);

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

    template <typename T>
    static bool set(QByteArrayView key,
                    const T &value,
                    std::chrono::seconds expiration,
                    ReturnType *returnType = nullptr);

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

    inline static bool setByKey(QByteArrayView groupKey,
                                QByteArrayView key,
                                const QByteArray &value,
                                std::chrono::seconds expiration,
                                ReturnType *returnType = nullptr);

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

    template <typename T>
    static bool setByKey(QByteArrayView groupKey,
                         QByteArrayView key,
                         const T &value,
                         std::chrono::seconds expiration,
                         ReturnType *returnType = nullptr);

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

    inline static bool add(QByteArrayView key,
                           const QByteArray &value,
                           std::chrono::seconds expiration,
                           ReturnType *returnType = nullptr);

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

    template <typename T>
    static bool add(QByteArrayView key,
                    const T &value,
                    std::chrono::seconds expiration,
                    ReturnType *returnType = nullptr);

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

    inline static bool addByKey(QByteArrayView groupKey,
                                QByteArrayView key,
                                const QByteArray &value,
                                std::chrono::seconds expiration,
                                ReturnType *returnType = nullptr);

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

    template <typename T>
    static bool addByKey(QByteArrayView groupKey,
                         QByteArrayView key,
                         const T &value,
                         std::chrono::seconds expiration,
                         ReturnType *returnType = nullptr);

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

    inline static bool replace(QByteArrayView key,
                               const QByteArray &value,
                               std::chrono::seconds expiration,
                               ReturnType *returnType = nullptr);

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

    template <typename T>
    static bool replace(QByteArrayView key,
                        const T &value,
                        std::chrono::seconds expiration,
                        ReturnType *returnType = nullptr);

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

    inline static bool replaceByKey(QByteArrayView groupKey,
                                    QByteArrayView key,
                                    const QByteArray &value,
                                    std::chrono::seconds expiration,
                                    ReturnType *returnType = nullptr);

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

    template <typename T>
    static bool replaceByKey(QByteArrayView groupKey,
                             QByteArrayView key,
                             const T &value,
                             std::chrono::seconds expiration,
                             ReturnType *returnType = nullptr);

    static QByteArray
        get(QByteArrayView key, uint64_t *cas = nullptr, ReturnType *returnType = nullptr);

    template <typename T>
    static T get(QByteArrayView key, uint64_t *cas = nullptr, ReturnType *returnType = nullptr);

    static QByteArray getByKey(QByteArrayView groupKey,
                               QByteArrayView key,
                               uint64_t *cas          = nullptr,
                               ReturnType *returnType = nullptr);

    template <typename T>
    static T getByKey(QByteArrayView groupKey,
                      QByteArrayView key,
                      uint64_t *cas          = nullptr,
                      ReturnType *returnType = nullptr);

    static bool remove(QByteArrayView key, ReturnType *returnType = nullptr);

    static bool
        removeByKey(QByteArrayView groupKey, QByteArrayView key, ReturnType *returnType = nullptr);

    static bool exist(QByteArrayView key, ReturnType *returnType = nullptr);

    static bool
        existByKey(QByteArrayView groupKey, QByteArrayView key, ReturnType *returnType = nullptr);

    static const time_t expirationNotAdd;

    static const std::chrono::seconds expirationNotAddDuration;

    static bool increment(QByteArrayView key,
                          uint32_t offset,
                          uint64_t *value        = nullptr,
                          ReturnType *returnType = nullptr);

    static bool incrementByKey(QByteArrayView groupKey,
                               QByteArrayView key,
                               uint64_t offset,
                               uint64_t *value        = nullptr,
                               ReturnType *returnType = nullptr);

    static bool incrementWithInitial(QByteArrayView key,
                                     uint64_t offset,
                                     uint64_t initial,
                                     time_t expiration,
                                     uint64_t *value        = nullptr,
                                     ReturnType *returnType = nullptr);

    inline static bool incrementWithInitial(QByteArrayView key,
                                            uint64_t offset,
                                            uint64_t initial,
                                            std::chrono::seconds expiration,
                                            uint64_t *value        = nullptr,
                                            ReturnType *returnType = nullptr);

    static bool incrementWithInitialByKey(QByteArrayView groupKey,
                                          QByteArrayView key,
                                          uint64_t offset,
                                          uint64_t initial,
                                          time_t expiration,
                                          uint64_t *value        = nullptr,
                                          ReturnType *returnType = nullptr);

    inline static bool incrementWithInitialByKey(QByteArrayView groupKey,
                                                 QByteArrayView key,
                                                 uint64_t offset,
                                                 uint64_t initial,
                                                 std::chrono::seconds expiration,
                                                 uint64_t *value        = nullptr,
                                                 ReturnType *returnType = nullptr);

    static bool decrement(QByteArrayView key,
                          uint32_t offset,
                          uint64_t *value        = nullptr,
                          ReturnType *returnType = nullptr);

    static bool decrementByKey(QByteArrayView groupKey,
                               QByteArrayView key,
                               uint64_t offset,
                               uint64_t *value        = nullptr,
                               ReturnType *returnType = nullptr);

    static bool decrementWithInitial(QByteArrayView key,
                                     uint64_t offset,
                                     uint64_t initial,
                                     time_t expiration,
                                     uint64_t *value        = nullptr,
                                     ReturnType *returnType = nullptr);

    inline static bool decrementWithInitial(QByteArrayView key,
                                            uint64_t offset,
                                            uint64_t initial,
                                            std::chrono::seconds expiration,
                                            uint64_t *value        = nullptr,
                                            ReturnType *returnType = nullptr);

    static bool decrementWithInitialByKey(QByteArrayView groupKey,
                                          QByteArrayView key,
                                          uint64_t offset,
                                          uint64_t initial,
                                          time_t expiration,
                                          uint64_t *value        = nullptr,
                                          ReturnType *returnType = nullptr);

    inline static bool decrementWithInitialByKey(QByteArrayView groupKey,
                                                 QByteArrayView key,
                                                 uint64_t offset,
                                                 uint64_t initial,
                                                 std::chrono::seconds expiration,
                                                 uint64_t *value        = nullptr,
                                                 ReturnType *returnType = nullptr);

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

    inline static bool cas(QByteArrayView key,
                           const QByteArray &value,
                           std::chrono::seconds expiration,
                           uint64_t cas,
                           ReturnType *returnType = nullptr);

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

    template <typename T>
    static bool cas(QByteArrayView key,
                    const T &value,
                    std::chrono::seconds expiration,
                    uint64_t cas,
                    ReturnType *returnType = nullptr);

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

    inline static bool casByKey(QByteArrayView groupKey,
                                QByteArrayView key,
                                const QByteArray &value,
                                std::chrono::seconds expiration,
                                uint64_t cas,
                                ReturnType *returnType = nullptr);

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

    template <typename T>
    static bool casByKey(QByteArrayView groupKey,
                         QByteArrayView key,
                         const T &value,
                         std::chrono::seconds expiration,
                         uint64_t cas,
                         ReturnType *returnType = nullptr);

    static bool flushBuffers(ReturnType *returnType = nullptr);

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

    inline static bool flush(std::chrono::seconds expiration, ReturnType *returnType = nullptr);

    static QHash<QByteArray, QByteArray> mget(const QByteArrayList &keys,
                                              QHash<QByteArray, uint64_t> *casValues = nullptr,
                                              ReturnType *returnType                 = nullptr);

    template <typename T>
    static QHash<QByteArray, T> mget(const QByteArrayList &keys,
                                     QHash<QByteArray, uint64_t> *casValues = nullptr,
                                     ReturnType *returnType                 = nullptr);

    static QHash<QByteArray, QByteArray> mgetByKey(QByteArrayView groupKey,
                                                   const QByteArrayList &keys,
                                                   QHash<QByteArray, uint64_t> *casValues = nullptr,
                                                   ReturnType *returnType = nullptr);

    template <typename T>
    static QHash<QByteArray, T> mgetByKey(QByteArrayView groupKey,
                                          const QByteArrayList &keys,
                                          QHash<QByteArray, uint64_t> *casValues = nullptr,
                                          ReturnType *returnType                 = nullptr);

    static bool touch(QByteArrayView key, time_t expiration, ReturnType *returnType = nullptr);

    inline static bool touch(QByteArrayView key,
                             std::chrono::seconds expiration,
                             ReturnType *returnType = nullptr);

    static bool touchByKey(QByteArrayView groupKey,
                           QByteArrayView key,
                           time_t expiration,
                           ReturnType *returnType = nullptr);

    inline static bool touchByKey(QByteArrayView groupKey,
                                  QByteArrayView key,
                                  std::chrono::seconds expiration,
                                  ReturnType *returnType = nullptr);

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

    static QVersionNumber libMemcachedVersion();
 
protected:
    bool setup(Application *app) override;
 
private:
    const std::unique_ptr<MemcachedPrivate> d_ptr;
};
 
inline bool Memcached::set(QByteArrayView key,
                           const QByteArray &value,
                           std::chrono::seconds expiration,
                           ReturnType *returnType)
{
    return Memcached::set(key, value, expiration.count(), returnType);
}
 
template <typename T>
bool Memcached::set(QByteArrayView key, const T &value, time_t expiration, ReturnType *returnType)
{
    QByteArray data;
    QDataStream out(&data, QIODeviceBase::WriteOnly);
    out << value;
    return Memcached::set(key, data, expiration, returnType);
}
 
template <typename T>
bool Memcached::set(QByteArrayView key,
                    const T &value,
                    std::chrono::seconds expiration,
                    ReturnType *returnType)
{
    return Memcached::set<T>(key, value, expiration.count(), returnType);
}
 
inline bool Memcached::setByKey(QByteArrayView groupKey,
                                QByteArrayView key,
                                const QByteArray &value,
                                std::chrono::seconds expiration,
                                ReturnType *returnType)
{
    return Memcached::setByKey(groupKey, key, value, expiration.count(), returnType);
}
 
template <typename T>
bool Memcached::setByKey(QByteArrayView groupKey,
                         QByteArrayView key,
                         const T &value,
                         time_t expiration,
                         ReturnType *returnType)
{
    QByteArray data;
    QDataStream out(&data, QIODeviceBase::WriteOnly);
    out << value;
    return Memcached::setByKey(groupKey, key, data, expiration, returnType);
}
 
template <typename T>
bool Memcached::setByKey(QByteArrayView groupKey,
                         QByteArrayView key,
                         const T &value,
                         std::chrono::seconds expiration,
                         ReturnType *returnType)
{
    return Memcached::setByKey<T>(groupKey, key, value, expiration.count(), returnType);
}
 
inline bool Memcached::add(QByteArrayView key,
                           const QByteArray &value,
                           std::chrono::seconds expiration,
                           ReturnType *returnType)
{
    return Memcached::add(key, value, expiration.count(), returnType);
}
 
template <typename T>
bool Memcached::add(QByteArrayView key, const T &value, time_t expiration, ReturnType *returnType)
{
    QByteArray data;
    QDataStream out(&data, QIODeviceBase::WriteOnly);
    out << value;
    return Memcached::add(key, data, expiration, returnType);
}
 
template <typename T>
bool Memcached::add(QByteArrayView key,
                    const T &value,
                    std::chrono::seconds expiration,
                    ReturnType *returnType)
{
    return Memcached::add<T>(key, value, expiration.count(), returnType);
}
 
inline bool Memcached::addByKey(QByteArrayView groupKey,
                                QByteArrayView key,
                                const QByteArray &value,
                                std::chrono::seconds expiration,
                                ReturnType *returnType)
{
    return Memcached::addByKey(groupKey, key, value, expiration.count(), returnType);
}
 
template <typename T>
bool Memcached::addByKey(QByteArrayView groupKey,
                         QByteArrayView key,
                         const T &value,
                         time_t expiration,
                         ReturnType *returnType)
{
    QByteArray data;
    QDataStream out(&data, QIODeviceBase::WriteOnly);
    out << value;
    return Memcached::addByKey(groupKey, key, data, expiration, returnType);
}
 
template <typename T>
bool Memcached::addByKey(QByteArrayView groupKey,
                         QByteArrayView key,
                         const T &value,
                         std::chrono::seconds expiration,
                         ReturnType *returnType)
{
    return Memcached::addByKey<T>(groupKey, key, value, expiration.count(), returnType);
}
 
inline bool Memcached::replace(QByteArrayView key,
                               const QByteArray &value,
                               std::chrono::seconds expiration,
                               ReturnType *returnType)
{
    return Memcached::replace(key, value, expiration.count(), returnType);
}
 
template <typename T>
bool Memcached::replace(QByteArrayView key,
                        const T &value,
                        time_t expiration,
                        ReturnType *returnType)
{
    QByteArray data;
    QDataStream out(&data, QIODeviceBase::WriteOnly);
    out << value;
    return Memcached::replace(key, data, expiration, returnType);
}
 
template <typename T>
bool Memcached::replace(QByteArrayView key,
                        const T &value,
                        std::chrono::seconds expiration,
                        ReturnType *returnType)
{
    return Memcached::replace<T>(key, value, expiration.count(), returnType);
}
 
inline bool Memcached::replaceByKey(QByteArrayView groupKey,
                                    QByteArrayView key,
                                    const QByteArray &value,
                                    std::chrono::seconds expiration,
                                    ReturnType *returnType)
{
    return Memcached::replaceByKey(groupKey, key, value, expiration.count(), returnType);
}
 
template <typename T>
bool Memcached::replaceByKey(QByteArrayView groupKey,
                             QByteArrayView key,
                             const T &value,
                             time_t expiration,
                             ReturnType *returnType)
{
    QByteArray data;
    QDataStream out(&data, QIODeviceBase::WriteOnly);
    out << value;
    return Memcached::replaceByKey(groupKey, key, data, expiration, returnType);
}
 
template <typename T>
bool Memcached::replaceByKey(QByteArrayView groupKey,
                             QByteArrayView key,
                             const T &value,
                             std::chrono::seconds expiration,
                             ReturnType *returnType)
{
    return Memcached::replaceByKey<T>(groupKey, key, value, expiration.count(), returnType);
}
 
inline bool Memcached::incrementWithInitial(QByteArrayView key,
                                            uint64_t offset,
                                            uint64_t initial,
                                            std::chrono::seconds expiration,
                                            uint64_t *value,
                                            ReturnType *returnType)
{
    return Memcached::incrementWithInitial(
        key, offset, initial, expiration.count(), value, returnType);
}
 
inline bool Memcached::incrementWithInitialByKey(QByteArrayView groupKey,
                                                 QByteArrayView key,
                                                 uint64_t offset,
                                                 uint64_t initial,
                                                 std::chrono::seconds expiration,
                                                 uint64_t *value,
                                                 ReturnType *returnType)
{
    return Memcached::incrementWithInitialByKey(
        groupKey, key, offset, initial, expiration.count(), value, returnType);
}
 
inline bool Memcached::decrementWithInitial(QByteArrayView key,
                                            uint64_t offset,
                                            uint64_t initial,
                                            std::chrono::seconds expiration,
                                            uint64_t *value,
                                            ReturnType *returnType)
{
    return Memcached::decrementWithInitial(
        key, offset, initial, expiration.count(), value, returnType);
}
 
inline bool Memcached::decrementWithInitialByKey(QByteArrayView groupKey,
                                                 QByteArrayView key,
                                                 uint64_t offset,
                                                 uint64_t initial,
                                                 std::chrono::seconds expiration,
                                                 uint64_t *value,
                                                 ReturnType *returnType)
{
    return Memcached::decrementWithInitialByKey(
        groupKey, key, offset, initial, expiration.count(), value, returnType);
}
 
template <typename T>
T Memcached::get(QByteArrayView key, uint64_t *cas, ReturnType *returnType)
{
    T retVal;
    QByteArray ba = Memcached::get(key, cas, returnType);
    if (!ba.isEmpty()) {
        QDataStream in(&ba, QIODeviceBase::ReadOnly);
        in >> retVal;
    }
    return retVal;
}
 
template <typename T>
T Memcached::getByKey(QByteArrayView groupKey,
                      QByteArrayView key,
                      uint64_t *cas,
                      ReturnType *returnType)
{
    T retVal;
    QByteArray ba = Memcached::getByKey(groupKey, key, cas, returnType);
    if (!ba.isEmpty()) {
        QDataStream in(&ba, QIODeviceBase::ReadOnly);
        in >> retVal;
    }
    return retVal;
}
 
inline bool Memcached::cas(QByteArrayView key,
                           const QByteArray &value,
                           std::chrono::seconds expiration,
                           uint64_t cas,
                           ReturnType *returnType)
{
    return Memcached::cas(key, value, expiration.count(), cas, returnType);
}
 
template <typename T>
bool Memcached::cas(QByteArrayView key,
                    const T &value,
                    time_t expiration,
                    uint64_t cas,
                    ReturnType *returnType)
{
    QByteArray data;
    QDataStream out(&data, QIODeviceBase::WriteOnly);
    out << value;
    return Memcached::cas(key, data, expiration, cas, returnType);
}
 
template <typename T>
bool Memcached::cas(QByteArrayView key,
                    const T &value,
                    std::chrono::seconds expiration,
                    uint64_t cas,
                    ReturnType *returnType)
{
    return Memcached::cas<T>(key, value, expiration.count(), cas, returnType);
}
 
inline bool Memcached::casByKey(QByteArrayView groupKey,
                                QByteArrayView key,
                                const QByteArray &value,
                                std::chrono::seconds expiration,
                                uint64_t cas,
                                ReturnType *returnType)
{
    return Memcached::casByKey(groupKey, key, value, expiration.count(), cas, returnType);
}
 
template <typename T>
bool Memcached::casByKey(QByteArrayView groupKey,
                         QByteArrayView key,
                         const T &value,
                         time_t expiration,
                         uint64_t cas,
                         ReturnType *returnType)
{
    QByteArray data;
    QDataStream out(&data, QIODeviceBase::WriteOnly);
    out << value;
    return Memcached::casByKey(groupKey, key, data, expiration, cas, returnType);
}
 
template <typename T>
bool Memcached::casByKey(QByteArrayView groupKey,
                         QByteArrayView key,
                         const T &value,
                         std::chrono::seconds expiration,
                         uint64_t cas,
                         ReturnType *returnType)
{
    return Memcached::casByKey<T>(groupKey, key, value, expiration.count(), cas, returnType);
}
 
inline bool Memcached::flush(std::chrono::seconds expiration, ReturnType *returnType)
{
    return Memcached::flush(expiration.count(), returnType);
}
 
template <typename T>
QHash<QByteArray, T> Memcached::mget(const QByteArrayList &keys,
                                     QHash<QByteArray, uint64_t> *casValues,
                                     ReturnType *returnType)
{
    QHash<QByteArray, T> hash;
    const QHash<QByteArray, QByteArray> _data = Memcached::mget(keys, casValues, returnType);
    if (!_data.empty()) {
        for (const auto &[key, value] : _data.asKeyValueRange()) {
            T retVal;
            QDataStream in(value);
            in >> retVal;
            hash.insert(key, retVal);
        }
    }
    return hash;
}
 
template <typename T>
QHash<QByteArray, T> Memcached::mgetByKey(QByteArrayView groupKey,
                                          const QByteArrayList &keys,
                                          QHash<QByteArray, uint64_t> *casValues,
                                          ReturnType *returnType)
{
    QHash<QByteArray, T> hash;
    const QHash<QByteArray, QByteArray> _data =
        Memcached::mgetByKey(groupKey, keys, casValues, returnType);
    if (!_data.empty()) {
        for (const auto &[key, value] : _data.asKeyValueRange()) {
            T retVal;
            QDataStream in(value);
            in >> retVal;
            hash.insert(key, retVal);
        }
    }
    return hash;
}
 
inline bool
    Memcached::touch(QByteArrayView key, std::chrono::seconds expiration, ReturnType *returnType)
{
    return Memcached::touch(key, expiration.count(), returnType);
}
 
inline bool Memcached::touchByKey(QByteArrayView groupKey,
                                  QByteArrayView key,
                                  std::chrono::seconds expiration,
                                  ReturnType *returnType)
{
    return Memcached::touchByKey(groupKey, key, expiration.count(), returnType);
}
 
} // namespace Cutelyst