C++ FORMAT函数代码示例

static ssize_t data_file_t_convert_from(data_t *data, fastcall_convert_from *fargs){ // {{{
	ssize_t                ret;
	
	if(fargs->src == NULL)
		return -EINVAL; 
		
	switch(fargs->format){
		case FORMAT(config):;
		case FORMAT(human):;
		case FORMAT(native):;
			request_t r_config[] = {
				{ HK(filename), *fargs->src },
				hash_end
			};
			return file_new((file_t **)&data->ptr, r_config);

		case FORMAT(hash):;
			hash_t            *config;
			
			data_get(ret, TYPE_HASHT, config, fargs->src);
			if(ret != 0)
				return -EINVAL;
			
			return file_new((file_t **)&data->ptr, config);
			
		default:
			break;
	};
	return -ENOSYS;
} // }}}

static ssize_t data_length_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
	ssize_t                ret;
	length_t              *fdata;
	
	if(dst->ptr != NULL)
		return -EINVAL;
	
	switch(fargs->format){
		case FORMAT(hash):;
			hash_t                *config;
			
			data_get(ret, TYPE_HASHT, config, fargs->src);
			if(ret != 0)
				return ret;
			
			if( (fdata = malloc(sizeof(length_t))) == NULL)
				return -ENOMEM;
			
			hash_holder_consume(ret, fdata->data, config, HK(data));
			if(ret != 0){
				free(fdata);
				return -EINVAL;
			}
			
			fdata->format = FORMAT(clean);
			hash_data_get(ret, TYPE_FORMATT, fdata->format, config, HK(format));
			
			dst->ptr = fdata;
			return 0;
			
		default:
			break;
	}
	return -ENOSYS;
} // }}}

/*static ssize_t data_env_t_copy(data_t *src, fastcall_copy *fargs){ // {{{
	env_t                 *fdata             = (env_t *)src->ptr;
	env_t                 *new_fdata         = NULL;
	
	if(fargs->dest == NULL)
		return -EINVAL;
	
	if(fdata){
		if( (new_fdata = malloc(sizeof(env_t))) == NULL)
			return -EINVAL;
		
		new_fdata->key = fdata->key;
	}
	fargs->dest->type = src->type;
	fargs->dest->ptr  = new_fdata;
	return 0;
} // }}}*/
static ssize_t data_env_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
	ssize_t                ret;
	env_t                 *fdata;
	
	if(dst->ptr != NULL)
		return data_env_t_handler(dst, (fastcall_header *)fargs);  // already inited - pass to underlying data
	
	if(fargs->src == NULL)
		return -EINVAL;
	
	if( (ret = data_env_t_alloc(dst, NULL)) != 0)
		return ret;
	
	fdata = (env_t *)dst->ptr;
	
	switch(fargs->format){
		case FORMAT(config):;
		case FORMAT(human):;
			data_t                 hkey              = DATA_PTR_HASHKEYT(&fdata->key);
			
			fastcall_convert_from r_convert = { { 4, ACTION_CONVERT_FROM }, fargs->src, fargs->format };
			return data_query(&hkey, &r_convert);
			
		default:
			break;
	}
	return -ENOSYS;
} // }}}

	String Object::getString() const
	{
		switch (this->getNativeType())
		{
		default:
			throw ObjectConversionException(FORMAT("Unknown DataType %u", this->getNativeType()));

		case NIL:
			return "";

		case BOOLEAN:
			return this->data.boolean ? "true" : "false";

		case NUMBER:
			return FORMAT("%f", this->data.number);

		case ADDRESS:
			return FORMAT("%u", this->data.address);

		case STRING:
			return this->data.string;

		case USERDATA:
		{
			std::stringstream ss;
			ss << this->data.userdata;
			return ss.str();
		}
		}
	}

static ssize_t data_timestamp_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
	char                   buffer[DEF_BUFFER_SIZE] = { 0 };
	timestamp_t           *fdata;
	
	if(fargs->src == NULL)
		return -EINVAL;
	
	if(dst->ptr == NULL){ // no buffer, alloc new
		if(data_timestamp_t_alloc(dst, NULL) != 0)
			return -ENOMEM;
	}
	
	fdata = (timestamp_t *)dst->ptr;
	switch( fargs->format ){
		case FORMAT(config):;
		case FORMAT(human):;
			fastcall_read r_read_str = { { 5, ACTION_READ }, 0, &buffer, sizeof(buffer) - 1 };
			if(data_query(fargs->src, &r_read_str) != 0)
				return -EFAULT;
			return timestamp_from_string(&fdata->time, buffer, r_read_str.buffer_size);
		
		case FORMAT(clean):;
		case FORMAT(binary):;
			fastcall_read r_read = { { 5, ACTION_READ }, 0, &fdata->time, sizeof(fdata->time) };
			return data_query(fargs->src, &r_read);
		
		default:
			break;
	};
	return -ENOSYS;
} // }}}

void TOptions::LogOptions(TLogOptionEvent OnLogOption)
{
  for (size_t Index = 0; Index < FOriginalOptions.size(); ++Index)
  {
    const TOption & Option = FOriginalOptions[Index];
    UnicodeString LogStr;
    switch (Option.Type)
    {
      case otParam:
        LogStr = FORMAT(L"Parameter: %s", Option.Value.c_str());
        assert(Option.Name.IsEmpty());
        break;

      case otSwitch:
        LogStr =
          FORMAT(L"Switch:    %c%s%s%s",
            FSwitchMarks[1], Option.Name.c_str(), (Option.Value.IsEmpty() ? UnicodeString() : FSwitchValueDelimiters.SubString(1, 1)).c_str(), Option.Value.c_str());
        break;

      default:
        FAIL;
        break;
    }
    OnLogOption(LogStr);
  }
}

static ssize_t timestamp_to_string(time_t time, char *string, size_t *string_size, format_t format){ // {{{
	ssize_t                ret;
	intmax_t               time_format       = -1;
	struct tm              timetm;
	
	if(gmtime_r(&time, &timetm) == NULL)
		return -EINVAL;
	
	switch(format){
		case FORMAT(human):
		case FORMAT(time_rfc2822):      if(time_format == -1) time_format = 0;
		case FORMAT(time_rfc3339):      if(time_format == -1) time_format = 1;
		case FORMAT(time_slash_dmyhms): if(time_format == -1) time_format = 2;
		case FORMAT(time_slash_dmyhm):  if(time_format == -1) time_format = 3;
		case FORMAT(time_slash_dmy):    if(time_format == -1) time_format = 4;
		case FORMAT(time_dot_dmyhms):   if(time_format == -1) time_format = 5;
		case FORMAT(time_dot_dmyhm):    if(time_format == -1) time_format = 6;
		case FORMAT(time_dot_dmy):      if(time_format == -1) time_format = 7;
		case FORMAT(time_unix):         if(time_format == -1) time_format = 8;
		default:
			if(time_format == -1)
				break;
			
			if( (ret = strftime(string, *string_size, time_formats[time_format], &timetm)) == 0)
				return -EFAULT;
			
			*string_size = ret;
			return 0;
	}
	return -ENOSYS;
} // }}}

static ssize_t data_timestamp_t_convert_to(data_t *src, fastcall_convert_to *fargs){ // {{{
	ssize_t                ret;
	char                   buffer[DEF_BUFFER_SIZE];
	uintmax_t              buffer_size       = sizeof(buffer);
	uintmax_t              transfered        = 0;
	timestamp_t           *fdata             = (timestamp_t *)src->ptr;
	time_t                 time_val          = timestamp_gettime(fdata);
	
	if(fargs->dest == NULL || fdata == NULL)
		return -EINVAL;
	
	switch( fargs->format ){
		case FORMAT(native):;
		case FORMAT(packed):;
			fastcall_write r_write = { { 5, ACTION_WRITE }, 0, &time_val, sizeof(time_val) };
			ret        = data_query(fargs->dest, &r_write);
			transfered = r_write.buffer_size;
			break;
		
		default:
			if( (ret = timestamp_to_string(time_val, buffer, &buffer_size, fargs->format)) != 0)
				return ret;
			
			fastcall_write r_write2 = { { 5, ACTION_WRITE }, 0, &buffer, buffer_size };
			ret        = data_query(fargs->dest, &r_write2);
			transfered = r_write.buffer_size;
			break;
	}
	if(fargs->header.nargs >= 5)
		fargs->transfered = transfered;
	
	return ret;
} // }}}

//---------------------------------------------------------------------------
UnicodeString __fastcall TPropertiesDialog::LoadRemoteToken(
  const TRemoteToken & Token)
{
  UnicodeString Result;
  if (FUserGroupByID)
  {
    if (Token.IDValid)
    {
      if (Token.NameValid)
      {
        Result = FORMAT(L"%s [%d]", (Token.Name, int(Token.ID)));
      }
      else
      {
        Result = FORMAT(L"[%d]", (int(Token.ID)));
      }
    }
    else
    {
      // be it valid or not
      Result = Token.Name;
    }
  }
  else
  {
    // what if name is not filled in?
    Result = Token.Name;
  }
  return Result;
}

std::string Media::mimetype(Format f) const{
    if(f == Track::Vorbis) return "audio/ogg";
    if(f == Track::MP3) return "audio/mpeg";
    FORMAT(".aiff", "audio/aiff")
    FORMAT(".flac", "audio/flac")
    FORMAT(".wav", "audio/wav")
    return "application/octet-stream";
}

static ssize_t data_list_t_convert_to(data_t *src, fastcall_convert_to *fargs){ // {{{
	ssize_t                ret               = 0;
	ssize_t                qret;
	list_chunk_t          *chunk;
	list_t                *fdata             = (list_t *)src->ptr;
	data_t                 sl_output         = DATA_SLIDERT(fargs->dest, 0);
	
	switch(fargs->format){
		case FORMAT(packed):;
			for(chunk = fdata->head; chunk; chunk = chunk->cnext){
				// remove ref_t from top
				hash_t           r_key[] = {
					{ 0, DATA_HASHKEYT(HK(data)) },
					hash_end
				};
				data_t           d_key     = DATA_PTR_HASHT(r_key);
				fastcall_control r_control = {
					{ 5, ACTION_CONTROL },
					HK(data),
					&d_key,
					NULL
				};
				if( (ret = data_query(&chunk->data, &r_control)) < 0)
					break;
				
				data_t         d_data             = DATA_PTR_DATAT(r_control.value);
				
				fastcall_convert_to r_convert = { { 5, ACTION_CONVERT_TO }, &sl_output, FORMAT(packed) };
				ret = data_query(&d_data, &r_convert);
				
				data_slider_t_set_offset(&sl_output, r_convert.transfered, SEEK_CUR);
				
				if(ret < 0)
					break;
			}
			
			// terminate list
			data_t                 terminator         = { TYPE_LISTENDT, NULL };
			data_t                 d_data             = DATA_PTR_DATAT(&terminator);
			
			fastcall_convert_to r_convert = { { 5, ACTION_CONVERT_TO }, &sl_output, FORMAT(packed) };
			qret = data_query(&d_data, &r_convert);
			
			data_slider_t_set_offset(&sl_output, r_convert.transfered, SEEK_CUR);
			
			if(qret < 0)
				ret = qret;
			break;
			
		default:
			return -ENOSYS;
	}
	if(fargs->header.nargs >= 5)
		fargs->transfered = data_slider_t_get_offset(&sl_output);
	
	return ret;
} // }}}

const NAString QualifiedName::getQualifiedNameAsAnsiNTFilenameString() const
{
  // Preallocate a result buffer that'll be big enough most of the time
  // (so += won't reallocate+copy most of the time).
  NAString result((NASize_T)40, CmpCommon::statementHeap());

  NAString catName(CmpCommon::statementHeap());
  NAString schName(CmpCommon::statementHeap());
  NAString objName(CmpCommon::statementHeap());

  formatAsAnsiIdentifier = TRUE;	// put quotes on delimited identifiers

  if ( NOT getCatalogName().isNull() ) {
    catName = FORMAT(getCatalogName());
    makeSafeFilenamePart(catName, "SQLMX_DEFAULT_CATALOG_");
  }
  if ( NOT getSchemaName().isNull() ) {
    schName = FORMAT(getSchemaName());
    makeSafeFilenamePart(schName, "SQLMX_DEFAULT_SCHEMA_");
  }
  if ( NOT getObjectName().isNull() ) {
    objName = FORMAT(getObjectName());
  }
  makeSafeFilenamePart(objName, "SQLMX_DEFAULT_FILE_");

  formatAsAnsiIdentifier = FALSE;	// reset to initial value

  size_t totlen = catName.length() + schName.length() + objName.length() + 2;

  if ( totlen > 255 ) {					// need to truncate
    // +1 so round off doesn't give us less than what we need to chop
    size_t chopLen = totlen - 255 + 1;  
             
    if ( catName.length() - chopLen/2 <= 0 )		// cat too short
      schName.remove( schName.length() - chopLen );
    else if ( schName.length() - chopLen/2 <= 0 )	// sch too short
      catName.remove( catName.length() - chopLen );
    else {						// chop from both
      // remember position starts at 0 and length is 1 more
      chopLen /= 2;
      catName.remove( catName.length() - chopLen - 1 );
      schName.remove( schName.length() - chopLen - 1 );
    }
  }

  if (NOT catName.isNull()) {
    result = catName;
    result += ".";
  }
  if (NOT schName.isNull()) {
    result += schName;
    result += ".";
  }
  result += objName;

  return result;
}

inline int __checkString (const wchar_t* __str)
{
    wchar_t* __charIterator;
    for (__charIterator = (wchar_t*)__str; *__charIterator; __charIterator++)
    {
		if (FORMAT(*__charIterator) < START_SYMBOL || FORMAT(*__charIterator) > STOP_SYMBOL)
			return 0;
    }
    return 1;
}

static ssize_t data_uint16_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
	ssize_t                ret;
	char                  *endptr;
	char                   buffer[DEF_BUFFER_SIZE];
	uintmax_t              transfered                = 0;
	
	if(fargs->src == NULL)
		return -EINVAL;
	
	#ifndef OPTIMIZE_UINT
	if(dst->ptr == NULL){ // no buffer, alloc new
		if( (dst->ptr = malloc(sizeof(uint16_t))) == NULL)
			return -ENOMEM;
	}
	#endif

	switch( fargs->format ){
		case FORMAT(config):;
		case FORMAT(human):; // TODO fix it for slider_t 
			fastcall_read r_read_str = { { 5, ACTION_READ }, 0, &buffer, sizeof(buffer) - 1 };
			if( (ret = data_query(fargs->src, &r_read_str)) < 0){
				// TODO memleak
				return ret;
			}
			buffer[r_read_str.buffer_size] = '\0';

			SET_TYPE_UINT16T(dst) = (void *)((uintmax_t)((uint16_t )strtoul(buffer, &endptr, 10)));
			transfered = (endptr - buffer);
			break;

		case FORMAT(native):;
		case FORMAT(packed):;
			if(fargs->src->type == dst->type){
				SET_TYPE_UINT16T(dst) = (void *)((uintmax_t) DEREF_TYPE_UINT16T(fargs->src));
				ret = 0;
			}else{
				fastcall_read r_read = { { 5, ACTION_READ }, 0, &buffer, sizeof(uint16_t) };
				if( (ret = data_query(fargs->src, &r_read)) < 0){
					// TODO memleak
					return ret;
				}
				
				SET_TYPE_UINT16T(dst) = (void *)((uintmax_t)(*((uint16_t *)buffer)));
			}
			transfered = sizeof(uint16_t);
			break;
			
		default:
			return -ENOSYS;
	};
	if(fargs->header.nargs >= 5)
		fargs->transfered = transfered;
	
	return 0;
} // }}}

static void *thread_get_geoloc(void *vargs)
{
    struct cb_args *a = (struct cb_args *) vargs;
    struct geoip *g = geoip_get_info(a->ip, 0);

    enum e_status i_status = a->status;
    const char *s_status = a->status & STATUS_AFK ? "AFK" :
        i_status & STATUS_PLAYING ? "playing" :
        i_status & STATUS_SHOP ? "in shop" :
        i_status & STATUS_INVENTORY ? "in inventory" :
        i_status & STATUS_ROOM ? "in a room" :
        i_status & STATUS_LOBBY ? "in lobby" :
        i_status & STATUS_ONLINE ? "connecting" :
        "offline"; /* wut ? impossible !§§!§ */

    if (a->nick_to == NULL || a->jid_to == NULL)
    {
        if (g == NULL)
            printf("ip:%s is %s\n", a->ip, s_status);
        else
        {
            printf("ip:%s (%s) is %s\n", a->ip, g->country_name, s_status);
            geoip_free(g);
        }
    }
    else
    {
        int r = time(NULL) % 3;
        const char *format = r == 0 ? "He's from %s... currently %s" :
            r == 1 ? "That's a guy from %s. He is %s" :
            "I met him in %s but now he's %s";

        char *message;

        if (g == NULL)
            FORMAT(message, "He's %s", s_status);
        else
        {
            FORMAT(message, format, g->country_name, s_status);
            geoip_free(g);
        }

        xmpp_send_message(a->nick_to, a->jid_to, message);

        free(message);
    }

    free(a->ip);
    free(a->nick_to);
    free(a->jid_to);
    free(a);

    pthread_exit(NULL);
}