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

voidzconfig_destroy (zconfig_t **self_p){    assert (self_p);    if (*self_p) {        zconfig_t *self = *self_p;        //  Destroy all children and siblings recursively        if (self->child)            zconfig_destroy (&self->child);        if (self->next)            zconfig_destroy (&self->next);        zlist_destroy (&self->comments);        free (self->name);        free (self->value);        free (self);        *self_p = NULL;    }}

static voidclient_destroy (client_t **self_p){    assert (self_p);    if (*self_p) {        client_t *self = *self_p;        fmq_config_destroy (&self->config);        fmq_msg_destroy (&self->request);        fmq_msg_destroy (&self->reply);        //  Destroy subscriptions                                 while (zlist_size (self->subs)) {                             sub_t *sub = (sub_t *) zlist_pop (self->subs);            sub_destroy (&sub);                                   }                                                         zlist_destroy (&self->subs);                              free (self);        *self_p = NULL;    }}

voidzconfig_comment (zconfig_t *self, char *format, ...){    if (format) {        if (!self->comments) {            self->comments = zlist_new ();            zlist_autofree (self->comments);        }        va_list argptr;        va_start (argptr, format);        char *string = zsys_vprintf (format, argptr);        va_end (argptr);                zlist_append (self->comments, string);        free (string);    }    else        zlist_destroy (&self->comments);}

static voidzsync_node_destroy (zsync_node_t **self_p){    assert (self_p);    if (*self_p) {        zsync_node_t *self = *self_p;                zuuid_destroy (&self->own_uuid);              // TODO destroy all zsync_peers        zlist_destroy (&self->peers);        zhash_destroy (&self->zyre_peers);        zyre_destroy (&self->zyre);        free (self);        self_p = NULL;    }}

int main(void){	zctx_t *ctx = zctx_new();	lbbroker_t *self = (lbbroker_t *)zmalloc(sizeof(lbbroker_t));	self->frontend = zsocket_new(ctx, ZMQ_ROUTER);	self->backend = zsocket_new(ctx, ZMQ_ROUTER);#if (defined (WIN32))	zsocket_bind(self->frontend, "tcp://*:5672"); // frontend	zsocket_bind(self->backend, "tcp://*:5673"); // backend#else	zsocket_bind(self->frontend, "ipc://frontend.ipc");	zsocket_bind(self->backend, "ipc://backend.ipc");#endif	int client_nbr;	for (client_nbr = 0; client_nbr < NBR_CLIENTS; client_nbr++)		zthread_new(client_task, NULL);	int worker_nbr;	for (worker_nbr = 0; worker_nbr < NBR_WORKERS; worker_nbr++)		zthread_new(worker_task, NULL);	// Queue of available workers	self->workers = zlist_new();	// Prepare reactor and fire it up	zloop_t *reactor = zloop_new();	zmq_pollitem_t poller = { self->backend, 0, ZMQ_POLLIN };	zloop_poller(reactor, &poller, s_handle_backend, self);	zloop_start(reactor);	zloop_destroy(&reactor);	// When we're done, clean up properly	while (zlist_size(self->workers)) {		zframe_t *frame = (zframe_t *)zlist_pop(self->workers);		zframe_destroy(&frame);	}	zlist_destroy(&self->workers);	zctx_destroy(&ctx);	free(self);	return 0;}

/*PUB tcp://*:9003<<  [ "(?stock:[A-Z][A-Z0-9]+)" ]    [ timestamp :f64            ]    [ price     :f64            ]*/int main(int argc, const char* argv[]){  SetConsoleTitle(L"tickz.server");  // initialize random number generator  srand( (unsigned int)time(NULL) );  // initialize stock data  tick_t msft = tick_new("MSFT", 41.78);  tick_t aapl = tick_new("AAPL", 95.35);  tick_t goog = tick_new("GOOG",571.09);  tick_t yhoo = tick_new("YHOO", 34.53);  tick_t bbry = tick_new("BBRY", 10.90);    zlist_t *stocks = zlist_new();  zlist_append(stocks,&msft);  zlist_append(stocks,&aapl);  zlist_append(stocks,&goog);  zlist_append(stocks,&yhoo);  zlist_append(stocks,&bbry);    // set up publisher  zctx_t *ctx = zctx_new();  void *pub = zsocket_new(ctx,ZMQ_PUB);  zsocket_bind(pub,"tcp://*:9003");  // set up main loop  zloop_t *loop = zloop_new();  zloop_data_t loopdata;  loopdata.stocks = stocks;  loopdata.socket = pub;  // every 500 ms, update the stocks and publish the new data  int timer = zloop_timer(loop,500,0,onloop,&loopdata); //TOOD: take delay as input  zloop_start(loop); //NOTE: CTRL+C will cleanly interrupt the infinite loop    // clean up  zctx_destroy(&ctx);  zlist_destroy(&stocks);  return 0;}

void cleanup_push (cleaner_fun_f *fun, void * arg){    pthread_mutex_lock(&mutex);    if (! cleanup_list || cleaner_pid != getpid())    {        // This odd dance is to handle forked processes that do not exec        if (cleaner_pid != 0 && cleanup_list) {            zlist_destroy(&cleanup_list);        }        cleanup_list = zlist_new();        cleaner_pid = getpid();        atexit(cleanup);    }    struct cleaner * c = calloc(sizeof(struct cleaner), 1);    c->fun = fun;    c->arg = arg;    /* Ignore return code, no way to return it callery anyway... */    (void) zlist_push(cleanup_list, c);    pthread_mutex_unlock(&mutex);}

voidzinterface_test(bool verbose){    printf(" * zinterface: ");    zlist_t *interfaces = zinterface_list();    assert(interfaces);    if (verbose) {        printf("Len: %zu/n", zlist_size(interfaces));        zinterface_t *iface = zlist_first(interfaces);        while (iface) {            printf ("%s/t%s/t%s/t%s/n", zinterface_name(iface), zinterface_address(iface),                zinterface_netmask(iface), zinterface_broadcast(iface));            iface = zlist_next(interfaces);        }    }    zlist_destroy(&interfaces);    printf("OK/n");}

voidztask_job_request_dump (ztask_job_request_t *self){    assert (self);    zclock_log("ztask_job_request: Processes=%ld", zhash_size (self->processes));    zlist_t *keys = zhash_keys (self->processes);    char *key = (char *) zlist_first (keys);    ztask_job_proc_t *p;    while (key) {        zclock_log ("ztask_job_request: key=%s", key);        p = (ztask_job_proc_t *) zhash_lookup (self->processes, key);        ztask_job_proc_dump (p);        key = (char *) zlist_next (keys);    }    zlist_destroy (&keys);}

zlist_t *zlist_dup (zlist_t *self){    if (!self)        return NULL;    zlist_t *copy = zlist_new ();    copy->autofree = self->autofree;    if (copy) {        node_t *node;        for (node = self->head; node; node = node->next) {            if (!zlist_append (copy, node->item)) {                zlist_destroy (&copy);                break;            }        }    }    return copy;}

voidzconfig_destroy (zconfig_t **self_p){    assert (self_p);    if (*self_p) {        zconfig_t *self = *self_p;        //  Destroy all children and siblings recursively        zconfig_destroy (&self->child);        zconfig_destroy (&self->next);        //  Destroy other properties and then self        zlist_destroy (&self->comments);        zfile_destroy (&self->file);        free (self->name);        free (self->value);        free (self);        *self_p = NULL;    }}

voidzhash_comment (zhash_t *self, const char *format, ...){    if (format) {        if (!self->comments) {            self->comments = zlist_new ();            if (!self->comments)                return;            zlist_autofree (self->comments);        }        va_list argptr;        va_start (argptr, format);        char *string = zsys_vprintf (format, argptr);        va_end (argptr);        if (string)            zlist_append (self->comments, string);        zstr_free (&string);    }    else        zlist_destroy (&self->comments);}

voidzre_msg_destroy (zre_msg_t **self_p){    assert (self_p);    if (*self_p) {        zre_msg_t *self = *self_p;        //  Free class properties        zframe_destroy (&self->routing_id);        free (self->ipaddress);        if (self->groups)            zlist_destroy (&self->groups);        zhash_destroy (&self->headers);        zmsg_destroy (&self->content);        free (self->group);        //  Free object itself        free (self);        *self_p = NULL;    }}

voidzctx_destroy (zctx_t **self_p){    assert (self_p);    if (*self_p) {        zctx_t *self = *self_p;        //  Destroy all sockets        while (zlist_size (self->sockets))            zctx__socket_destroy (self, zlist_first (self->sockets));        zlist_destroy (&self->sockets);        zmutex_destroy (&self->mutex);        //  ZMQ context may not yet be instantiated        if (self->context && !self->shadow)            zmq_term (self->context);        free (self);        *self_p = NULL;    }}

int module_start_all (modhash_t *mh){    zlist_t *uuids;    char *uuid;    int rc = -1;    if (!(uuids = zhash_keys (mh->zh_byuuid)))        oom ();    uuid = zlist_first (uuids);    while (uuid) {        module_t *p = zhash_lookup (mh->zh_byuuid, uuid);        assert (p != NULL);        if (module_start (p) < 0)            goto done;        uuid = zlist_next (uuids);    }    rc = 0;done:    zlist_destroy (&uuids);    return rc;}

static voidmount_sub_store (mount_t *self, client_t *client, fmq_msg_t *request){    //  Store subscription along with any previous ones    //  Coalesce subscriptions that are on same path    char *path = fmq_msg_path (request);    sub_t *sub = (sub_t *) zlist_first (self->subs);    while (sub) {        if (client == sub->client) {            //  If old subscription is superset/same as new, ignore new            if (strncmp (path, sub->path, strlen (sub->path)) == 0)                return;            else            //  If new subscription is superset of old one, remove old            if (strncmp (sub->path, path, strlen (path)) == 0) {                zlist_remove (self->subs, sub);                sub_destroy (&sub);                sub = (sub_t *) zlist_first (self->subs);            }            else                sub = (sub_t *) zlist_next (self->subs);        }        else            sub = (sub_t *) zlist_next (self->subs);    }    //  New subscription for this client, append to our list    sub = sub_new (client, path, fmq_msg_cache (request));    zlist_append (self->subs, sub);    //  If client requested resync, send full mount contents now    if (fmq_msg_options_number (client->request, "RESYNC", 0) == 1) {        zlist_t *patches = fmq_dir_resync (self->dir, self->alias);        while (zlist_size (patches)) {            fmq_patch_t *patch = (fmq_patch_t *) zlist_pop (patches);            sub_patch_add (sub, patch);            fmq_patch_destroy (&patch);        }        zlist_destroy (&patches);    }}

zctx_t *zctx_new (void){    zctx_t *self = (zctx_t *) zmalloc (sizeof (zctx_t));    if (!self)        return NULL;    self->sockets = zlist_new ();    self->mutex = zmutex_new ();    if (!self->sockets || !self->mutex) {        zlist_destroy (&self->sockets);        zmutex_destroy (&self->mutex);        free (self);        return NULL;    }    self->iothreads = 1;    self->pipehwm = 1000;       self->sndhwm = 1000;    self->rcvhwm = 1000;    zsys_catch_interrupts ();    return self;}

static voidclient_destroy (client_t **self_p){    assert (self_p);    if (*self_p) {        client_t *self = *self_p;        fmq_config_destroy (&self->config);        int server_nbr;        for (server_nbr = 0; server_nbr < self->nbr_servers; server_nbr++) {            server_t *server = self->servers [server_nbr];            server_destroy (&server);        }        //  Destroy subscriptions                                 while (zlist_size (self->subs)) {                             sub_t *sub = (sub_t *) zlist_pop (self->subs);            sub_destroy (&sub);                                   }                                                         zlist_destroy (&self->subs);                              free (self);        *self_p = NULL;    }}

module_t *module_lookup_byname (modhash_t *mh, const char *name){    zlist_t *uuids;    char *uuid;    module_t *result = NULL;    if (!(uuids = zhash_keys (mh->zh_byuuid)))        oom ();    uuid = zlist_first (uuids);    while (uuid) {        module_t *p = zhash_lookup (mh->zh_byuuid, uuid);        assert (p != NULL);        if (!strcmp (module_get_name (p), name)) {            result = p;            break;        }        uuid = zlist_next (uuids);        p = NULL;    }    zlist_destroy (&uuids);    return result;}

int cache_expire_entries (struct cache *cache, int current_epoch, int thresh){    zlist_t *keys;    char *ref;    struct cache_entry *hp;    int count = 0;    if (!(keys = zhash_keys (cache->zh)))        oom ();    while ((ref = zlist_pop (keys))) {        if ((hp = zhash_lookup (cache->zh, ref))            && !cache_entry_get_dirty (hp)            && cache_entry_get_valid (hp)            && (thresh == 0 || cache_entry_age (hp, current_epoch) > thresh)) {                zhash_delete (cache->zh, ref);                count++;        }        free (ref);    }    zlist_destroy (&keys);    return count;}

void lsmod_map_hash (zhash_t *mods, flux_lsmod_f cb, void *arg){    zlist_t *keys = NULL;    const char *key;    mod_t *m;    int errnum = 0;    if (!(keys = zhash_keys (mods)))        oom ();    key = zlist_first (keys);    while (key != NULL) {        if ((m = zhash_lookup (mods, key))) {            if (cb (m->name, m->size, m->digest, m->idle,                                       nodeset_str (m->nodeset), arg) < 0) {                if (errno > errnum)                    errnum = errno;            }        }        key = zlist_next (keys);    }    zlist_destroy (&keys);}

zlist_t *zdir_resync (zdir_t *self, const char *alias){    zlist_t *patches = zlist_new ();    if (!patches)        return NULL;    zfile_t **files = zdir_flatten (self);    uint index;    for (index = 0;; index++) {        zfile_t *file = files [index];        if (!file)            break;        if (zlist_append (patches, zdir_patch_new (            self->path, file, patch_create, alias))) {            zlist_destroy (&patches);            break;        }    }    freen (files);    return patches;}

voidzproto_example_destroy (zproto_example_t **self_p){    assert (self_p);    if (*self_p) {        zproto_example_t *self = *self_p;        //  Free class properties        zframe_destroy (&self->routing_id);        free (self->data);        if (self->aliases)            zlist_destroy (&self->aliases);        zhash_destroy (&self->headers);        zchunk_destroy (&self->public_key);        zuuid_destroy (&self->identifier);        zframe_destroy (&self->address);        zmsg_destroy (&self->content);        //  Free object itself        free (self);        *self_p = NULL;    }}

static void emit_command_help_from_pattern (const char *pattern, FILE *fp){    zhash_t *zh = NULL;    zlist_t *keys = NULL;    const char *cat;    zh = get_command_list_hash (pattern);    if (zh == NULL)        return;    keys = zhash_keys (zh);    zlist_sort (keys, (zlist_compare_fn *) category_cmp);    cat = zlist_first (keys);    while (cat) {        emit_command_list_category (zh, cat, fp);        if ((cat = zlist_next (keys)))            fprintf (fp, "/n");    }    zlist_destroy (&keys);    zhash_destroy (&zh);    return;}

END_TEST//  --------------------------------------------------------------------------/// Try to _pop () a zlist_t *START_TEST(test_msg_pop_l){    sam_selftest_introduce ("test_msg_pop_h");    zmsg_t *zmsg = zmsg_new ();    if (zmsg_pushstr (zmsg, "value2") ||        zmsg_pushstr (zmsg, "value1") ||        zmsg_pushstr (zmsg, "2")) {        ck_abort_msg ("could not build zmsg");    }    sam_msg_t *msg = sam_msg_new (&zmsg);    ck_assert_int_eq (sam_msg_size (msg), 3);    zlist_t *list;    int rc = sam_msg_pop (msg, "l", &list);    ck_assert_int_eq (rc, 0);    ck_assert_int_eq (sam_msg_size (msg), 0);    ck_assert_int_eq (zlist_size (list), 2);    ck_assert_str_eq (zlist_first (list), "value1");    ck_assert_str_eq (zlist_next (list), "value2");    ck_assert (zlist_next (list) == NULL);    zlist_destroy (&list);    sam_msg_destroy (&msg);}

zlist_t *zhash_keys (zhash_t *self){    assert (self);    zlist_t *keys = zlist_new ();    if (!keys)        return NULL;    zlist_set_destructor (keys, self->key_destructor);    zlist_set_duplicator (keys, self->key_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 (zlist_append (keys, (void *) item->key)) {                zlist_destroy (&keys);                break;            }            item = item->next;        }    }    return keys;}

void flux_msg_handler_destroy (flux_msg_handler_t *w){    if (w) {        assert (w->magic == HANDLER_MAGIC);        flux_msg_handler_stop (w);        if (w->match.topic_glob)            free (w->match.topic_glob);        if (w->coproc)            coproc_destroy (w->coproc);        if (w->backlog) {            flux_msg_t *msg;            while ((msg = zlist_pop (w->backlog)))                flux_msg_destroy (msg);            zlist_destroy (&w->backlog);        }        if (w->wait_match.topic_glob)            free (w->wait_match.topic_glob);        if (w->arg_free)            w->arg_free (w->arg);        w->magic = ~HANDLER_MAGIC;        dispatch_usecount_decr (w->d);        free (w);    }}

static voidzyre_node_destroy (zyre_node_t **self_p){    assert (self_p);    if (*self_p) {        zyre_node_t *self = *self_p;        zpoller_destroy (&self->poller);        zuuid_destroy (&self->uuid);        zhash_destroy (&self->peers);        zhash_destroy (&self->peer_groups);        zlist_destroy (&self->own_groups);        zhash_destroy (&self->headers);        zsock_destroy (&self->inbox);        zsock_destroy (&self->outbox);        zactor_destroy (&self->beacon);        zactor_destroy (&self->gossip);        zstr_free (&self->endpoint);        zstr_free (&self->gossip_bind);        zstr_free (&self->gossip_connect);        free (self->name);        free (self);        *self_p = NULL;    }}

//.........这里部分代码省略.........        if (primary [0].revents & ZMQ_POLLIN) {            msg = zmsg_recv (localbe);            if (!msg)                break;          //  Interrupted            zframe_t *address = zmsg_unwrap (msg);            zlist_append (workers, address);            local_capacity++;            //  If it's READY, don't route the message any further            zframe_t *frame = zmsg_first (msg);            if (memcmp (zframe_data (frame), LRU_READY, 1) == 0)                zmsg_destroy (&msg);        }        //  Or handle reply from peer broker        else if (primary [1].revents & ZMQ_POLLIN) {            msg = zmsg_recv (cloudbe);            if (!msg)                break;          //  Interrupted            //  We don't use peer broker address for anything            zframe_t *address = zmsg_unwrap (msg);            zframe_destroy (&address);        }        //  Route reply to cloud if it's addressed to a broker        for (argn = 2; msg && argn < argc; argn++) {            char *data = (char *) zframe_data (zmsg_first (msg));            size_t size = zframe_size (zmsg_first (msg));            if (size == strlen (argv [argn])                    &&  memcmp (data, argv [argn], size) == 0)                zmsg_send (&msg, cloudfe);        }        //  Route reply to client if we still need to        if (msg)            zmsg_send (&msg, localfe);        //  Handle capacity updates        if (primary [2].revents & ZMQ_POLLIN) {            char *status = zstr_recv (statefe);            cloud_capacity = atoi (status);            free (status);        }        //  Handle monitor message        if (primary [3].revents & ZMQ_POLLIN) {            char *status = zstr_recv (monitor);            printf ("%s/n", status);            free (status);        }        //  Now route as many clients requests as we can handle        //  - If we have local capacity we poll both localfe and cloudfe        //  - If we have cloud capacity only, we poll just localfe        //  - Route any request locally if we can, else to cloud        //        while (local_capacity + cloud_capacity) {            zmq_pollitem_t secondary [] = {                { localfe, 0, ZMQ_POLLIN, 0 },                { cloudfe, 0, ZMQ_POLLIN, 0 }            };            if (local_capacity)                rc = zmq_poll (secondary, 2, 0);            else                rc = zmq_poll (secondary, 1, 0);            assert (rc >= 0);            if (secondary [0].revents & ZMQ_POLLIN)                msg = zmsg_recv (localfe);            else if (secondary [1].revents & ZMQ_POLLIN)                msg = zmsg_recv (cloudfe);            else                break;      //  No work, go back to primary            if (local_capacity) {                zframe_t *frame = (zframe_t *) zlist_pop (workers);                zmsg_wrap (msg, frame);                zmsg_send (&msg, localbe);                local_capacity--;            }            else {                //  Route to random broker peer                int random_peer = randof (argc - 2) + 2;                zmsg_pushmem (msg, argv [random_peer], strlen (argv [random_peer]));                zmsg_send (&msg, cloudbe);            }        }        if (local_capacity != previous) {            //  We stick our own address onto the envelope            zstr_sendm (statebe, self);            //  Broadcast new capacity            zstr_sendf (statebe, "%d", local_capacity);        }    }    //  When we're done, clean up properly    while (zlist_size (workers)) {        zframe_t *frame = (zframe_t *) zlist_pop (workers);        zframe_destroy (&frame);    }    zlist_destroy (&workers);    zctx_destroy (&ctx);    return EXIT_SUCCESS;}

//.........这里部分代码省略.........      zlist_add(thing, zonemaster);      zlist_add(zonemaster, thing);      notify_quiet(player, "Zone Master added to object.");      break;    case ZONE_DELETE:      if( !*tname || !*pname ) {        notify_quiet(player, "This switch expects two arguments.");        return;      }      /* Find out what the zone is */      init_match(player, pname, NOTYPE);      match_everything(0);      zonemaster = noisy_match_result();      if (zonemaster == NOTHING)        return;           init_match(player, tname, NOTYPE);      match_everything(0);      thing = noisy_match_result();      if( thing == NOTHING )        return;      if(!zlist_inlist(thing, zonemaster)) {        notify_quiet(player, "That is not one of this object's Zone Masters.");        return;      }      /* only need to control zmo or be zonewiz to delete          or control object */      if(!Controls(player, thing) &&         !Controls(player, zonemaster) &&          !could_doit(player, zonemaster, A_LZONEWIZ, 0, 0)         ) {        notify_quiet(player, "Permission denied.");        return;      }      if ( (NoMod(thing) && !WizMod(player)) ||           (Backstage(player) && NoBackstage(thing)) ) {        notify_quiet(player, "Permission denied.");        return;      }      zlist_del(thing, zonemaster);      zlist_del(zonemaster, thing);      notify_quiet(player, "Deleted.");      break;    case ZONE_PURGE:      if( !*tname || *pname) {        notify_quiet(player, "This switch expects one argument.");        return;      }      /* Find out what the zone is */      init_match(player, tname, NOTYPE);      match_everything(0);      thing = noisy_match_result();      if (thing == NOTHING)        return;      if( ZoneMaster(thing) ) {        if(!Controls(player, thing) &&           !could_doit(player, thing, A_LZONEWIZ, 0, 0)) {          notify_quiet(player, "Permission denied.");          return;        }        if ( (NoMod(thing) && !WizMod(player)) ||             (Backstage(player) && NoBackstage(thing)) ) {          notify_quiet(player, "Permission denied.");          return;        }        zlist_destroy(thing);        notify_quiet(player, "All objects removed from zone.");      }      else {        if(!Controls(player, thing)) {          notify_quiet(player, "Permission denied.");          return;        }        if ( (NoMod(thing) && !WizMod(player)) ||             (Backstage(player) && NoBackstage(thing)) ) {          notify_quiet(player, "Permission denied.");          return;        }        zlist_destroy(thing);        notify_quiet(player, "Object removed from all zones.");      }      break;    default:      notify_quiet(player, "Unknown switch!");      break;  }  return;}