C++ clist_new函数代码示例

static struct mailimf_fields * build_fields(void)
{
  struct mailimf_fields * fields;
  struct mailimf_field * f;
  clist * list;
  struct mailimf_from * from;
	struct mailimf_to * to;
  struct mailimf_mailbox * mb;
  struct mailimf_address * addr;
  struct mailimf_mailbox_list * mb_list;
  struct mailimf_address_list * addr_list;
  clist * fields_list;

  /* build headers */

  fields_list = clist_new();
  
  /* build header 'From' */
  
  list = clist_new();
  mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
    strdup("[email protected]"));
  clist_append(list, mb);
  mb_list = mailimf_mailbox_list_new(list);
  
  from = mailimf_from_new(mb_list);
  
  f = mailimf_field_new(MAILIMF_FIELD_FROM,
    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
    from, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
    NULL, NULL, NULL, NULL);

  clist_append(fields_list, f);
  
  /* build header To */

  list = clist_new();
  mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="),
    strdup("[email protected]"));
  addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL);
  clist_append(list, addr);
  addr_list = mailimf_address_list_new(list);
  
  to = mailimf_to_new(addr_list);

  f = mailimf_field_new(MAILIMF_FIELD_TO,
    NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
    NULL, NULL, NULL, to, NULL, NULL, NULL, NULL, NULL,
    NULL, NULL, NULL, NULL);
  
  clist_append(fields_list, f);
  
  fields = mailimf_fields_new(fields_list);
  
  return fields;
}

hand
hand_new (void) {
    hand h;
    h.bet = 0;
    h.cards = clist_new();
    return h;
}

LIBETPAN_EXPORT
struct mailstorage * mailstorage_new(const char * sto_id)
{
  struct mailstorage * storage;

  storage = malloc(sizeof(struct mailstorage));
  if (storage == NULL)
    goto err;

  if (sto_id != NULL) {
    storage->sto_id = strdup(sto_id);
    if (storage->sto_id == NULL)
      goto free;
  }
  else
    storage->sto_id = NULL;

  storage->sto_data = NULL;
  storage->sto_session = NULL;
  storage->sto_driver = NULL;
  storage->sto_shared_folders = clist_new();
  if (storage->sto_shared_folders == NULL)
    goto free_id;

  return storage;

 free_id:
  if (storage->sto_id != NULL)
    free(storage->sto_id);
 free:
  free(storage);
 err:
  return NULL;
}

int
mailimap_quota_quota_list_empty_parse(mailstream * fd, MMAPString *buffer,
    size_t * indx, clist ** result,
    size_t progr_rate, progress_function * progr_fun)
{
  size_t cur_token;
  int r;
  clist * quota_resource_list;

  cur_token = * indx;

  r = mailimap_oparenth_parse(fd, buffer, &cur_token);
  if (r != MAILIMAP_NO_ERROR) {
    return r;
  }

  r = mailimap_cparenth_parse(fd, buffer, &cur_token);
  if (r != MAILIMAP_NO_ERROR) {
    return r;
  }

  quota_resource_list = clist_new();
  if (!quota_resource_list) {
    return MAILIMAP_ERROR_MEMORY;
  }

  * result = quota_resource_list;
  * indx = cur_token;
  
  return MAILIMAP_NO_ERROR;
}

static int mhdriver_list_folders(mailsession * session, const char * mb,
				 struct mail_list ** result)
{
  clist * list;
  int r;
  struct mailmh * mh;
  struct mail_list * ml;

  mh = get_mh_session(session);

  if (mh == NULL)
    return MAIL_ERROR_BAD_STATE;

  list = clist_new();
  if (list == NULL)
    return MAIL_ERROR_MEMORY;

  r =  get_list_folders(mh->mh_main, &list);
  if (r != MAIL_NO_ERROR)
    return r;

  ml = mail_list_new(list);
  if (ml == NULL)
    goto free;

  * result = ml;

  return MAIL_NO_ERROR;

 free:
  clist_foreach(list, (clist_func) free, NULL);
  clist_free(list);
  return MAIL_ERROR_MEMORY;
}

LIBETPAN_EXPORT
struct mailimap_set *
mailimap_set_new_single_item(struct mailimap_set_item * item)
{
  struct mailimap_set * set;
  clist * list;
  int r;
  
  list = clist_new();
  if (list == NULL)
    return NULL;
  
  r = clist_append(list, item);
  if (r < 0) {
    clist_free(list);
    return NULL;
  }
	  
  set = mailimap_set_new(list);
  if (set == NULL) {
    clist_free(list);
    return NULL;
  }

  return set;
}

void test_case_cscore_004(const UINT32 cscore_md_id)
{
    void *csdoc_words_1;
    void *csdoc_words_2;
    void *csdoc_words_3;
    void *csdoc_words_list;
    void *csword_docs;
    void *csdoc;

    csdoc_words_list = clist_new(MM_CSDOC_WORDS, 0);
    ASSERT(NULL_PTR != csdoc_words_list);

    /*make csdoc_words_1 = {doc={1001,1002,1003}, words={pepople, republic, of, china}}*/
    csdoc_words_1 = cscore_csdoc_words_new(cscore_md_id);
    ASSERT(NULL_PTR != csdoc_words_1);
    csdoc = (void *)cscore_csdoc_words_get_doc(cscore_md_id, csdoc_words_1);
    __test_case_cscore_csdoc_set_doc(cscore_md_id, csdoc, 1001, 1002, 1003);
    __test_case_cscore_csdoc_words_add_words(cscore_md_id, csdoc_words_1, 4, (UINT8 *)"pepole", (UINT8 *)"republic", (UINT8 *)"of", (UINT8 *)"china");
    clist_push_back(csdoc_words_list, (void *)csdoc_words_1);

    /*make csdoc_words_2 = {doc={1101,1002,1003}, words={pepople, working, hard}}*/
    csdoc_words_2 = cscore_csdoc_words_new(cscore_md_id);
    ASSERT(NULL_PTR != csdoc_words_2);    
    csdoc = (void *)cscore_csdoc_words_get_doc(cscore_md_id, csdoc_words_2);
    __test_case_cscore_csdoc_set_doc(cscore_md_id, csdoc, 1101, 1002, 1003);
    __test_case_cscore_csdoc_words_add_words(cscore_md_id, csdoc_words_2, 3, (UINT8 *)"pepole", (UINT8 *)"working", (UINT8 *)"hard");
    clist_push_back(csdoc_words_list, (void *)csdoc_words_2);

    /*make csdoc_words_3 = {doc={1101,1002,1003}, words={pepople, living, happ}}*/
    csdoc_words_3 = cscore_csdoc_words_new(cscore_md_id);
    ASSERT(NULL_PTR != csdoc_words_3);    
    csdoc = (void *)cscore_csdoc_words_get_doc(cscore_md_id, csdoc_words_3);
    __test_case_cscore_csdoc_set_doc(cscore_md_id, csdoc, 1011, 1002, 1003);
    __test_case_cscore_csdoc_words_add_words(cscore_md_id, csdoc_words_3, 3, (UINT8 *)"pepole", (UINT8 *)"living", (UINT8 *)"happ");
    clist_push_back(csdoc_words_list, (void *)csdoc_words_3);

    /*import csdoc_words_1 into bigtable*/
    dbg_log(SEC_0137_DEMO, 9)(LOGSTDOUT, "[DEBUG] test_case_cscore_004: import beg\n");
    ASSERT(EC_TRUE == cscore_csdoc_words_list_import(cscore_md_id, csdoc_words_list));
    clist_free_with_modi(csdoc_words_list, cscore_md_id);
    dbg_log(SEC_0137_DEMO, 9)(LOGSTDOUT, "[DEBUG] test_case_cscore_004: import end\n");

    /*make csword_docs ready*/
    csword_docs = cscore_csword_docs_new(cscore_md_id);
    ASSERT(NULL_PTR != csword_docs);

    /*add cswords to csword_docs*/
    __test_case_cscore_csword_docs_set_word(cscore_md_id, csword_docs, (UINT8 *)"pepole");

    dbg_log(SEC_0137_DEMO, 9)(LOGSTDOUT, "[DEBUG] test_case_cscore_004: export beg\n");
    ASSERT(EC_TRUE == cscore_csword_docs_export(cscore_md_id, CBGT_SELECT_FROM_ALL_TABLE, csword_docs));
    dbg_log(SEC_0137_DEMO, 9)(LOGSTDOUT, "[DEBUG] test_case_cscore_004: export end\n");
    dbg_log(SEC_0137_DEMO, 9)(LOGSTDOUT, "[DEBUG] test_case_cscore_004: export result:\n");
    cscore_csword_docs_print(LOGSTDOUT, csword_docs);
    cscore_csword_docs_free(cscore_md_id, csword_docs);

    return;
}

static clist * read_group_time_list(newsnntp * f)
{
  char * line;
  char * group_name;
  time_t date;
  char * email;
  clist * group_time_list;
  struct newsnntp_group_time * n;
  int r;

  group_time_list = clist_new();
  if (group_time_list == NULL)
    goto err;

  while (1) {
    char * p;
    char * remaining;
    
    line = read_line(f);
    
    if (line == NULL)
      goto free_list;

    if (mailstream_is_end_multiline(line))
      break;
    
    p = cut_token(line);
    if (p == NULL)
      continue;
      
    date = strtoul(p, &remaining, 10);

    p = remaining;
    parse_space(&p);

    email = p;
    
    group_name = line;
    
    n = group_time_new(group_name, date, email);
    if (n == NULL)
      goto free_list;
    
    r = clist_append(group_time_list, n);
    if (r < 0) {
      group_time_free(n);
      goto free_list;
    }
  }
  
  return group_time_list;

 free_list:
  group_time_list_free(group_time_list);
 err:
  return NULL;
}

static clist * read_distrib_default_value_list(newsnntp * f)
{
  char * line;
  uint32_t weight;
  char * group_pattern;
  char * meaning;
  clist * distrib_default_value_list;
  struct newsnntp_distrib_default_value * n;
  int r;

  distrib_default_value_list = clist_new();
  if (distrib_default_value_list == NULL)
    goto err;

  while (1) {
    char * p;
    char * remaining;
      
    line = read_line(f);
    if (line == NULL)
      goto free_list;

    if (mailstream_is_end_multiline(line))
      break;

    p = line;

    weight = strtoul(p, &remaining, 10);
    p = remaining;
    parse_space(&p);
      
    p = cut_token(line);
    if (p == NULL)
      continue;

    meaning = p;
    group_pattern = line;

    n = distrib_default_value_new(weight, group_pattern, meaning);
    if (n == NULL)
      goto free_list;

    r = clist_append(distrib_default_value_list, n);
    if (r < 0) {
      distrib_default_value_free(n);
      goto free_list;
    }
  }

  return distrib_default_value_list;

 free_list:
  distrib_default_value_list_free(distrib_default_value_list);
 err:
  return NULL;
}

struct mailimap_section * mailimap_section_new_empty(void)
{
  clist * list;

  list = clist_new();
  if (list == NULL)
    return NULL;

  return mailimap_section_new(list);
}

struct mailimap_status_att_list * mailimap_status_att_list_new_empty(void)
{
  clist * list;

  list = clist_new();
  if (list == NULL)
    return NULL;

  return mailimap_status_att_list_new(list);
}

struct mailmime_content *
mailmime_content_dup(struct mailmime_content * content)
{
  clist * list;
  struct mailmime_type * type;
  int r;
  struct mailmime_content * dup_content;
  char * subtype;

  type = mailmime_type_dup(content->ct_type);
  if (type == NULL)
    goto err;
  
  subtype = strdup(content->ct_subtype);
  if (subtype == NULL)
    goto free_type;
  
  list = clist_new();
  if (list == NULL)
    goto free_subtype;
  
  if (content->ct_parameters != NULL) {
    clistiter * cur;
    
    for(cur = clist_begin(content->ct_parameters) ;
        cur != NULL ; cur = clist_next(cur)) {
      struct mailmime_parameter * param;
      
      param = mailmime_parameter_dup(clist_content(cur));
      if (param == NULL)
        goto free_list;
      
      r = clist_append(list, param);
      if (r < 0) {
        mailmime_parameter_free(param);
        goto free_list;
      }
    }
  }
  
  dup_content = mailmime_content_new(type, subtype, list);
  if (dup_content == NULL)
    goto free_list;

  return dup_content;
  
 free_list:
  clist_foreach(list, (clist_func) mailmime_parameter_free, NULL);
 free_subtype:
  free(subtype);
 free_type:
  mailmime_type_free(type);
 err:
  return NULL;
}

static int mailimap_enable_parse(mailstream * fd, MMAPString * buffer,
	size_t * indx,
	struct mailimap_capability_data ** result,
	size_t progr_rate,
	progress_function * progr_fun)
{
  size_t cur_token;
  int r;
  int res;
	struct mailimap_capability_data * capabilities;
  clist * cap_list;
  
  cur_token = * indx;
  
  r = mailimap_token_case_insensitive_parse(fd, buffer, &cur_token, "ENABLED");
  if (r != MAILIMAP_NO_ERROR) {
    res = r;
    goto err;
  }
  
  r = mailimap_capability_list_parse(fd, buffer, &cur_token,
                                     &cap_list,
                                     progr_rate, progr_fun);
  if (r == MAILIMAP_ERROR_PARSE) {
    cap_list = clist_new();
    if (cap_list == NULL) {
      res = MAILIMAP_ERROR_MEMORY;
      goto err;
    }
    r = MAILIMAP_NO_ERROR;
  }
  if (r != MAILIMAP_NO_ERROR) {
    res = r;
    goto err;
  }
  
  capabilities = mailimap_capability_data_new(cap_list);
  if (capabilities == NULL) {
    res = MAILIMAP_ERROR_MEMORY;
    goto free_list;
  }
  
  * result = capabilities;
  * indx = cur_token;
  
  return MAILIMAP_NO_ERROR;
  
free_list:
  if (cap_list) {
    clist_foreach(cap_list, (clist_func) mailimap_capability_free, NULL);
    clist_free(cap_list);
  }
err:
  return res;
}

LIBETPAN_EXPORT
struct mailimap_set * mailimap_set_new_empty(void)
{
  clist * list;

  list = clist_new();
  if (list == NULL)
    return NULL;

  return mailimap_set_new(list);
}

struct mailimap_search_key *
mailimap_search_key_new_multiple_empty(void)
{
  clist * list;

  list = clist_new();
  if (list == NULL)
    return NULL;

  return mailimap_search_key_new_multiple(list);
}