Async set-like commands interface about omcache HOT 2 CLOSED

struct protocol_binary_set_request_body_s {
  uint32_t flags;
  uint32_t expiration;
} __attribute__((packed));

static int async_omc_set_cmd(omcache_t *mc, protocol_binary_command opcode,
                             const unsigned char *key, size_t key_len,
                             const unsigned char *value, size_t value_len,

                             protocol_binary_set_request_body_s* expiration_and_flags,

                             uint64_t cas,

                             omcache_req_t *requests,
                             size_t *req_count,
                             omcache_value_t *values,
                             size_t *value_count,

                             int32_t timeout_msec)
{
  if (req_count == NULL || *req_count == 0)
    return OMCACHE_INVALID;

  memset(requests, 0, sizeof(*requests) * *req_count);
  if (values && value_count)
    memset(values, 0, sizeof(*values) * *value_count);


  size_t extra_len = sizeof(protocol_binary_set_request_body_s);
  if (opcode == PROTOCOL_BINARY_CMD_APPEND || opcode == PROTOCOL_BINARY_CMD_APPENDQ ||
      opcode == PROTOCOL_BINARY_CMD_PREPEND || opcode == PROTOCOL_BINARY_CMD_PREPENDQ)
    extra_len = 0;

  omcache_req_t& req = requests[0];
  req.server_index = -1;
  req.header.opcode = opcode;
  req.header.extlen = extra_len;
  req.header.keylen = htobe16(key_len);
  req.header.bodylen = htobe32(key_len + value_len + extra_len);
  req.header.cas = htobe64(cas);
  req.extra = expiration_and_flags;
  req.key = key;
  req.data = value;

  return omcache_command(mc, requests, req_count, values, value_count, timeout_msec);
}


int async_omcache_add(omcache_t *mc,
                      const unsigned char *key, size_t key_len,
                      const unsigned char *value, size_t value_len,

                      protocol_binary_set_request_body_s* expiration_and_flags,

                      omcache_req_t *requests,
                      size_t *req_count,
                      omcache_value_t *values,
                      size_t *value_count,

                      int32_t timeout_msec)
{
  return async_omc_set_cmd(mc, QCMD(PROTOCOL_BINARY_CMD_ADD),
                           key, key_len, value, value_len,
                           expiration_and_flags, 0,

                           requests,
                           req_count,
                           values,
                           value_count,

                           timeout_msec);
}

int async_omcache_delete(omcache_t *mc,
                         const unsigned char *key, size_t key_len,

                         omcache_req_t *requests,
                         size_t *req_count,
                         omcache_value_t *values,
                         size_t *value_count,
                         int32_t timeout_msec)
{
  if (req_count == NULL || *req_count == 0)
    return OMCACHE_INVALID;

  memset(requests, 0, sizeof(*requests) * *req_count);
  if (values && value_count)
    memset(values, 0, sizeof(*values) * *value_count);

  omcache_req_t *req = &requests[0];
  req->server_index = -1;
  req->header.opcode = QCMD(PROTOCOL_BINARY_CMD_DELETE);
  req->header.keylen = htobe16(key_len);
  req->header.bodylen = htobe32(key_len);
  req->key = key;
  return omcache_command(mc, requests, req_count, values, value_count, timeout_msec);
}