Add bitfield api

src/sw/redis++/command.h

@@ -319,6 +319,19 @@ inline void bitpos(Connection &connection,
                     end);
 }
 
+template <typename Input>
+inline void bitfield(Connection &connection,
+                    const StringView &key,
+                    Input first,
+                    Input last) {
+    assert(first != last);
+
+    CmdArgs args;
+    args << "BITFIELD" << key << std::make_pair(first, last);
+
+    connection.send(args);
+}
+
 inline void decr(Connection &connection, const StringView &key) {
     connection.send("DECR %b", key.data(), key.size());
 }

src/sw/redis++/queued_redis.h

@@ -356,6 +356,18 @@ class QueuedRedis {
         return command(cmd::bitop_range<Input>, op, destination, first, last);
     }
 
+    template <typename Input>
+    QueuedRedis& bitfield(const StringView &key, Input first, Input last) {
+        range_check("BITFIELD", first, last);
+
+        return command(cmd::bitfield<Input>, key, first, last);
+    }
+
+    template <typename T>
+    QueuedRedis& bitfield(const StringView &key, std::initializer_list<T> il) {
+        return bitfield(key, il.begin(), il.end());
+    }
+
     template <typename T>
     QueuedRedis& bitop(BitOp op,
                         const StringView &destination,

src/sw/redis++/redis.h

@@ -721,6 +721,50 @@ class Redis {
     /// @see https://redis.io/commands/getbit
     long long getbit(const StringView &key, long long offset);
 
+    /// @brief Batch operations on multiple bits of a string.
+    ///
+    /// Example:
+    /// @code{.cpp}
+    /// std::vector<std::string> ops = {"SET", "u1", "1", "1","SET", "u1", "3", "0","SET", "u1", "6", "1"};
+    /// std::vector<long long> vals;
+    /// redis.bitfield("bitfieldkey", ops.begin(), ops.end(), std::back_inserter(vals));
+    /// for (int i = 0; i < vals.size(); i++) {
+    ///     std::cout << vals[i] << std::endl;
+    /// }
+    /// @endcode
+    /// @param key Key where the string is stored.
+    /// @param first Iterator to the first sub command.
+    /// @param last Off-the-end iterator to the given sub commands range.
+    /// @param output Output iterator to the destination where the result is saved.
+    /// @note The destination should be a container of `long long` type,
+    ///       the value of the corresponding is only `1` or `0`.
+    /// @see https://redis.io/commands/bitfield
+    template <typename Input, typename Output>
+    void bitfield(const StringView &key, Input first, Input last, Output output);
+
+    /// @brief Batch operations on multiple bits of a string.
+    /// Example:
+    /// @code{.cpp}
+    /// std::vector<long long> vals;
+    /// redis.bitfield("bitfieldkey",
+    ///                {"SET", "u1", "1", "1","SET", "u1", "3", "0","SET", "u1", "6", "1"},
+    ///                std::back_inserter(vals));
+    /// for (int i = 0; i < vals.size(); i++) {
+    ///     std::cout << vals[i] << std::endl;
+    /// }
+    /// @endcode
+    /// @param key Key where the string is stored.
+    /// @param first Iterator to the first sub command.
+    /// @param last Off-the-end iterator to the given sub commands range.
+    /// @param output Output iterator to the destination where the result is saved.
+    /// @note The destination should be a container of `long long` type,
+    ///       the value of the corresponding is only `1` or `0`.
+    /// @see https://redis.io/commands/bitfield
+    template <typename T, typename Output>
+    void bitfield(const StringView &key, std::initializer_list<T> il, Output output) {
+        bitfield(key, il.begin(), il.end(), output);
+    }
+
     /// @brief Get the substring of the string stored at key.
     /// @param key Key.
     /// @param start Start index (inclusive) of the range. 0 means the beginning of the string.

src/sw/redis++/redis.hpp

@@ -235,6 +235,15 @@ long long Redis::bitop(BitOp op, const StringView &destination, Input first, Inp
     return reply::parse<long long>(*reply);
 }
 
+template <typename Input, typename Output>
+inline void Redis::bitfield(const StringView &key, Input first, Input last, Output output) {
+    range_check("BITFIELD", first, last);
+
+    auto reply = command(cmd::bitfield<Input>, key, first, last);
+
+    reply::to_array(*reply, output);
+}
+
 template <typename Input, typename Output>
 void Redis::mget(Input first, Input last, Output output) {
     range_check("MGET", first, last);

src/sw/redis++/redis_cluster.h

@@ -204,6 +204,14 @@ class RedisCluster {
         return bitop(op, destination, il.begin(), il.end());
     }
 
+    template <typename Input, typename Output>
+    void bitfield(const StringView &key, Input first, Input last, Output output);
+
+    template <typename T, typename Output>
+    void bitfield(const StringView &key, std::initializer_list<T> il, Output output) {
+        bitfield(key, il.begin(), il.end(), output);
+    }
+
     long long bitpos(const StringView &key,
                         long long bit,
                         long long start = 0,

src/sw/redis++/redis_cluster.hpp

@@ -192,6 +192,15 @@ long long RedisCluster::bitop(BitOp op, const StringView &destination, Input fir
     return reply::parse<long long>(*reply);
 }
 
+template <typename Input, typename Output>
+inline void RedisCluster::bitfield(const StringView &key, Input first, Input last, Output output) {
+    range_check("BITFIELD", first, last);
+
+    auto reply = command(cmd::bitfield<Input>, key, first, last);
+
+    reply::to_array(*reply, output);
+}
+
 template <typename Input, typename Output>
 void RedisCluster::mget(Input first, Input last, Output output) {
     range_check("MGET", first, last);

test/src/sw/redis++/string_cmds_test.hpp

@@ -149,6 +149,26 @@ void StringCmdTest<RedisInstance>::_test_bit() {
     // dest_key -> 11101111
     v = _redis.get(dest_key);
     REDIS_ASSERT(v && *v == std::string(1, '\xEF'), "failed to test bitop");
+
+
+    auto bitfield_key = test_key("bitfield_src");
+    // bitfield_key -> 01000010
+    std::vector<std::string> ops = {"SET", "u1", "1", "1","SET", "u1", "3", "0","SET", "u1", "6", "1"};
+    std::vector<long long> vals;
+    _redis.bitfield(bitfield_key, ops.begin(), ops.end(), std::back_inserter(vals));
+    REDIS_ASSERT(_redis.getbit(bitfield_key, 1) == 1, "failed to test bitfield");
+    REDIS_ASSERT(_redis.getbit(bitfield_key, 3) == 0, "failed to test bitfield");
+    REDIS_ASSERT(_redis.getbit(bitfield_key, 6) == 1, "failed to test bitfield");
+    REDIS_ASSERT(_redis.bitcount(bitfield_key) == 2, "failed to test bitfield");
+
+    // bitfield_key -> 10011001
+    vals.clear();
+    _redis.bitfield(bitfield_key, {"SET", "u1", "0", "1","SET", "u1", "1", "0","SET", "u1", "4", "1", "SET", "u1", "7", "1"},
+                 std::back_inserter(vals));
+    REDIS_ASSERT(_redis.getbit(bitfield_key, 0) == 1, "failed to test bitfield");
+    REDIS_ASSERT(_redis.getbit(bitfield_key, 4) == 1, "failed to test bitfield");
+    REDIS_ASSERT(_redis.getbit(bitfield_key, 7) == 1, "failed to test bitfield");
+    REDIS_ASSERT(_redis.bitcount(bitfield_key) == 4, "failed to test bitfield");
 }
 
 template <typename RedisInstance>