C++ (Cpp) msgpack_zone_new Examples

Example #1

File: unpack.c Project: Keith-Redding/msgpack

bool msgpack_unpack_next(msgpack_unpacked* result,
		const char* data, size_t len, size_t* off)
{
	msgpack_unpacked_destroy(result);

	size_t noff = 0;
	if(off != NULL) { noff = *off; }

	if(len <= noff) {
		return false;
	}

	msgpack_zone* z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);

	template_context ctx;
	template_init(&ctx);

	ctx.user.z = z;
	ctx.user.referenced = false;

	int e = template_execute(&ctx, data, len, &noff);
	if(e <= 0) {
		msgpack_zone_free(z);
		return false;
	}

	if(off != NULL) { *off = noff; }

	result->zone = z;
	result->data = template_data(&ctx);

	return true;
}

Example #2

File: unpack.c Project: Keith-Redding/msgpack

msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac)
{
	if(!msgpack_unpacker_flush_zone(mpac)) {
		return NULL;
	}

	msgpack_zone* r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
	if(r == NULL) {
		return NULL;
	}

	msgpack_zone* old = mpac->z;
	mpac->z = r;

	return old;
}

Example #3

File: unpack.c Project: nokute78/fluent-bit

msgpack_unpack_return
msgpack_unpack_next(msgpack_unpacked* result,
        const char* data, size_t len, size_t* off)
{
    size_t noff = 0;
    msgpack_unpacked_destroy(result);

    if(off != NULL) { noff = *off; }

    if(len <= noff) {
        return MSGPACK_UNPACK_CONTINUE;
    }

    if (!result->zone) {
        result->zone = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
    }

    if (!result->zone) {
        return MSGPACK_UNPACK_NOMEM_ERROR;
    }
    else {
        int e;
        template_context ctx;
        template_init(&ctx);

        ctx.user.z = result->zone;
        ctx.user.referenced = false;

        e = template_execute(&ctx, data, len, &noff);
        if(e < 0) {
            msgpack_zone_free(result->zone);
            result->zone = NULL;
            return MSGPACK_UNPACK_PARSE_ERROR;
        }


        if(e == 0) {
            return MSGPACK_UNPACK_CONTINUE;
        }

        if(off != NULL) { *off = noff; }

        result->data = template_data(&ctx);

        return MSGPACK_UNPACK_SUCCESS;
    }
}

Example #4

File: groonga_suggest_httpd.c Project: fusuian/groonga

static void *
recv_from_learner(void *arg)
{
  void *zmq_recv_sock;
  recv_thd_data *thd = arg;

  if ((zmq_recv_sock = zmq_socket(thd->zmq_ctx, ZMQ_SUB))) {
    if (!zmq_connect(zmq_recv_sock, thd->recv_endpoint)) {
      grn_ctx ctx;
      if (!grn_ctx_init(&ctx, 0)) {
        if ((!grn_ctx_use(&ctx, db))) {
          msgpack_zone *mempool;
          if ((mempool = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE))) {
            grn_obj cmd_buf;
            zmq_pollitem_t items[] = {
              { zmq_recv_sock, 0, ZMQ_POLLIN, 0}
            };
            GRN_TEXT_INIT(&cmd_buf, 0);
            zmq_setsockopt(zmq_recv_sock, ZMQ_SUBSCRIBE, "", 0);
            while (loop) {
              zmq_poll(items, 1, 10000);
              if (items[0].revents & ZMQ_POLLIN) {
                recv_handler(&ctx, zmq_recv_sock, mempool, &cmd_buf);
              }
            }
            grn_obj_unlink(&ctx, &cmd_buf);
            msgpack_zone_free(mempool);
          } else {
            print_error("cannot create msgpack zone.");
          }
          /* db_close */
        } else {
          print_error("error in grn_db_open() on recv thread.");
        }
        grn_ctx_fin(&ctx);
      } else {
        print_error("error in grn_ctx_init() on recv thread.");
      }
    } else {
      print_error("cannot create recv zmq_socket.");
    }
  } else {
    print_error("cannot connect zmq_socket.");
  }
  return NULL;
}

Example #5

File: unpack.c Project: nokute78/fluent-bit

bool msgpack_unpacker_init(msgpack_unpacker* mpac, size_t initial_buffer_size)
{
    char* buffer;
    void* ctx;
    msgpack_zone* z;

    if(initial_buffer_size < COUNTER_SIZE) {
        initial_buffer_size = COUNTER_SIZE;
    }

    buffer = (char*)malloc(initial_buffer_size);
    if(buffer == NULL) {
        return false;
    }

    ctx = malloc(sizeof(template_context));
    if(ctx == NULL) {
        free(buffer);
        return false;
    }

    z = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
    if(z == NULL) {
        free(ctx);
        free(buffer);
        return false;
    }

    mpac->buffer = buffer;
    mpac->used = COUNTER_SIZE;
    mpac->free = initial_buffer_size - mpac->used;
    mpac->off = COUNTER_SIZE;
    mpac->parsed = 0;
    mpac->last_parsed = 0;
    mpac->initial_buffer_size = initial_buffer_size;
    mpac->z = z;
    mpac->ctx = ctx;

    init_count(mpac->buffer);

    template_init(CTX_CAST(mpac->ctx));
    CTX_CAST(mpac->ctx)->user.z = mpac->z;
    CTX_CAST(mpac->ctx)->user.referenced = false;

    return true;
}

Example #6

File: unpack.c Project: nokute78/fluent-bit

msgpack_zone* msgpack_unpacker_release_zone(msgpack_unpacker* mpac)
{
    msgpack_zone* r;
    msgpack_zone* old;

    if(!msgpack_unpacker_flush_zone(mpac)) {
        return NULL;
    }

    r = msgpack_zone_new(MSGPACK_ZONE_CHUNK_SIZE);
    if(r == NULL) {
        return NULL;
    }

    old = mpac->z;
    mpac->z = r;
    CTX_CAST(mpac->ctx)->user.z = mpac->z;

    return old;
}