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

zhash_t *zhash_dup (zhash_t *self){    if (!self)        return NULL;    zhash_t *copy = zhash_new ();    if (copy) {        copy->destructor = self->destructor;        copy->duplicator = self->duplicator;        uint index;        size_t limit = primes [self->prime_index];        for (index = 0; index < limit; index++) {            item_t *item = self->items [index];            while (item) {                if (zhash_insert (copy, item->key, item->value)) {                    zhash_destroy (&copy);                    break;                }                item = item->next;            }        }    }    return copy;}

voidzcertstore_insert (zcertstore_t *self, zcert_t **cert_p){    zlist_append (self->cert_list, *cert_p);    zhash_insert (self->cert_hash, zcert_public_txt (*cert_p), *cert_p);    *cert_p = NULL;             //  We own this now}

void agent_control_message (agent_t *self){    zmsg_t *msg = zmsg_recv (self->control);    char *command = zmsg_pop (msg);    if (strcmp (command, "CONNECT") == 0) {        char *endpoint = zmsg_pop (msg);        printf ("I: connecting to %s.../n", endpoint);        int rc = zmq_connect (self->router, endpoint);        assert (rc == 0);        server_t *server = server_new (endpoint);        zhash_insert (self->servers, endpoint, server);        zhash_freefn (self->servers, endpoint, s_server_free);        zlist_append (self->actives, server);        server->ping_at = s_clock () + PING_INTERVAL;        server->expires = s_clock () + SERVER_TTL;        free (endpoint);    }    else    if (strcmp (command, "REQUEST") == 0) {        assert (!self->request);    //  Strict request-reply cycle        //  Prefix request with sequence number and empty envelope        char sequence_text [10];        sprintf (sequence_text, "%u", ++self->sequence);        zmsg_push (msg, sequence_text);        //  Take ownership of request message        self->request = msg;        msg = NULL;        //  Request expires after global timeout        self->expires = s_clock () + GLOBAL_TIMEOUT;    }    free (command);    zmsg_destroy (&msg);}

static voids_zdir_watch_subscribe (zdir_watch_t *watch, const char *path){    if (watch->verbose)        zsys_info ("zdir_watch: Subscribing to directory path: %s", path);    zdir_watch_sub_t *sub = (zdir_watch_sub_t *) zmalloc (sizeof (zdir_watch_sub_t));    sub->dir = zdir_new (path, NULL);    if (!sub->dir) {        if (watch->verbose)            zsys_error ("zdir_watch: Unable to create zdir for path: %s", path);        zsock_signal (watch->pipe, 1);        return;    }    int rc = zhash_insert (watch->subs, path, sub);    if (rc) {        if (watch->verbose)            zsys_error ("zdir_watch: Unable to insert path '%s' into subscription list", path);        zsock_signal (watch->pipe, 1);        return;    }    void *item = zhash_freefn (watch->subs, path, s_sub_free);    if (item != sub) {        if (watch->verbose)            zsys_error ("zdir_watch: Unable to set free fn for path %s", path);        zsock_signal (watch->pipe, 1);        return;    }    if (watch->verbose)        zsys_info ("zdir_watch: Successfully subscribed to %s", path);    zsock_signal (watch->pipe, 0);}

static void fixup_newjob_event (flux_t *h, int64_t nj){    json_object *ss = NULL;    json_object *jcb = NULL;    int64_t js = J_NULL;    char *key = xasprintf ("%"PRId64, nj);    jscctx_t *ctx = getctx (h);    /* We fix up ordering problem only when new job       event hasn't been reported through a kvs watch     */    jcb = Jnew ();    ss = Jnew ();    Jadd_int64 (jcb, JSC_JOBID, nj);    Jadd_int64 (ss, JSC_STATE_PAIR_OSTATE , (int64_t) js);    Jadd_int64 (ss, JSC_STATE_PAIR_NSTATE, (int64_t) js);    json_object_object_add (jcb, JSC_STATE_PAIR, ss);    if (zhash_insert (ctx->active_jobs, key, (void *)(intptr_t)js) < 0) {        flux_log (h, LOG_ERR, "new_job_cb: inserting a job to hash failed");        goto done;    }    if (invoke_cbs (h, nj, jcb, 0) < 0) {        flux_log (h, LOG_ERR,                     "makeup_newjob_event: failed to invoke callbacks");        goto done;    }done:    Jput (jcb);    free (key);    return;}

static zhash_t *determine_all_min_bandwidth (struct rdl *rdl,                                             zlist_t *running_jobs){    double root_bw;    double *curr_value = NULL;    struct resource *root = NULL;    job_t *curr_job = NULL;    char job_id_str[100];    zhash_t *job_hash = zhash_new ();    root = rdl_resource_get (rdl, "default");    root_bw = get_max_bandwidth (root);    curr_job = zlist_first (running_jobs);    while (curr_job != NULL) {        curr_value = (double *)malloc (sizeof (double));        *curr_value = root_bw;        sprintf (job_id_str, "%d", curr_job->id);        zhash_insert (job_hash, job_id_str, curr_value);        zhash_freefn (job_hash, job_id_str, free);        curr_job = zlist_next (running_jobs);    }    determine_all_min_bandwidth_helper (root, root_bw, job_hash);    return job_hash;}

static halutils_err_e _disp_table_insert (disp_table_t *self, uint32_t key,        disp_table_func_fp func_fp){    if (func_fp == NULL) {        return HALUTILS_ERR_NULL_POINTER;    }    DBE_DEBUG (DBG_HAL_UTILS | DBG_LVL_TRACE,            "[halutils:disp_table] Registering function (%p) opcode (%u) into dispatch table/n",            func_fp, key);    func_fp_wrapper_t *func_fp_wrapper = zmalloc (sizeof *func_fp_wrapper);    ASSERT_ALLOC (func_fp_wrapper, err_func_wrapper_alloc);    /* Initialize func_p_wrapper struct */    func_fp_wrapper->func_fp = func_fp;    char *key_c = halutils_stringify_key (key);    ASSERT_ALLOC (key_c, err_key_c_alloc);    int zerr = zhash_insert (self->table_h, key_c, func_fp_wrapper);    ASSERT_TEST(zerr == 0, "Could not insert item into dispatch table", err_insert_hash);    /* Setup free function */    zhash_freefn (self->table_h, key_c, _disp_table_free_item);    free (key_c);    return HALUTILS_SUCCESS;err_insert_hash:    free (key_c);err_key_c_alloc:    free (func_fp_wrapper);err_func_wrapper_alloc:    return HALUTILS_ERR_ALLOC;}

static voidsub_patch_add (sub_t *self, fmq_patch_t *patch){    //  Skip file creation if client already has identical file    fmq_patch_digest_set (patch);    if (fmq_patch_op (patch) == patch_create) {        char *digest = zhash_lookup (self->cache, fmq_patch_virtual (patch));        if (digest && strcasecmp (digest, fmq_patch_digest (patch)) == 0)            return;             //  Just skip patch for this client    }    //  Remove any previous patches for the same file    fmq_patch_t *existing = (fmq_patch_t *) zlist_first (self->client->patches);    while (existing) {        if (streq (fmq_patch_virtual (patch), fmq_patch_virtual (existing))) {            zlist_remove (self->client->patches, existing);            fmq_patch_destroy (&existing);            break;        }        existing = (fmq_patch_t *) zlist_next (self->client->patches);    }    if (fmq_patch_op (patch) == patch_create)        zhash_insert (self->cache,            fmq_patch_digest (patch), fmq_patch_virtual (patch));    //  Track that we've queued patch for client, so we don't do it twice    zlist_append (self->client->patches, fmq_patch_dup (patch));}

static service_t *s_service_require (broker_t *self, zframe_t *service_frame){    assert (service_frame);    char *name = zframe_strdup (service_frame);    service_t *service =        (service_t *) zhash_lookup (self->services, name);    if (service == NULL) {        service = (service_t *) zmalloc (sizeof (service_t));        service->broker = self;        service->name = name;        service->requests = zlist_new ();        service->waiting = zlist_new ();        service->blacklist = zlist_new ();        zhash_insert (self->services, name, service);        zhash_freefn (self->services, name, s_service_destroy);        if (self->verbose)            zclock_log ("I: added service: %s", name);    }    else        free (name);    return service;}

voidzyre_group_join (zyre_group_t *self, zyre_peer_t *peer){    assert (self);    assert (peer);    zhash_insert (self->peers, zyre_peer_identity (peer), peer);    zyre_peer_set_status (peer, zyre_peer_status (peer) + 1);}

static int barrier_add_client (barrier_t *b, char *sender, zmsg_t **zmsg){    if (zhash_insert (b->clients, sender, *zmsg) < 0)        return -1;    zhash_freefn (b->clients, sender, (zhash_free_fn *)free_zmsg);    *zmsg = NULL; /* list owns it now */    return 0;}

static int barrier_add_client (barrier_t *b, char *sender, const flux_msg_t *msg){    flux_msg_t *cpy = flux_msg_copy (msg, true);    if (!cpy || zhash_insert (b->clients, sender, cpy) < 0)        return -1;    zhash_freefn (b->clients, sender, (zhash_free_fn *)flux_msg_destroy);    return 0;}

voidzcert_set_meta (zcert_t *self, const char *name, const char *format, ...){    va_list argptr;    va_start (argptr, format);    char *value = zsys_vprintf (format, argptr);    va_end (argptr);    zhash_insert (self->metadata, name, value);    zstr_free (&value);}

zargs_t *zargs_new (int argc, char **argv){    assert (argc > 0);    assert (argv);    zargs_t *self = (zargs_t *) zmalloc (sizeof (zargs_t));    assert (self);    //  Initialize class properties here    self->progname = argv [0];    assert (self->progname);    self->arguments = zlist_new ();    assert (self->arguments);    self->parameters = zhash_new ();    assert (self->parameters);    if (argc == 1)        return self;    int idx = 1;    bool params_only = false;    while (argv [idx]) {        if (params_only || argv [idx][0] != '-')            zlist_append (self->arguments, argv [idx]);        else {	    if (streq (argv [idx], "--")) {	        params_only = true;            idx ++;            continue;	    }	    else            if (argv [idx+1] && argv [idx+1][0] != '-') {                zhash_insert (self->parameters, argv [idx], argv [idx+1]);                idx ++;            }            else {                zhash_insert (self->parameters, argv [idx], ZARG_PARAM_EMPTY);            }        }        idx ++;    }    return self;}

static pipe_t *pipe_new (server_t *server, const char *name){    pipe_t *self = (pipe_t *) zmalloc (sizeof (pipe_t));    self->name = strdup (name);    self->server = server;    zhash_insert (server->pipes, name, self);    zhash_freefn (server->pipes, name, s_delete_pipe);    return self;}

static int new_job_cb (const char *key, int64_t val, void *arg, int errnum){    int64_t nj = 0;    int64_t js = 0;    JSON ss = NULL;    JSON jcb = NULL;    char k[20] = {'/0'};    char path[20] = {'/0'};    flux_t h = (flux_t) arg;    jscctx_t *ctx = getctx (h);    if (ctx->first_time == 1) {        /* watch is invoked immediately and we shouldn't         * rely on that event at all.         */        ctx->first_time = 0;        return 0;    }    if (chk_errnum (h, errnum) < 0) return 0;    flux_log (h, LOG_DEBUG, "new_job_cb invoked: key(%s), val(%ld)", key, val);    js = J_NULL;    nj = val-1;    snprintf (k, 20, "%ld", nj);    snprintf (path, 20, "lwj.%ld", nj);    if (zhash_insert (ctx->active_jobs, k, (void *)(intptr_t)js) < 0) {        flux_log (h, LOG_ERR, "new_job_cb: inserting a job to hash failed");        goto done;    }    flux_log (h, LOG_DEBUG, "jobstate_hdlr registered");    jcb = Jnew ();    ss = Jnew ();    Jadd_int64 (jcb, JSC_JOBID, nj);    Jadd_int64 (ss, JSC_STATE_PAIR_OSTATE , (int64_t) js);    Jadd_int64 (ss, JSC_STATE_PAIR_NSTATE, (int64_t) js);    json_object_object_add (jcb, JSC_STATE_PAIR, ss);    if (invoke_cbs (h, nj, jcb, errnum) < 0) {        flux_log (h, LOG_ERR, "new_job_cb: failed to invoke callbacks");    }    if (reg_jobstate_hdlr (h, path, job_state_cb) == -1) {        flux_log (h, LOG_ERR, "new_job_cb: reg_jobstate_hdlr: %s",             strerror (errno));    }done:    /* always return 0 so that reactor won't return */    return 0;}

int store_payload(zhash_t *object_hash, char *obj_name, Tag tag, zframe_t *payload, enum INSERT_DATA_POLICY policy) {    char tag_str[BUFSIZE];    zhash_t *single_object_hash = (zhash_t *)zhash_lookup(object_hash, obj_name);    tag_to_string(tag, tag_str);    if( single_object_hash==NULL) {        single_object_hash = zhash_new();        zhash_insert(object_hash, obj_name, (void *)single_object_hash);    }    zframe_t *payload_frame = (zframe_t *)zhash_lookup(single_object_hash, tag_str);    if( policy == yield) {        if(payload_frame!=NULL) return -1;    } else if(policy==force) {        if(payload_frame!=NULL) {            zframe_destroy(&payload_frame);            zhash_delete(single_object_hash, tag_str);        }    }    return(zhash_insert(single_object_hash, tag_str, (void *)payload));}

void CSetAdd(cset_t *self, const uint8_t *srcip, const uint8_t *srcport,    const uint8_t *dstip, const uint8_t *dstport,    void *value){    assert(self);    assert(srcip);    assert(srcport);    assert(dstip);    assert(dstport);    const char *key = CSetCreateKey(srcip, srcport, dstip, dstport);    zhash_insert(self->hash, key, value);    zhash_freefn (self->hash, key, _cset_free_fn);}

static int build_name_array (zhash_t *ha, const char *k, json_object *ns){    int i = (intptr_t) zhash_lookup (ha, k);    if ((void *)((intptr_t)i) == NULL) {        char *t = xstrdup (k);        i = json_object_array_length (ns);        Jadd_ar_str (ns, t);        zhash_insert (ha, k, (void *)(intptr_t)i+1);        free (t);    } else        i--;    return i;}

bool adminCmdInit(void) {    // initialize the admin commands hashtable    if (!(adminCommands = zhash_new())) {        error ("Cannot initialize admin commands hashtable correctly.");        return false;    }    zhash_insert(adminCommands, "spawn",          adminCmdSpawnPc);    zhash_insert(adminCommands, "jump",           adminCmdJump);    zhash_insert(adminCommands, "additem",        adminCmdAddItem);    zhash_insert(adminCommands, "test",           adminCmdTest);    zhash_insert(adminCommands, "where",          adminCmdWhere);    zhash_insert(adminCommands, "changeCamera",   adminCmdChangeCamera);    zhash_insert(adminCommands, "setStamina",     adminCmdSetStamina);    zhash_insert(adminCommands, "setSP",          adminCmdSetSP);    zhash_insert(adminCommands, "setLevel",       adminCmdSetLevel);    return true;}

zyre_group_t *zyre_group_new (const char *name, zhash_t *container){    zyre_group_t *self = (zyre_group_t *) zmalloc (sizeof (zyre_group_t));    self->name = strdup (name);    self->peers = zhash_new ();        //  Insert into container if requested    if (container) {        zhash_insert (container, name, self);        zhash_freefn (container, name, s_delete_group);    }    return self;}

static int64_t * seq_create (seqhash_t *s, const char *name){    int rc;    int64_t *v;    if (zhash_lookup (s->vhash, name)) {        errno = EEXIST;        return (NULL);    }    v = seq_new ();    rc = zhash_insert (s->vhash, xstrdup (name), v);    assert (rc >= 0);    zhash_freefn (s->vhash, name, free);    return (v);}

static barrier_t *barrier_create (ctx_t *ctx, const char *name, int nprocs){    barrier_t *b;    b = xzmalloc (sizeof (barrier_t));    b->name = xstrdup (name);    b->nprocs = nprocs;    if (!(b->clients = zhash_new ()))        oom ();    b->ctx = ctx;    zhash_insert (ctx->barriers, b->name, b);    zhash_freefn (ctx->barriers, b->name, barrier_destroy);    return b;}

zhash_t *zhash_unpack (zframe_t *frame){    zhash_t *self = zhash_new ();    if (!self)        return NULL;    assert (frame);    if (zframe_size (frame) < 4)        return self;            //  Arguable...    byte *needle = zframe_data (frame);    byte *ceiling = needle + zframe_size (frame);    size_t nbr_items = ntohl (*(uint32_t *) needle);    needle += 4;    while (nbr_items && needle < ceiling) {        //  Get key as string        size_t key_size = *needle++;        if (needle + key_size <= ceiling) {            char key [256];            memcpy (key, needle, key_size);            key [key_size] = 0;            needle += key_size;            //  Get value as longstr            if (needle + 4 <= ceiling) {                size_t value_size = ntohl (*(uint32_t *) needle);                needle += 4;                //  Be wary of malformed frames                if (needle + value_size <= ceiling) {                    char *value = (char *) malloc (value_size + 1);                    memcpy (value, needle, value_size);                    value [value_size] = 0;                    needle += value_size;                    //  Hash takes ownership of value                    if (zhash_insert (self, key, value)) {                        zhash_destroy (&self);                        break;                    }                }            }        }    }    //  Hash will free values in destructor    if (self)        zhash_autofree (self);    return self;}

static int command_list_read (zhash_t *h, const char *path){    int i;    int rc = -1;    int n = 0;    json_t *o = NULL;    if (!(o = command_list_file_read (path)))        goto out;    n = json_array_size (o);    for (i = 0; i < n; i++) {        const char *category;        const char *command;        const char *description;        json_t *entry;        zlist_t *zl;        if (!(entry = json_array_get (o, i))) {            log_msg ("%s: entry %d is not an object", path, i);            goto out;        }        if (json_unpack (entry, "{s:s s:s s:s}",                                "category", &category,                                "command", &command,                                "description", &description) < 0) {            log_msg ("%s: Missing element in JSON entry %d", path, i);            goto out;        }        if (!(zl = zhash_lookup (h, category))) {            char *s = strdup (category);            if (s == NULL)                goto out;            zl = zlist_new ();            //zlist_set_destructor (zl, (czmq_destructor *) cmdhelp_destroy);            zhash_insert (h, s, (void *) zl);            zhash_freefn (h, s, (zhash_free_fn *) cmd_list_destroy);            free (s);        }        zlist_append (zl, cmdhelp_create (command, description));    }    rc = 0;out:    json_decref (o);    return (rc);}

// somewhat counterintuitively, this returns NULL if everything's ok.char * create_trigger(zhash_t * triggers,                      char * rule_id,                       zctx_t * context,                      triggerconfig_t * tconf) {  void * trigger_pipe = zthread_fork(context, trigger, tconf);  send_sync("ping", trigger_pipe);  char * pipe_resp = zstr_recv(trigger_pipe);  if(strcmp(pipe_resp, "pong") == 0) {    zhash_insert(triggers, rule_id, trigger_pipe);    free(pipe_resp);    return NULL;  } else {    zclock_log("something went wrong creating a trigger: %s", pipe_resp);    return pipe_resp;  }}

static service_t *s_service_require(server_t *self, const char *service_name){	char *name = strdup(service_name);	service_t *service = (service_t *) zhash_lookup(self->services, name);	if (service == NULL) {		service = (service_t *) zmalloc(sizeof(service_t));		service->broker = self;		service->name = name;		service->requests = zlist_new();		service->waiting = zlist_new();		zhash_insert(self->services, name, service);		zhash_freefn(self->services, name, s_service_destroy);	} else	    zstr_free(&name);	return service;}

voidzhash_update (zhash_t *self, char *key, void *value){	item_t *item;    assert (self);    assert (key);        item = s_item_lookup (self, key);    if (item) {        if (item->free_fn)            (item->free_fn) (item->value);        item->value = value;    }    else        zhash_insert (self, key, value);}

bool staticDataAdd(StaticData *self, StaticDataId id, void *object) {    if (self->locked) {        sdError(self, "StaticData has been locked and cannot be modified anymore.");        return false;    }    StaticDataKey key;    staticDataGenKey(self, id, key);    if (zhash_insert(self->hashtable, key, object) != 0) {        sdError(self, "Cannot insert the object '%s'", key);        return false;    }    return true;}