Redis.h

Go to the documentation of this file.

 
#ifndef REDIS_H
#define REDIS_H
 
#include "Arduino.h"
#include "Client.h"
 
#include <vector>
 
typedef enum
{
  RedisSuccess = 0,
  RedisNotConnectedFailure = 1,
  RedisAuthFailure = 2,
} RedisReturnValue;
 
typedef enum
{
  RedisSubscribeBadCallback = -255,
  RedisSubscribeSetupFailure,
  RedisSubscribeServerDisconnected,
  RedisSubscribeOtherError,
  RedisSubscribeSuccess = 0
} RedisSubscribeResult;
 
typedef enum
{
  RedisMessageBadResponseType = -255,
  RedisMessageTruncatedResponse,
  RedisMessageUnknownType,
} RedisMessageError;
 
typedef enum
{
  XtrimCompareExact = '=',
  XtrimCompareAtLeast = '~'
} XtrimCompareType;
 
class Redis
{
public:
  typedef void (*RedisMsgCallback)(Redis *, String channel, String message);
  typedef void (*LoopCallback)();
  typedef void (*RedisMsgErrorCallback)(Redis *, RedisMessageError);
 
  Redis(Client &client) : conn(client) {}
 
  ~Redis() {}
  Redis(const Redis &) = delete;
  Redis &operator=(const Redis &) = delete;
  Redis(const Redis &&) = delete;
  Redis &operator=(const Redis &&) = delete;
 
  RedisReturnValue authenticate(const char *password);
 
  bool set(const char *key, const char *value);
 
  String get(const char *key);
 
  bool del(const char *key);
 
  bool exists(const char *key);
 
  int append(const char *key, const char *value);
 
  int publish(const char *channel, const char *message);
 
  bool expire(const char *key, int seconds) { return _expire_(key, seconds, "EXPIRE"); }
 
  bool expire_at(const char *key, int timestamp) { return _expire_(key, timestamp, "EXPIREAT"); }
 
  bool pexpire(const char *key, int ms) { return _expire_(key, ms, "PEXPIRE"); }
 
  bool pexpire_at(const char *key, int timestamp) { return _expire_(key, timestamp, "PEXPIREAT"); }
 
  bool persist(const char *key);
 
  int pttl(const char *key) { return _ttl_(key, "PTTL"); }
 
  int ttl(const char *key) { return _ttl_(key, "TTL"); }
 
  bool hset(const char *key, const char *field, const char *value) { return _hset_(key, field, value, "HSET"); }
 
  bool hsetnx(const char *key, const char *field, const char *value) { return _hset_(key, field, value, "HSETNX"); }
 
  String hget(const char *key, const char *field);
 
  bool hdel(const char *key, const char *field);
 
  int hlen(const char *key);
 
  int hstrlen(const char *key, const char *field);
 
  bool hexists(const char *key, const char *field);
 
  String lindex(const char *key, int index);
 
  int llen(const char *key);
 
  String lpop(const char *key);
 
  int lpos(const char *key, const char *element);
 
  int lpush(const char *key, const char *value, bool exclusive = false);
 
  std::vector<String> lrange(const char *key, int start, int stop);
 
  int lrem(const char *key, int count, const char *element);
 
  bool lset(const char *key, int index, const char *element);
 
  bool ltrim(const char *key, int start, int stop);
 
  String rpop(const char *key);
 
  int rpush(const char *key, const char *value, bool exclusive = false);
 
  bool subscribe(const char *channel) { return _subscribe(SubscribeSpec{false, String(channel)}); }
 
  bool psubscribe(const char *pattern) { return _subscribe(SubscribeSpec{true, String(pattern)}); }
 
  bool unsubscribe(const char *channelOrPattern);
 
  bool tsadd(const char *key, long timestamp, const int value);
 
  int xack(const char *key, const char *group, const char *id);
 
  String xadd(const char *key, const char *id, const char *field,
              const char *value);
 
  std::vector<String> xautoclaim(const char *key, const char *group,
    const char* consumer, unsigned int min_idle_time, const char *start,
    unsigned int count, bool justid);
 
  std::vector<String> xclaim(const char *key, const char* group,
    const char *consumer,
    unsigned int min_idle_time, const char *id, unsigned int idle_ms,
    unsigned int time_ms, unsigned int retrycount, bool force, bool justid,
    const char *lastid);
 
  int xdel(const char *key, const char *id);
 
  bool xgroup_create(const char *key, const char *group, const char *id,
                     bool mkstream);
 
  int xgroup_createconsumer(const char *key, const char *group,
                            const char *consumer);
 
  int xgroup_delconsumer(const char *key, const char *group,
                          const char *consumer);
 
  int xgroup_destroy(const char *key, const char *group);
 
  bool xgroup_setid(const char* key, const char *group, const char *id);
 
  std::vector<String> xinfo_consumers(const char *key, const char* group);
 
  std::vector<String> xinfo_groups(const char *key);
 
  std::vector<String> xinfo_stream(const char *key, bool full,
                                    unsigned int count);
 
  int xlen(const char *key);
 
  std::vector<String> xpending(const char *key, const char* group,
    unsigned int min_idle_time, const char *start, const char *end,
    unsigned int count, const char *consumer);
 
  std::vector<String> xrange(const char *key, const char *start,
    const char *end, unsigned int count);
 
  std::vector<String> xread(unsigned int count, unsigned int block,
    const char *key, const char *id);
 
  std::vector<String> xreadgroup(const char *group, const char *consumer,
    unsigned int count, unsigned int block_ms, bool noack, const char *key,
    const char *id);
 
  std::vector<String> xrevrange(const char *key, const char *end,
    const char* start, unsigned int count);
 
  int xtrim(const char *key, const char *strategy, XtrimCompareType compare,
                 int threshold, int count);
 
  // auxiliary functions
 
  bool isErrorReturn(std::vector<String>& returnVec);
 
  bool isNilReturn(String returnString) { return returnString == "(nil)"; }
 
  RedisSubscribeResult startSubscribing(RedisMsgCallback messageCallback, RedisMsgErrorCallback errorCallback = nullptr);
  RedisSubscribeResult startSubscribingNonBlocking(RedisMsgCallback messageCallback, LoopCallback loopCallback, RedisMsgErrorCallback errorCallback = nullptr);
 
  void stopSubscribing() { subLoopRun = false; }
 
  String info(const char *section);
 
  // The following are (obstensibly) for library testing purposes only
  void setTestContext(const void *context) { _test_context = context; }
  const void *getTestContext() { return _test_context; }
 
private:
  typedef struct
  {
    bool pattern;
    String spec;
  } SubscribeSpec;
 
  bool _subscribe(SubscribeSpec spec);
 
  Client &conn;
  std::vector<SubscribeSpec> subSpec;
  bool subscriberMode = false;
  bool subLoopRun = false;
 
  bool _expire_(const char *, int, const char *);
  int _ttl_(const char *, const char *);
  bool _hset_(const char *, const char *, const char *, const char *);
 
  const void *_test_context;
};
 
#endif