自学教程：C++ GRN_API_RETURN函数代码示例

grn_rcgrn_tokenizer_query_set_raw_string(grn_ctx *ctx,                                   grn_tokenizer_query *query,                                   const char *string,                                   size_t string_length){  GRN_API_ENTER;  if (query->query_buf) {    GRN_PLUGIN_FREE(ctx, query->query_buf);  }  if (string_length == 0) {    query->query_buf = NULL;    query->ptr = NULL;    query->length = 0;    query->need_normalize = GRN_TRUE;  } else {    query->query_buf = (char *)GRN_PLUGIN_MALLOC(ctx, string_length + 1);    if (!query->query_buf) {      GRN_PLUGIN_ERROR(ctx, GRN_TOKENIZER_ERROR,                       "[tokenizer][query] failed to duplicate query");      GRN_API_RETURN(ctx->rc);    }    grn_memcpy(query->query_buf, string, string_length);    query->query_buf[string_length] = '/0';    query->ptr = query->query_buf;    query->length = string_length;  }  GRN_API_RETURN(ctx->rc);}

grn_obj *grn_type_create(grn_ctx *ctx, const char *name, unsigned int name_size,                grn_obj_flags flags, unsigned int size){  grn_id id;  struct _grn_type *res = NULL;  grn_obj *db;  if (!ctx || !ctx->impl || !(db = ctx->impl->db)) {    ERR(GRN_INVALID_ARGUMENT, "db not initialized");    return NULL;  }  GRN_API_ENTER;  if (grn_db_check_name(ctx, name, name_size)) {    GRN_DB_CHECK_NAME_ERR("[type][create]", name, name_size);    GRN_API_RETURN(NULL);  }  if (!GRN_DB_P(db)) {    ERR(GRN_INVALID_ARGUMENT, "invalid db assigned");    GRN_API_RETURN(NULL);  }  id = grn_obj_register(ctx, db, name, name_size);  if (id && (res = GRN_MALLOC(sizeof(grn_db_obj)))) {    GRN_DB_OBJ_SET_TYPE(res, GRN_TYPE);    res->obj.header.flags = flags;    res->obj.header.domain = GRN_ID_NIL;    GRN_TYPE_SIZE(&res->obj) = size;    if (grn_db_obj_init(ctx, db, id, DB_OBJ(res))) {      // grn_obj_delete(ctx, db, id);      GRN_FREE(res);      GRN_API_RETURN(NULL);    }  }  GRN_API_RETURN((grn_obj *)res);}

grn_obj *grn_token_get_data(grn_ctx *ctx, grn_token *token){  GRN_API_ENTER;  if (!token) {    ERR(GRN_INVALID_ARGUMENT, "token must not be NULL");    GRN_API_RETURN(NULL);  }  GRN_API_RETURN(&(token->data));}

grn_token_statusgrn_token_get_status(grn_ctx *ctx, grn_token *token){  GRN_API_ENTER;  if (!token) {    ERR(GRN_INVALID_ARGUMENT, "token must not be NULL");    GRN_API_RETURN(GRN_TOKEN_CONTINUE);  }  GRN_API_RETURN(token->status);}

uint64_tgrn_token_get_source_offset(grn_ctx *ctx, grn_token *token){  GRN_API_ENTER;  if (!token) {    ERR(GRN_INVALID_ARGUMENT,        "[token][source-offset][get] token must not be NULL");    GRN_API_RETURN(0);  }  GRN_API_RETURN(token->source_offset);}

grn_boolgrn_token_have_overlap(grn_ctx *ctx, grn_token *token){  GRN_API_ENTER;  if (!token) {    ERR(GRN_INVALID_ARGUMENT,        "[token][overlap][have] token must not be NULL");    GRN_API_RETURN(0);  }  GRN_API_RETURN(token->have_overlap);}

grn_boolgrn_token_get_force_prefix_search(grn_ctx *ctx, grn_token *token){  GRN_API_ENTER;  if (!token) {    ERR(GRN_INVALID_ARGUMENT,        "[token][force-prefix-search][get] token must not be NULL");    GRN_API_RETURN(GRN_FALSE);  }  GRN_API_RETURN(token->force_prefix_search);}

uint32_tgrn_token_get_position(grn_ctx *ctx, grn_token *token){  GRN_API_ENTER;  if (!token) {    ERR(GRN_INVALID_ARGUMENT,        "[token][position][get] token must not be NULL");    GRN_API_RETURN(0);  }  GRN_API_RETURN(token->position);}

uint32_tgrn_token_get_source_first_character_length(grn_ctx *ctx, grn_token *token){  GRN_API_ENTER;  if (!token) {    ERR(GRN_INVALID_ARGUMENT,        "[token][source-first-character-length][get] token must not be NULL");    GRN_API_RETURN(0);  }  GRN_API_RETURN(token->source_first_character_length);}

grn_tokenizer_query *grn_tokenizer_query_open(grn_ctx *ctx, int num_args, grn_obj **args,                         unsigned int normalize_flags){  grn_obj *flags;  grn_obj *query_str;  grn_obj *tokenize_mode;  GRN_API_ENTER;  flags = grn_ctx_pop(ctx);  query_str = grn_ctx_pop(ctx);  tokenize_mode = grn_ctx_pop(ctx);  if (query_str == NULL) {    GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "missing argument");    GRN_API_RETURN(NULL);  }  if ((num_args < 1) || (args == NULL) || (args[0] == NULL)) {    GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT, "invalid NULL pointer");    GRN_API_RETURN(NULL);  }  {    grn_tokenizer_query * const query =        GRN_PLUGIN_MALLOC(ctx, sizeof(grn_tokenizer_query));    if (!query) {      GRN_API_RETURN(NULL);    }    grn_tokenizer_query_init(ctx, query);    grn_tokenizer_query_set_raw_string(ctx,                                       query,                                       GRN_TEXT_VALUE(query_str),                                       GRN_TEXT_LEN(query_str));    if (ctx->rc != GRN_SUCCESS) {      GRN_PLUGIN_FREE(ctx, query);      GRN_API_RETURN(NULL);    }    if (flags) {      grn_tokenizer_query_set_flags(ctx, query, GRN_UINT32_VALUE(flags));    }    if (tokenize_mode) {      grn_tokenizer_query_set_mode(ctx, query, GRN_UINT32_VALUE(tokenize_mode));    }    grn_tokenizer_query_set_normalize_flags(ctx, query, normalize_flags);    grn_tokenizer_query_set_lexicon(ctx, query, args[0]);    grn_tokenizer_query_ensure_have_tokenized_delimiter(ctx, query);    GRN_API_RETURN(query);  }}

grn_rcgrn_token_set_position(grn_ctx *ctx, grn_token *token, uint32_t position){  GRN_API_ENTER;  if (!token) {    ERR(GRN_INVALID_ARGUMENT,        "[token][position][set] token must not be NULL");    GRN_API_RETURN(ctx->rc);  }  token->position = position;  GRN_API_RETURN(ctx->rc);}

grn_rcgrn_token_set_force_prefix_search(grn_ctx *ctx, grn_token *token, grn_bool force){  GRN_API_ENTER;  if (!token) {    ERR(GRN_INVALID_ARGUMENT,        "[token][force-prefix-search][set] token must not be NULL");    GRN_API_RETURN(ctx->rc);  }  token->force_prefix_search = force;  GRN_API_RETURN(ctx->rc);}

uint32_tgrn_type_size(grn_ctx *ctx, grn_obj *type){  uint32_t size;  GRN_API_ENTER;  if (!type) {    ERR(GRN_INVALID_ARGUMENT, "[type][size] type is NULL");    GRN_API_RETURN(0);  }  size = GRN_TYPE_SIZE(DB_OBJ(type));  GRN_API_RETURN(size);}

grn_rcgrn_windows_event_logger_set(grn_ctx *ctx, const char *event_source_name){#ifdef WIN32    grn_rc rc;    grn_logger windows_event_logger;    grn_windows_event_logger_data *data;    if (ctx) {        GRN_API_ENTER;    }    data = malloc(sizeof(grn_windows_event_logger_data));    if (!data) {        if (ctx) {            ERR(GRN_NO_MEMORY_AVAILABLE,                "failed to allocate user data for Windows event logger");            GRN_API_RETURN(ctx->rc);        } else {            return GRN_NO_MEMORY_AVAILABLE;        }    }    if (event_source_name) {        data->event_source_name = grn_strdup_raw(event_source_name);    } else {        data->event_source_name = grn_strdup_raw("libgroonga");    }    data->event_source = INVALID_HANDLE_VALUE;    windows_event_logger.max_level = GRN_LOG_DEFAULT_LEVEL;    windows_event_logger.flags     = GRN_LOG_TIME | GRN_LOG_MESSAGE;    windows_event_logger.user_data = data;    windows_event_logger.log       = windows_event_logger_log;    windows_event_logger.reopen    = windows_event_logger_reopen;    windows_event_logger.fin       = windows_event_logger_fin;    rc = grn_logger_set(ctx, &windows_event_logger);    if (rc != GRN_SUCCESS) {        windows_event_logger.fin(ctx, windows_event_logger.user_data);    }    if (ctx) {        GRN_API_RETURN(rc);    } else {        return rc;    }#else /* WIN32 */    return GRN_FUNCTION_NOT_IMPLEMENTED;#endif /* WIN32 */}

grn_obj *grn_command_input_get_arguments(grn_ctx *ctx,                                grn_command_input *input){  GRN_API_ENTER;  GRN_API_RETURN((grn_obj *)(input->arguments));}

unsigned intgrn_tokenizer_query_get_normalize_flags(grn_ctx *ctx,                                        grn_tokenizer_query *query){  GRN_API_ENTER;  GRN_API_RETURN(query->normalize_flags);}

grn_rcgrn_tokenizer_query_set_lexicon(grn_ctx *ctx,                                grn_tokenizer_query *query,                                grn_obj *lexicon){  GRN_API_ENTER;  if (query->lexicon != lexicon) {    query->lexicon = lexicon;    if (query->lexicon) {      grn_table_get_info(ctx,                         query->lexicon,                         NULL,                         &(query->encoding),                         NULL,                         NULL,                         NULL);    } else {      query->encoding = ctx->encoding;    }    query->need_normalize = GRN_TRUE;  }  GRN_API_RETURN(ctx->rc);}

unsigned intgrn_tokenizer_query_get_token_filter_index(grn_ctx *ctx,                                           grn_tokenizer_query *query){  GRN_API_ENTER;  GRN_API_RETURN(query->token_filter_index);}

grn_obj *grn_tokenizer_create(grn_ctx *ctx,                     const char *name,                     int name_length){  grn_obj *tokenizer;  GRN_API_ENTER;  tokenizer = grn_proc_create(ctx,                              name,                              name_length,                              GRN_PROC_TOKENIZER,                              NULL,                              NULL,                              NULL,                              0,                              NULL);  if (!tokenizer) {    if (name_length < 0) {      name_length = strlen(name);    }    GRN_PLUGIN_ERROR(ctx,                     GRN_TOKENIZER_ERROR,                     "[tokenizer][create] failed to create: <%.*s>",                     name_length, name);  }  GRN_API_RETURN(tokenizer);}

grn_obj *grn_command_input_add(grn_ctx *ctx,                      grn_command_input *input,                      const char *name,                      int name_size,                      grn_bool *added){  grn_obj *argument = NULL;  /* TODO: Use grn_bool */  int internal_added = GRN_FALSE;  GRN_API_ENTER;  if (name_size == -1) {    name_size = strlen(name);  }  if (input->arguments) {    grn_hash_add(ctx, input->arguments, name, name_size, (void **)&argument,                 &internal_added);    if (internal_added) {      GRN_TEXT_INIT(argument, 0);    }  }  if (added) {    *added = internal_added;  }  GRN_API_RETURN(argument);}

grn_rcgrn_token_copy(grn_ctx *ctx,               grn_token *token,               grn_token *source){  GRN_API_ENTER;  if (!token) {    ERR(GRN_INVALID_ARGUMENT, "[token][copy] token must not be NULL");    goto exit;  }  GRN_TEXT_SET(ctx,               &(token->data),               GRN_TEXT_VALUE(&(source->data)),               GRN_TEXT_LEN(&(source->data)));  token->status = source->status;  token->source_offset = source->source_offset;  token->source_length = source->source_length;  token->source_first_character_length = source->source_first_character_length;  token->have_overlap = source->have_overlap;  grn_token_metadata_reset(ctx, &(token->metadata));  grn_token_metadata_copy(ctx, &(token->metadata), &(source->metadata));  token->force_prefix_search = source->force_prefix_search;  token->position = source->position;exit:  GRN_API_RETURN(ctx->rc);}

/* It should be renamed to grn_snip_close() and marked as internal. * TODO: 3.0 */grn_rcgrn_snip_close_real(grn_ctx *ctx, grn_snip *snip){  snip_cond *cond, *cond_end;  if (!snip) { return GRN_INVALID_ARGUMENT; }  GRN_API_ENTER;  if (snip->flags & GRN_SNIP_COPY_TAG) {    int i;    snip_cond *sc;    const char *dot = snip->defaultopentag, *dct = snip->defaultclosetag;    for (i = snip->cond_len, sc = snip->cond; i; i--, sc++) {      if (sc->opentag != dot) { GRN_FREE((void *)sc->opentag); }      if (sc->closetag != dct) { GRN_FREE((void *)sc->closetag); }    }    if (dot) { GRN_FREE((void *)dot); }    if (dct) { GRN_FREE((void *)dct); }  }  if (snip->nstr) {    grn_obj_close(ctx, snip->nstr);  }  for (cond = snip->cond, cond_end = cond + snip->cond_len;       cond < cond_end; cond++) {    grn_snip_cond_close(ctx, cond);  }  GRN_FREE(snip);  GRN_API_RETURN(GRN_SUCCESS);}

grn_boolgrn_tokenizer_query_have_tokenized_delimiter(grn_ctx *ctx,                                             grn_tokenizer_query *query){  GRN_API_ENTER;  grn_tokenizer_query_ensure_have_tokenized_delimiter(ctx, query);  GRN_API_RETURN(query->have_tokenized_delimiter);}

grn_boolgrn_operator_exec_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y){  grn_bool r = GRN_FALSE;  GRN_API_ENTER;  DO_EQ(x, y, r);  GRN_API_RETURN(r);}

grn_boolgrn_operator_exec_greater_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y){  grn_bool r = GRN_FALSE;  GRN_API_ENTER;  DO_COMPARE(x, y, r, >=);  GRN_API_RETURN(r);}

grn_boolgrn_operator_exec_less(grn_ctx *ctx, grn_obj *x, grn_obj *y){  grn_bool r = GRN_FALSE;  GRN_API_ENTER;  DO_COMPARE(x, y, r, <);  GRN_API_RETURN(r);}

grn_boolgrn_operator_exec_not_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y){  grn_bool r = GRN_FALSE;  GRN_API_ENTER;  r = exec_equal(ctx, x, y);  GRN_API_RETURN(!r);}

grn_boolgrn_operator_exec_prefix(grn_ctx *ctx, grn_obj *target, grn_obj *prefix){  grn_bool matched;  GRN_API_ENTER;  matched = exec_text_operator_bulk_bulk(ctx, GRN_OP_PREFIX, target, prefix);  GRN_API_RETURN(matched);}

grn_rcgrn_token_fin(grn_ctx *ctx, grn_token *token){  GRN_API_ENTER;  grn_token_metadata_fin(ctx, &(token->metadata));  GRN_OBJ_FIN(ctx, &(token->data));  GRN_API_RETURN(ctx->rc);}

const char *grn_token_get_data_raw(grn_ctx *ctx, grn_token *token, size_t *length){  GRN_API_ENTER;  if (!token) {    ERR(GRN_INVALID_ARGUMENT,        "[token][data][get][raw] token must not be NULL");    if (length) {      *length = 0;    }    GRN_API_RETURN(NULL);  }  if (length) {    *length = GRN_TEXT_LEN(&(token->data));  }  GRN_API_RETURN(GRN_TEXT_VALUE(&(token->data)));}