std::string JsonUtils::MapLayerJson(const MapLayerJSConfig::Layer& layer, const DbHeader& db_header, const std::string& locale) { // Get the legend for the specified locale. const LegendLocale& legend_locale = layer.legend_.GetLegendLocale(locale); // Create the map of field name-value pairs for the output JSON. std::string icon_name = "icons/" + legend_locale.icon.GetValue().LegendHref(); bool is_imagery = (layer.type_ == MapLayerJSConfig::Layer::Imagery); double opacity = 1.0; std::map<std::string, std::string> field_map; field_map["id"] = Itoa(layer.channel_id_); field_map["version"] = Itoa(layer.index_version_); field_map["label"] = Quoted(legend_locale.name.GetValue()); field_map["icon"] = Quoted(icon_name); field_map["initialState"] = JsonUtils::JsonBool(legend_locale.isChecked.GetValue()); field_map["isPng"] = JsonUtils::JsonBool(!is_imagery); field_map["opacity"] = DoubleToString(opacity); field_map["requestType"] = Quoted( MapLayerRequestType(db_header.is_mercator_, layer)); // TODO: add new locale fields // opacity (needs locale entry and ui) // look_at (needs ui) std::string lookAt(legend_locale.lookAt.GetValue().utf8()); field_map["lookAt"] = JsonUtils::LookAtJson(lookAt); return JsonObject(field_map); }
ErrInf::ErrInf(const char *str, StreamManip &manip) { char tmp[256]; reason = string(str).append("\nIt occured in line "); reason.append(Itoa(manip.GetLine(), &tmp[0], 10)); reason.append(" position "); reason.append(Itoa(manip.GetPos(), &tmp[0], 10)); reason.append("\n"); };
void CfgLoad() { std::strcpy(cfgW, Itoa(get_config_int("gfxmode", "width", 640)).c_str()); std::strcpy(cfgH, Itoa(get_config_int("gfxmode", "height", 480)).c_str()); cfgFull = get_config_int("gfxmode", "fullscreen", 0); cfgZoom = get_config_int("gfxmode", "zoomin", 0); LoadControls(); }
int main(void) { Itoa(123456789, BUFFER, BUFFER_SIZE); printf("%s\n", BUFFER); Itoa(0, BUFFER, 256); printf("%s\n", BUFFER); getchar(); return 0; }
const char* PacketLogger::UserIDTOString(unsigned char Id) { // Users should override this static char str[256]; Itoa(Id, str, 10); return (const char*) str; }
void SystemAddress::ToString(bool writePort, char *dest) const { if (*this==UNASSIGNED_SYSTEM_ADDRESS) { strcpy(dest, "UNASSIGNED_SYSTEM_ADDRESS"); return; } #if defined(_XBOX) || defined(X360) #else in_addr in; in.s_addr = binaryAddress; // cellSysmoduleLoadModule(CELL_SYSMODULE_NETCTL); // sys_net_initialize_network(); const char *ntoaStr = inet_ntoa( in ); strcpy(dest, ntoaStr); if (writePort) { strcat(dest, ":"); Itoa(port, dest+strlen(dest), 10); } #endif }
// Test the CachedReadAccessor Pread() method. // This is the main method exposed by CachedReadAccessor. bool TestCachedReadAccessorPreadPerformance() { uint32 segment_id = 0; // Read request that is contained in 1 block. FileBundleReaderSegment segment(file_pool_, path_base_, segment_names_[segment_id], segment_names_[segment_id], segment_id); uint32 request_count = 1500; // typical 1500B for some Fusion packets. uint32 best_mb_per_sec = 0; uint32 best_kilobytes = 0; for(uint32 bytes = 1 << 14; bytes < 1 << 22; bytes <<= 1) { uint32 kilobytes = bytes / 1024; std::string prefix = "Cached read 2x " + Itoa(kilobytes) + "KB"; uint32 mb_per_sec = TestReadAll(segment, request_count, 2, bytes, prefix); if (mb_per_sec > best_mb_per_sec) { best_mb_per_sec = mb_per_sec; best_kilobytes = kilobytes; } } uint32 uncached_mb_per_sec = TestReadAll(segment, request_count, 0, 0, std::string("Uncached read")); if (best_mb_per_sec > uncached_mb_per_sec) { std::cerr << "Cached is optimal " << best_mb_per_sec << " MB/sec cached with " << best_kilobytes << "KB buffers vs Uncached " << uncached_mb_per_sec << " MB/sec" << std::endl; } else { std::cerr << "Uncached is optimal " << uncached_mb_per_sec << " MB/sec vs Cached " << best_mb_per_sec << " MB/sec with " << best_kilobytes << "KB buffers" << std::endl; } return true; }
const char *SystemAddress::ToString(bool writePort) const { if (*this==UNASSIGNED_SYSTEM_ADDRESS) return "UNASSIGNED_SYSTEM_ADDRESS"; #ifdef _XBOX360 return ""; #else static unsigned char strIndex=0; static char str[8][22]; in_addr in; in.s_addr = binaryAddress; strcpy(str[strIndex], inet_ntoa( in )); if (writePort) { strcat(str[strIndex], ":"); Itoa(port, str[strIndex]+strlen(str[strIndex]), 10); } unsigned char lastStrIndex=strIndex; strIndex++; if (strIndex==8) strIndex=0; return (char*) str[lastStrIndex]; #endif }
string Lex_Result::ToString() { char tmp[256]; string res; res.append(" res_type ") .append(max<double>(13 - strlen(type_names[res_type]), 0), ' ') .append(type_names[res_type]); res.append(" res_int ").append(Itoa(res_int, tmp, 10)); res.append(" res_val ").append(Gcvt(res_val, 12, tmp)); res.append(" res_str ").append(res_str).append("\n"); return res; }
void Painting::SetParameter(std::string p, std::string v) { if(p == "file") { file = std::atoi(v.c_str()); std::string canvasFileName = "saves/game"; canvasFileName += Itoa(file + 1); canvasFileName += ".bmp"; canvas = load_bitmap(canvasFileName.c_str(), 0); return; } Entity::SetParameter(p, v); }
std::string JsonUtils::LookAtJson(const std::string& lookAtSpec) { if (lookAtSpec.empty()) return Quoted(std::string("none")); // LookAtSpec format is : // longitude|latitude|altitude|... // we only care for these 3. std::vector<std::string> tokens; TokenizeString(lookAtSpec, tokens, "|"); double altitude = strtod(tokens[2].c_str(), NULL); int zoomLevel = AltitudeToZoomLevel(altitude); // Create the map of field name-value pairs for the output JSON. std::map<std::string, std::string> field_map; field_map["lat"] = tokens[1]; field_map["lng"] = tokens[0]; field_map["zoom"] = Itoa(zoomLevel); field_map["altitude"] = DoubleToString(altitude); return JsonObject(field_map); }
int IsPalindrome(int num) { char *str = (char *) malloc(2*DIGITS); //printf("IsPalindrome num = %d\n",num); Itoa(num, str); int len = strlen(str); //printf("IsPalindrome str = %s\n",str); int start = 0; int end = len-1; while(start < end) { if(str[start] != str[end]) { return 0; } start++; end--; } return 1; }
RNS2BindResult RNS2_Berkley::BindSharedIPV4And6( RNS2_BerkleyBindParameters *bindParameters, const char *file, unsigned int line ) { (void) file; (void) line; (void) bindParameters; #if RAKNET_SUPPORT_IPV6==1 int ret=0; struct addrinfo hints; struct addrinfo *servinfo=0, *aip; // will point to the results PrepareAddrInfoHints2(&hints); hints.ai_family=bindParameters->addressFamily; char portStr[32]; Itoa(bindParameters->port,portStr,10); // On Ubuntu, "" returns "No address associated with hostname" while 0 works. if (bindParameters->hostAddress && (_stricmp(bindParameters->hostAddress,"UNASSIGNED_SYSTEM_ADDRESS")==0 || bindParameters->hostAddress[0]==0)) { getaddrinfo(0, portStr, &hints, &servinfo); } else { getaddrinfo(bindParameters->hostAddress, portStr, &hints, &servinfo); } // Try all returned addresses until one works for (aip = servinfo; aip != NULL; aip = aip->ai_next) { // Open socket. The address type depends on what // getaddrinfo() gave us. rns2Socket = socket__(aip->ai_family, aip->ai_socktype, aip->ai_protocol); if (rns2Socket == -1) return BR_FAILED_TO_BIND_SOCKET; ret = bind__(rns2Socket, aip->ai_addr, (int) aip->ai_addrlen ); if (ret>=0) { // Is this valid? memcpy(&boundAddress.address.addr6, aip->ai_addr, sizeof(boundAddress.address.addr6)); freeaddrinfo(servinfo); // free the linked-list SetSocketOptions(); SetNonBlockingSocket(bindParameters->nonBlockingSocket); SetBroadcastSocket(bindParameters->setBroadcast); GetSystemAddressIPV4And6( rns2Socket, &boundAddress ); return BR_SUCCESS; } else { closesocket__(rns2Socket); } } return BR_FAILED_TO_BIND_SOCKET; #else return BR_REQUIRES_RAKNET_SUPPORT_IPV6_DEFINE; #endif }
enum Command getCommand() { unsigned char getAngleX[] = {"getanglex"}; unsigned char getAngleY[] = {"getangley"}; unsigned char getAngleZ[] = {"getanglez"}; unsigned char getOsTime[] = {"getostime\0"}; unsigned char getDistanceToGround[] = {"getdtg"}; unsigned char getAllCommands0[] = {"?"}; unsigned char getAllCommands1[] = {"--help"}; unsigned char getAllCommands2[] = {"--h"}; unsigned char getStatusAllTasks[] = {"getstatustasks"}; unsigned char stopTaskWithId[] = {"stoptask"}; unsigned char* lrc = lastReceivedCommand(); char c2[10]; Itoa(Strlen(lrc),c2,10); WriteDebugInfo(c2); WriteDebugInfo("<-\n\r"); Itoa(Strlen(stopTaskWithId),c2,10); WriteDebugInfo(c2); WriteDebugInfo(lrc); WriteDebugInfo("<-\n\r"); //check if there are spaces in lrc int i; int spacePosition[COMMANDLENGTH]; int amountOfSpaces = 0; int lengthLrc = Strlen(lrc); for (i=0;i<lengthLrc;i++) { if (lrc[i] == ' ') { spacePosition[amountOfSpaces] = i; amountOfSpaces++; } } //get first command unsigned char firstCommand[spacePosition[0]+1]; if (amountOfSpaces > 0) { int j; for (j=0;j<spacePosition[0];j++) { firstCommand[j] = lrc[j]; } firstCommand[j] = '\0'; } if (sameString(getAngleX,lrc)) { return CommandRotationX; } else if (sameString(getAngleY,lrc)) { return CommandRotationY; } else if (sameString(getAngleZ,lrc)) { return CommandRotationZ; } else if (sameString(getOsTime,lrc)) { return commandOsTime; } else if (sameString(getDistanceToGround,lrc)) { return commandDistanceToGround; } else if (sameString(getAllCommands0,lrc) || sameString(getAllCommands1,lrc) || sameString(getAllCommands2,lrc)) { return CommandHelp; } else if (sameString(getStatusAllTasks,lrc)) { return CommandAllTaskStatus; } else if (sameString(stopTaskWithId,firstCommand)) { //get fisrt parameter unsigned char firstParam[spacePosition[1]-(spacePosition[0])]; if (amountOfSpaces > 1) { int j; for (j=spacePosition[1]+1;j<spacePosition[1]-(spacePosition[0]);j++) { firstParam[j-spacePosition[0]+1] = lrc[j-spacePosition[0]]; } firstParam[j-spacePosition[0]] = '\0'; } char c[10]; Itoa(spacePosition[1],c,10); getFirstParameter(firstParam); return CommandStopTaskWithId; } else if (lrc[0] != '\0'){ WriteDebugInformation(lrc,DirectDebug); WriteDebugInformation("Not a valid command.\n\r/>", DirectDebug); clearLastCommand(); } return CommandNoCommand; }
int Printf (char* messageVoulu, ...){ int i = 0, j = 0, k; int variable, nbArg; char *value; char buffer[MAX_LENGTH]; int alloue = 0; arg_list alist; alist = arg_start (); nbArg = 0; // tant que l'on est pas a la fin du message while (messageVoulu[i] != '\0') { // si on a un %, il faut recuperer la variable // la transformer en chaine et la rajouter au resultat if (messageVoulu[i] == '%') { nbArg++; if (nbArg < 4) { i++; variable = arg_arg (alist); switch (messageVoulu[i]) { case 'd': // un entier value = Itoa (variable); alloue = 1; break; case 'i': value = Itoa (variable); alloue = 1; break; case 'c': value = malloc(2*sizeof(char)); if(value == 0) return -1; value[0] = (char) variable; value[1] = '\0'; alloue = 1; break; case 's': // un string value = (char*) variable; break; default: PutString("argument %"); PutChar(messageVoulu[i]); PutString(" invalide\n"); return -1; break; } k = 0; while (value[k] != '\0') { buffer[j] = value[k]; j++; k++; } } else // si on veut lire un 4eme argument { if(alloue) free(value); arg_end(alist); return -1; } } else { buffer[j] = messageVoulu[i]; j++; } i++; } PutString(buffer); // on vide le buffer (sinon, il y a des affichages en trop for (i = 0; i < MAX_LENGTH; i++) { buffer[i] = '\0'; } if(alloue) free(value); arg_end(alist); return 0; }