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