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

intcmd_pfs_getid(const char *sel_path, const char *name, int privateid){	hammer2_ioc_pfs_t pfs;	int ecode = 0;	int fd;	uint32_t status;	char *pfs_id_str = NULL;	if ((fd = hammer2_ioctl_handle(sel_path)) < 0)		return(1);	bzero(&pfs, sizeof(pfs));	snprintf(pfs.name, sizeof(pfs.name), "%s", name);	if (ioctl(fd, HAMMER2IOC_PFS_LOOKUP, &pfs) < 0) {		perror("ioctl");		ecode = 1;	} else {		if (privateid)			uuid_to_string(&pfs.pfs_fsid, &pfs_id_str, &status);		else			uuid_to_string(&pfs.pfs_clid, &pfs_id_str, &status);		printf("%s/n", pfs_id_str);		free(pfs_id_str);		pfs_id_str = NULL;	}	close(fd);	return (ecode);}

mach_port_tAuthHostInstance::lookup(SessionId jobId){    StLock<Mutex> _(*this);        mach_port_t pluginhostPort = MACH_PORT_NULL;    kern_return_t result;    const char *serviceName;    /* PR-7483709 const */ uuid_t instanceId = UUID_INITIALIZER_FROM_SESSIONID(jobId);    uuid_string_t s;    if ((mHostType == securityAgent)) {	if (!(session().attributes() & sessionHasGraphicAccess))	    CssmError::throwMe(CSSM_ERRCODE_NO_USER_INTERACTION);	if (inDarkWake())	    CssmError::throwMe(CSSM_ERRCODE_IN_DARK_WAKE);    }        if (mHostType == securityAgent)	serviceName = SECURITYAGENT_BOOTSTRAP_NAME_BASE;    else	serviceName = AUTHORIZATIONHOST_BOOTSTRAP_NAME_BASE;    secdebug("AuthHostInstance", "looking up %s instance %s", serviceName,      uuid_to_string(instanceId, s)); // XXX/gh  debugging    if ((result = bootstrap_look_up3(bootstrap_port, serviceName,      &pluginhostPort, 0, instanceId, BOOTSTRAP_SPECIFIC_INSTANCE)) != KERN_SUCCESS) {        Syslog::error("error %d looking up %s instance %s", result, serviceName,	  uuid_to_string(instanceId, s));    } else	secdebug("AuthHostInstance", "port = %x", (unsigned int)pluginhostPort);    return pluginhostPort;}

int rmnode (lua_State *L) {  TreeNode *node = checktree(L, 1);  TreeNode *parent = node->parent;  int i;  char uuid_str[40];  uuid_to_string(&node->uuid, uuid_str);  printd("Removing node with uuid %s/n", uuid_str);  if (parent != NULL) {    uuid_to_string(&parent->uuid, uuid_str);    printd("Node has parent with uuid %s. Remove reference from parent's children list./n", uuid_str);    for (i = 0; i < parent->children_count; ++i) {      if (parent->children != NULL && parent->children[i] != NULL &&          0 == custom_uuid_compare(node->uuid, parent->children[i]->uuid))      {        parent->children[i] = NULL;        /* free (unref) userdata in parent node */        luaL_unref(L, LUA_REGISTRYINDEX, parent->udreflist[i]);        parent->udreflist[i] = LUA_REFNIL;      }    }  }  // free node strucrure  /* free (unref) userdata in current node */  for (i = 0; i < node->children_count; ++i) {    if (node->udreflist != NULL && node->udreflist[i] != LUA_REFNIL) {      luaL_unref(L, LUA_REGISTRYINDEX, node->udreflist[i]);      node->udreflist[i] = LUA_REFNIL;      node->children[i]->parent = NULL;    }  }  if (node->dataType == LUA_TSTRING)    free(node->data.charVal);  if (node->name)    free(node->name);  if (node->children)    free(node->children);  if (node->udreflist)    free(node->udreflist);  node->udreflist = NULL;  node->children = NULL;  node->parent = NULL;  node->name = NULL;  return 0;}

static char *_soap_addressing_generate_id(void){  uuid_t uuid;  uint32_t status;  char *ret, *buf;  uuid_create(&uuid, &status);  if (status != uuid_s_ok)  {    log_error("uuidcreate failed (%s)", _soap_addressing_uuid_error(status));    return NULL;  }  uuid_to_string(&uuid, &buf, &status);  if (status != uuid_s_ok)  {    log_error("uuid_to_string failed (%s)", _soap_addressing_uuid_error(status));    return NULL;  }  if (!(ret = (char *)malloc(128)))  {    log_error("malloc failed (%s)", strerror(errno));    free(buf);    return NULL;  }  sprintf(ret, "%s/%s", soap_server_get_name(), buf);  free(buf);  return ret;}

static void read_handler(BLECharacteristic characteristic,                         const uint8_t *value,                         size_t value_length,                         uint16_t value_offset,                         BLEGATTError error) {  char uuid_buffer[UUID_STRING_BUFFER_LENGTH];  Uuid characteristic_uuid = ble_characteristic_get_uuid(characteristic);  uuid_to_string(&characteristic_uuid, uuid_buffer);  APP_LOG(APP_LOG_LEVEL_INFO, "Read Characteristic %s, %u bytes, error: %u", uuid_buffer, value_length, error);  for (size_t i = 0; i < value_length; ++i) {    APP_LOG(APP_LOG_LEVEL_INFO, "0x%02x", value[i]);  }  	const Uuid node_service_4_uuid =				UuidMake(0x18, 0xcd, 0xa7, 0x84, 0x4b, 0xd3, 0x43, 0x70,								 0x85, 0xbb, 0xbf, 0xed, 0x91, 0xec, 0x86, 0xaf);  // node sensor data incoming  if (uuid_equal(&characteristic_uuid, &node_service_4_uuid)) {  	APP_LOG(APP_LOG_LEVEL_INFO, "Incoming sensor data...");  	if(value_length + node_ctx.read_node_buffer_pos > node_ctx.read_node_buffer_max) {  		process_read_buffer();  		node_ctx.read_node_buffer_pos = 0;  	}  	char *buff = (char *)&node_ctx.read_node_buffer;  		memcpy(buff+node_ctx.read_node_buffer_pos, value, value_length);  	  	node_ctx.read_node_buffer_pos += value_length;  }  }

voidficlUuidToString(FICL_VM *pVM){#ifndef	TESTMAIN	char	*uuid;	uint32_t status;#endif	uuid_t	*u;#if FICL_ROBUST > 1	vmCheckStack(pVM, 1, 0);#endif	u = (uuid_t *)stackPopPtr(pVM->pStack);#ifndef	TESTMAIN	uuid_to_string(u, &uuid, &status);	if (status != uuid_s_ok) {		stackPushPtr(pVM->pStack, uuid);		stackPushINT(pVM->pStack, strlen(uuid));	} else#endif		stackPushINT(pVM->pStack, -1);	return;}

static void draw_data_row(GContext* ctx, const Layer *cell_layer,                          MenuIndex *cell_index, void *data) {  ScanResult *result = list_get_by_index(cell_index->row);  // Build the title string:  char title[32];  // Annotate with "NODE" if the device has a heart rate service:  char *node_str = result->has_node_service ? "NODE" : "";  // If there is a local name, show it, otherwise use the device address:  if (strlen(result->local_name)) {    snprintf(title, sizeof(title), "%s %s", result->local_name, node_str);  } else {    const BTDeviceAddress address = bt_device_get_address(result->device);    snprintf(title, sizeof(title), BT_DEVICE_ADDRESS_FMT " %s",             BT_DEVICE_ADDRESS_XPLODE(address), node_str);  }  // Build the subtitle string:  char subtitle[UUID_STRING_BUFFER_LENGTH];  if (result->has_services) {    // Make a displayable string of the first Service UUID:    uuid_to_string(&result->first_service_uuid, subtitle);  } else {    // If advertisement did not contain Service UUIDs:    strncpy(subtitle, "No Service UUIDs", sizeof(subtitle));  }  menu_cell_basic_draw(ctx, cell_layer, title, subtitle, NULL);}

static void descriptor_write_handler(BLEDescriptor descriptor,                                     BLEGATTError error) {  char uuid_buffer[UUID_STRING_BUFFER_LENGTH];  Uuid descriptor_uuid = ble_descriptor_get_uuid(descriptor);  uuid_to_string(&descriptor_uuid, uuid_buffer);  APP_LOG(APP_LOG_LEVEL_INFO, "Write response for Descriptor %s (error=%u)", uuid_buffer, error);}

zmq::uuid_t::uuid_t (){    uint32_t status;    uuid_create (&uuid, &status);    zmq_assert (status == uuid_s_ok);    uuid_to_string (&uuid, &uuid_str, &status);    zmq_assert (status == uuid_s_ok);}

static void write_handler(BLECharacteristic characteristic,                          BLEGATTError error) {  char uuid_buffer[UUID_STRING_BUFFER_LENGTH];  Uuid characteristic_uuid = ble_characteristic_get_uuid(characteristic);  uuid_to_string(&characteristic_uuid, uuid_buffer);  APP_LOG(APP_LOG_LEVEL_INFO, "Write response for Characteristic %s (error=%u)", uuid_buffer, error);}

static intefi_print_var(CHAR16 *varnamearg, EFI_GUID *matchguid, int lflag){	UINTN		datasz, i;	EFI_STATUS	status;	UINT32		attr;	CHAR16		*data;	char		*str;	uint32_t	uuid_status;	int		is_ascii;	datasz = 0;	status = RS->GetVariable(varnamearg, matchguid, &attr,	    &datasz, NULL);	if (status != EFI_BUFFER_TOO_SMALL) {		printf("Can't get the variable: error %#lx/n", status);		return (CMD_ERROR);	}	data = malloc(datasz);	status = RS->GetVariable(varnamearg, matchguid, &attr,	    &datasz, data);	if (status != EFI_SUCCESS) {		printf("Can't get the variable: error %#lx/n", status);		return (CMD_ERROR);	}	uuid_to_string((uuid_t *)matchguid, &str, &uuid_status);	if (lflag) {		printf("%s 0x%x %S", str, attr, varnamearg);	} else {		printf("%s 0x%x %S=", str, attr, varnamearg);		is_ascii = 1;		free(str);		str = (char *)data;		for (i = 0; i < datasz - 1; i++) {			/* Quick hack to see if this ascii-ish string printable range plus tab, cr and lf */			if ((str[i] < 32 || str[i] > 126) && str[i] != 9 && str[i] != 10 && str[i] != 13) {				is_ascii = 0;				break;			}		}		if (str[datasz - 1] != '/0')			is_ascii = 0;		if (is_ascii)			printf("%s", str);		else {			for (i = 0; i < datasz / 2; i++) {				if (isalnum(data[i]) || isspace(data[i]))					printf("%c", data[i]);				else					printf("//x%02x", data[i]);			}		}	}	free(data);	if (pager_output("/n"))		return (CMD_WARN);	return (CMD_OK);}

char* pn_i_genuuid(void) {    char *generated;    uuid_t uuid;    uint32_t rc;    uuid_create(&uuid, &rc);    // Under FreeBSD the returned string is newly allocated from the heap    uuid_to_string(&uuid, &generated, &rc);    return generated;}

// ------------------------------------------------------------------------ ////  Main Functions// ------------------------------------------------------------------------ //void log_app_info() {    extern const PebbleProcessInfo __pbl_app_info;    LOG("APP Version: %d.%d", __pbl_app_info.process_version.major, __pbl_app_info.process_version.minor);    LOG("Name: %s", __pbl_app_info.name);    LOG("Company: %s", __pbl_app_info.company);    char uuidString[UUID_STRING_BUFFER_LENGTH];    uuid_to_string((Uuid*)&__pbl_app_info.uuid, uuidString);    LOG("UUID: %s", uuidString);}

static const char *uuid(uuid_t *id){	static char buffer[64];	char *s;	uuid_to_string(id, &s, NULL);	strcpy(buffer, s);	free(s);	return (buffer);}

static void subscribe_handler(BLECharacteristic characteristic,                              BLESubscription subscription_type,                              BLEGATTError error) {  char uuid_buffer[UUID_STRING_BUFFER_LENGTH];  Uuid characteristic_uuid = ble_characteristic_get_uuid(characteristic);  uuid_to_string(&characteristic_uuid, uuid_buffer);  APP_LOG(APP_LOG_LEVEL_INFO, "Subscription to Characteristic %s (subscription_type=%u, error=%u)",          uuid_buffer, subscription_type, error);}

static int hpss_get_bfid(struct fsal_obj_handle *fsal_obj_hdl,			 caddr_t buffer_addr,			 size_t buffer_size,			 size_t *p_output_size,			 void *arg){	struct hpss_fsal_obj_handle *obj_hdl;	sec_cred_t *p_ucreds = arg;	hpss_vattr_t hpss_vattr;	char *tmp_str_uuid;	int rc;	/* sanity checks. */	if (!fsal_obj_hdl || !p_output_size || !buffer_addr || !p_ucreds)		return ERR_FSAL_FAULT;	obj_hdl = container_of(fsal_obj_hdl,			       struct hpss_fsal_obj_handle,			       obj_handle);	rc = hpss_GetAttrHandle(&(obj_hdl->handle->ns_handle),				NULL,				p_ucreds,				NULL,				&hpss_vattr);	/**	 * /!/ WARNING : When the directory handle is stale, HPSS returns ENOTDIR.	 *     Thus, in this case, we must double check	 *     by checking the directory handle.	 */	if (rc == HPSS_ENOTDIR)		if (HPSSFSAL_IsStaleHandle(&obj_hdl->handle->ns_handle,					  p_ucreds))			return ERR_FSAL_STALE;	if (rc)		return hpss2fsal_error(rc);	uuid_to_string(&(hpss_vattr.va_soid.ObjectID),		      (char **)&tmp_str_uuid, &rc);	if (rc != 0)		return hpss2fsal_error(rc);	*p_output_size = snprintf(buffer_addr, buffer_size, "%s", tmp_str_uuid);	/* HPSS returns a string that it has just allocated.	 * Free it to avoid memory leak.	 */	free(tmp_str_uuid);	return 0;}

const char *dmsg_uuid_to_str(uuid_t *uuid, char **strp){	uint32_t status;	if (*strp) {		free(*strp);		*strp = NULL;	}	uuid_to_string(uuid, strp, &status);	return (*strp);}

void uuuid_to_string(struct uuuid_t* uuuid, char** out, int* status){	uint32_t st;	uuid_to_string(&uuuid->uuid, out, &st);	if (st == uuid_s_ok)		*status = UUUID_OK;	else		*status = UUUID_ERR;}

char *guul_get_uuid(){        uuid_t uuid;        uint32_t status;        char *result = NULL;        uuid_create (&uuid, &status);        uuid_to_string (&uuid, &result, &status);        return result;}

    void ConfigurationPrivate::save()    {        QMutexLocker guard(&mutex);        QString key(uuid_to_string(id));        // Read configuration        QSettings conf;        conf.beginGroup("Configurations");        conf.beginGroup(key);        QByteArray ciphertext = encryptMap(data, key);        conf.setValue("data", ciphertext);        conf.setValue("title", title);    }

const std::string uuid (){  uuid_t id;  uint32_t status;  char *buffer (0);  uuid_create (&id, &status);  uuid_to_string (&id, &buffer, &status);  std::string res (buffer);  free (buffer);  return res;}

intmain(int argc, char **argv){    char str[1000];    afsUUID u1, u2;    uuid_create(&u1);    uuid_to_string(&u1, str, sizeof(str));    printf("u: %s/n", str);    return 0;}

zmq::uuid_t::uuid_t (){#ifdef ZMQ_HAVE_HPUX    unsigned32 status;#else    uint32_t status;#endif    uuid_create (&uuid, &status);    zmq_assert (status == uuid_s_ok);    uuid_to_string (&uuid, &string_buf, &status);    zmq_assert (status == uuid_s_ok);    create_blob ();}

static Datumspecial_uuid_value(const char *name){	uuid_t	   *uuid = get_cached_uuid_t(0);	char	   *str;	uuid_rc_t	rc;	rc = uuid_load(uuid, name);	if (rc != UUID_RC_OK)		pguuid_complain(rc);	str = uuid_to_string(uuid);	return DirectFunctionCall1(uuid_in, CStringGetDatum(str));}

/* len is unused with OSSP, but we want to have the same number of args */static Datumuuid_generate_internal(int mode, const uuid_t *ns, const char *name, int len){	uuid_t	   *uuid = get_cached_uuid_t(0);	char	   *str;	uuid_rc_t	rc;	rc = uuid_make(uuid, mode, ns, name);	if (rc != UUID_RC_OK)		pguuid_complain(rc);	str = uuid_to_string(uuid);	return DirectFunctionCall1(uuid_in, CStringGetDatum(str));}

static void descriptor_read_handler(BLEDescriptor descriptor,                                    const uint8_t *value,                                    size_t value_length,                                    uint16_t value_offset,                                    BLEGATTError error) {  char uuid_buffer[UUID_STRING_BUFFER_LENGTH];  Uuid descriptor_uuid = ble_descriptor_get_uuid(descriptor);  uuid_to_string(&descriptor_uuid, uuid_buffer);  APP_LOG(APP_LOG_LEVEL_INFO, "Read Descriptor %s, %u bytes, error: %u", uuid_buffer, value_length, error);  for (size_t i = 0; i < value_length; ++i) {    APP_LOG(APP_LOG_LEVEL_INFO, "0x%02x", value[i]);  }}

/* * Create an LDAP server container entry. */static void rpc_ns__ldap_export_server(LDAP *ld,	char *dn,	rpc_if_handle_t if_spec,	unsigned32 *status	){	unsigned_char_p_t uuid = NULL;	rpc_if_id_t if_id;	LDAPMod *modV[4];	LDAPMod modRpcNsObjectID, modObjectClass;	char *valueRpcNsObjectID[2], *valueObjectClass[3];	rpc_if_inq_id(if_spec, &if_id, status);	if (*status != rpc_s_ok) {		return;	}	uuid_to_string(&if_id.uuid, &uuid, status);	if (*status != rpc_s_ok) {		return;	}	valueRpcNsObjectID[0] = uuid;	valueRpcNsObjectID[1] = NULL;	modRpcNsObjectID.mod_op = LDAP_MOD_ADD;	modRpcNsObjectID.mod_type = "rpcNsObjectID";	modRpcNsObjectID.mod_values = valueRpcNsObjectID;	valueObjectClass[0] = "rpcServer";	valueObjectClass[1] = "rpcEntry";	valueObjectClass[2] = "top";	modObjectClass.mod_op = LDAP_MOD_ADD;	modObjectClass.mod_type = "objectClass";	modObjectClass.mod_values = valueObjectClass;	modV[0] = &modRpcNsObjectID;	modV[1] = &modObjectClass;	modV[2] = NULL;	if (ldap_add_s(ld, dn, modV) != LDAP_SUCCESS) {		*status = rpc_s_update_failed;	} else {		*status = rpc_s_ok;	}	rpc_string_free(&uuid, status);}

//void node_debug(struct NodeState *nodeState, char *fmt, ...)void node_debug(struct NodeState *nodeState, ...){	va_list arg;	char s[BUFSIZE];	va_start(arg, nodeState);	char *fmt = va_arg(arg, char*);	vsnprintf(s, BUFSIZE, fmt, arg);	va_end(arg);	uuid_to_string(nodeID, nodeState->self->ID)	printf("%lld %s: %s/n", getClock(), nodeID, s);}