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;
 
class Redis
{
public:
  typedef void (*RedisMsgCallback)(Redis *, String channel, String message);
  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);
 
  RedisSubscribeResult startSubscribing(RedisMsgCallback messageCallback, 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