C++ (Cpp) rpb_put_resp__free_unpacked Examples

Example #1

File: pb_messages.c Project: denisphillips/debris

int riak_pb_put(struct riak_pb_transport *pbtransport,
                struct riak_object *riak_obj,
                struct riak_put_options *options,
                struct riak_response *response) {

   void *msgbuf;
   unsigned msglen;
   RpbPutReq putmsg = RPB_PUT_REQ__INIT;

   putmsg.bucket.data = malloc(riak_obj->bucket.len);
   memcpy(&putmsg.bucket.data, &riak_obj->bucket.data, riak_obj->bucket.len);
   putmsg.bucket.len  = riak_obj->bucket.len;

   // TODO: key may not be present
   putmsg.has_key=1;
   putmsg.key.data = malloc(riak_obj->key.len);
   memcpy(&putmsg.key.data, &riak_obj->key.data, riak_obj->key.len);
   putmsg.key.len  = riak_obj->key.len;

   RpbContent *content = malloc(sizeof(RpbContent));
   rpb_content__init(content);
   putmsg.content = content;

   content->value.len  = riak_obj->value.len;
   content->value.data = (uint8_t*)malloc(riak_obj->value.len);
   memcpy(&putmsg.content->value.data, &riak_obj->value.data, riak_obj->value.len);

   // process get options
   if(options != 0) {
     // TODO
   }
   msglen = rpb_put_req__get_packed_size (&putmsg);
   msgbuf = malloc (msglen);
   rpb_put_req__pack (&putmsg, msgbuf);

   struct pb_request request;
   request.reqid = MSG_RPBPUTREQ;
   request.msglength = msglen;
   request.reqdata = msgbuf;
   pbtransport->send_message(pbtransport->transport_data, &request);
   free(msgbuf);

   struct pb_response pbresponse;
   pbresponse.expected_respid = MSG_RPBPUTRESP;

   int pbr = pbtransport->receive_message(pbtransport->transport_data, &pbresponse);
   if(pbr >= 0) {
     // decode the PB response etc
     RpbPutResp *putresp = rpb_put_resp__unpack(NULL, pbresponse.msglength, pbresponse.respdata);
     rpb_put_resp__free_unpacked(putresp, NULL);
     free(pbresponse.respdata);
     return 0;
   } else {
     return -1;
   }
   /// TODO: errors!
   return 0;
}

Example #2

File: riack_kv.c Project: iehoyeba/riack

int riack_put(struct RIACK_CLIENT *client,
			struct RIACK_OBJECT object,
			struct RIACK_OBJECT* preturned_object,
			struct RIACK_PUT_PROPERTIES* properties)
{
	int result;
	size_t packed_size;
	struct RIACK_PB_MSG msg_req, *msg_resp;
	ProtobufCAllocator pb_allocator;
	RpbPutReq put_req;
	RpbPutResp *put_resp;
	uint8_t *request_buffer;

    if (!client || !object.bucket.value) {
		return RIACK_ERROR_INVALID_INPUT;
	}

	pb_allocator = riack_pb_allocator(&client->allocator);
	result = RIACK_ERROR_COMMUNICATION;
	rpb_put_req__init(&put_req);
	riack_copy_object_to_rpbputreq(client, &object, &put_req);
    riack_set_object_properties(properties, &put_req);

	packed_size = rpb_put_req__get_packed_size(&put_req);
	request_buffer = (uint8_t*)RMALLOC(client, packed_size);
	if (request_buffer) {
		rpb_put_req__pack(&put_req, request_buffer);
		msg_req.msg_code = mc_RpbPutReq;
		msg_req.msg_len = packed_size;
		msg_req.msg = request_buffer;
		if ((riack_send_message(client, &msg_req) > 0)&&
			(riack_receive_message(client, &msg_resp) > 0))
		{
			if (msg_resp->msg_code == mc_RpbPutResp) {
				result = RIACK_SUCCESS;
				if (preturned_object) {
					put_resp = rpb_put_resp__unpack(&pb_allocator, msg_resp->msg_len, msg_resp->msg);
					if (put_resp) {
						riak_set_object_response_values(client, preturned_object, put_resp);
						rpb_put_resp__free_unpacked(put_resp, &pb_allocator);
					} else {
						result = RIACK_FAILED_PB_UNPACK;
					}
				}
			} else {
				riack_got_error_response(client, msg_resp);
				result = RIACK_ERROR_RESPONSE;
			}
			riack_message_free(client, &msg_resp);
		}
		RFREE(client, request_buffer);
	}
    riack_free_copied_rpb_put_req(client, &put_req);
	return result;
}