Method runBitfieldOperationsWithCache

src/types/redis_bitmap.cc:866–915

template <bool ReadOnly>
rocksdb::Status Bitmap::runBitfieldOperationsWithCache(engine::Context &ctx, SegmentCacheStore &cache,
                                                       const std::vector<BitfieldOperation> &ops,
                                                       std::vector<std::optional<BitfieldValue>> *rets) {
  ArrayBitfieldBitmap bitfield;
  for (BitfieldOperation op : ops) {
    // found all bytes that contents the bitfield.
    uint32_t first_byte = op.offset / 8;
    uint32_t last_bytes = (op.offset + op.encoding.Bits() - 1) / 8 + 1;
    uint32_t bytes = last_bytes - first_byte;

    auto segment_status = CopySegmentsBytesToBitfield(ctx, cache, first_byte, bytes, &bitfield);
    if (!segment_status.ok()) {
      return segment_status;
    }

    // Convert the bitfield from a buffer to an integer.
    uint64_t unsigned_old_value = 0;
    auto s = GetBitfieldInteger(bitfield, op.offset, op.encoding, &unsigned_old_value);
    if (!s.ok()) {
      return s;
    }

    if constexpr (ReadOnly) {
      rets->emplace_back() = {op.encoding, unsigned_old_value};
      continue;
    }

    auto &ret = rets->emplace_back();
    uint64_t unsigned_new_value = 0;
    // BitfieldOp failed only when the length or bits illegal.
    // BitfieldOperation already check above case in construction function.
    if (BitfieldOp(op, unsigned_old_value, &unsigned_new_value).GetValue()) {
      if (op.type != BitfieldOperation::Type::kGet) {
        Status _ = bitfield.SetBitfield(op.offset, op.encoding.Bits(), unsigned_new_value);
        s = CopyBitfieldBytesToSegments(ctx, cache, bitfield, first_byte, bytes);
        if (!s.ok()) {
          return s;
        }
      }

      if (op.type == BitfieldOperation::Type::kSet) {
        unsigned_new_value = unsigned_old_value;
      }

      ret = {op.encoding, unsigned_new_value};
    }
  }

  return rocksdb::Status::OK();
}

template rocksdb::Status Bitmap::bitfield<false>(engine::Context &ctx, const Slice &,
                                                 const std::vector<BitfieldOperation> &,