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

intzsock_connect (zsock_t *self, const char *format, ...){    assert (self);    assert (zsock_is (self));    //  Expand format to get full endpoint    va_list argptr;    va_start (argptr, format);    char *endpoint = zsys_vprintf (format, argptr);    va_end (argptr);    int rc = zmq_connect (self->handle, endpoint);    #if (ZMQ_VERSION < ZMQ_MAKE_VERSION (4,0,0))    int retries = 4;    while (rc == -1 && zmq_errno () == ECONNREFUSED && retries) {        //  This bruteforces a synchronization between connecting and        //  binding threads on ZeroMQ v3.2 and earlier, where the bind        //  MUST happen before the connect on inproc transports.        zclock_sleep (250);        rc = zmq_connect (self->handle, endpoint);        retries--;    }#endif    free (endpoint);    return rc;}

intzcert_save (zcert_t *self, char *format, ...){    assert (self);    assert (format);    va_list argptr;    va_start (argptr, format);    char *filename = zsys_vprintf (format, argptr);    va_end (argptr);    //  Save public certificate using specified filename    zcert_save_public (self, filename);    //  Now save secret certificate using filename with "_secret" suffix    s_save_metadata_all (self);    zconfig_comment (self->config, "   ZeroMQ CURVE **Secret** Certificate");    zconfig_comment (self->config, "   DO NOT PROVIDE THIS FILE TO OTHER USERS nor change its permissions.");    zconfig_put (self->config, "/curve/public-key", self->public_txt);    zconfig_put (self->config, "/curve/secret-key", self->secret_txt);        char filename_secret [256];    snprintf (filename_secret, 256, "%s_secret", filename);    zsys_file_mode_private ();    int rc = zconfig_save (self->config, filename_secret);    zsys_file_mode_default ();        zstr_free (&filename);    return rc;}

intzsys_dir_create (const char *pathname, ...){    va_list argptr;    va_start (argptr, pathname);    char *formatted = zsys_vprintf (pathname, argptr);    va_end (argptr);    //  Create parent directory levels if needed    char *slash = strchr (formatted + 1, '/');    while (true) {        if (slash)            *slash = 0;         //  Cut at slash        mode_t mode = zsys_file_mode (formatted);        if (mode == (mode_t)-1) {            //  Does not exist, try to create it#if (defined (__WINDOWS__))            if (!CreateDirectoryA (formatted, NULL))#else            if (mkdir (formatted, 0775))#endif                return -1;      //  Failed        }        else        if ((mode & S_IFDIR) == 0) {            //  Not a directory, abort        }        if (!slash)             //  End if last segment            break;        *slash = '/';        slash = strchr (slash + 1, '/');    }    free (formatted);    return 0;}

static char *s_vprintf (const char *format, ...){    va_list argptr;    va_start (argptr, format);    char *string = zsys_vprintf (format, argptr);    va_end (argptr);    return (string);}

voidzsys_debug (const char *format, ...){    va_list argptr;    va_start (argptr, format);    char *string = zsys_vprintf (format, argptr);    va_end (argptr);    s_log ('D', string);    free (string);}

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);}

voidzre_log_msg_set_data (zre_log_msg_t *self, char *format, ...){    //  Format data from provided arguments    assert (self);    va_list argptr;    va_start (argptr, format);    free (self->data);    self->data = zsys_vprintf (format, argptr);    va_end (argptr);}

voidzre_msg_set_ipaddress (zre_msg_t *self, const char *format, ...){    //  Format ipaddress from provided arguments    assert (self);    va_list argptr;    va_start (argptr, format);    free (self->ipaddress);    self->ipaddress = zsys_vprintf (format, argptr);    va_end (argptr);}

voidzre_msg_set_group (zre_msg_t *self, const char *format, ...){    //  Format group from provided arguments    assert (self);    va_list argptr;    va_start (argptr, format);    free (self->group);    self->group = zsys_vprintf (format, argptr);    va_end (argptr);}

voidzconfig_putf (zconfig_t *self, const char *path, const char *format, ...){    assert (self);    va_list argptr;    va_start (argptr, format);    char *value = zsys_vprintf (format, argptr);    va_end (argptr);    zconfig_put (self, path, value);    zstr_free (&value);}

voidzgossip_msg_set_value (zgossip_msg_t *self, const char *format, ...){    //  Format value from provided arguments    assert (self);    va_list argptr;    va_start (argptr, format);    free (self->value);    self->value = zsys_vprintf (format, argptr);    va_end (argptr);}

voidzauth_configure_plain (zauth_t *self, char *domain, char *filename, ...){    assert (self);    assert (domain);    va_list argptr;    va_start (argptr, filename);    char *formatted = zsys_vprintf (filename, argptr);    va_end (argptr);    zstr_sendx (self->pipe, "PLAIN", domain, formatted, NULL);    free (formatted);}

voidzyre_gossip_connect (zyre_t *self, const char *format, ...){    assert (self);    va_list argptr;    va_start (argptr, format);    char *string = zsys_vprintf (format, argptr);    va_end (argptr);    zstr_sendx (self->actor, "GOSSIP CONNECT", string, NULL);    free (string);}

voidzyre_set_announce (zyre_t *self, const char *format, ...){    assert (self);    va_list argptr;    va_start (argptr, format);    char *string = zsys_vprintf (format, argptr);    va_end (argptr);    zstr_sendx (self->actor, "SET ANNOUNCE", string, NULL);    free (string);}

voidzyre_set_header (zyre_t *self, const char *name, const char *format, ...){    assert (self);    va_list argptr;    va_start (argptr, format);    char *string = zsys_vprintf (format, argptr);    va_end (argptr);    zstr_sendx (self->actor, "SET HEADER", name, string, NULL);    free (string);}

voidzauth_configure_curve (zauth_t *self, char *domain, char *location, ...){    assert (self);    assert (domain);    assert (location);    va_list argptr;    va_start (argptr, location);    char *formatted = zsys_vprintf (location, argptr);    va_end (argptr);    zstr_sendx (self->pipe, "CURVE", domain, formatted, NULL);    free (formatted);}

intzyre_set_endpoint (zyre_t *self, const char *format, ...){    assert (self);    va_list argptr;    va_start (argptr, format);    char *string = zsys_vprintf (format, argptr);    va_end (argptr);    zstr_sendx (self->actor, "SET ENDPOINT", string, NULL);    free (string);    return zsock_wait (self->actor) == 0? 0: -1;}

voidzyre_log_connect (zyre_log_t *self, const char *format, ...){    assert (self);    if (self->publisher) {        va_list argptr;        va_start (argptr, format);        char *endpoint = zsys_vprintf (format, argptr);        va_end (argptr);        int rc = zsocket_connect (self->publisher, "%s", endpoint);        assert (rc == 0);        free (endpoint);    }}

voidzconfig_set_value (zconfig_t *self, char *format, ...){    assert (self);    free (self->value);    if (format) {        va_list argptr;        va_start (argptr, format);        self->value = zsys_vprintf (format, argptr);        va_end (argptr);    }    else        self->value = NULL;}

intzstr_sendf (void *dest, const char *format, ...){    assert (dest);    assert (format);    va_list argptr;    va_start (argptr, format);    char *string = zsys_vprintf (format, argptr);    va_end (argptr);    int rc = s_send_string (dest, false, string);    free (string);    return rc;}

zconfig_t *zconfig_loadf (const char *format, ...){    va_list argptr;    va_start (argptr, format);    char *filename = zsys_vprintf (format, argptr);    va_end (argptr);    if (filename) {        zconfig_t *config = zconfig_load (filename);        free (filename);        return config;    }    else        return NULL;}

intzstr_sendm (void *zocket, const char *format, ...){    assert (zocket);    assert (format);        va_list argptr;    va_start (argptr, format);    char *string = zsys_vprintf (format, argptr);    va_end (argptr);        int rc = s_send_string (zocket, true, string);    free (string);    return rc;}

intzconfig_savef (zconfig_t *self, const char *format, ...){    assert (self);    va_list argptr;    va_start (argptr, format);    char *filename = zsys_vprintf (format, argptr);    va_end (argptr);    if (filename) {        int rc = zconfig_save (self, filename);        zstr_free (&filename);        return rc;    }    else        return -1;}

intzsys_dir_delete (const char *pathname, ...){    va_list argptr;    va_start (argptr, pathname);    char *formatted = zsys_vprintf (pathname, argptr);    va_end (argptr);#if (defined (__WINDOWS__))    int rc = RemoveDirectoryA (formatted)? 0: -1;#else    int rc = rmdir (formatted);#endif    free (formatted);    return rc;}

zcert_t *zcert_load (char *format, ...){#if (ZMQ_VERSION_MAJOR == 4)    assert (format);    va_list argptr;    va_start (argptr, format);    char *filename = zsys_vprintf (format, argptr);    va_end (argptr);    //  Try first to load secret certificate, which has both keys    //  Then fallback to loading public certificate    char filename_secret [256];    snprintf (filename_secret, 256, "%s_secret", filename);    zconfig_t *root = zconfig_load (filename_secret);    if (!root)        root = zconfig_load (filename);            zcert_t *self = NULL;    if (root) {        char *public_text = zconfig_resolve (root, "/curve/public-key", NULL);        char *secret_text = zconfig_resolve (root, "/curve/secret-key", NULL);        if (public_text && strlen (public_text) == 40) {            byte public_key [32] = { 0 };            byte secret_key [32] = { 0 };            zmq_z85_decode (public_key, public_text);            if (secret_text && strlen (secret_text) == 40)                zmq_z85_decode (secret_key, secret_text);            //  Load metadata into certificate            self = zcert_new_from (public_key, secret_key);            zconfig_t *metadata = zconfig_locate (root, "/metadata");            zconfig_t *item = metadata? zconfig_child (metadata): NULL;            while (item) {                zcert_set_meta (self, zconfig_name (item), zconfig_value (item));                item = zconfig_next (item);            }        }    }    zconfig_destroy (&root);    zstr_free (&filename);    return self;#else       return NULL;#endif}

zcertstore_t *zcertstore_new (char *location, ...){    zcertstore_t *self = (zcertstore_t *) zmalloc (sizeof (zcertstore_t));    assert (self);        self->cert_list = zlist_new ();    self->cert_hash = zhash_new ();    if (location) {        va_list argptr;        va_start (argptr, location);        self->location = zsys_vprintf (location, argptr);        va_end (argptr);        s_load_certs_from_disk (self);    }    return self;}

voidzhash_comment (zhash_t *self, const 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);}

intzyre_shouts (zyre_t *self, const char *group, const char *format, ...){    assert (self);    assert (group);    assert (format);    va_list argptr;    va_start (argptr, format);    char *string = zsys_vprintf (format, argptr);    va_end (argptr);    zstr_sendm (self->actor, "SHOUT");    zstr_sendm (self->actor, group);    zstr_send  (self->actor, string);    free (string);    return 0;}

voidzre_msg_groups_append (zre_msg_t *self, const char *format, ...){    //  Format into newly allocated string    assert (self);    va_list argptr;    va_start (argptr, format);    char *string = zsys_vprintf (format, argptr);    va_end (argptr);    //  Attach string to list    if (!self->groups) {        self->groups = zlist_new ();        zlist_autofree (self->groups);    }    zlist_append (self->groups, string);    free (string);}

voidzre_msg_headers_insert (zre_msg_t *self, const char *key, const char *format, ...){    //  Format into newly allocated string    assert (self);    va_list argptr;    va_start (argptr, format);    char *string = zsys_vprintf (format, argptr);    va_end (argptr);    //  Store string in hash table    if (!self->headers) {        self->headers = zhash_new ();        zhash_autofree (self->headers);    }    zhash_update (self->headers, key, string);    free (string);}