float EditorQuickOpen::_path_cmp(String search, String path) const { if (search == path) { return 1.2f; } if (path.findn(search) != -1) { return 1.1f; } return path.to_lower().similarity(search.to_lower()); }
String MimeManager::standardiseValue(const String &value) { String standardised = value; standardised.to_lower(); standardised.trim(_S(".")); return standardised; }
static String _fixstr(const String& p_what,const String& p_str) { if (p_what.findn("$"+p_str)!=-1) //blender and other stuff return p_what.replace("$"+p_str,""); if (p_what.to_lower().ends_with("-"+p_str)) //collada only supports "_" and "-" besides letters return p_what.substr(0,p_what.length()-(p_str.length()+1)); return p_what; }
static bool _teststr(const String& p_what,const String& p_str) { if (p_what.findn("$"+p_str)!=-1) //blender and other stuff return true; if (p_what.to_lower().ends_with("-"+p_str)) //collada only supports "_" and "-" besides letters return true; return false; }
void ResourceFormatImporter::get_importers_for_extension(const String &p_extension, List<Ref<ResourceImporter> > *r_importers) { for (int i = 0; i < importers.size(); i++) { List<String> local_exts; importers[i]->get_recognized_extensions(&local_exts); for (List<String>::Element *F = local_exts.front(); F; F = F->next()) { if (p_extension.to_lower() == F->get()) { r_importers->push_back(importers[i]); } } } }
String RenameDialog::_postprocess(const String &subject) { int style_id = opt_style->get_selected(); String result = subject; if (style_id == 1) { // CamelCase to Under_Line result = result.camelcase_to_underscore(true); result = _regex("_+", result, "_"); } else if (style_id == 2) { // Under_Line to CamelCase RegEx pattern("_+(.?)"); Array matches = pattern.search_all(result); // _ name would become empty. Ignore if (matches.size() && result != "_") { String buffer; int start = 0; int end = 0; for (int i = 0; i < matches.size(); ++i) { start = ((Ref<RegExMatch>)matches[i])->get_start(1); buffer += result.substr(end, start - end - 1); buffer += result.substr(start, 1).to_upper(); end = start + 1; } buffer += result.substr(end, result.size() - (end + 1)); result = buffer.replace("_", "").capitalize(); } } int case_id = opt_case->get_selected(); if (case_id == 1) { // To Lowercase result = result.to_lower(); } else if (case_id == 2) { // To Upercase result = result.to_upper(); } return result; }
Ref<ResourceImporter> ResourceFormatImporter::get_importer_by_extension(const String &p_extension) const { Ref<ResourceImporter> importer; float priority = 0; for (int i = 0; i < importers.size(); i++) { List<String> local_exts; importers[i]->get_recognized_extensions(&local_exts); for (List<String>::Element *F = local_exts.front(); F; F = F->next()) { if (p_extension.to_lower() == F->get() && importers[i]->get_priority() > priority) { importer = importers[i]; priority = importers[i]->get_priority(); } } } return importer; }
Color Color::named(const String &p_name) { if (_named_colors.empty()) _populate_named_colors(); // from color_names.inc String name = p_name; // Normalize name name = name.replace(" ", ""); name = name.replace("-", ""); name = name.replace("_", ""); name = name.replace("'", ""); name = name.replace(".", ""); name = name.to_lower(); const Map<String, Color>::Element *color = _named_colors.find(name); if (color) { return color->value(); } else { ERR_EXPLAIN("Invalid Color Name: " + p_name); ERR_FAIL_V(Color()); } }
Error EditorSceneImporterFBXConv::_parse_fbx(State& state,const String& p_path) { state.base_path=p_path.get_base_dir(); if (p_path.to_lower().ends_with("g3dj")) { return _parse_json(state,p_path.basename()+".g3dj"); } String tool = EDITOR_DEF("fbxconv/path",""); ERR_FAIL_COND_V( !FileAccess::exists(tool),ERR_UNCONFIGURED); String wine = EDITOR_DEF("fbxconv/use_wine",""); List<String> args; String path=p_path; if (wine!="") { List<String> wpargs; wpargs.push_back("-w"); wpargs.push_back(p_path); String pipe; //winepath to convert to windows path int wpres; Error wperr = OS::get_singleton()->execute(wine+"path",wpargs,true,NULL,&pipe,&wpres); ERR_FAIL_COND_V(wperr!=OK,ERR_CANT_CREATE); ERR_FAIL_COND_V(wpres!=0,ERR_CANT_CREATE); path=pipe.strip_edges(); args.push_back(tool); tool=wine; } args.push_back("-o"); args.push_back(TTR("G3DJ")); args.push_back(path); int res; Error err = OS::get_singleton()->execute(tool,args,true,NULL,NULL,&res); ERR_FAIL_COND_V(err!=OK,ERR_CANT_CREATE); ERR_FAIL_COND_V(res!=0,ERR_CANT_CREATE); return _parse_json(state,p_path.basename()+".g3dj"); }
Error HTTPClient::poll() { switch (status) { case STATUS_RESOLVING: { ERR_FAIL_COND_V(resolving == IP::RESOLVER_INVALID_ID, ERR_BUG); IP::ResolverStatus rstatus = IP::get_singleton()->get_resolve_item_status(resolving); switch (rstatus) { case IP::RESOLVER_STATUS_WAITING: return OK; // Still resolving case IP::RESOLVER_STATUS_DONE: { IP_Address host = IP::get_singleton()->get_resolve_item_address(resolving); Error err = tcp_connection->connect_to_host(host, conn_port); IP::get_singleton()->erase_resolve_item(resolving); resolving = IP::RESOLVER_INVALID_ID; if (err) { status = STATUS_CANT_CONNECT; return err; } status = STATUS_CONNECTING; } break; case IP::RESOLVER_STATUS_NONE: case IP::RESOLVER_STATUS_ERROR: { IP::get_singleton()->erase_resolve_item(resolving); resolving = IP::RESOLVER_INVALID_ID; close(); status = STATUS_CANT_RESOLVE; return ERR_CANT_RESOLVE; } break; } } break; case STATUS_CONNECTING: { StreamPeerTCP::Status s = tcp_connection->get_status(); switch (s) { case StreamPeerTCP::STATUS_CONNECTING: { return OK; } break; case StreamPeerTCP::STATUS_CONNECTED: { if (ssl) { Ref<StreamPeerSSL> ssl; if (!handshaking) { // Connect the StreamPeerSSL and start handshaking ssl = Ref<StreamPeerSSL>(StreamPeerSSL::create()); ssl->set_blocking_handshake_enabled(false); Error err = ssl->connect_to_stream(tcp_connection, ssl_verify_host, conn_host); if (err != OK) { close(); status = STATUS_SSL_HANDSHAKE_ERROR; return ERR_CANT_CONNECT; } connection = ssl; handshaking = true; } else { // We are already handshaking, which means we can use your already active SSL connection ssl = static_cast<Ref<StreamPeerSSL> >(connection); ssl->poll(); // Try to finish the handshake } if (ssl->get_status() == StreamPeerSSL::STATUS_CONNECTED) { // Handshake has been successfull handshaking = false; status = STATUS_CONNECTED; return OK; } else if (ssl->get_status() != StreamPeerSSL::STATUS_HANDSHAKING) { // Handshake has failed close(); status = STATUS_SSL_HANDSHAKE_ERROR; return ERR_CANT_CONNECT; } // ... we will need to poll more for handshake to finish } else { status = STATUS_CONNECTED; } return OK; } break; case StreamPeerTCP::STATUS_ERROR: case StreamPeerTCP::STATUS_NONE: { close(); status = STATUS_CANT_CONNECT; return ERR_CANT_CONNECT; } break; } } break; case STATUS_CONNECTED: { // Connection established, requests can now be made return OK; } break; case STATUS_REQUESTING: { while (true) { uint8_t byte; int rec = 0; Error err = _get_http_data(&byte, 1, rec); if (err != OK) { close(); status = STATUS_CONNECTION_ERROR; return ERR_CONNECTION_ERROR; } if (rec == 0) return OK; // Still requesting, keep trying! response_str.push_back(byte); int rs = response_str.size(); if ( (rs >= 2 && response_str[rs - 2] == '\n' && response_str[rs - 1] == '\n') || (rs >= 4 && response_str[rs - 4] == '\r' && response_str[rs - 3] == '\n' && response_str[rs - 2] == '\r' && response_str[rs - 1] == '\n')) { // End of response, parse. response_str.push_back(0); String response; response.parse_utf8((const char *)response_str.ptr()); Vector<String> responses = response.split("\n"); body_size = 0; chunked = false; body_left = 0; chunk_left = 0; read_until_eof = false; response_str.clear(); response_headers.clear(); response_num = RESPONSE_OK; // Per the HTTP 1.1 spec, keep-alive is the default, but in practice // it's safe to assume it only if the explicit header is found, allowing // to handle body-up-to-EOF responses on naive servers; that's what Curl // and browsers do bool keep_alive = false; for (int i = 0; i < responses.size(); i++) { String header = responses[i].strip_edges(); String s = header.to_lower(); if (s.length() == 0) continue; if (s.begins_with("content-length:")) { body_size = s.substr(s.find(":") + 1, s.length()).strip_edges().to_int(); body_left = body_size; } else if (s.begins_with("transfer-encoding:")) { String encoding = header.substr(header.find(":") + 1, header.length()).strip_edges(); if (encoding == "chunked") { chunked = true; } } else if (s.begins_with("connection: keep-alive")) { keep_alive = true; } if (i == 0 && responses[i].begins_with("HTTP")) { String num = responses[i].get_slicec(' ', 1); response_num = num.to_int(); } else { response_headers.push_back(header); } } if (body_size || chunked) { status = STATUS_BODY; } else if (!keep_alive) { read_until_eof = true; status = STATUS_BODY; } else { status = STATUS_CONNECTED; } return OK; } } // Wait for response return OK; } break; case STATUS_DISCONNECTED: { return ERR_UNCONFIGURED; } break; case STATUS_CONNECTION_ERROR: { return ERR_CONNECTION_ERROR; } break; case STATUS_CANT_CONNECT: { return ERR_CANT_CONNECT; } break; case STATUS_CANT_RESOLVE: { return ERR_CANT_RESOLVE; } break; } return OK; }
String IOMLCode::encodeBody(shared_ptr<OMLContext> context, const String& text, bool postProcess, bool preserveStartLineSpaces, bool convertCR) { String value = text; if ( (postProcess) && (context->getMode() != omlRenderModeSearch) && (!context->getRow()) ) { // Detect degli url { String protocolsFindLinkOption = context->getPage()->getOption(Options::url_options::protocols_find_link); //String protocolsFindLinkOption = Options::instance()->getOption(Options::url_options::protocols_find_link); //String UrlMatch = _S("(")+getProtocolsFindLinkOption()+_S(")://(\\w*:\\w*@)?[-\\w.]+(:\\d+)?(/([\\w/_.]*(\\?\\S+)?)?)?"); //String UrlMatch = _S("((")+getProtocolsFindLinkOption()+_S(")(\\W+\\S+[^).,:;?\\]\\} \\r\\n$]+))"); //String UrlMatch = _S("(")+protocolsFindLinkOption+_S(")://(\\w*:\\w*@)?[-\\w.]+(:\\d+)?(/([\\w/_.]*(\\?\\S+)?)?)?"); // 0.11: //String UrlMatch = _S("(") + protocolsFindLinkOption + _S(")://\\S+"); // 1.0: String UrlMatch = _S("(") + protocolsFindLinkOption + _S("):[/\?]\\S+"); // La versione sotto sarebbe meglio, ma non funziona, ad esempio con il link seguente: // skype:?chat&blob=iCnRW4EXR0H_funqp8i2FpbcobXxBfFkllPp0s2NMRd_sbDEOEr5Je-RzNUi //String UrlMatch = _S("(")+protocolsFindLinkOption+_S("):\\S+"); String UrlReplace = _S("[url]$0[/url]"); //if(regex_match(value, RegexManager::instance()->getRegex(UrlMatch, true))) value = regex_replace(value, RegexManager::instance()->getRegex(UrlMatch, true), UrlReplace); //String MailMatch = _S("\\b((([A-Za-z0-9$_.+%=-])|%[A-Fa-f0-9]{2})+@(([A-Za-z0-9$_.+!*,;/?:%&=-])|%[A-Fa-f0-9]{2})+\\.[a-zA-Z0-9]{1,4})"); String MailMatch = _S("(\\w+\\.)*\\w+@(\\w+\\.)+[A-Za-z]+"); String MailReplace = _S("[email]$0[/email]"); //if(regex_match(value, RegexManager::instance()->getRegex(MailMatch, true))) value = regex_replace(value, RegexManager::instance()->getRegex(MailMatch, true), MailReplace); } if(value != text) { // Sono stati inseriti tag, ricomputo... return encodeOML(context, value); } } // Risolvo gli escaping value.replace_all(_S("\\["), _S("[")); //value.replace_all(_S("\\]"), _S("]")); // Encoding html value = encode(context, value); if(postProcess) { // Emoticons if( (context->getMode() != omlRenderModeSearch) && (context->getPage() != nullptr) ) { String valueLower = value; valueLower.to_lower(); //const StringMap &emoticons = IdeSystem::instance()->getEmoticons(); //for(StringMap::const_iterator i = emoticons.begin(); i != emoticons.end(); ++i) const OMLManager::Emoticons &emoticons = OMLManager::instance()->getEmoticons(); for(OMLManager::Emoticons::const_iterator i = emoticons.begin(); i != emoticons.end(); ++i) { //const String &code = i->first; shared_ptr<OMLEmoticon> emo = *i; const String &code = emo->getCode(); // Ottimizzazione, se non lo trovo con una 'find' secca sull'equivalente in lower-case, // inutile cercarlo via regex. if(valueLower.find(emo->getCode()) != String::npos) { //const String &name = i->second; const String &name = emo->getName(); String title = getText(context, _S("emoticons.") + name); String url = context->getPage()->getSkin()->getImageUrl(_S("emoticons/")+name+_S(".gif")); String out = String::format(_S(" <img src=\"%S\" alt=\"%S\" title=\"%S\"> ").c_str(), url.c_str(), code.c_str(), title.c_str()); // Se prima o dopo non c' niente, o c' un carattere : String codeRegexQuote = regex_quote(code); // RegEx presa da Invision // $txt = preg_replace( "!(?<=[^\w&;/])$code(?=.\W|\W.|\W$)!ei", "\$this->convert_emoticon('$code', '$image')", $txt ); //String re = _S("!(?<=[^\\w&;/])") + codeRegexQuote + _S("(?=.\\W|\\W.|\\W$)!ei"); //String re = _S("( ")+codeRegexQuote+_S(" |^")+codeRegexQuote+_S(" | ")+codeRegexQuote+_S("$|^")+codeRegexQuote+_S("$)"); // Non sono riuscito a far e il detect dei limiti della stringa, per cui aggiungo due spazi prima e trimmo dopo. value = _S(" ") + value + _S(" "); //String charsEmoBoundary = _S("\\s\\n\\r:),;"); //String re = String::format(_S("(?<=[%S])%S(?=[%S])").c_str(), charsEmoBoundary.c_str(), codeRegexQuote.c_str(), charsEmoBoundary.c_str()); String re = String::format(_S("(?<=[\\s])%S(?=[\\s])").c_str(), codeRegexQuote.c_str()); // URGENT: da ottimizzare con una // shared_ptr<boost::wregex> re = regex_create(regex, nocase); value = regex_replace(value, RegexManager::instance()->getRegex(re, true), out); // Tolgo i due spazi messi sopra value = value.substr(1,value.length()-2); } } } } // Encoding dei \n if ( (context->getMode() == omlRenderModeSearch) || (context->getRow()) ) { value.replace_all(_S("\n"), _S(" ")); } else { if(preserveStartLineSpaces) { for(;;) { String::size_type posCR = value.find(_S("\n")); if(posCR == String::npos) break; String::size_type posFirstNoSpace = value.find_first_not_of(_S(" "), posCR+1); if(posFirstNoSpace == String::npos) posFirstNoSpace = value.length(); String startLineText = value.substr(posCR+1, posFirstNoSpace - (posCR+1)); startLineText.replace_all(_S(" "),_S(" ")); value = value.substr(0,posCR) + _S("<br>") + startLineText + value.substr(posFirstNoSpace); } } else if(convertCR) { value.replace_all(_S("\n"), _S("<br />")); } } // Ulteriore encoding finale di sicurezza XSS, trasformo i '\' in '\'. value.replace_all(_S("\\"),_S("\")); return value; }
int main (int argc, char *argv[]) { Test test ("dmzTypesStringTest", argc, argv); String str1; test.validate ( "Default string constructor creates empty string.", !str1.get_buffer () && !str1.get_length () && !str1.get_size ()); String str2 ("Foo"); const Int32 Str2Len (str2.get_length ()); test.validate ( "String (char *) constructor creates string of correct length and size.", str2.get_buffer () && (Str2Len == 3) && (str2.get_size () > Str2Len)); String str3 ("aaa"); String str4 ("bbb"); str3 << str4; const Int32 Str3Len (str3.get_length ()); test.validate ( "String to String stream operator.", !strcmp ("aaabbb", str3.get_buffer ()) && (Str3Len == 6) && (Str3Len < str3.get_size ())); const char *CharData = "Test String Value"; const int CharDataLength = strlen (CharData); String inputValue (CharData); String copyCtrResult (inputValue); test.validate ( "String copy constructor contains valid string.", (copyCtrResult.get_length () == CharDataLength) && (!strcmp (copyCtrResult.get_buffer (), CharData))); String str5 ("..a...b....c.....d..."); str5.replace_sub ("..", "."); test.validate ( "String replace_sub sequential pattern.", !strcmp (str5.get_buffer (), ".a.b.c.d.") && (str5.get_length () == 9) && (str5.get_length () < str5.get_size ())); String str6 ("123456789"); str6.flush (); test.validate ( "String flush function.", !strcmp ("" , str6.get_buffer ()) && (str6.get_length () == 0) && (str6.get_size () >= 10)); String str7 ("123456789"); str7.empty (); test.validate ( "String empty function.", (str7.get_buffer () == 0) && (str7.get_length () == 0) && (str7.get_size () == 0)); String str8; str8.repeat ("123", 3); test.validate ( "String repeat function.", !strcmp ("123123123", str8.get_buffer ()) && (str8.get_length () == 9) && (str8.get_size () >= 10)); String str9 ("123456789aaa"); str9.shift (-9); test.validate ( "String shift left.", !strcmp ("aaa", str9.get_buffer ()) && (str9.get_length () == 3) && (str9.get_size () > 3)); String str10 ("123456789"); str10.shift (-9); test.validate ( "String shift left to flush.", !strcmp ("", str10.get_buffer ()) && (str10.get_length () == 0) && (str10.get_size () >= 1)); String str11 ("aaa"); str11.shift (6, 'b'); test.validate ( "String shift right.", !strcmp ("bbbbbbaaa", str11.get_buffer ()) && (str11.get_length () == 9) && (str11.get_size () > 9)); String str12 ("123456789"); str12.flush (); test.validate ( "Flush - String empty but not null.", !str12 && !str12.is_null ()); String str13 ("123456789"); str13.empty (); test.validate ( "Empty - String empty and null.", !str13 && str13.is_null ()); String str14; str14 += 'A'; str14 += 'B'; test.validate ("Append char 'A' and 'B'", str14 == "AB"); String strAppend1 ("12345"); String strAppend2 ("67890"); String strResultAppend1 = strAppend1 + strAppend2; String strResultAppend2 (""); strResultAppend2 = strResultAppend2.append (strAppend1); strResultAppend2 = strResultAppend2.append (strAppend2); test.validate ( "Appending strings with plus operator.", !strcmp ("1234567890", strResultAppend1.get_buffer ())); test.validate ( "Appending strings with append function.", !strcmp ("1234567890", strResultAppend2.get_buffer ())); String strRepeat ("repeat!"); String strRepeatResult (""); strRepeatResult = strRepeatResult.repeat (strRepeat, 4); test.validate ( "Repeating a string", !strcmp ("repeat!repeat!repeat!repeat!", strRepeatResult.get_buffer ())); String strBoolean1 ("this is a test string!"); String strBoolean2 ("this is a test string!"); String strBoolean3 ("this is 4 test string!"); test.validate ( "String equality operator", strBoolean1 == strBoolean2); test.validate ( "String inequality operator", strBoolean1 != strBoolean3); String strToUpperInitial ("this is a test string with symbols$%^!&*("); String strToLowerInitial ("THIS IS A TEST STRING WITH SYMBOLS$%^!&*("); String strToUpperFuncResult = strToUpperInitial.get_upper (); String strToLowerFuncResult = strToUpperInitial.get_lower (); strToUpperInitial.to_upper (); strToLowerInitial.to_lower (); test.validate ( "To upper case inplace", !strcmp ("THIS IS A TEST STRING WITH SYMBOLS$%^!&*(", strToUpperInitial.get_buffer ())); test.validate ( "To lower case inplace", !strcmp ("this is a test string with symbols$%^!&*(", strToLowerInitial.get_buffer ())); test.validate ( "To upper case conversion function", !strcmp ("THIS IS A TEST STRING WITH SYMBOLS$%^!&*(", strToUpperFuncResult.get_buffer ())); test.validate ( "To lower case conversion function", !strcmp ("this is a test string with symbols$%^!&*(", strToLowerFuncResult.get_buffer ())); String strSetGetChar ("abcdefghijk"); const char grabbedChar1 = strSetGetChar.get_char (3); const char grabbedChar2 = strSetGetChar.get_char (5); test.validate ( "Get a character - 1", (grabbedChar1 == 'd')); test.validate ( "Get a character - 2", (grabbedChar2 == 'f')); test.validate ( "Set a character - 1", strSetGetChar.set_char (3, 'x') && !strcmp ("abcxefghijk", strSetGetChar.get_buffer ())); test.validate ( "Set a character - 2", strSetGetChar.set_char (5, 'y') && !strcmp ("abcxeyghijk", strSetGetChar.get_buffer ())); String strGetSub ("a1b2c3d4e5f6g7"); String strSubRecieved1 = strGetSub.get_sub (2); String strSubRecieved2 = strGetSub.get_sub (2, 3); String strSubRecieved3 = strGetSub.get_sub (2, 2); String strSubRecieved4 = strGetSub.get_sub (12, 13); String strSubRecieved5 = strGetSub.get_sub (14); String strSubRecieved6 = strGetSub.get_sub (-1); String strSubRecieved7 = strGetSub.get_sub (-5); String strSubRecieved8 = strGetSub.get_sub (-15); test.validate ( "Get substring - single index", strSubRecieved1 == String ("b2c3d4e5f6g7")); test.validate ( "Get substring - index, index + 1", strSubRecieved2 == String ("b2")); test.validate ( "Get substring - index, index", strSubRecieved3 == String ("b")); test.validate ( "Get substring - lastIndex - 1, lastIndex", strSubRecieved4 == String ("g7")); test.validate ( "Get substring - out of bounds after last index", strSubRecieved5.is_null ()); test.validate ( "Get substring - negative index, last character", strSubRecieved6 == String ("7")); test.validate ( "Get substring - negative index, last 5 characters", strSubRecieved7 == String ("5f6g7")); test.validate ( "Get substring - negative index with magnitude too large", strSubRecieved8.is_null ()); Int32 findIndex; String strFindSubTarget ("item"); String strFindSub1 ("01234567item0123item012345item01"); String strFindSub2 ("01234item"); Boolean findSubResult1 = strFindSub1.find_sub (strFindSubTarget, findIndex); test.validate ( "Find substring - initial occurance", findSubResult1 && (findIndex == 8)); Boolean findSubResult2 = strFindSub1.find_sub ( strFindSubTarget, findIndex, findIndex + strFindSubTarget.get_length()); test.validate ( "Find substring - occurance 2", findSubResult2 && (findIndex == 16)); Boolean findSubResult3 = strFindSub1.find_sub ( strFindSubTarget, findIndex, findIndex + strFindSubTarget.get_length()); test.validate ( "Find substring - initial occurance", findSubResult3 && (findIndex == 26)); Boolean findSubResult4 = strFindSub1.find_sub ( strFindSubTarget, findIndex, findIndex + strFindSubTarget.get_length()); test.validate ( "Find substring - no more occurances", !findSubResult4); Int32 findIndex2; Boolean findSubResult5 = strFindSub2.find_sub (strFindSubTarget, findIndex2); test.validate ( "Find substring - initial occurance (test 2)", findSubResult5 && (findIndex2 == 5)); Boolean findSubResult6 = strFindSub2.find_sub ( strFindSubTarget, findIndex2, findIndex2 + strFindSubTarget.get_length()); test.validate ( "Find substring - no more occurances (test 2)", !findSubResult6); Int32 index (-1); String strFindSub3 ("String to compare."); String strFindSub4 (strFindSub3); test.validate ( "find_sub returns True when sub string is the same", strFindSub3.find_sub (strFindSub4, index)); return test.result (); }
Error HTTPClient::poll(){ switch(status) { case STATUS_RESOLVING: { ERR_FAIL_COND_V(resolving==IP::RESOLVER_INVALID_ID,ERR_BUG); IP::ResolverStatus rstatus = IP::get_singleton()->get_resolve_item_status(resolving); switch(rstatus) { case IP::RESOLVER_STATUS_WAITING: return OK; //still resolving case IP::RESOLVER_STATUS_DONE: { IP_Address host = IP::get_singleton()->get_resolve_item_address(resolving); Error err = tcp_connection->connect(host,conn_port); IP::get_singleton()->erase_resolve_item(resolving); resolving=IP::RESOLVER_INVALID_ID; if (err) { status=STATUS_CANT_CONNECT; return err; } status=STATUS_CONNECTING; } break; case IP::RESOLVER_STATUS_NONE: case IP::RESOLVER_STATUS_ERROR: { IP::get_singleton()->erase_resolve_item(resolving); resolving=IP::RESOLVER_INVALID_ID; close(); status=STATUS_CANT_RESOLVE; return ERR_CANT_RESOLVE; } break; } } break; case STATUS_CONNECTING: { StreamPeerTCP::Status s = tcp_connection->get_status(); switch(s) { case StreamPeerTCP::STATUS_CONNECTING: { return OK; //do none } break; case StreamPeerTCP::STATUS_CONNECTED: { if (ssl) { Ref<StreamPeerSSL> ssl = StreamPeerSSL::create(); Error err = ssl->connect(tcp_connection,true,ssl_verify_host?conn_host:String()); if (err!=OK) { close(); status=STATUS_SSL_HANDSHAKE_ERROR; return ERR_CANT_CONNECT; } //print_line("SSL! TURNED ON!"); connection=ssl; } status=STATUS_CONNECTED; return OK; } break; case StreamPeerTCP::STATUS_ERROR: case StreamPeerTCP::STATUS_NONE: { close(); status=STATUS_CANT_CONNECT; return ERR_CANT_CONNECT; } break; } } break; case STATUS_CONNECTED: { //request something please return OK; } break; case STATUS_REQUESTING: { while(true) { uint8_t byte; int rec=0; Error err = _get_http_data(&byte,1,rec); if (err!=OK) { close(); status=STATUS_CONNECTION_ERROR; return ERR_CONNECTION_ERROR; } if (rec==0) return OK; //keep trying! response_str.push_back(byte); int rs = response_str.size(); if ( (rs>=2 && response_str[rs-2]=='\n' && response_str[rs-1]=='\n') || (rs>=4 && response_str[rs-4]=='\r' && response_str[rs-3]=='\n' && rs>=4 && response_str[rs-2]=='\r' && response_str[rs-1]=='\n') ) { //end of response, parse. response_str.push_back(0); String response; response.parse_utf8((const char*)response_str.ptr()); //print_line("END OF RESPONSE? :\n"+response+"\n------"); Vector<String> responses = response.split("\n"); body_size=0; chunked=false; body_left=0; chunk_left=0; response_headers.clear(); response_num = RESPONSE_OK; for(int i=0;i<responses.size();i++) { String header = responses[i].strip_edges(); String s = header.to_lower(); if (s.length()==0) continue; if (s.begins_with("content-length:")) { body_size = s.substr(s.find(":")+1,s.length()).strip_edges().to_int(); body_left=body_size; } if (s.begins_with("transfer-encoding:")) { String encoding = header.substr(header.find(":")+1,header.length()).strip_edges(); //print_line("TRANSFER ENCODING: "+encoding); if (encoding=="chunked") { chunked=true; } } if (i==0 && responses[i].begins_with("HTTP")) { String num = responses[i].get_slicec(' ',1); response_num=num.to_int(); } else { response_headers.push_back(header); } } if (body_size==0 && !chunked) { status=STATUS_CONNECTED; //ask for something again? } else { status=STATUS_BODY; } return OK; } } //wait for response return OK; } break; case STATUS_DISCONNECTED: { return ERR_UNCONFIGURED; } break; case STATUS_CONNECTION_ERROR: { return ERR_CONNECTION_ERROR; } break; case STATUS_CANT_CONNECT: { return ERR_CANT_CONNECT; } break; case STATUS_CANT_RESOLVE: { return ERR_CANT_RESOLVE; } break; } return OK; }
void dmz::ArchivePluginObject::_init (Config &local) { RuntimeContext *context (get_plugin_runtime_context ()); init_archive_scope (local); if (is_archive_scope_empty ()) { add_archive_scope ("archive"); } _defaultHandle = _defs.create_named_handle (ObjectAttributeDefaultName); Config filterList; if (local.lookup_all_config ("archive", filterList)) { ConfigIterator it; Config filter; // Read list in reverse order so they are stored in the correct order in the // filter list. while (filterList.get_prev_config (it, filter)) { const String ArchiveName (config_to_string ("name", filter, ArchiveDefaultName)); const Handle ArchiveHandle (activate_archive (ArchiveName)); _log.info << "Activating archive: " << ArchiveName << endl; FilterStruct *fs (filter.has_children () ? new FilterStruct : 0); if (fs) { const String ModeStr = config_to_string ("mode", filter, "export|import"); if (ModeStr) { StringTokenizer st (ModeStr, '|'); String value; while (st.get_next (value)) { trim_ascii_white_space (value); value.to_lower (); if (value == "import") { fs->mode |= LocalImportMask; } else if (value == "export") { fs->mode |= LocalExportMask; } else { _log.error << "Unknown archive mode: " << value << endl; } } } Config objects; if (filter.lookup_all_config ("object-type-set.object-type", objects)) { ConfigIterator typesIt; Config typeConfig; while (objects.get_next_config (typesIt, typeConfig)) { const String Name (config_to_string ("name", typeConfig)); const Boolean Exclude (config_to_boolean ("exclude", typeConfig, True)); if (Exclude) { if (!fs->exTypes.add_object_type (Name, context)) { _log.error << "Unable to add object type: '" << Name << "' to archive filter for archive: " << _defs.lookup_named_handle_name (ArchiveHandle) << endl; } else { _log.info << "Excluding object type: " << Name << endl; } } else if (!fs->inTypes.add_object_type (Name, context)) { _log.error << "Unable to add object type: '" << Name << "' to archive filter for archive: " << _defs.lookup_named_handle_name (ArchiveHandle) << endl; } else { _log.info << "Including object type: " << Name << endl; } } } else { _log.info << "No object types filtered for: " << ArchiveName << endl; } Config attrConfig; if (filter.lookup_all_config ("attribute", attrConfig)) { ConfigIterator attrIt; Config currentAttr; while (attrConfig.get_next_config (attrIt, currentAttr)) { const String Name ( config_to_string ("name", currentAttr, ObjectAttributeDefaultName)); const Boolean Contains ( config_to_boolean ("contains", currentAttr, False)); const Mask AttrMask (local_config_to_mask (currentAttr, _log)); if (Contains) { FilterAttrStruct *fas (new FilterAttrStruct (Name, AttrMask)); if (fas) { fas->next = fs->list; fs->list = fas; } } else { const Handle AttrHandle (_defs.create_named_handle (Name)); Mask *ptr (new Mask (AttrMask)); if (ptr && !fs->attrTable.store (AttrHandle, ptr)) { delete ptr; ptr = 0; _log.error << "Unable to store mask for object attribute: " << Name << ". Possible duplicate?" << endl; } } } } Config stateConfig; if (filter.lookup_all_config ("state", stateConfig)) { ConfigIterator stateIt; Config state; while (stateConfig.get_next_config (stateIt, state)) { Handle attrHandle (_defaultHandle); const String AttrName (config_to_string ("attribute", state)); if (AttrName) { attrHandle = _defs.create_named_handle (AttrName); } Mask stateMask; _defs.lookup_state (config_to_string ("name", state), stateMask); if (stateMask) { Mask *ptr (fs->stateTable.lookup (attrHandle)); if (ptr) { (*ptr) |= stateMask; } else { ptr = new Mask (stateMask); if (ptr && !fs->stateTable.store (attrHandle, ptr)) { delete ptr; ptr = 0; } } } } } FilterListStruct *fls = _filterTable.lookup (ArchiveHandle); if (!fls) { fls = new FilterListStruct (ArchiveHandle); if (!_filterTable.store (ArchiveHandle, fls)) { delete fls; fls = 0; } } if (fls) { fs->next = fls->list; fls->list = fs; } } } } else { _log.info << "Activating default archive" << endl; activate_default_archive (); } }
void dmz::QtModuleCanvasBasic::_init (Config &local) { qwidget_config_read ("widget", local, this); const Int32 MinX = config_to_int32 ("scene.min.x", local, -50000); const Int32 MinY = config_to_int32 ("scene.min.y", local, -50000); const Int32 MaxX = config_to_int32 ("scene.max.x", local, 100000); const Int32 MaxY = config_to_int32 ("scene.max.y", local, 100000); _scene.setSceneRect (QRectF (MinX, MinY, MaxX - MinX, MaxY - MinY)); //_scene.setItemIndexMethod (QGraphicsScene::NoIndex); _canvas = new QtCanvasView (this); _canvas->setTransformationAnchor (QGraphicsView::AnchorViewCenter); _canvas->setResizeAnchor (QGraphicsView::AnchorViewCenter); const Boolean ScrollBars = config_to_boolean ("scrollbars.value", local, False); if (!ScrollBars) { _canvas->setHorizontalScrollBarPolicy (Qt::ScrollBarAlwaysOff); _canvas->setVerticalScrollBarPolicy (Qt::ScrollBarAlwaysOff); } _canvas->setMouseTracking (true); //_canvas->setDragMode (QGraphicsView::ScrollHandDrag); setObjectName (get_plugin_name ().get_buffer ()); _scene.setObjectName (objectName () + "Scene"); _canvas->setObjectName (objectName () + "View"); _canvas->setScene (&_scene); //_canvas->setBackgroundBrush (QPixmap ("/assets/images/background1.png")); QVBoxLayout *layout (new QVBoxLayout ()); layout->addWidget (_canvas); setLayout (layout); setMouseTracking (true); _inputModuleName = config_to_string ("module.input.name", local); if (_canvas) { _keyEvent.set_source_handle (get_plugin_handle ()); _mouseEvent.set_source_handle (get_plugin_handle ()); String value; Boolean enableOpenGL (False); if (local.lookup_attribute ("canvas.opengl", value)) { if (value.to_lower () == "true") { enableOpenGL = True; } } Boolean enableAntialiasing (False); if (local.lookup_attribute ("canvas.antialiasing", value)) { if (value.to_lower () == "true") { enableAntialiasing = True; } } if (enableOpenGL) { _canvas->setViewport (new QGLWidget (QGLFormat (QGL::SampleBuffers))); _log.info << "OpenGL enabled" << endl; } if (enableAntialiasing) { if (enableOpenGL) { _canvas->setRenderHint (QPainter::HighQualityAntialiasing, true); _log.info << "High Quality Antialiasing enabled" << endl; } else { _canvas->setRenderHint (QPainter::Antialiasing, true); _log.info << "Antialiasing enabled" << endl; } } if (local.lookup_attribute ("canvas.textantialiasing", value)) { if (value.to_lower () == "true") { _canvas->setRenderHint (QPainter::TextAntialiasing, true); _log.info << "Test Antialiasing enabled" << endl; } } _canvas->setRenderHint (QPainter::SmoothPixmapTransform, true); set_zoom_min_value (config_to_float32 ("canvas.zoom.min", local, _zoomMin)); set_zoom_max_value (config_to_float32 ("canvas.zoom.max", local, _zoomMax)); set_zoom_step_value (config_to_float32 ("canvas.zoom.step", local, _zoomStep)); set_zoom (config_to_float32 ("canvas.zoom.default", local, _zoomDefault)); } }