Datasets:

---

monsterapi

/

code_search_net

like 0

Follow

MonsterAPI 14

[ "public", "function", "fetchByMessageNr", "(", "$", "number", ",", "$", "deleteFromServer", "=", "false", ")", "{", "if", "(", "$", "this", "->", "options", "->", "uidReferencing", ")", "{", "$", "messages", "=", "array_flip", "(", "$", "this", "->", "listUniqueIdentifiers", "(", ")", ")", ";", "}", "else", "{", "$", "messages", "=", "$", "this", "->", "listMessages", "(", ")", ";", "}", "if", "(", "!", "isset", "(", "$", "messages", "[", "$", "number", "]", ")", ")", "{", "throw", "new", "ezcMailNoSuchMessageException", "(", "$", "number", ")", ";", "}", "return", "new", "ezcMailImapSet", "(", "$", "this", "->", "connection", ",", "array", "(", "0", "=>", "$", "number", ")", ",", "$", "deleteFromServer", ",", "array", "(", "'uidReferencing'", "=>", "$", "this", "->", "options", "->", "uidReferencing", ")", ")", ";", "}" ]

[ "Returns", "an", "{", "@link", "ezcMailImapSet", "}", "containing", "only", "the", "$number", "-", "th", "message", "in", "the", "current", "mailbox", "." ]

[ "public", "function", "fetchFromOffset", "(", "$", "offset", ",", "$", "count", "=", "0", ",", "$", "deleteFromServer", "=", "false", ")", "{", "if", "(", "$", "count", "<", "0", ")", "{", "throw", "new", "ezcMailInvalidLimitException", "(", "$", "offset", ",", "$", "count", ")", ";", "}", "if", "(", "$", "this", "->", "options", "->", "uidReferencing", ")", "{", "$", "messages", "=", "array_values", "(", "$", "this", "->", "listUniqueIdentifiers", "(", ")", ")", ";", "$", "ids", "=", "array_flip", "(", "$", "messages", ")", ";", "if", "(", "$", "count", "===", "0", ")", "{", "$", "count", "=", "count", "(", "$", "messages", ")", ";", "}", "if", "(", "!", "isset", "(", "$", "ids", "[", "$", "offset", "]", ")", ")", "{", "throw", "new", "ezcMailOffsetOutOfRangeException", "(", "$", "offset", ",", "$", "count", ")", ";", "}", "$", "range", "=", "array", "(", ")", ";", "for", "(", "$", "i", "=", "$", "ids", "[", "$", "offset", "]", ";", "$", "i", "<", "min", "(", "$", "count", ",", "count", "(", "$", "messages", ")", ")", ";", "$", "i", "++", ")", "{", "$", "range", "[", "]", "=", "$", "messages", "[", "$", "i", "]", ";", "}", "}", "else", "{", "$", "messages", "=", "array_keys", "(", "$", "this", "->", "listMessages", "(", ")", ")", ";", "if", "(", "$", "count", "===", "0", ")", "{", "$", "count", "=", "count", "(", "$", "messages", ")", ";", "}", "$", "range", "=", "array_slice", "(", "$", "messages", ",", "$", "offset", "-", "1", ",", "$", "count", ",", "true", ")", ";", "if", "(", "!", "isset", "(", "$", "range", "[", "$", "offset", "-", "1", "]", ")", ")", "{", "throw", "new", "ezcMailOffsetOutOfRangeException", "(", "$", "offset", ",", "$", "count", ")", ";", "}", "}", "return", "new", "ezcMailImapSet", "(", "$", "this", "->", "connection", ",", "$", "range", ",", "$", "deleteFromServer", ",", "array", "(", "'uidReferencing'", "=>", "$", "this", "->", "options", "->", "uidReferencing", ")", ")", ";", "}" ]

[ "Returns", "an", "{", "@link", "ezcMailImapSet", "}", "with", "$count", "messages", "starting", "from", "$offset", "from", "the", "current", "mailbox", "." ]

[ "public", "function", "searchMailbox", "(", "$", "criteria", "=", "null", ")", "{", "$", "uid", "=", "(", "$", "this", "->", "options", "->", "uidReferencing", ")", "?", "self", "::", "UID", ":", "self", "::", "NO_UID", ";", "if", "(", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED", "&&", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED_READONLY", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"Can't call searchMailbox() on the IMAP transport when a mailbox is not selected.\"", ")", ";", "}", "$", "criteria", "=", "trim", "(", "$", "criteria", ")", ";", "if", "(", "empty", "(", "$", "criteria", ")", ")", "{", "$", "criteria", "=", "'ALL'", ";", "}", "$", "matchingMessages", "=", "array", "(", ")", ";", "$", "tag", "=", "$", "this", "->", "getNextTag", "(", ")", ";", "$", "this", "->", "connection", "->", "sendData", "(", "\"{$tag} {$uid}SEARCH {$criteria}\"", ")", ";", "$", "response", "=", "$", "this", "->", "getResponse", "(", "'* SEARCH'", ")", ";", "if", "(", "strpos", "(", "$", "response", ",", "'* SEARCH'", ")", "!==", "false", ")", "{", "$", "ids", "=", "substr", "(", "trim", "(", "$", "response", ")", ",", "9", ")", ";", "if", "(", "trim", "(", "$", "ids", ")", "!==", "\"\"", ")", "{", "$", "matchingMessages", "=", "explode", "(", "' '", ",", "$", "ids", ")", ";", "}", "}", "$", "response", "=", "trim", "(", "$", "this", "->", "getResponse", "(", "$", "tag", ",", "$", "response", ")", ")", ";", "if", "(", "$", "this", "->", "responseType", "(", "$", "response", ")", "!=", "self", "::", "RESPONSE_OK", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"The IMAP server could not search the messages by the specified criteria: {$response}.\"", ")", ";", "}", "return", "new", "ezcMailImapSet", "(", "$", "this", "->", "connection", ",", "array_values", "(", "$", "matchingMessages", ")", ",", "false", ",", "array", "(", "'uidReferencing'", "=>", "$", "this", "->", "options", "->", "uidReferencing", ")", ")", ";", "}" ]

[ "Returns", "an", "{", "@link", "ezcMailImapSet", "}", "containing", "the", "messages", "which", "match", "the", "provided", "$criteria", "from", "the", "current", "mailbox", "." ]

[ "public", "function", "sortFromOffset", "(", "$", "offset", ",", "$", "count", "=", "0", ",", "$", "sortCriteria", ",", "$", "reverse", "=", "false", ")", "{", "if", "(", "$", "count", "<", "0", ")", "{", "throw", "new", "ezcMailInvalidLimitException", "(", "$", "offset", ",", "$", "count", ")", ";", "}", "$", "range", "=", "array", "(", ")", ";", "if", "(", "$", "this", "->", "options", "->", "uidReferencing", ")", "{", "$", "uids", "=", "array_values", "(", "$", "this", "->", "listUniqueIdentifiers", "(", ")", ")", ";", "$", "flip", "=", "array_flip", "(", "$", "uids", ")", ";", "if", "(", "!", "isset", "(", "$", "flip", "[", "$", "offset", "]", ")", ")", "{", "throw", "new", "ezcMailOffsetOutOfRangeException", "(", "$", "offset", ",", "$", "count", ")", ";", "}", "$", "start", "=", "$", "flip", "[", "$", "offset", "]", ";", "$", "messages", "=", "$", "this", "->", "sort", "(", "$", "uids", ",", "$", "sortCriteria", ",", "$", "reverse", ")", ";", "if", "(", "$", "count", "===", "0", ")", "{", "$", "count", "=", "count", "(", "$", "messages", ")", ";", "}", "$", "ids", "=", "array_keys", "(", "$", "messages", ")", ";", "for", "(", "$", "i", "=", "$", "start", ";", "$", "i", "<", "$", "count", ";", "$", "i", "++", ")", "{", "$", "range", "[", "]", "=", "$", "ids", "[", "$", "i", "]", ";", "}", "}", "else", "{", "$", "messageCount", "=", "$", "this", "->", "countByFlag", "(", "'ALL'", ")", ";", "$", "messages", "=", "array_keys", "(", "$", "this", "->", "sort", "(", "range", "(", "1", ",", "$", "messageCount", ")", ",", "$", "sortCriteria", ",", "$", "reverse", ")", ")", ";", "if", "(", "$", "count", "===", "0", ")", "{", "$", "count", "=", "count", "(", "$", "messages", ")", ";", "}", "$", "range", "=", "array_slice", "(", "$", "messages", ",", "$", "offset", "-", "1", ",", "$", "count", ",", "true", ")", ";", "if", "(", "!", "isset", "(", "$", "range", "[", "$", "offset", "-", "1", "]", ")", ")", "{", "throw", "new", "ezcMailOffsetOutOfRangeException", "(", "$", "offset", ",", "$", "count", ")", ";", "}", "}", "return", "new", "ezcMailImapSet", "(", "$", "this", "->", "connection", ",", "$", "range", ",", "false", ",", "array", "(", "'uidReferencing'", "=>", "$", "this", "->", "options", "->", "uidReferencing", ")", ")", ";", "}" ]

[ "Returns", "an", "{", "@link", "ezcMailImapSet", "}", "containing", "$count", "messages", "starting", "from", "$offset", "sorted", "by", "$sortCriteria", "from", "the", "current", "mailbox", "." ]

[ "public", "function", "sortMessages", "(", "$", "messages", ",", "$", "sortCriteria", ",", "$", "reverse", "=", "false", ")", "{", "$", "messages", "=", "$", "this", "->", "sort", "(", "$", "messages", ",", "$", "sortCriteria", ",", "$", "reverse", ")", ";", "return", "new", "ezcMailImapSet", "(", "$", "this", "->", "connection", ",", "array_keys", "(", "$", "messages", ")", ",", "false", ",", "array", "(", "'uidReferencing'", "=>", "$", "this", "->", "options", "->", "uidReferencing", ")", ")", ";", "}" ]

[ "Returns", "an", "{", "@link", "ezcMailImapSet", "}", "containing", "messages", "$messages", "sorted", "by", "$sortCriteria", "from", "the", "current", "mailbox", "." ]

[ "public", "function", "fetchByFlag", "(", "$", "flag", ")", "{", "$", "messages", "=", "$", "this", "->", "searchByFlag", "(", "$", "flag", ")", ";", "return", "new", "ezcMailImapSet", "(", "$", "this", "->", "connection", ",", "$", "messages", ",", "false", ",", "array", "(", "'uidReferencing'", "=>", "$", "this", "->", "options", "->", "uidReferencing", ")", ")", ";", "}" ]

[ "Returns", "an", "{", "@link", "ezcMailImapSet", "}", "containing", "messages", "with", "a", "certain", "flag", "from", "the", "current", "mailbox", "." ]

[ "public", "function", "countByFlag", "(", "$", "flag", ")", "{", "$", "flag", "=", "$", "this", "->", "normalizeFlag", "(", "$", "flag", ")", ";", "$", "messages", "=", "$", "this", "->", "searchByFlag", "(", "$", "flag", ")", ";", "return", "count", "(", "$", "messages", ")", ";", "}" ]

[ "Wrapper", "function", "to", "fetch", "count", "of", "messages", "by", "a", "certain", "flag", "." ]

[ "public", "function", "setFlag", "(", "$", "messages", ",", "$", "flag", ")", "{", "$", "uid", "=", "(", "$", "this", "->", "options", "->", "uidReferencing", ")", "?", "self", "::", "UID", ":", "self", "::", "NO_UID", ";", "if", "(", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"Can't call setFlag() when a mailbox is not selected.\"", ")", ";", "}", "$", "flag", "=", "$", "this", "->", "normalizeFlag", "(", "$", "flag", ")", ";", "if", "(", "in_array", "(", "$", "flag", ",", "self", "::", "$", "basicFlags", ")", ")", "{", "$", "tag", "=", "$", "this", "->", "getNextTag", "(", ")", ";", "$", "this", "->", "connection", "->", "sendData", "(", "\"{$tag} {$uid}STORE {$messages} +FLAGS (\\\\{$flag})\"", ")", ";", "$", "response", "=", "trim", "(", "$", "this", "->", "getResponse", "(", "$", "tag", ")", ")", ";", "if", "(", "$", "this", "->", "responseType", "(", "$", "response", ")", "!=", "self", "::", "RESPONSE_OK", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"The IMAP server could not set flag '{$flag}' on the messages '{$messages}': {$response}.\"", ")", ";", "}", "}", "else", "{", "throw", "new", "ezcMailTransportException", "(", "\"Flag '{$flag}' is not allowed for setting.\"", ")", ";", "}", "return", "true", ";", "}" ]

[ "Sets", "$flag", "on", "$messages", "." ]

[ "protected", "function", "searchByFlag", "(", "$", "flag", ")", "{", "$", "uid", "=", "(", "$", "this", "->", "options", "->", "uidReferencing", ")", "?", "self", "::", "UID", ":", "self", "::", "NO_UID", ";", "if", "(", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED", "&&", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED_READONLY", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"Can't call searchByFlag() on the IMAP transport when a mailbox is not selected.\"", ")", ";", "}", "$", "matchingMessages", "=", "array", "(", ")", ";", "$", "flag", "=", "$", "this", "->", "normalizeFlag", "(", "$", "flag", ")", ";", "if", "(", "in_array", "(", "$", "flag", ",", "self", "::", "$", "extendedFlags", ")", ")", "{", "$", "tag", "=", "$", "this", "->", "getNextTag", "(", ")", ";", "$", "this", "->", "connection", "->", "sendData", "(", "\"{$tag} {$uid}SEARCH ({$flag})\"", ")", ";", "$", "response", "=", "$", "this", "->", "getResponse", "(", "'* SEARCH'", ")", ";", "if", "(", "strpos", "(", "$", "response", ",", "'* SEARCH'", ")", "!==", "false", ")", "{", "$", "ids", "=", "substr", "(", "trim", "(", "$", "response", ")", ",", "9", ")", ";", "if", "(", "trim", "(", "$", "ids", ")", "!==", "\"\"", ")", "{", "$", "matchingMessages", "=", "explode", "(", "' '", ",", "$", "ids", ")", ";", "}", "}", "$", "response", "=", "trim", "(", "$", "this", "->", "getResponse", "(", "$", "tag", ",", "$", "response", ")", ")", ";", "if", "(", "$", "this", "->", "responseType", "(", "$", "response", ")", "!=", "self", "::", "RESPONSE_OK", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"The IMAP server could not search the messages by flags: {$response}.\"", ")", ";", "}", "}", "else", "{", "throw", "new", "ezcMailTransportException", "(", "\"Flag '{$flag}' is not allowed for searching.\"", ")", ";", "}", "return", "$", "matchingMessages", ";", "}" ]

[ "Returns", "an", "array", "of", "message", "numbers", "from", "the", "selected", "mailbox", "which", "have", "a", "certain", "flag", "set", "." ]

[ "public", "function", "noop", "(", ")", "{", "if", "(", "$", "this", "->", "state", "!=", "self", "::", "STATE_NOT_AUTHENTICATED", "&&", "$", "this", "->", "state", "!=", "self", "::", "STATE_AUTHENTICATED", "&&", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED", "&&", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED_READONLY", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"Can not issue NOOP command if not connected.\"", ")", ";", "}", "$", "tag", "=", "$", "this", "->", "getNextTag", "(", ")", ";", "$", "this", "->", "connection", "->", "sendData", "(", "\"{$tag} NOOP\"", ")", ";", "$", "response", "=", "trim", "(", "$", "this", "->", "getResponse", "(", "$", "tag", ")", ")", ";", "if", "(", "$", "this", "->", "responseType", "(", "$", "response", ")", "!=", "self", "::", "RESPONSE_OK", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"NOOP failed: {$response}.\"", ")", ";", "}", "}" ]

[ "Sends", "a", "NOOP", "command", "to", "the", "server", "use", "it", "to", "keep", "the", "connection", "alive", "." ]

[ "public", "function", "capability", "(", ")", "{", "if", "(", "$", "this", "->", "state", "!=", "self", "::", "STATE_NOT_AUTHENTICATED", "&&", "$", "this", "->", "state", "!=", "self", "::", "STATE_AUTHENTICATED", "&&", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED", "&&", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED_READONLY", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"Trying to request capability when not connected to server.\"", ")", ";", "}", "$", "tag", "=", "$", "this", "->", "getNextTag", "(", ")", ";", "$", "this", "->", "connection", "->", "sendData", "(", "\"{$tag} CAPABILITY\"", ")", ";", "$", "response", "=", "$", "this", "->", "connection", "->", "getLine", "(", ")", ";", "while", "(", "$", "this", "->", "responseType", "(", "$", "response", ")", "!=", "self", "::", "RESPONSE_UNTAGGED", "&&", "strpos", "(", "$", "response", ",", "'* CAPABILITY '", ")", "===", "false", ")", "{", "$", "response", "=", "$", "this", "->", "connection", "->", "getLine", "(", ")", ";", "}", "$", "result", "=", "trim", "(", "$", "response", ")", ";", "$", "response", "=", "trim", "(", "$", "this", "->", "getResponse", "(", "$", "tag", ")", ")", ";", "if", "(", "$", "this", "->", "responseType", "(", "$", "response", ")", "!=", "self", "::", "RESPONSE_OK", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"The IMAP server responded negative to the CAPABILITY command: {$response}.\"", ")", ";", "}", "return", "explode", "(", "' '", ",", "str_replace", "(", "'* CAPABILITY '", ",", "''", ",", "$", "result", ")", ")", ";", "}" ]

[ "Returns", "an", "array", "with", "the", "capabilities", "of", "the", "IMAP", "server", "." ]

[ "public", "function", "expunge", "(", ")", "{", "if", "(", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"Can not issue EXPUNGE command if a mailbox is not selected.\"", ")", ";", "}", "$", "tag", "=", "$", "this", "->", "getNextTag", "(", ")", ";", "$", "this", "->", "connection", "->", "sendData", "(", "\"{$tag} EXPUNGE\"", ")", ";", "$", "response", "=", "trim", "(", "$", "this", "->", "getResponse", "(", "$", "tag", ")", ")", ";", "if", "(", "$", "this", "->", "responseType", "(", "$", "response", ")", "!=", "self", "::", "RESPONSE_OK", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"EXPUNGE failed: {$response}.\"", ")", ";", "}", "}" ]

[ "Sends", "an", "EXPUNGE", "command", "to", "the", "server", "." ]

[ "public", "function", "append", "(", "$", "mailbox", ",", "$", "mail", ",", "$", "flags", "=", "null", ")", "{", "if", "(", "$", "this", "->", "state", "!=", "self", "::", "STATE_AUTHENTICATED", "&&", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED", "&&", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED_READONLY", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"Can't call append() if not authenticated.\"", ")", ";", "}", "$", "tag", "=", "$", "this", "->", "getNextTag", "(", ")", ";", "$", "mailSize", "=", "strlen", "(", "$", "mail", ")", ";", "if", "(", "!", "is_null", "(", "$", "flags", ")", ")", "{", "for", "(", "$", "i", "=", "0", ";", "$", "i", "<", "count", "(", "$", "flags", ")", ";", "$", "i", "++", ")", "{", "$", "flags", "[", "$", "i", "]", "=", "'\\\\'", ".", "$", "this", "->", "normalizeFlag", "(", "$", "flags", "[", "$", "i", "]", ")", ";", "}", "$", "flagList", "=", "implode", "(", "' '", ",", "$", "flags", ")", ";", "$", "command", "=", "\"{$tag} APPEND {$mailbox} ({$flagList}) {{$mailSize}}\"", ";", "}", "else", "{", "$", "command", "=", "\"{$tag} APPEND {$mailbox} {{$mailSize}}\"", ";", "}", "$", "this", "->", "connection", "->", "sendData", "(", "$", "command", ")", ";", "$", "response", "=", "trim", "(", "$", "this", "->", "connection", "->", "getLine", "(", ")", ")", ";", "if", "(", "strpos", "(", "$", "response", ",", "'TRYCREATE'", ")", "!==", "false", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"Mailbox does not exist: {$response}.\"", ")", ";", "}", "if", "(", "$", "this", "->", "responseType", "(", "$", "response", ")", "==", "self", "::", "RESPONSE_FEEDBACK", ")", "{", "$", "this", "->", "connection", "->", "sendData", "(", "$", "mail", ")", ";", "$", "response", "=", "trim", "(", "$", "this", "->", "getResponse", "(", "$", "tag", ")", ")", ";", "if", "(", "$", "this", "->", "responseType", "(", "$", "response", ")", "!=", "self", "::", "RESPONSE_OK", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"The IMAP server could not append message to mailbox '{$mailbox}': {$response}.\"", ")", ";", "}", "}", "elseif", "(", "$", "this", "->", "responseType", "(", "$", "response", ")", "!=", "self", "::", "RESPONSE_OK", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"The IMAP server could not append message to mailbox '{$mailbox}': {$response}.\"", ")", ";", "}", "}" ]

[ "Appends", "$mail", "to", "the", "$mailbox", "mailbox", "." ]

[ "protected", "function", "normalizeFlag", "(", "$", "flag", ")", "{", "$", "flag", "=", "strtoupper", "(", "$", "flag", ")", ";", "$", "flag", "=", "str_replace", "(", "'\\\\'", ",", "''", ",", "$", "flag", ")", ";", "return", "trim", "(", "$", "flag", ")", ";", "}" ]

[ "Clears", "$flag", "of", "unwanted", "characters", "and", "makes", "it", "uppercase", "." ]

[ "protected", "function", "sort", "(", "$", "messages", ",", "$", "sortCriteria", ",", "$", "reverse", "=", "false", ")", "{", "$", "uid", "=", "(", "$", "this", "->", "options", "->", "uidReferencing", ")", "?", "self", "::", "UID", ":", "self", "::", "NO_UID", ";", "if", "(", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED", "&&", "$", "this", "->", "state", "!=", "self", "::", "STATE_SELECTED_READONLY", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"Can't call sort() on the IMAP transport when a mailbox is not selected.\"", ")", ";", "}", "$", "result", "=", "array", "(", ")", ";", "$", "query", "=", "ucfirst", "(", "strtolower", "(", "$", "sortCriteria", ")", ")", ";", "$", "messageNumbers", "=", "implode", "(", "','", ",", "$", "messages", ")", ";", "$", "tag", "=", "$", "this", "->", "getNextTag", "(", ")", ";", "$", "this", "->", "connection", "->", "sendData", "(", "\"{$tag} {$uid}FETCH {$messageNumbers} (BODY.PEEK[HEADER.FIELDS ({$query})])\"", ")", ";", "$", "response", "=", "trim", "(", "$", "this", "->", "connection", "->", "getLine", "(", ")", ")", ";", "while", "(", "strpos", "(", "$", "response", ",", "$", "tag", ")", "===", "false", ")", "{", "if", "(", "strpos", "(", "$", "response", ",", "' FETCH ('", ")", "!==", "false", ")", "{", "if", "(", "$", "this", "->", "options", "->", "uidReferencing", ")", "{", "preg_match", "(", "'/^\\* [0-9]+ FETCH \\(UID ([0-9]+)/'", ",", "$", "response", ",", "$", "matches", ")", ";", "}", "else", "{", "preg_match", "(", "'/^\\* ([0-9]+) FETCH/'", ",", "$", "response", ",", "$", "matches", ")", ";", "}", "$", "messageNumber", "=", "$", "matches", "[", "1", "]", ";", "}", "if", "(", "strpos", "(", "$", "response", ",", "$", "query", ")", "!==", "false", ")", "{", "$", "strippedResponse", "=", "trim", "(", "trim", "(", "str_replace", "(", "\"{$query}: \"", ",", "''", ",", "$", "response", ")", ")", ",", "'\"'", ")", ";", "switch", "(", "$", "query", ")", "{", "case", "'Date'", ":", "$", "strippedResponse", "=", "strtotime", "(", "$", "strippedResponse", ")", ";", "break", ";", "case", "'Subject'", ":", "case", "'From'", ":", "case", "'Sender'", ":", "case", "'To'", ":", "$", "strippedResponse", "=", "ezcMailTools", "::", "mimeDecode", "(", "$", "strippedResponse", ")", ";", "break", ";", "default", ":", "break", ";", "}", "$", "result", "[", "$", "messageNumber", "]", "=", "$", "strippedResponse", ";", "}", "// in case the mail doesn't have the $sortCriteria header (like junk mail missing Subject header)", "if", "(", "strpos", "(", "$", "response", ",", "')'", ")", "!==", "false", "&&", "!", "isset", "(", "$", "result", "[", "$", "messageNumber", "]", ")", ")", "{", "$", "result", "[", "$", "messageNumber", "]", "=", "''", ";", "}", "$", "response", "=", "trim", "(", "$", "this", "->", "connection", "->", "getLine", "(", ")", ")", ";", "}", "if", "(", "$", "this", "->", "responseType", "(", "$", "response", ")", "!=", "self", "::", "RESPONSE_OK", ")", "{", "throw", "new", "ezcMailTransportException", "(", "\"The IMAP server could not sort the messages: {$response}.\"", ")", ";", "}", "if", "(", "$", "reverse", "===", "true", ")", "{", "natcasesort", "(", "$", "result", ")", ";", "$", "result", "=", "array_reverse", "(", "$", "result", ",", "true", ")", ";", "}", "else", "{", "natcasesort", "(", "$", "result", ")", ";", "}", "return", "$", "result", ";", "}" ]

[ "Sorts", "message", "numbers", "array", "$messages", "by", "the", "specified", "$sortCriteria", "." ]

[ "protected", "function", "responseType", "(", "$", "line", ")", "{", "if", "(", "strpos", "(", "$", "line", ",", "'OK '", ")", "!==", "false", "&&", "strpos", "(", "$", "line", ",", "'OK '", ")", "==", "6", ")", "{", "return", "self", "::", "RESPONSE_OK", ";", "}", "if", "(", "strpos", "(", "$", "line", ",", "'NO '", ")", "!==", "false", "&&", "strpos", "(", "$", "line", ",", "'NO '", ")", "==", "6", ")", "{", "return", "self", "::", "RESPONSE_NO", ";", "}", "if", "(", "strpos", "(", "$", "line", ",", "'BAD '", ")", "!==", "false", "&&", "strpos", "(", "$", "line", ",", "'BAD '", ")", "==", "6", ")", "{", "return", "self", "::", "RESPONSE_BAD", ";", "}", "if", "(", "strpos", "(", "$", "line", ",", "'* '", ")", "!==", "false", "&&", "strpos", "(", "$", "line", ",", "'* '", ")", "==", "0", ")", "{", "return", "self", "::", "RESPONSE_UNTAGGED", ";", "}", "if", "(", "strpos", "(", "$", "line", ",", "'+ '", ")", "!==", "false", "&&", "strpos", "(", "$", "line", ",", "'+ '", ")", "==", "0", ")", "{", "return", "self", "::", "RESPONSE_FEEDBACK", ";", "}", "throw", "new", "ezcMailTransportException", "(", "\"Unrecognized IMAP response in line: {$line}\"", ")", ";", "}" ]

[ "Parses", "$line", "to", "return", "the", "response", "code", "." ]

[ "protected", "function", "getResponse", "(", "$", "tag", ",", "$", "response", "=", "null", ")", "{", "if", "(", "is_null", "(", "$", "response", ")", ")", "{", "$", "response", "=", "$", "this", "->", "connection", "->", "getLine", "(", ")", ";", "}", "while", "(", "strpos", "(", "$", "response", ",", "$", "tag", ")", "===", "false", ")", "{", "if", "(", "strpos", "(", "$", "response", ",", "' BAD '", ")", "!==", "false", "||", "strpos", "(", "$", "response", ",", "' NO '", ")", "!==", "false", ")", "{", "break", ";", "}", "$", "response", "=", "$", "this", "->", "connection", "->", "getLine", "(", ")", ";", "}", "return", "$", "response", ";", "}" ]

[ "Reads", "the", "responses", "from", "the", "server", "until", "encountering", "$tag", "." ]

[ "protected", "function", "getNextTag", "(", ")", "{", "$", "tagLetter", "=", "substr", "(", "$", "this", "->", "currentTag", ",", "0", ",", "1", ")", ";", "$", "tagNumber", "=", "intval", "(", "substr", "(", "$", "this", "->", "currentTag", ",", "1", ")", ")", ";", "$", "tagNumber", "++", ";", "if", "(", "$", "tagLetter", "==", "'Z'", "&&", "$", "tagNumber", "==", "10000", ")", "{", "$", "tagLetter", "=", "'A'", ";", "$", "tagNumber", "=", "1", ";", "}", "if", "(", "$", "tagNumber", "==", "10000", ")", "{", "$", "tagLetter", "++", ";", "$", "tagNumber", "=", "0", ";", "}", "$", "this", "->", "currentTag", "=", "$", "tagLetter", ".", "sprintf", "(", "\"%04s\"", ",", "$", "tagNumber", ")", ";", "return", "$", "this", "->", "currentTag", ";", "}" ]

[ "Generates", "the", "next", "IMAP", "tag", "to", "prepend", "to", "client", "commands", "." ]

[ "protected", "function", "getMessageSectionSize", "(", "$", "response", ")", "{", "$", "size", "=", "0", ";", "preg_match", "(", "'/\\{(.*)\\}/'", ",", "$", "response", ",", "$", "matches", ")", ";", "if", "(", "count", "(", "$", "matches", ")", ">", "0", ")", "{", "$", "size", "=", "(", "int", ")", "$", "matches", "[", "1", "]", ";", "}", "return", "$", "size", ";", "}" ]

[ "Returns", "the", "size", "of", "a", "FETCH", "section", "in", "bytes", "." ]

[ "public", "function", "getNextLine", "(", ")", "{", "if", "(", "$", "this", "->", "currentMessage", "===", "null", ")", "{", "$", "this", "->", "nextMail", "(", ")", ";", "}", "if", "(", "$", "this", "->", "hasMoreMailData", ")", "{", "$", "data", "=", "$", "this", "->", "connection", "->", "getLine", "(", ")", ";", "if", "(", "rtrim", "(", "$", "data", ")", "===", "\".\"", ")", "{", "$", "this", "->", "hasMoreMailData", "=", "false", ";", "// remove the mail if required by the user.", "if", "(", "$", "this", "->", "deleteFromServer", "==", "true", ")", "{", "$", "this", "->", "connection", "->", "sendData", "(", "\"DELE {$this->currentMessage}\"", ")", ";", "$", "response", "=", "$", "this", "->", "connection", "->", "getLine", "(", ")", ";", "// ignore response", "}", "return", "null", ";", "}", "return", "$", "data", ";", "}", "return", "null", ";", "}" ]

[ "Returns", "one", "line", "of", "data", "from", "the", "current", "mail", "in", "the", "set", "." ]

[ "public", "function", "nextMail", "(", ")", "{", "if", "(", "$", "this", "->", "currentMessage", "===", "null", ")", "{", "$", "this", "->", "currentMessage", "=", "reset", "(", "$", "this", "->", "messages", ")", ";", "}", "else", "{", "$", "this", "->", "currentMessage", "=", "next", "(", "$", "this", "->", "messages", ")", ";", "}", "if", "(", "$", "this", "->", "currentMessage", "!==", "false", ")", "{", "$", "this", "->", "connection", "->", "sendData", "(", "\"RETR {$this->currentMessage}\"", ")", ";", "$", "response", "=", "$", "this", "->", "connection", "->", "getLine", "(", ")", ";", "if", "(", "strpos", "(", "$", "response", ",", "\"+OK\"", ")", "===", "0", ")", "{", "$", "this", "->", "hasMoreMailData", "=", "true", ";", "return", "true", ";", "}", "else", "{", "throw", "new", "ezcMailTransportException", "(", "\"The POP3 server sent a negative reply when requesting mail.\"", ")", ";", "}", "}", "return", "false", ";", "}" ]

[ "Moves", "the", "set", "to", "the", "next", "mail", "and", "returns", "true", "upon", "success", "." ]

[ "public", "function", "register", "(", "$", "name", ",", "$", "service", ",", "$", "replace", "=", "false", ")", "{", "$", "this", "->", "set", "(", "$", "name", ",", "$", "service", ",", "$", "replace", ")", ";", "return", "$", "this", ";", "}" ]

[ "register", "a", "app", "service" ]

[ "public", "function", "fire", "(", ")", "{", "if", "(", "!", "$", "this", "->", "confirmToProceed", "(", ")", ")", "{", "return", ";", "}", "$", "this", "->", "prepareDatabase", "(", ")", ";", "// Next, we will check to see if a path option has been defined. If it has", "// we will use the path relative to the root of this installation folder", "// so that migrations may be run for any path within the applications.", "$", "this", "->", "container", "[", "'migrator'", "]", "->", "run", "(", "$", "this", "->", "getMigrationPaths", "(", ")", ",", "[", "'pretend'", "=>", "$", "this", "->", "option", "(", "'pretend'", ")", ",", "'step'", "=>", "$", "this", "->", "option", "(", "'step'", ")", ",", "]", ")", ";", "// Once the migrator has run we will grab the note output and send it out to", "// the console screen, since the migrator itself functions without having", "// any instances of the OutputInterface contract passed into the class.", "foreach", "(", "$", "this", "->", "container", "[", "'migrator'", "]", "->", "getNotes", "(", ")", "as", "$", "note", ")", "{", "$", "this", "->", "output", "->", "writeln", "(", "$", "note", ")", ";", "}", "// Finally, if the \"seed\" option has been given, we will re-run the database", "// seed task to re-populate the database, which is convenient when adding", "// a migration and a seed at the same time, as it is only this command.", "if", "(", "$", "this", "->", "option", "(", "'seed'", ")", ")", "{", "$", "this", "->", "call", "(", "'db:seed'", ",", "[", "'--force'", "=>", "true", "]", ")", ";", "}", "}" ]

[ "Execute", "the", "console", "command", "." ]

[ "protected", "function", "prepareDatabase", "(", ")", "{", "$", "this", "->", "container", "[", "'migrator'", "]", "->", "setConnection", "(", "$", "this", "->", "option", "(", "'database'", ")", ")", ";", "if", "(", "!", "$", "this", "->", "container", "[", "'migrator'", "]", "->", "repositoryExists", "(", ")", ")", "{", "$", "this", "->", "call", "(", "'migrate:install'", ",", "[", "'--database'", "=>", "$", "this", "->", "option", "(", "'database'", ")", "]", ")", ";", "}", "}" ]

[ "Prepare", "the", "migration", "database", "for", "running", "." ]

[ "protected", "function", "registerEvent", "(", "$", "name", ",", "Closure", "$", "callback", ")", "{", "if", "(", "!", "isset", "(", "static", "::", "$", "dispatcher", ")", ")", "{", "$", "this", "->", "initEventDispatcher", "(", ")", ";", "}", "static", "::", "$", "dispatcher", "->", "listen", "(", "$", "name", ",", "$", "callback", ")", ";", "}" ]

[ "Register", "an", "event", "for", "the", "dispatcher", "to", "listen", "for", "." ]

[ "protected", "function", "fireEvent", "(", "$", "name", ",", "$", "payload", "=", "null", ")", "{", "if", "(", "!", "isset", "(", "static", "::", "$", "dispatcher", ")", ")", "{", "$", "this", "->", "initEventDispatcher", "(", ")", ";", "}", "static", "::", "$", "dispatcher", "->", "fire", "(", "$", "name", ",", "$", "payload", ")", ";", "}" ]

[ "Fire", "off", "an", "event", "." ]

[ "public", "function", "up", "(", ")", "{", "$", "db", "=", "Database", "::", "get", "(", ")", ";", "$", "table", "=", "File", "::", "trait_get_database_table", "(", ")", ";", "$", "tables", "=", "$", "db", "->", "get_column", "(", "\"SHOW TABLES LIKE '\"", ".", "$", "table", ".", "\"'\"", ",", "[", "]", ")", ";", "if", "(", "count", "(", "$", "tables", ")", "==", "0", ")", "{", "$", "db", "->", "query", "(", "\"\n\t\t\t\tCREATE TABLE IF NOT EXISTS `\"", ".", "$", "table", ".", "\"` (\n\t\t\t\t `id` int(11) unsigned NOT NULL AUTO_INCREMENT,\n\t\t\t\t `name` varchar(128) COLLATE utf8_unicode_ci NOT NULL,\n\t\t\t\t `unique_name` varchar(128) COLLATE utf8_unicode_ci NOT NULL,\n\t\t\t\t `md5sum` varchar(128) COLLATE utf8_unicode_ci NOT NULL,\n\t\t\t\t `mime_type` varchar(128) COLLATE utf8_unicode_ci NOT NULL,\n\t\t\t\t `size` int(11) NOT NULL,\n\t\t\t\t `created` datetime NOT NULL,\n\t\t\t\t `deleted` datetime NOT NULL,\n\t\t\t\t\tPRIMARY KEY (`id`)\n\t\t\t\t) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=1 ;\n\t\t\t\"", ",", "[", "]", ")", ";", "}", "}" ]

[ "Migrate", "up" ]

[ "public", "function", "clean", "(", "Composer", "$", "composer", ")", "{", "$", "rootPkg", "=", "$", "composer", "->", "getPackage", "(", ")", ";", "$", "extra", "=", "$", "rootPkg", "->", "getExtra", "(", ")", ";", "if", "(", "!", "isset", "(", "$", "extra", "[", "'wordpress-install-dir'", "]", ")", ")", "{", "return", ";", "}", "$", "filesystem", "=", "new", "Filesystem", "(", ")", ";", "$", "filesystem", "->", "remove", "(", "$", "extra", "[", "'wordpress-install-dir'", "]", ".", "'/wp-content'", ")", ";", "}" ]

[ "Clean", "up", "the", "WordPress", "installation", "directory", "." ]

[ "public", "function", "copy", "(", "$", "target", ")", "{", "if", "(", "!", "parent", "::", "copy", "(", "$", "target", ")", ")", "return", "false", ";", "return", "file_put_contents", "(", "$", "target", ",", "$", "this", "->", "content", ")", "!==", "false", ";", "}" ]

[ "Copies", "the", "text", "file", "s", "content", "to", "the", "local", "filesystem", "." ]

[ "protected", "static", "function", "boot", "(", ")", "{", "parent", "::", "boot", "(", ")", ";", "static", "::", "saving", "(", "function", "(", "Model", "$", "branch", ")", "{", "$", "parentColumn", "=", "$", "branch", "->", "getParentColumn", "(", ")", ";", "if", "(", "Request", "::", "has", "(", "$", "parentColumn", ")", "&&", "Request", "::", "input", "(", "$", "parentColumn", ")", "==", "$", "branch", "->", "getKey", "(", ")", ")", "{", "throw", "new", "\\", "Exception", "(", "trans", "(", "'merchant.parent_select_error'", ")", ")", ";", "}", "if", "(", "Request", "::", "has", "(", "'_order'", ")", ")", "{", "$", "order", "=", "Request", "::", "input", "(", "'_order'", ")", ";", "Request", "::", "offsetUnset", "(", "'_order'", ")", ";", "static", "::", "tree", "(", ")", "->", "saveOrder", "(", "$", "order", ")", ";", "return", "false", ";", "}", "return", "$", "branch", ";", "}", ")", ";", "}" ]

[ "{" ]

[ "public", "function", "setPermissionNames", "(", "$", "any", ",", "$", "none", ",", "$", "user", ",", "$", "anon", ")", "{", "if", "(", "$", "any", ")", "{", "$", "this", "->", "any", "=", "$", "any", ";", "}", "if", "(", "$", "none", ")", "{", "$", "this", "->", "none", "=", "$", "none", ";", "}", "if", "(", "$", "user", ")", "{", "$", "this", "->", "user", "=", "$", "user", ";", "}", "if", "(", "$", "anon", ")", "{", "$", "this", "->", "anon", "=", "$", "anon", ";", "}", "}" ]

[ "Set", "the", "names", "of", "the", "permissions", "to", "use", "for", "any", "none", "user", "and", "anonymous", "rules", ".", "Set", "any", "of", "these", "to", "null", "to", "continue", "using", "the", "current", "name", "." ]

[ "public", "function", "check", "(", "Request", "$", "request", ")", "{", "//first check the exemptions. If the request passes any of", "//these, skip all other rules and grant explicit access.", "foreach", "(", "$", "this", "->", "exemptions", "as", "$", "exemption", ")", "{", "try", "{", "if", "(", "true", "===", "$", "this", "->", "checkRule", "(", "$", "request", ",", "$", "exemption", ")", ")", "{", "return", "true", ";", "}", "//catch any exceptions - a failed exemption shouldn't", "//fail the firewall entirely. Just move to on to the", "//next one.", "}", "catch", "(", "BlockadeException", "$", "e", ")", "{", "}", "}", "//check the rules. If they fail they will throw exceptions.", "foreach", "(", "$", "this", "->", "rules", "as", "$", "rule", ")", "{", "$", "this", "->", "checkRule", "(", "$", "request", ",", "$", "rule", ")", ";", "}", "//all rules have passed, but we can't be sure the request is", "//good as there may be other firewalls. Returning false is", "//this Firewall saying 'not sure' to the FirewallListener.", "return", "false", ";", "}" ]

[ "Check", "if", "a", "Request", "has", "permission", "to", "access", "a", "resource", "." ]

[ "protected", "function", "_process", "(", "$", "css", ")", "{", "$", "css", "=", "str_replace", "(", "\"\\r\\n\"", ",", "\"\\n\"", ",", "$", "css", ")", ";", "// preserve empty comment after '>'", "// http://www.webdevout.net/css-hacks#in_css-selectors", "$", "css", "=", "preg_replace", "(", "'@>/\\\\*\\\\s*\\\\*/@'", ",", "'>/*keep*/'", ",", "$", "css", ")", ";", "// preserve empty comment between property and value", "// http://css-discuss.incutio.com/?page=BoxModelHack", "$", "css", "=", "preg_replace", "(", "'@/\\\\*\\\\s*\\\\*/\\\\s*:@'", ",", "'/*keep*/:'", ",", "$", "css", ")", ";", "$", "css", "=", "preg_replace", "(", "'@:\\\\s*/\\\\*\\\\s*\\\\*/@'", ",", "':/*keep*/'", ",", "$", "css", ")", ";", "// apply callback to all valid comments (and strip out surrounding ws", "$", "css", "=", "preg_replace_callback", "(", "'@\\\\s*/\\\\*([\\\\s\\\\S]*?)\\\\*/\\\\s*@'", ",", "array", "(", "$", "this", ",", "'_commentCB'", ")", ",", "$", "css", ")", ";", "// remove ws around { } and last semicolon in declaration block", "$", "css", "=", "preg_replace", "(", "'/\\\\s*{\\\\s*/'", ",", "'{'", ",", "$", "css", ")", ";", "$", "css", "=", "preg_replace", "(", "'/;?\\\\s*}\\\\s*/'", ",", "'}'", ",", "$", "css", ")", ";", "// remove ws surrounding semicolons", "$", "css", "=", "preg_replace", "(", "'/\\\\s*;\\\\s*/'", ",", "';'", ",", "$", "css", ")", ";", "// remove ws around urls", "$", "css", "=", "preg_replace", "(", "'/\n url\\\\( # url(\n \\\\s*\n ([^\\\\)]+?) # 1 = the URL (really just a bunch of non right parenthesis)\n \\\\s*\n \\\\) # )\n /x'", ",", "'url($1)'", ",", "$", "css", ")", ";", "// remove ws between rules and colons", "$", "css", "=", "preg_replace", "(", "'/\n \\\\s*\n ([{;]) # 1 = beginning of block or rule separator \n \\\\s*\n ([\\\\*_]?[\\\\w\\\\-]+) # 2 = property (and maybe IE filter)\n \\\\s*\n :\n \\\\s*\n (\\\\b|[#\\'\"]) # 3 = first character of a value\n /x'", ",", "'$1$2:$3'", ",", "$", "css", ")", ";", "// remove ws in selectors", "$", "css", "=", "preg_replace_callback", "(", "'/\n (?: # non-capture\n \\\\s*\n [^~>+,\\\\s]+ # selector part\n \\\\s*\n [,>+~] # combinators\n )+\n \\\\s*\n [^~>+,\\\\s]+ # selector part\n { # open declaration block\n /x'", ",", "array", "(", "$", "this", ",", "'_selectorsCB'", ")", ",", "$", "css", ")", ";", "// minimize hex colors", "$", "css", "=", "preg_replace", "(", "'/([^=])#([a-f\\\\d])\\\\2([a-f\\\\d])\\\\3([a-f\\\\d])\\\\4([\\\\s;\\\\}])/i'", ",", "'$1#$2$3$4$5'", ",", "$", "css", ")", ";", "// remove spaces between font families", "$", "css", "=", "preg_replace_callback", "(", "'/font-family:([^;}]+)([;}])/'", ",", "array", "(", "$", "this", ",", "'_fontFamilyCB'", ")", ",", "$", "css", ")", ";", "$", "css", "=", "preg_replace", "(", "'/@import\\\\s+url/'", ",", "'@import url'", ",", "$", "css", ")", ";", "// replace any ws involving newlines with a single newline", "$", "css", "=", "preg_replace", "(", "'/[ \\\\t]*\\\\n+\\\\s*/'", ",", "\"\\n\"", ",", "$", "css", ")", ";", "// separate common descendent selectors w/ newlines (to limit line lengths)", "$", "css", "=", "preg_replace", "(", "'/([\\\\w#\\\\.\\\\*]+)\\\\s+([\\\\w#\\\\.\\\\*]+){/'", ",", "\"$1\\n$2{\"", ",", "$", "css", ")", ";", "// Use newline after 1st numeric value (to limit line lengths).", "$", "css", "=", "preg_replace", "(", "'/\n ((?:padding|margin|border|outline):\\\\d+(?:px|em)?) # 1 = prop : 1st numeric value\n \\\\s+\n /x'", ",", "\"$1\\n\"", ",", "$", "css", ")", ";", "// prevent triggering IE6 bug: http://www.crankygeek.com/ie6pebug/", "$", "css", "=", "preg_replace", "(", "'/:first-l(etter|ine)\\\\{/'", ",", "':first-l$1 {'", ",", "$", "css", ")", ";", "return", "trim", "(", "$", "css", ")", ";", "}" ]

[ "Minify", "a", "CSS", "string" ]

[ "protected", "function", "_commentCB", "(", "$", "m", ")", "{", "$", "hasSurroundingWs", "=", "(", "trim", "(", "$", "m", "[", "0", "]", ")", "!==", "$", "m", "[", "1", "]", ")", ";", "$", "m", "=", "$", "m", "[", "1", "]", ";", "// $m is the comment content w/o the surrounding tokens, ", "// but the return value will replace the entire comment.", "if", "(", "$", "m", "===", "'keep'", ")", "{", "return", "'/**/'", ";", "}", "if", "(", "$", "m", "===", "'\" \"'", ")", "{", "// component of http://tantek.com/CSS/Examples/midpass.html", "return", "'/*\" \"*/'", ";", "}", "if", "(", "preg_match", "(", "'@\";\\\\}\\\\s*\\\\}/\\\\*\\\\s+@'", ",", "$", "m", ")", ")", "{", "// component of http://tantek.com/CSS/Examples/midpass.html", "return", "'/*\";}}/* */'", ";", "}", "if", "(", "$", "this", "->", "_inHack", ")", "{", "// inversion: feeding only to one browser", "if", "(", "preg_match", "(", "'@\n ^/ # comment started like /*/\n \\\\s*\n (\\\\S[\\\\s\\\\S]+?) # has at least some non-ws content\n \\\\s*\n /\\\\* # ends like /*/ or /**/\n @x'", ",", "$", "m", ",", "$", "n", ")", ")", "{", "// end hack mode after this comment, but preserve the hack and comment content", "$", "this", "->", "_inHack", "=", "false", ";", "return", "\"/*/{$n[1]}/**/\"", ";", "}", "}", "if", "(", "substr", "(", "$", "m", ",", "-", "1", ")", "===", "'\\\\'", ")", "{", "// comment ends like \\*/", "// begin hack mode and preserve hack", "$", "this", "->", "_inHack", "=", "true", ";", "return", "'/*\\\\*/'", ";", "}", "if", "(", "$", "m", "!==", "''", "&&", "$", "m", "[", "0", "]", "===", "'/'", ")", "{", "// comment looks like /*/ foo */", "// begin hack mode and preserve hack", "$", "this", "->", "_inHack", "=", "true", ";", "return", "'/*/*/'", ";", "}", "if", "(", "$", "this", "->", "_inHack", ")", "{", "// a regular comment ends hack mode but should be preserved", "$", "this", "->", "_inHack", "=", "false", ";", "return", "'/**/'", ";", "}", "// Issue 107: if there's any surrounding whitespace, it may be important, so ", "// replace the comment with a single space", "return", "$", "hasSurroundingWs", "// remove all other comments", "?", "' '", ":", "''", ";", "}" ]

[ "Process", "a", "comment", "and", "return", "a", "replacement" ]

[ "function", "fix", "(", "\\", "SplFileInfo", "$", "file", ",", "$", "content", ")", "{", "$", "tokens", "=", "Tokens", "::", "fromCode", "(", "$", "content", ")", ";", "for", "(", "$", "index", "=", "$", "tokens", "->", "count", "(", ")", "-", "1", ";", "$", "index", ">=", "0", ";", "--", "$", "index", ")", "{", "$", "token", "=", "$", "tokens", "[", "$", "index", "]", ";", "if", "(", "!", "$", "token", "->", "isGivenKind", "(", "T_FUNCTION", ")", ")", "{", "continue", ";", "}", "$", "startParenthesisIndex", "=", "$", "tokens", "->", "getNextTokenOfKind", "(", "$", "index", ",", "[", "'('", "]", ")", ";", "$", "endParenthesisIndex", "=", "$", "tokens", "->", "findBlockEnd", "(", "Tokens", "::", "BLOCK_TYPE_PARENTHESIS_BRACE", ",", "$", "startParenthesisIndex", ")", ";", "$", "startBraceIndex", "=", "$", "tokens", "->", "getNextTokenOfKind", "(", "$", "endParenthesisIndex", ",", "[", "';'", ",", "'{'", "]", ")", ";", "$", "startBraceToken", "=", "$", "tokens", "[", "$", "startBraceIndex", "]", ";", "if", "(", "$", "startBraceToken", "->", "equals", "(", "'{'", ")", ")", "{", "// fix single-line whitespace before {", "// eg: `function foo(){}` => `function foo() {}`", "// eg: `function foo() {}` => `function foo() {}`", "if", "(", "!", "$", "tokens", "[", "$", "startBraceIndex", "-", "1", "]", "->", "isWhitespace", "(", ")", "||", "$", "tokens", "[", "$", "startBraceIndex", "-", "1", "]", "->", "isWhitespace", "(", "$", "this", "->", "singleLineWhitespaceOptions", ")", ")", "{", "$", "tokens", "->", "ensureWhitespaceAtIndex", "(", "$", "startBraceIndex", "-", "1", ",", "1", ",", "' '", ")", ";", "}", "}", "$", "afterParenthesisIndex", "=", "$", "tokens", "->", "getNextNonWhitespace", "(", "$", "endParenthesisIndex", ")", ";", "$", "afterParenthesisToken", "=", "$", "tokens", "[", "$", "afterParenthesisIndex", "]", ";", "if", "(", "$", "afterParenthesisToken", "->", "isGivenKind", "(", "T_USE", ")", ")", "{", "$", "useStartParenthesisIndex", "=", "$", "tokens", "->", "getNextTokenOfKind", "(", "$", "afterParenthesisIndex", ",", "[", "'('", "]", ")", ";", "$", "useEndParenthesisIndex", "=", "$", "tokens", "->", "findBlockEnd", "(", "Tokens", "::", "BLOCK_TYPE_PARENTHESIS_BRACE", ",", "$", "useStartParenthesisIndex", ")", ";", "// fix whitespace after T_USE", "$", "tokens", "->", "ensureWhitespaceAtIndex", "(", "$", "afterParenthesisIndex", "+", "1", ",", "0", ",", "' '", ")", ";", "// remove single-line edge whitespaces inside use parentheses", "$", "this", "->", "fixParenthesisInnerEdge", "(", "$", "tokens", ",", "$", "useStartParenthesisIndex", ",", "$", "useEndParenthesisIndex", ")", ";", "// fix whitespace before T_USE", "$", "tokens", "->", "ensureWhitespaceAtIndex", "(", "$", "afterParenthesisIndex", "-", "1", ",", "1", ",", "' '", ")", ";", "}", "// remove single-line edge whitespaces inside parameters list parentheses", "$", "this", "->", "fixParenthesisInnerEdge", "(", "$", "tokens", ",", "$", "startParenthesisIndex", ",", "$", "endParenthesisIndex", ")", ";", "// remove whitespace before (", "// eg: `function foo () {}` => `function foo() {}`", "if", "(", "$", "tokens", "[", "$", "startParenthesisIndex", "-", "1", "]", "->", "isWhitespace", "(", ")", ")", "{", "$", "tokens", "[", "$", "startParenthesisIndex", "-", "1", "]", "->", "clear", "(", ")", ";", "}", "// fix whitespace after T_FUNCTION", "// eg: `function foo() {}` => `function foo() {}`", "// $tokens->ensureWhitespaceAtIndex($index + 1, 0, ' ');", "}", "return", "$", "tokens", "->", "generateCode", "(", ")", ";", "}" ]

[ "{" ]

[ "public", "function", "onKernelRequest", "(", "GetResponseEvent", "$", "event", ")", "{", "$", "request", "=", "$", "event", "->", "getRequest", "(", ")", ";", "if", "(", "$", "request", "->", "isMethod", "(", "'post'", ")", ")", "{", "$", "formId", "=", "$", "request", "->", "request", "->", "getInt", "(", "'form[form_id]'", ",", "0", ",", "true", ")", ";", "if", "(", "$", "formId", ">", "0", ")", "{", "$", "form", "=", "$", "this", "->", "container", "->", "get", "(", "'netvlies.form'", ")", "->", "get", "(", "$", "formId", ")", ";", "$", "sf2Form", "=", "$", "form", "->", "getSf2Form", "(", ")", ";", "$", "sf2Form", "->", "bind", "(", "$", "request", ")", ";", "if", "(", "$", "sf2Form", "->", "isValid", "(", ")", ")", "{", "$", "form", "->", "setSuccess", "(", "true", ")", ";", "$", "event", "=", "new", "FormEvent", "(", "$", "form", ")", ";", "$", "dispatcher", "=", "$", "this", "->", "container", "->", "get", "(", "'event_dispatcher'", ")", ";", "$", "dispatcher", "->", "dispatch", "(", "'form.success'", ",", "$", "event", ")", ";", "}", "}", "}", "}" ]

[ "Checks", "if", "a", "form", "post", "request", "was", "mad", ".", "If", "so", "it", "validates", "the", "form", "input", "and", "upon", "success", "dispatches", "the", "form", "success", "event", "which", "can", "be", "used", "for", "further", "custom", "handling", "of", "the", "received", "data", "." ]

[ "public", "function", "getAttribute", "(", "$", "key", ")", "{", "if", "(", "!", "$", "this", "->", "isValueObject", "(", "$", "key", ")", ")", "{", "return", "parent", "::", "getAttribute", "(", "$", "key", ")", ";", "}", "if", "(", "!", "$", "this", "->", "isValueObjectCached", "(", "$", "key", ")", ")", "{", "// Allow other mutators and such to do their work first.", "$", "value", "=", "parent", "::", "getAttribute", "(", "$", "key", ")", ";", "// Don't cast empty $value.", "if", "(", "$", "value", "===", "null", "||", "$", "value", "===", "''", ")", "{", "return", "null", ";", "}", "// Cache the instantiated value for future access.", "// This allows tests such as ($model->casted === $model->casted) to be true.", "$", "this", "->", "cacheValueObject", "(", "$", "key", ",", "$", "this", "->", "createValueObject", "(", "$", "key", ",", "$", "value", ")", ")", ";", "}", "return", "$", "this", "->", "getCachedValueObject", "(", "$", "key", ")", ";", "}" ]

[ "@param", "string", "$key" ]

[ "public", "function", "findAll", "(", "array", "$", "filter", "=", "[", "]", ",", "array", "$", "options", "=", "[", "]", ")", ":", "DocumentsCollection", "{", "$", "cursor", "=", "$", "this", "->", "getCollection", "(", ")", "->", "find", "(", "$", "filter", ",", "$", "options", ")", ";", "return", "new", "DocumentsCollection", "(", "$", "this", "->", "documentManager", ",", "$", "cursor", ",", "$", "this", "->", "documentClass", ")", ";", "}" ]

[ "@param", "array", "$filter", "@param", "array", "$options" ]

[ "public", "function", "findOne", "(", "array", "$", "filter", "=", "[", "]", ",", "array", "$", "options", "=", "[", "]", ")", "{", "$", "documents", "=", "$", "this", "->", "findAll", "(", "$", "filter", ",", "[", "'limit'", "=>", "1", "]", "+", "$", "options", ")", ";", "return", "$", "documents", "->", "valid", "(", ")", "?", "$", "documents", "->", "current", "(", ")", ":", "null", ";", "}" ]

[ "@param", "array", "$filter", "@param", "array", "$options" ]

[ "public", "function", "findOneAndDelete", "(", "array", "$", "filter", ",", "array", "$", "options", "=", "[", "]", ")", "{", "$", "options", "[", "'typeMap'", "]", "=", "[", "'root'", "=>", "$", "this", "->", "documentManager", "->", "getProxyClass", "(", "$", "this", "->", "documentClass", ")", ",", "'document'", "=>", "'array'", ",", "]", ";", "$", "document", "=", "$", "this", "->", "getCollection", "(", ")", "->", "findOneAndDelete", "(", "$", "filter", ",", "$", "options", ")", ";", "if", "(", "$", "document", "instanceof", "DocumentManagerAwareInterface", ")", "{", "$", "document", "->", "setManager", "(", "$", "this", "->", "documentManager", ")", ";", "}", "return", "$", "document", ";", "}" ]

[ "@param", "array", "$filter", "@param", "array", "$options" ]

[ "public", "function", "findOneAndUpdate", "(", "array", "$", "filter", ",", "array", "$", "update", ",", "array", "$", "options", "=", "[", "]", ")", "{", "$", "options", "[", "'typeMap'", "]", "=", "[", "'root'", "=>", "$", "this", "->", "documentManager", "->", "getProxyClass", "(", "$", "this", "->", "documentClass", ")", ",", "'document'", "=>", "'array'", ",", "]", ";", "$", "document", "=", "$", "this", "->", "getCollection", "(", ")", "->", "findOneAndUpdate", "(", "$", "filter", ",", "$", "update", ",", "$", "options", ")", ";", "if", "(", "$", "document", "instanceof", "DocumentManagerAwareInterface", ")", "{", "$", "document", "->", "setManager", "(", "$", "this", "->", "documentManager", ")", ";", "}", "return", "$", "document", ";", "}" ]

[ "@param", "array", "$filter", "@param", "array", "$update", "@param", "array", "$options" ]

[ "public", "function", "findOneAndReplace", "(", "array", "$", "filter", ",", "$", "replacement", ",", "array", "$", "options", "=", "[", "]", ")", "{", "$", "options", "[", "'typeMap'", "]", "=", "[", "'root'", "=>", "$", "this", "->", "documentManager", "->", "getProxyClass", "(", "$", "this", "->", "documentClass", ")", ",", "'document'", "=>", "'array'", ",", "]", ";", "$", "document", "=", "$", "this", "->", "getCollection", "(", ")", "->", "findOneAndReplace", "(", "$", "filter", ",", "$", "replacement", ",", "$", "options", ")", ";", "if", "(", "$", "document", "instanceof", "DocumentManagerAwareInterface", ")", "{", "$", "document", "->", "setManager", "(", "$", "this", "->", "documentManager", ")", ";", "}", "return", "$", "document", ";", "}" ]

[ "@param", "array", "$filter", "@param", "array|object", "$replacement", "@param", "array", "$options" ]

[ "public", "static", "function", "is_spam", "(", "array", "$", "values", "=", "[", "]", ")", "{", "$", "query_string", "=", "self", "::", "make_request", "(", "$", "values", ")", ";", "// If Akismet is not active, always return error", "if", "(", "!", "class_exists", "(", "'Akismet'", ")", "||", "!", "\\", "Akismet", "::", "get_api_key", "(", ")", ")", "{", "return", "new", "\\", "WP_Error", "(", "500", ",", "'Akismet is not active.'", ")", ";", "}", "// Make request", "add_filter", "(", "'akismet_ua'", ",", "[", "static", "::", "class", ",", "'get_ua'", "]", ",", "9", ")", ";", "$", "response", "=", "\\", "Akismet", "::", "http_post", "(", "$", "query_string", ",", "'comment-check'", ")", ";", "remove_filter", "(", "'akismet_ua'", ",", "[", "static", "::", "class", ",", "'get_ua'", "]", ",", "9", ")", ";", "// Parse result", "switch", "(", "$", "response", "[", "1", "]", ")", "{", "case", "'true'", ":", "return", "true", ";", "// This is spam.", "break", ";", "case", "'false'", ":", "return", "false", ";", "// This is not spam.", "break", ";", "default", ":", "// Something is wrong", "if", "(", "isset", "(", "$", "response", "[", "0", "]", "[", "'x-akismet-debug-help'", "]", ")", "&&", "!", "empty", "(", "$", "response", "[", "0", "]", "[", "'x-akismet-debug-help'", "]", ")", ")", "{", "$", "message", "=", "$", "response", "[", "0", "]", "[", "'x-akismet-debug-help'", "]", ";", "}", "else", "{", "$", "message", "=", "'Akismet return the invalid result. Something is wrong.'", ";", "}", "return", "new", "\\", "WP_Error", "(", "500", ",", "$", "message", ")", ";", "break", ";", "}", "}" ]

[ "Check", "if", "data", "is", "spam" ]

[ "public", "static", "function", "make_request", "(", "array", "$", "args", "=", "[", "]", ")", "{", "$", "args", "=", "wp_parse_args", "(", "[", "'blog'", "=>", "get_option", "(", "'home'", ")", ",", "'blog_lang'", "=>", "get_locale", "(", ")", ",", "'blog_charset'", "=>", "get_option", "(", "'blog_charset'", ")", ",", "'user_ip'", "=>", "isset", "(", "$", "_SERVER", "[", "'REMOTE_ADDR'", "]", ")", "?", "$", "_SERVER", "[", "'REMOTE_ADDR'", "]", ":", "''", ",", "'user_agent'", "=>", "isset", "(", "$", "_SERVER", "[", "'HTTP_USER_AGENT'", "]", ")", "?", "$", "_SERVER", "[", "'HTTP_USER_AGENT'", "]", ":", "''", ",", "'referrer'", "=>", "isset", "(", "$", "_SERVER", "[", "'HTTP_REFERER'", "]", ")", "?", "$", "_SERVER", "[", "'HTTP_REFERER'", "]", ":", "''", ",", "]", ",", "$", "args", ")", ";", "// Add server variables", "foreach", "(", "$", "_SERVER", "as", "$", "key", "=>", "$", "value", ")", "{", "switch", "(", "$", "key", ")", "{", "case", "'REMOTE_ADDR'", ":", "case", "'HTTP_USER_AGENT'", ":", "case", "'HTTP_REFERER'", ":", "case", "'HTTP_COOKIE'", ":", "case", "'HTTP_COOKIE2'", ":", "case", "'PHP_AUTH_PW'", ":", "// Ignore", "break", ";", "default", ":", "$", "args", "[", "$", "key", "]", "=", "$", "value", ";", "break", ";", "}", "}", "return", "http_build_query", "(", "$", "args", ")", ";", "}" ]

[ "Make", "request", "arguments" ]

[ "protected", "function", "getMigrationPaths", "(", ")", "{", "// Here, we will check to see if a path option has been defined. If it has we will", "// use the path relative to the root of the installation folder so our database", "// migrations may be run for any customized path from within the application.", "if", "(", "$", "this", "->", "input", "->", "hasOption", "(", "'path'", ")", "&&", "$", "this", "->", "option", "(", "'path'", ")", ")", "{", "return", "[", "root_path", "(", "$", "this", "->", "option", "(", "'path'", ")", ")", "]", ";", "}", "return", "array_merge", "(", "[", "$", "this", "->", "getMigrationPath", "(", ")", "]", ",", "$", "this", "->", "container", "[", "'migrator'", "]", "->", "paths", "(", ")", ")", ";", "}" ]

[ "Get", "all", "of", "the", "migration", "paths", "." ]

[ "public", "function", "get", "(", "$", "url", ",", "$", "data", "=", "[", "]", ",", "$", "method", "=", "'post'", ")", "{", "$", "ch", "=", "curl_init", "(", "$", "this", "->", "gitlab_host", ".", "'/api/v3'", ".", "$", "url", ")", ";", "curl_setopt", "(", "$", "ch", ",", "CURLOPT_HEADER", ",", "0", ")", ";", "curl_setopt", "(", "$", "ch", ",", "CURLOPT_HTTPHEADER", ",", "array", "(", "'PRIVATE-TOKEN:'", ".", "$", "this", "->", "private_key", ")", ")", ";", "if", "(", "$", "this", "->", "debug", ")", "{", "curl_setopt", "(", "$", "ch", ",", "CURLOPT_VERBOSE", ",", "true", ")", ";", "if", "(", "!", "\\", "sb", "\\", "Gateway", "::", "$", "command_line", ")", "{", "$", "curl_log", "=", "fopen", "(", "\"php://temp\"", ",", "'rw'", ")", ";", "curl_setopt", "(", "$", "ch", ",", "CURLOPT_STDERR", ",", "$", "curl_log", ")", ";", "}", "}", "curl_setopt", "(", "$", "ch", ",", "CURLOPT_RETURNTRANSFER", ",", "true", ")", ";", "if", "(", "$", "data", ")", "{", "curl_setopt", "(", "$", "ch", ",", "CURLOPT_POST", ",", "true", ")", ";", "curl_setopt", "(", "$", "ch", ",", "CURLOPT_POSTFIELDS", ",", "http_build_query", "(", "$", "data", ")", ")", ";", "if", "(", "$", "method", "!=", "'post'", ")", "{", "curl_setopt", "(", "$", "ch", ",", "CURLOPT_CUSTOMREQUEST", ",", "$", "method", ")", ";", "}", "}", "$", "error", "=", "curl_error", "(", "$", "ch", ")", ";", "$", "error_no", "=", "curl_errno", "(", "$", "ch", ")", ";", "if", "(", "$", "error_no", ")", "{", "throw", "(", "new", "\\", "Exception", "(", "$", "error", ".", "': '", ".", "$", "error_no", ")", ")", ";", "}", "$", "data", "=", "json_decode", "(", "curl_exec", "(", "$", "ch", ")", ")", ";", "if", "(", "$", "this", "->", "debug", "&&", "!", "\\", "sb", "\\", "Gateway", "::", "$", "command_line", ")", "{", "rewind", "(", "$", "curl_log", ")", ";", "$", "output", "=", "fread", "(", "$", "curl_log", ",", "2048", ")", ";", "echo", "\"<pre>\"", ".", "print_r", "(", "$", "output", ",", "1", ")", ".", "\"</pre>\"", ";", "fclose", "(", "$", "curl_log", ")", ";", "}", "return", "$", "data", ";", "}" ]

[ "GRabs", "data", "from", "a", "URL", "and", "json_decodes", "it" ]

[ "public", "function", "find", "(", "ExampleDescriptor", "$", "descriptor", ")", "{", "$", "filename", "=", "$", "descriptor", "->", "getFilePath", "(", ")", ";", "$", "file", "=", "$", "this", "->", "getExampleFileContents", "(", "$", "filename", ")", ";", "if", "(", "!", "$", "file", ")", "{", "return", "\"** File not found : {$filename} **\"", ";", "}", "return", "implode", "(", "''", ",", "array_slice", "(", "$", "file", ",", "$", "descriptor", "->", "getStartingLine", "(", ")", "-", "1", ",", "$", "descriptor", "->", "getLineCount", "(", ")", ")", ")", ";", "}" ]

[ "Attempts", "to", "find", "the", "example", "contents", "for", "the", "given", "descriptor", "." ]

[ "private", "function", "getExampleFileContents", "(", "$", "filename", ")", "{", "$", "normalizedPath", "=", "null", ";", "foreach", "(", "$", "this", "->", "exampleDirectories", "as", "$", "directory", ")", "{", "$", "exampleFileFromConfig", "=", "$", "this", "->", "constructExamplePath", "(", "$", "directory", ",", "$", "filename", ")", ";", "if", "(", "is_readable", "(", "$", "exampleFileFromConfig", ")", ")", "{", "$", "normalizedPath", "=", "$", "exampleFileFromConfig", ";", "break", ";", "}", "}", "if", "(", "!", "$", "normalizedPath", ")", "{", "if", "(", "is_readable", "(", "$", "this", "->", "getExamplePathFromSource", "(", "$", "filename", ")", ")", ")", "{", "$", "normalizedPath", "=", "$", "this", "->", "getExamplePathFromSource", "(", "$", "filename", ")", ";", "}", "elseif", "(", "is_readable", "(", "$", "this", "->", "getExamplePathFromExampleDirectory", "(", "$", "filename", ")", ")", ")", "{", "$", "normalizedPath", "=", "$", "this", "->", "getExamplePathFromExampleDirectory", "(", "$", "filename", ")", ";", "}", "elseif", "(", "is_readable", "(", "$", "filename", ")", ")", "{", "$", "normalizedPath", "=", "$", "filename", ";", "}", "}", "return", "$", "normalizedPath", "&&", "is_readable", "(", "$", "normalizedPath", ")", "?", "file", "(", "$", "normalizedPath", ")", ":", "null", ";", "}" ]

[ "Attempts", "to", "find", "the", "requested", "example", "file", "and", "returns", "its", "contents", "or", "null", "if", "no", "file", "was", "found", "." ]

[ "public", "function", "rankingTeamPointsAction", "(", "$", "id", ")", "{", "$", "group", "=", "$", "this", "->", "getDoctrine", "(", ")", "->", "getRepository", "(", "'VideoGamesRecordsCoreBundle:Group'", ")", "->", "getWithGame", "(", "$", "id", ")", ";", "$", "breadcrumbs", "=", "$", "this", "->", "getGroupBreadcrumbs", "(", "$", "group", ")", ";", "$", "breadcrumbs", "->", "addItem", "(", "'game.pointchartranking.full'", ")", ";", "return", "$", "this", "->", "render", "(", "'VideoGamesRecordsTeamBundle:Ranking:points-chart.html.twig'", ",", "[", "'ranking'", "=>", "$", "this", "->", "getDoctrine", "(", ")", "->", "getRepository", "(", "'VideoGamesRecordsTeamBundle:TeamGroup'", ")", "->", "getRankingPoints", "(", "$", "id", ",", "100", ",", "null", ")", ",", "]", ")", ";", "}" ]

[ "@Route", "(", "/", "ranking", "-", "points", "/", "id", "/", "{", "id", "}", "requirements", "=", "{", "id", ":", "[", "1", "-", "9", "]", "\\", "d", "*", "}", "name", "=", "vgr_team_group_ranking_points", ")", "@Method", "(", "GET", ")", "@Cache", "(", "smaxage", "=", "10", ")" ]

[ "public", "function", "rankingTeamMedalsAction", "(", "$", "id", ")", "{", "$", "group", "=", "$", "this", "->", "getDoctrine", "(", ")", "->", "getRepository", "(", "'VideoGamesRecordsCoreBundle:Group'", ")", "->", "getWithGame", "(", "$", "id", ")", ";", "$", "breadcrumbs", "=", "$", "this", "->", "getGroupBreadcrumbs", "(", "$", "group", ")", ";", "$", "breadcrumbs", "->", "addItem", "(", "'game.medalranking.full'", ")", ";", "return", "$", "this", "->", "render", "(", "'VideoGamesRecordsTeamBundle:Ranking:medals.html.twig'", ",", "[", "'ranking'", "=>", "$", "this", "->", "getDoctrine", "(", ")", "->", "getRepository", "(", "'VideoGamesRecordsTeamBundle:TeamGroup'", ")", "->", "getRankingMedals", "(", "$", "id", ",", "100", ",", "null", ")", ",", "]", ")", ";", "}" ]

[ "@Route", "(", "/", "ranking", "-", "medals", "/", "id", "/", "{", "id", "}", "requirements", "=", "{", "id", ":", "[", "1", "-", "9", "]", "\\", "d", "*", "}", "name", "=", "vgr_team_group_ranking_medals", ")", "@Method", "(", "GET", ")", "@Cache", "(", "smaxage", "=", "10", ")" ]

[ "protected", "function", "getContent", "(", "View", "$", "view", ",", "$", "format", ")", "{", "$", "template", "=", "$", "this", "->", "twig", "->", "resolveTemplate", "(", "$", "view", "->", "getTemplate", "(", ")", ")", ";", "return", "$", "template", "->", "render", "(", "$", "view", "->", "getDataAsArray", "(", ")", ")", ";", "}" ]

[ "{" ]

[ "public", "function", "search", "(", "$", "params", ")", "{", "$", "this", "->", "load", "(", "$", "params", ")", ";", "$", "query", "=", "$", "this", "->", "_query", "(", ")", ";", "$", "dataProvider", "=", "new", "ActiveDataProvider", "(", "[", "'query'", "=>", "$", "query", ",", "'pagination'", "=>", "[", "'pageSize'", "=>", "10", ",", "]", ",", "'sort'", "=>", "[", "'attributes'", "=>", "[", "'code'", ",", "'common_name'", ",", "'official_name'", ",", "'has_postcodes'", "]", ",", "]", "]", ")", ";", "if", "(", "!", "$", "this", "->", "validate", "(", ")", ")", "{", "// uncomment the following line if you do not want to return any records when validation fails", "// $query->where('0=1');", "return", "$", "dataProvider", ";", "}", "$", "query", "->", "andFilterWhere", "(", "[", "'iso_2'", "=>", "$", "this", "->", "code", "]", ")", ";", "$", "query", "->", "andFilterWhere", "(", "[", "'default_label.common_name'", "=>", "$", "this", "->", "common_name", "]", ")", ";", "$", "query", "->", "andFilterWhere", "(", "[", "'default_label.official_name'", "=>", "$", "this", "->", "official_name", "]", ")", ";", "return", "$", "dataProvider", ";", "}" ]

[ "Creates", "data", "provider", "instance", "with", "search", "query", "applied" ]

[ "public", "function", "populate", "(", "$", "data", "=", "array", "(", ")", ")", "{", "if", "(", "isset", "(", "$", "data", "[", "'title'", "]", ")", "&&", "$", "data", "[", "'title'", "]", "!=", "null", ")", "{", "$", "this", "->", "title", "=", "$", "data", "[", "'title'", "]", ";", "}", "if", "(", "isset", "(", "$", "data", "[", "'subtitle'", "]", ")", "&&", "$", "data", "[", "'subtitle'", "]", "!=", "null", ")", "{", "$", "this", "->", "subtitle", "=", "$", "data", "[", "'subtitle'", "]", ";", "}", "if", "(", "isset", "(", "$", "data", "[", "'active'", "]", ")", "&&", "$", "data", "[", "'active'", "]", "!=", "null", ")", "{", "$", "this", "->", "active", "=", "$", "data", "[", "'active'", "]", ";", "}", "}" ]

[ "Populate", "from", "an", "array", "." ]

[ "public", "function", "Lexer", "(", "$", "template", ",", "$", "output", "=", "array", "(", ")", ",", "$", "position", "=", "0", ")", "{", "$", "output", "=", "$", "this", "->", "PregCapture", "(", "$", "template", ",", "$", "output", ",", "$", "position", ")", ";", "$", "length", "=", "strlen", "(", "$", "template", ")", ";", "$", "lex", "=", "array", "(", ")", ";", "$", "lex", "[", "'text'", "]", "=", "substr", "(", "$", "template", ",", "$", "position", ",", "$", "length", ")", ";", "$", "lex", "[", "'start'", "]", "=", "$", "position", ";", "$", "lex", "[", "'end'", "]", "=", "$", "length", ";", "$", "lex", "[", "'length'", "]", "=", "(", "$", "length", "-", "$", "position", ")", ";", "$", "lex", "[", "'flag'", "]", "=", "false", ";", "$", "lex", "[", "'inverse'", "]", "=", "false", ";", "$", "lex", "[", "'key'", "]", "=", "false", ";", "$", "lex", "[", "'param'", "]", "=", "false", ";", "$", "output", "[", "]", "=", "$", "lex", ";", "return", "$", "output", ";", "}" ]

[ "@param", "$template", "@param", "array", "$output", "@param", "int", "$position", "@return", "array" ]

[ "private", "function", "PregCapture", "(", "&", "$", "template", ",", "&", "$", "output", ",", "&", "$", "position", ")", "{", "while", "(", "preg_match", "(", "ISlicer", "::", "PATTERN", ",", "$", "template", ",", "$", "result", ",", "PREG_OFFSET_CAPTURE", ",", "$", "position", ")", ">", "0", ")", "{", "$", "capture", "=", "new", "PregOffsetCapture", "(", "$", "result", ")", ";", "$", "lex", "=", "array", "(", ")", ";", "$", "lex", "[", "'text'", "]", "=", "substr", "(", "$", "template", ",", "$", "position", ",", "$", "capture", "->", "SliceBegin", "(", ")", "-", "$", "position", ")", ";", "$", "lex", "[", "'start'", "]", "=", "$", "capture", "->", "SliceBegin", "(", ")", ";", "$", "lex", "[", "'end'", "]", "=", "$", "capture", "->", "SliceEnd", "(", ")", ";", "$", "lex", "[", "'length'", "]", "=", "$", "capture", "->", "SliceLength", "(", ")", ";", "$", "lex", "[", "'flag'", "]", "=", "$", "capture", "->", "Capture", "(", "ISlicer", "::", "FLAG", ")", ";", "$", "lex", "[", "'inverse'", "]", "=", "$", "capture", "->", "Capture", "(", "ISlicer", "::", "INVERSE", ")", ";", "$", "lex", "[", "'key'", "]", "=", "$", "capture", "->", "Capture", "(", "ISlicer", "::", "KEY", ")", ";", "$", "lex", "[", "'param'", "]", "=", "$", "capture", "->", "Capture", "(", "ISlicer", "::", "PARAMETER", ")", ";", "$", "position", "=", "$", "lex", "[", "'end'", "]", ";", "if", "(", "$", "capture", "->", "Capture", "(", "ISlicer", "::", "FLAG", ")", "===", "ISlicer", "::", "C_CLOSE", ")", "{", "$", "output", "[", "]", "=", "$", "lex", ";", "break", ";", "}", "$", "a", "=", "$", "capture", "->", "Capture", "(", "ISlicer", "::", "BEFORE", ")", "===", "ISlicer", "::", "A", ";", "$", "b", "=", "$", "capture", "->", "Capture", "(", "ISlicer", "::", "AFTER", ")", "===", "ISlicer", "::", "H", ";", "if", "(", "$", "a", "&&", "$", "b", ")", "{", "$", "this", "->", "PregCapture", "(", "$", "template", ",", "$", "lex", "[", "'child'", "]", ",", "$", "position", ")", ";", "}", "else", "{", "unset", "(", "$", "lex", "[", "'child'", "]", ")", ";", "}", "$", "output", "[", "]", "=", "$", "lex", ";", "}", "return", "$", "output", ";", "}" ]

[ "@param", "$template", "@param", "$output", "@param", "$position", "@return", "array" ]

[ "protected", "static", "function", "getAdapterName", "(", "$", "name", ",", "$", "namespace", "=", "'TeamSpeak3/Adapter'", ")", "{", "$", "path", "=", "self", "::", "getFilePath", "(", "$", "namespace", ")", ";", "$", "scan", "=", "scandir", "(", "$", "path", ")", ";", "foreach", "(", "$", "scan", "as", "$", "node", ")", "{", "$", "file", "=", "Str", "::", "factory", "(", "$", "node", ")", "->", "toLower", "(", ")", ";", "if", "(", "$", "file", "->", "startsWith", "(", "$", "name", ")", "&&", "$", "file", "->", "endsWith", "(", "\".php\"", ")", ")", "{", "return", "str_replace", "(", "'.php'", ",", "''", ",", "\"Adams\\\\TeamSpeak3\\\\Adapter\\\\\"", ".", "$", "node", ")", ";", "}", "}", "throw", "new", "AdapterException", "(", "\"adapter '\"", ".", "$", "name", ".", "\"' does not exist\"", ")", ";", "}" ]

[ "Returns", "the", "name", "of", "an", "adapter", "class", "by", "$name", "." ]

[ "public", "function", "addGraphMetadata", "(", "GraphNode", "$", "node", ",", "GraphMetadataInterface", "$", "data", ")", "{", "$", "this", "->", "nodes", "[", "]", "=", "[", "'node'", "=>", "$", "node", ",", "'object'", "=>", "$", "data", ",", "]", ";", "return", "$", "this", ";", "}" ]

[ "Add", "OpenGraph", "metadata" ]

[ "public", "function", "getRootNodesWithTree", "(", ")", "{", "// $all = $this->findAll();", "$", "all", "=", "$", "this", "->", "findBy", "(", "[", "]", ",", "[", "'sortMaterializedPath'", "=>", "'ASC'", "]", ")", ";", "$", "allRootNodes", "=", "array", "(", ")", ";", "foreach", "(", "$", "all", "as", "$", "node", ")", "{", "if", "(", "$", "node", "->", "isRootNode", "(", ")", ")", "{", "$", "allRootNodes", "[", "]", "=", "$", "node", ";", "}", "}", "foreach", "(", "$", "allRootNodes", "as", "$", "root", ")", "{", "$", "root", "->", "buildTree", "(", "$", "all", ")", ";", "}", "return", "$", "allRootNodes", ";", "}" ]

[ "{" ]

[ "public", "function", "match", "(", "$", "actual", ")", "{", "$", "this", "->", "actual", "=", "$", "actual", ";", "$", "truthyMatcher", "=", "new", "TruthyMatcher", "(", ")", ";", "return", "$", "truthyMatcher", "->", "match", "(", "$", "actual", ")", "===", "false", ";", "}" ]

[ "{" ]

[ "public", "function", "get", "(", "$", "path", ",", "callable", "$", "callback", ")", "{", "$", "route", "=", "new", "Route", "(", "'GET'", ",", "$", "path", ",", "$", "callback", ")", ";", "$", "this", "->", "_routes", "[", "]", "=", "$", "route", ";", "return", "$", "route", ";", "}" ]

[ "Maps", "a", "GET", "request", "to", "a", "callable", "." ]

[ "public", "function", "post", "(", "$", "path", ",", "callable", "$", "callback", ")", "{", "$", "route", "=", "new", "Route", "(", "'POST'", ",", "$", "path", ",", "$", "callback", ")", ";", "$", "this", "->", "_routes", "[", "]", "=", "$", "route", ";", "return", "$", "route", ";", "}" ]

[ "Maps", "a", "POST", "request", "to", "a", "callable", "." ]

[ "public", "function", "put", "(", "$", "path", ",", "callable", "$", "callback", ")", "{", "$", "route", "=", "new", "Route", "(", "'PUT'", ",", "$", "path", ",", "$", "callback", ")", ";", "$", "this", "->", "_routes", "[", "]", "=", "$", "route", ";", "return", "$", "route", ";", "}" ]

[ "Maps", "a", "PUT", "request", "to", "a", "callable", "." ]

[ "public", "function", "patch", "(", "$", "path", ",", "callable", "$", "callback", ")", "{", "$", "route", "=", "new", "Route", "(", "'PATCH'", ",", "$", "path", ",", "$", "callback", ")", ";", "$", "this", "->", "_routes", "[", "]", "=", "$", "route", ";", "return", "$", "route", ";", "}" ]

[ "Maps", "a", "PATCH", "request", "to", "a", "callable", "." ]

[ "public", "function", "delete", "(", "$", "path", ",", "callable", "$", "callback", ")", "{", "$", "route", "=", "new", "Route", "(", "'DELETE'", ",", "$", "path", ",", "$", "callback", ")", ";", "$", "this", "->", "_routes", "[", "]", "=", "$", "route", ";", "return", "$", "route", ";", "}" ]

[ "Maps", "a", "DELETE", "request", "to", "a", "callable", "." ]

[ "public", "function", "match", "(", "$", "method", ",", "$", "path", ",", "callable", "$", "callback", ")", "{", "$", "route", "=", "new", "Route", "(", "mb_strtoupper", "(", "$", "method", ")", ",", "$", "path", ",", "$", "callback", ")", ";", "$", "this", "->", "_routes", "[", "]", "=", "$", "route", ";", "return", "$", "route", ";", "}" ]

[ "Maps", "a", "request", "to", "a", "callable", "." ]

[ "public", "function", "update", "(", "Request", "$", "request", ")", "{", "if", "(", "!", "$", "request", "->", "has", "(", "'password'", ")", ")", "{", "$", "this", "->", "validator", "->", "setData", "(", "$", "request", "->", "except", "(", "[", "'password'", ",", "'password_confirmation'", "]", ")", ")", ";", "}", "$", "user", "=", "$", "this", "->", "userRepo", "->", "getById", "(", "$", "request", "->", "user", "(", ")", "->", "id", ")", ";", "$", "this", "->", "authorize", "(", "'update'", ",", "$", "user", ")", ";", "$", "input", "=", "$", "this", "->", "validator", "->", "bind", "(", "'nick'", ",", "[", "'user_id'", "=>", "$", "user", "->", "id", "]", ")", "->", "bind", "(", "'email'", ",", "[", "'user_id'", "=>", "$", "user", "->", "id", "]", ")", "->", "validate", "(", "'update'", ")", ";", "$", "user", "=", "$", "this", "->", "userRepo", "->", "update", "(", "$", "user", ",", "$", "input", ")", ";", "return", "$", "this", "->", "respondWithSuccess", "(", "$", "user", ",", "new", "UserTransformer", "(", ")", ")", ";", "}" ]

[ "Updates", "the", "specified", "resource", "in", "the", "database", "." ]

[ "public", "function", "check", "(", "$", "file", ",", "$", "verify", "=", "null", ")", "{", "if", "(", "$", "this", "->", "prepareFile", "(", "$", "file", ")", ")", "{", "$", "leads", "=", "$", "this", "->", "leads", "(", ")", ";", "if", "(", "!", "is_null", "(", "$", "verify", ")", ")", "{", "if", "(", "isset", "(", "$", "leads", "[", "$", "verify", "]", ")", ")", "{", "return", "$", "this", "->", "checkLead", "(", "$", "leads", "[", "$", "verify", "]", ")", ";", "}", "return", "false", ";", "}", "else", "{", "foreach", "(", "$", "leads", "as", "$", "lead", ")", "{", "$", "results", "=", "$", "this", "->", "checkLead", "(", "$", "lead", ")", ";", "// We're sure we've found something.\r", "if", "(", "$", "results", "===", "true", ")", "{", "return", "true", ";", "}", "// We're sure this detective can find nothing.\r", "else", "if", "(", "$", "results", "===", "false", ")", "{", "break", ";", "}", "}", "}", "}", "return", "false", ";", "}" ]

[ "Check", "the", "the", "file", "against", "our", "leads", "." ]

[ "protected", "function", "closeCase", "(", "$", "ext", ",", "$", "mime", ",", "array", "$", "meta", "=", "array", "(", ")", ")", "{", "$", "this", "->", "caseClosed", "=", "true", ";", "$", "this", "->", "extension", "=", "$", "ext", ";", "$", "this", "->", "mime", "=", "$", "mime", ";", "$", "this", "->", "metadata", "=", "$", "meta", ";", "return", "true", ";", "}" ]

[ "Closes", "the", "case", "by", "setting", "protected", "properties", "." ]

[ "protected", "function", "leads", "(", ")", "{", "// Pull a list of methods that have the leadEXT syntax.\r", "$", "leads", "=", "preg_grep", "(", "'/^lead(?<ext>[A-Z0-9]+)$/'", ",", "get_class_methods", "(", "$", "this", ")", ")", ";", "// Organize them as an array where keys and values are the same thing.\r", "$", "leads", "=", "array_combine", "(", "$", "leads", ",", "$", "leads", ")", ";", "// Try to find an extension method from our file.\r", "$", "ext", "=", "\"lead\"", ".", "strtoupper", "(", "pathinfo", "(", "$", "this", "->", "file", ",", "PATHINFO_EXTENSION", ")", ")", ";", "// If that method exists,\r", "// bring it to the front of the array so that it is checked first.\r", "if", "(", "isset", "(", "$", "leads", "[", "$", "ext", "]", ")", ")", "{", "$", "newLeads", "=", "[", "$", "ext", "=>", "$", "leads", "[", "$", "ext", "]", "]", ";", "unset", "(", "$", "leads", "[", "$", "ext", "]", ")", ";", "$", "newLeads", "+=", "$", "leads", ";", "$", "leads", "=", "$", "newLeads", ";", "unset", "(", "$", "newleads", ")", ";", "}", "return", "$", "leads", ";", "}" ]

[ "Returns", "an", "array", "of", "file", "extensions", "this", "detective", "has", "leads", "on", "." ]

[ "public", "function", "consume", "(", ")", "{", "if", "(", "$", "this", "->", "logger", ")", "{", "$", "this", "->", "logger", "->", "debug", "(", "'Starting poller'", ")", ";", "}", "foreach", "(", "$", "this", "->", "middlewares", "as", "$", "middleware", ")", "{", "if", "(", "$", "middleware", "instanceof", "InitializableInterface", ")", "{", "$", "middleware", "->", "initialize", "(", ")", ";", "}", "}", "while", "(", "true", ")", "{", "if", "(", "$", "this", "->", "process", "(", ")", "===", "false", ")", "{", "break", ";", "}", "if", "(", "$", "this", "->", "sleep", "(", ")", "===", "false", ")", "{", "break", ";", "}", "}", "if", "(", "$", "this", "->", "logger", ")", "{", "$", "this", "->", "logger", "->", "debug", "(", "'Stopping poller'", ")", ";", "}", "}" ]

[ "{" ]

[ "function", "reset", "(", "$", "suffix", "=", "NULL", ",", "$", "lifetime", "=", "0", ")", "{", "if", "(", "!", "$", "this", "->", "dsn", ")", "return", "TRUE", ";", "$", "regex", "=", "'/'", ".", "preg_quote", "(", "$", "this", "->", "prefix", ".", "'.'", ",", "'/'", ")", ".", "'.+?'", ".", "preg_quote", "(", "$", "suffix", ",", "'/'", ")", ".", "'/'", ";", "$", "parts", "=", "explode", "(", "'='", ",", "$", "this", "->", "dsn", ",", "2", ")", ";", "switch", "(", "$", "parts", "[", "0", "]", ")", "{", "case", "'apc'", ":", "case", "'apcu'", ":", "$", "info", "=", "apc_cache_info", "(", "'user'", ")", ";", "if", "(", "!", "empty", "(", "$", "info", "[", "'cache_list'", "]", ")", ")", "{", "$", "key", "=", "array_key_exists", "(", "'info'", ",", "$", "info", "[", "'cache_list'", "]", "[", "0", "]", ")", "?", "'info'", ":", "'key'", ";", "$", "mtkey", "=", "array_key_exists", "(", "'mtime'", ",", "$", "info", "[", "'cache_list'", "]", "[", "0", "]", ")", "?", "'mtime'", ":", "'modification_time'", ";", "foreach", "(", "$", "info", "[", "'cache_list'", "]", "as", "$", "item", ")", "if", "(", "preg_match", "(", "$", "regex", ",", "$", "item", "[", "$", "key", "]", ")", "&&", "$", "item", "[", "$", "mtkey", "]", "+", "$", "lifetime", "<", "time", "(", ")", ")", "apc_delete", "(", "$", "item", "[", "$", "key", "]", ")", ";", "}", "return", "TRUE", ";", "case", "'redis'", ":", "$", "fw", "=", "Base", "::", "instance", "(", ")", ";", "$", "keys", "=", "$", "this", "->", "ref", "->", "keys", "(", "$", "this", "->", "prefix", ".", "'.*'", ".", "$", "suffix", ")", ";", "foreach", "(", "$", "keys", "as", "$", "key", ")", "{", "$", "val", "=", "$", "fw", "->", "unserialize", "(", "$", "this", "->", "ref", "->", "get", "(", "$", "key", ")", ")", ";", "if", "(", "$", "val", "[", "1", "]", "+", "$", "lifetime", "<", "time", "(", ")", ")", "$", "this", "->", "ref", "->", "del", "(", "$", "key", ")", ";", "}", "return", "TRUE", ";", "case", "'memcache'", ":", "foreach", "(", "memcache_get_extended_stats", "(", "$", "this", "->", "ref", ",", "'slabs'", ")", "as", "$", "slabs", ")", "foreach", "(", "array_filter", "(", "array_keys", "(", "$", "slabs", ")", ",", "'is_numeric'", ")", "as", "$", "id", ")", "foreach", "(", "memcache_get_extended_stats", "(", "$", "this", "->", "ref", ",", "'cachedump'", ",", "$", "id", ")", "as", "$", "data", ")", "if", "(", "is_array", "(", "$", "data", ")", ")", "foreach", "(", "$", "data", "as", "$", "key", "=>", "$", "val", ")", "if", "(", "preg_match", "(", "$", "regex", ",", "$", "key", ")", "&&", "$", "val", "[", "1", "]", "+", "$", "lifetime", "<", "time", "(", ")", ")", "memcache_delete", "(", "$", "this", "->", "ref", ",", "$", "key", ")", ";", "return", "TRUE", ";", "case", "'wincache'", ":", "$", "info", "=", "wincache_ucache_info", "(", ")", ";", "foreach", "(", "$", "info", "[", "'ucache_entries'", "]", "as", "$", "item", ")", "if", "(", "preg_match", "(", "$", "regex", ",", "$", "item", "[", "'key_name'", "]", ")", "&&", "$", "item", "[", "'use_time'", "]", "+", "$", "lifetime", "<", "time", "(", ")", ")", "wincache_ucache_delete", "(", "$", "item", "[", "'key_name'", "]", ")", ";", "return", "TRUE", ";", "case", "'xcache'", ":", "return", "TRUE", ";", "/* Not supported */", "case", "'folder'", ":", "if", "(", "$", "glob", "=", "@", "glob", "(", "$", "parts", "[", "1", "]", ".", "'*'", ")", ")", "foreach", "(", "$", "glob", "as", "$", "file", ")", "if", "(", "preg_match", "(", "$", "regex", ",", "basename", "(", "$", "file", ")", ")", "&&", "filemtime", "(", "$", "file", ")", "+", "$", "lifetime", "<", "time", "(", ")", ")", "@", "unlink", "(", "$", "file", ")", ";", "return", "TRUE", ";", "}", "return", "FALSE", ";", "}" ]

[ "Clear", "contents", "of", "cache", "backend" ]

[ "function", "load", "(", "$", "dsn", ")", "{", "$", "fw", "=", "Base", "::", "instance", "(", ")", ";", "if", "(", "$", "dsn", "=", "trim", "(", "$", "dsn", ")", ")", "{", "if", "(", "preg_match", "(", "'/^redis=(.+)/'", ",", "$", "dsn", ",", "$", "parts", ")", "&&", "extension_loaded", "(", "'redis'", ")", ")", "{", "$", "port", "=", "6379", ";", "$", "parts", "=", "explode", "(", "':'", ",", "$", "parts", "[", "1", "]", ",", "2", ")", ";", "if", "(", "count", "(", "$", "parts", ")", ">", "1", ")", "list", "(", "$", "host", ",", "$", "port", ")", "=", "$", "parts", ";", "else", "$", "host", "=", "$", "parts", "[", "0", "]", ";", "$", "this", "->", "ref", "=", "new", "Redis", ";", "if", "(", "!", "$", "this", "->", "ref", "->", "connect", "(", "$", "host", ",", "$", "port", ",", "2", ")", ")", "$", "this", "->", "ref", "=", "NULL", ";", "}", "elseif", "(", "preg_match", "(", "'/^memcache=(.+)/'", ",", "$", "dsn", ",", "$", "parts", ")", "&&", "extension_loaded", "(", "'memcache'", ")", ")", "foreach", "(", "$", "fw", "->", "split", "(", "$", "parts", "[", "1", "]", ")", "as", "$", "server", ")", "{", "$", "port", "=", "11211", ";", "$", "parts", "=", "explode", "(", "':'", ",", "$", "server", ",", "2", ")", ";", "if", "(", "count", "(", "$", "parts", ")", ">", "1", ")", "list", "(", "$", "host", ",", "$", "port", ")", "=", "$", "parts", ";", "else", "$", "host", "=", "$", "parts", "[", "0", "]", ";", "if", "(", "empty", "(", "$", "this", "->", "ref", ")", ")", "$", "this", "->", "ref", "=", "@", "memcache_connect", "(", "$", "host", ",", "$", "port", ")", "?", ":", "NULL", ";", "else", "memcache_add_server", "(", "$", "this", "->", "ref", ",", "$", "host", ",", "$", "port", ")", ";", "}", "if", "(", "empty", "(", "$", "this", "->", "ref", ")", "&&", "!", "preg_match", "(", "'/^folder\\h*=/'", ",", "$", "dsn", ")", ")", "$", "dsn", "=", "(", "$", "grep", "=", "preg_grep", "(", "'/^(apc|wincache|xcache)/'", ",", "array_map", "(", "'strtolower'", ",", "get_loaded_extensions", "(", ")", ")", ")", ")", "?", "// Auto-detect", "current", "(", "$", "grep", ")", ":", "// Use filesystem as fallback", "(", "'folder='", ".", "$", "fw", "->", "get", "(", "'TEMP'", ")", ".", "'cache/'", ")", ";", "if", "(", "preg_match", "(", "'/^folder\\h*=\\h*(.+)/'", ",", "$", "dsn", ",", "$", "parts", ")", "&&", "!", "is_dir", "(", "$", "parts", "[", "1", "]", ")", ")", "mkdir", "(", "$", "parts", "[", "1", "]", ",", "Base", "::", "MODE", ",", "TRUE", ")", ";", "}", "$", "this", "->", "prefix", "=", "$", "fw", "->", "hash", "(", "$", "_SERVER", "[", "'SERVER_NAME'", "]", ".", "$", "fw", "->", "get", "(", "'BASE'", ")", ")", ";", "return", "$", "this", "->", "dsn", "=", "$", "dsn", ";", "}" ]

[ "Load", "/", "auto", "-", "detect", "cache", "backend" ]

[ "public", "function", "actionIndex", "(", ")", "{", "$", "searchModel", "=", "new", "CountrySearch", ";", "$", "dataProvider", "=", "$", "searchModel", "->", "search", "(", "$", "_GET", ")", ";", "Tabs", "::", "clearLocalStorage", "(", ")", ";", "Url", "::", "remember", "(", ")", ";", "\\", "Yii", "::", "$", "app", "->", "session", "[", "'__crudReturnUrl'", "]", "=", "null", ";", "return", "$", "this", "->", "render", "(", "'index'", ",", "[", "'dataProvider'", "=>", "$", "dataProvider", ",", "'searchModel'", "=>", "$", "searchModel", ",", "]", ")", ";", "}" ]

[ "Lists", "all", "Country", "models", "." ]

[ "public", "function", "actionView", "(", "$", "id", ")", "{", "\\", "Yii", "::", "$", "app", "->", "session", "[", "'__crudReturnUrl'", "]", "=", "Url", "::", "previous", "(", ")", ";", "Url", "::", "remember", "(", ")", ";", "Tabs", "::", "rememberActiveState", "(", ")", ";", "return", "$", "this", "->", "render", "(", "'view'", ",", "[", "'model'", "=>", "$", "this", "->", "findModel", "(", "$", "id", ")", ",", "]", ")", ";", "}" ]

[ "Displays", "a", "single", "Country", "model", ".", "@param", "integer", "$id" ]

[ "public", "function", "actionCreate", "(", ")", "{", "$", "model", "=", "new", "Country", ";", "try", "{", "if", "(", "$", "model", "->", "load", "(", "$", "_POST", ")", "&&", "$", "model", "->", "save", "(", ")", ")", "{", "return", "$", "this", "->", "redirect", "(", "[", "'view'", ",", "'id'", "=>", "$", "model", "->", "id", "]", ")", ";", "}", "elseif", "(", "!", "\\", "Yii", "::", "$", "app", "->", "request", "->", "isPost", ")", "{", "$", "model", "->", "load", "(", "$", "_GET", ")", ";", "}", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "$", "msg", "=", "(", "isset", "(", "$", "e", "->", "errorInfo", "[", "2", "]", ")", ")", "?", "$", "e", "->", "errorInfo", "[", "2", "]", ":", "$", "e", "->", "getMessage", "(", ")", ";", "$", "model", "->", "addError", "(", "'_exception'", ",", "$", "msg", ")", ";", "}", "return", "$", "this", "->", "render", "(", "'create'", ",", "[", "'model'", "=>", "$", "model", "]", ")", ";", "}" ]

[ "Creates", "a", "new", "Country", "model", ".", "If", "creation", "is", "successful", "the", "browser", "will", "be", "redirected", "to", "the", "view", "page", "." ]

[ "public", "function", "actionUpdate", "(", "$", "id", ")", "{", "$", "model", "=", "$", "this", "->", "findModel", "(", "$", "id", ")", ";", "if", "(", "$", "model", "->", "load", "(", "$", "_POST", ")", "&&", "$", "model", "->", "save", "(", ")", ")", "{", "return", "$", "this", "->", "redirect", "(", "Url", "::", "previous", "(", ")", ")", ";", "}", "else", "{", "return", "$", "this", "->", "render", "(", "'update'", ",", "[", "'model'", "=>", "$", "model", ",", "]", ")", ";", "}", "}" ]

[ "Updates", "an", "existing", "Country", "model", ".", "If", "update", "is", "successful", "the", "browser", "will", "be", "redirected", "to", "the", "view", "page", "." ]

[ "public", "function", "actionDelete", "(", "$", "id", ")", "{", "try", "{", "$", "this", "->", "findModel", "(", "$", "id", ")", "->", "delete", "(", ")", ";", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "$", "msg", "=", "(", "isset", "(", "$", "e", "->", "errorInfo", "[", "2", "]", ")", ")", "?", "$", "e", "->", "errorInfo", "[", "2", "]", ":", "$", "e", "->", "getMessage", "(", ")", ";", "\\", "Yii", "::", "$", "app", "->", "getSession", "(", ")", "->", "addFlash", "(", "'error'", ",", "$", "msg", ")", ";", "return", "$", "this", "->", "redirect", "(", "Url", "::", "previous", "(", ")", ")", ";", "}", "// TODO: improve detection", "$", "isPivot", "=", "strstr", "(", "'$id'", ",", "','", ")", ";", "if", "(", "$", "isPivot", "==", "true", ")", "{", "return", "$", "this", "->", "redirect", "(", "Url", "::", "previous", "(", ")", ")", ";", "}", "elseif", "(", "isset", "(", "\\", "Yii", "::", "$", "app", "->", "session", "[", "'__crudReturnUrl'", "]", ")", "&&", "\\", "Yii", "::", "$", "app", "->", "session", "[", "'__crudReturnUrl'", "]", "!=", "'/'", ")", "{", "Url", "::", "remember", "(", "null", ")", ";", "$", "url", "=", "\\", "Yii", "::", "$", "app", "->", "session", "[", "'__crudReturnUrl'", "]", ";", "\\", "Yii", "::", "$", "app", "->", "session", "[", "'__crudReturnUrl'", "]", "=", "null", ";", "return", "$", "this", "->", "redirect", "(", "$", "url", ")", ";", "}", "else", "{", "return", "$", "this", "->", "redirect", "(", "[", "'index'", "]", ")", ";", "}", "}" ]

[ "Deletes", "an", "existing", "Country", "model", ".", "If", "deletion", "is", "successful", "the", "browser", "will", "be", "redirected", "to", "the", "index", "page", "." ]

[ "public", "function", "match", "(", "$", "actual", ")", "{", "$", "this", "->", "actual", "=", "$", "actual", ";", "try", "{", "$", "actual", "(", ")", ";", "}", "catch", "(", "Exception", "$", "exception", ")", "{", "$", "this", "->", "thrownException", "=", "$", "exception", ";", "}", "return", "$", "this", "->", "thrownException", "instanceof", "$", "this", "->", "expected", ";", "}" ]

[ "{" ]

[ "public", "function", "reportFailed", "(", "FailedMessage", "$", "message", ")", "{", "$", "explanation", "=", "'none thrown'", ";", "if", "(", "$", "this", "->", "thrownException", ")", "{", "$", "class", "=", "get_class", "(", "$", "this", "->", "thrownException", ")", ";", "$", "explanation", "=", "\"got $class\"", ";", "}", "$", "message", "->", "appendText", "(", "'Expected '", ")", "->", "appendText", "(", "$", "this", "->", "expected", ")", "->", "appendText", "(", "' to be thrown, '", ")", "->", "appendText", "(", "$", "explanation", ")", ";", "}" ]

[ "{" ]

[ "public", "function", "send", "(", "$", "printaitorViewObj", ")", "{", "$", "printJob", "[", "'PrinterJob'", "]", "=", "array", "(", "'text'", "=>", "$", "printaitorViewObj", "->", "viewTextRender", ",", "'printer_id'", "=>", "$", "printaitorViewObj", "->", "printerId", ",", ")", ";", "$", "PrinterJob", "=", "ClassRegistry", "::", "init", "(", "\"Printers.PrinterJob\"", ")", ";", "$", "save", "=", "$", "PrinterJob", "->", "save", "(", "$", "printJob", ")", ";", "if", "(", "!", "$", "save", ")", "{", "throw", "new", "CakeException", "(", "\"No se pudo guardar en en la DB el PrintJob\"", ")", ";", "}", "return", "true", ";", "}" ]

[ "Crea", "un", "archivo", "y", "lo", "coloca", "en", "la", "carpeta", "/", "tmp" ]

[ "public", "static", "function", "create", "(", "array", "$", "params", "=", "[", "]", ")", "{", "$", "assembler", "=", "new", "static", "(", ")", ";", "if", "(", "!", "empty", "(", "$", "params", ")", ")", "{", "array_walk", "(", "$", "params", ",", "function", "(", "$", "v", ",", "$", "k", ")", "use", "(", "$", "assembler", ")", "{", "$", "assembler", "->", "$", "k", "(", "function", "(", ")", "use", "(", "$", "v", ")", "{", "return", "$", "v", ";", "}", ")", ";", "}", ")", ";", "$", "assembler", "->", "assemble", "(", ")", ";", "}", "return", "$", "assembler", ";", "}" ]

[ "Static", "Assembler", "constructor", "Returns", "a", "new", "Assembler" ]

[ "public", "static", "function", "get", "(", "array", "$", "params", "=", "[", "]", ")", "{", "if", "(", "empty", "(", "self", "::", "$", "singleton", ")", ")", "{", "self", "::", "$", "singleton", "=", "static", "::", "create", "(", "$", "params", ")", ";", "}", "return", "self", "::", "$", "singleton", ";", "}" ]

[ "Return", "Singleton", "instance", "of", "Assembler" ]

[ "public", "function", "release", "(", "$", "var1", ")", "{", "$", "flip", "=", "array_flip", "(", "func_get_args", "(", ")", ")", ";", "$", "intersect", "=", "array_intersect_key", "(", "$", "this", "->", "values", ",", "$", "flip", ")", ";", "if", "(", "count", "(", "func_get_args", "(", ")", ")", ">", "1", ")", "{", "array_walk", "(", "$", "flip", ",", "function", "(", "&", "$", "v", ",", "$", "k", ")", "use", "(", "$", "intersect", ")", "{", "$", "v", "=", "$", "intersect", "[", "$", "k", "]", ";", "}", ")", ";", "return", "array_values", "(", "$", "flip", ")", ";", "}", "else", "{", "return", "array_pop", "(", "$", "intersect", ")", ";", "}", "}" ]

[ "Return", "an", "array", "of", "variables", "created", "else", "just", "a", "single", "value", "Usage", ":", "-", ">", "release", "(", "var1", "varN", ")", "-", ">", "release", "(", "var1", ")" ]

[ "public", "function", "assemble", "(", ")", "{", "foreach", "(", "$", "this", "->", "placeHolders", "as", "$", "name", "=>", "$", "placeholder", ")", "{", "if", "(", "!", "isset", "(", "$", "this", "->", "values", "[", "$", "name", "]", ")", ")", "{", "$", "this", "->", "values", "[", "$", "name", "]", "=", "$", "this", "->", "addVars", "(", "$", "placeholder", ")", ";", "}", "}", "return", "$", "this", ";", "}" ]

[ "Run", "the", "Assembly", "not", "returning", "any", "value", ".", "Assembly", "will", "not", "overwrite", "anything", "already", "assembled" ]

[ "public", "function", "merge", "(", "Assembler", "$", "other", ")", "{", "//N.B. reflection used so as to not expose values", "//via some public method", "$", "refl", "=", "new", "\\", "ReflectionObject", "(", "$", "other", ")", ";", "$", "reflValues", "=", "$", "refl", "->", "getProperty", "(", "'values'", ")", ";", "$", "reflValues", "->", "setAccessible", "(", "true", ")", ";", "$", "oValues", "=", "$", "reflValues", "->", "getValue", "(", "$", "other", ")", ";", "if", "(", "count", "(", "$", "oValues", ")", "==", "0", ")", "{", "return", "$", "this", ";", "}", "$", "this", "->", "values", "=", "array_merge", "(", "$", "this", "->", "values", ",", "$", "oValues", ")", ";", "return", "$", "this", ";", "}" ]

[ "Merge", "this", "assembly", "with", "another", ".", "Obeys", "the", "rules", "of", "array_merge" ]

[ "protected", "function", "addVars", "(", "\\", "Closure", "$", "func", ")", "{", "$", "args", "=", "(", "new", "\\", "ReflectionFunction", "(", "$", "func", ")", ")", "->", "getParameters", "(", ")", ";", "if", "(", "count", "(", "$", "args", ")", "===", "0", ")", "{", "return", "$", "func", "(", ")", ";", "}", "$", "fArgs", "=", "array_map", "(", "function", "(", "$", "key", ")", "{", "return", "$", "this", "->", "values", "[", "$", "key", "]", ";", "}", ",", "array_map", "(", "function", "(", "$", "arg", ")", "{", "return", "$", "arg", "->", "getName", "(", ")", ";", "}", ",", "$", "args", ")", ")", ";", "return", "call_user_func_array", "(", "$", "func", ",", "$", "fArgs", ")", ";", "}" ]

[ "Execute", "the", "function", "assigned", "to", "the", "value", "binding", "in", "values", "created", "earlier", "in", "the", "assembly" ]

[ "public", "function", "getHtml", "(", "Eresus_CMS_Request", "$", "request", ")", "{", "$", "legacyKernel", "=", "Eresus_Kernel", "::", "app", "(", ")", "->", "getLegacyKernel", "(", ")", ";", "$", "sections", "=", "$", "legacyKernel", "->", "sections", ";", "$", "args", "=", "$", "request", "->", "getMethod", "(", ")", "==", "'GET'", "?", "$", "request", "->", "query", ":", "$", "request", "->", "request", ";", "$", "item", "=", "$", "sections", "->", "get", "(", "$", "args", "->", "getInt", "(", "'section'", ")", ")", ";", "$", "response", "=", "$", "args", "->", "has", "(", "'update'", ")", "// TODO Использовать getMethod вметос 'update'", "?", "$", "this", "->", "updateAction", "(", "$", "item", ")", ":", "$", "this", "->", "formAction", "(", "$", "item", ",", "$", "args", ")", ";", "return", "$", "response", ";", "}" ]

[ "Возвращает", "разметку", "области", "контента" ]

[ "private", "function", "formAction", "(", "array", "$", "item", ")", "{", "$", "form", "=", "array", "(", "'name'", "=>", "'editURL'", ",", "'caption'", "=>", "ADM_EDIT", ",", "'width'", "=>", "'100%'", ",", "'fields'", "=>", "array", "(", "array", "(", "'type'", "=>", "'hidden'", ",", "'name'", "=>", "'update'", ",", "'value'", "=>", "$", "item", "[", "'id'", "]", ")", ",", "array", "(", "'type'", "=>", "'edit'", ",", "'name'", "=>", "'url'", ",", "'label'", "=>", "'URL:'", ",", "'width'", "=>", "'100%'", ",", "'value'", "=>", "isset", "(", "$", "item", "[", "'content'", "]", ")", "?", "$", "item", "[", "'content'", "]", ":", "''", ")", ",", ")", ",", "'buttons'", "=>", "array", "(", "'apply'", ",", "'cancel'", ")", ",", ")", ";", "/** @var TAdminUI $page */", "$", "page", "=", "Eresus_Kernel", "::", "app", "(", ")", "->", "getPage", "(", ")", ";", "$", "html", "=", "$", "page", "->", "renderForm", "(", "$", "form", ")", ";", "return", "$", "html", ";", "}" ]

[ "Возвращает", "разметку", "диалога" ]

[ "private", "function", "updateAction", "(", "array", "$", "item", ",", "Eresus_HTTP_Parameters", "$", "args", ")", "{", "$", "item", "[", "'content'", "]", "=", "$", "args", "->", "get", "(", "'url'", ")", ";", "Eresus_Kernel", "::", "app", "(", ")", "->", "getLegacyKernel", "(", ")", "->", "sections", "->", "update", "(", "$", "item", ")", ";", "return", "new", "Eresus_HTTP_Redirect", "(", "$", "args", "->", "get", "(", "'submitURL'", ")", ")", ";", "}" ]

[ "Сохраняет", "изменения" ]

[ "public", "function", "handle", "(", "GridInterface", "$", "grid", ",", "array", "$", "filters", "=", "[", "]", ",", "array", "$", "sorting", "=", "[", "]", ",", "array", "$", "slicing", "=", "[", "]", ")", "{", "$", "repository", "=", "$", "this", "->", "repositoryRegistry", "[", "$", "grid", "->", "getResource", "(", ")", "->", "getName", "(", ")", "]", ";", "$", "dataSourceBuilder", "=", "$", "repository", "->", "createDataSourceBuilder", "(", "$", "grid", "->", "getOptions", "(", ")", ")", ";", "$", "this", "->", "filterer", "->", "filter", "(", "$", "dataSourceBuilder", ",", "$", "grid", ",", "$", "filters", ")", ";", "$", "this", "->", "sorter", "->", "sort", "(", "$", "dataSourceBuilder", ",", "$", "grid", ",", "$", "sorting", ")", ";", "$", "this", "->", "slicer", "->", "slice", "(", "$", "dataSourceBuilder", ",", "$", "grid", ",", "$", "slicing", ")", ";", "return", "$", "this", "->", "gridViewFactory", "->", "create", "(", "$", "grid", ",", "$", "dataSourceBuilder", ")", ";", "}" ]

[ "{" ]

[ "protected", "function", "leadSVG", "(", ")", "{", "// Create a new sanitizer instance\r", "$", "sanitizer", "=", "new", "Sanitizer", "(", ")", ";", "// Load the dirty svg\r", "$", "dirtySVG", "=", "file_get_contents", "(", "$", "this", "->", "file", ")", ";", "// Pass it to the sanitizer and get it back clean\r", "$", "cleanSVG", "=", "$", "sanitizer", "->", "sanitize", "(", "$", "dirtySVG", ")", ";", "if", "(", "is_string", "(", "$", "cleanSVG", ")", ")", "{", "return", "$", "this", "->", "closeCase", "(", "\"svg\"", ",", "\"image/svg+xml\"", ")", ";", "}", "return", "false", ";", "}" ]

[ "Checks", "if", "thise", "file", "is", "a", "valid", "SVG", "." ]

[ "public", "static", "function", "resolve", "(", "$", "key", ")", "{", "if", "(", "$", "key", "==", "'B'", ")", "return", "0", ";", "$", "dict", "=", "static", "::", "$", "metric", ";", "if", "(", "preg_match", "(", "static", "::", "IEC_PATTERN", ",", "$", "key", ")", ")", "$", "dict", "=", "static", "::", "$", "binary", ";", "if", "(", "array_key_exists", "(", "$", "key", ",", "$", "dict", ")", ")", "return", "$", "dict", "[", "$", "key", "]", ";", "throw", "new", "UnitNotFoundException", "(", "sprintf", "(", "'Unit \"%s\" not found'", ",", "$", "key", ")", ")", ";", "}" ]

[ "Lookup", "the", "exponent", "based", "on", "prefix" ]

[ "public", "static", "function", "unitsAreDifferent", "(", "$", "first", ",", "$", "second", ")", "{", "return", "(", "preg_match", "(", "UnitResolver", "::", "SI_PATTERN", ",", "$", "first", ")", "&&", "preg_match", "(", "UnitResolver", "::", "IEC_PATTERN", ",", "$", "second", ")", ")", "||", "(", "preg_match", "(", "UnitResolver", "::", "IEC_PATTERN", ",", "$", "first", ")", "&&", "preg_match", "(", "UnitResolver", "::", "SI_PATTERN", ",", "$", "second", ")", ")", ";", "}" ]

[ "Check", "if", "two", "units", "are", "in", "the", "same", "family" ]

[ "public", "function", "set", "(", "$", "path", ",", "$", "value", ")", "{", "// if is readonly", "if", "(", "$", "this", "->", "readonly", "&&", "$", "this", "->", "has", "(", "$", "path", ")", ")", "{", "throw", "new", "RuntimeException", "(", "\"Config data have been setting readonly. don't allow change.\"", ")", ";", "}", "return", "parent", "::", "set", "(", "$", "path", ",", "$", "value", ")", ";", "}" ]

[ "set", "config", "value", "by", "path" ]

[ "public", "function", "execute", "(", "ProjectDescriptor", "$", "project", ")", "{", "$", "project", "->", "getIndexes", "(", ")", "->", "get", "(", "'elements'", ",", "new", "Collection", "(", ")", ")", "->", "set", "(", "'~\\\\'", ",", "$", "project", "->", "getNamespace", "(", ")", ")", ";", "$", "project", "->", "getIndexes", "(", ")", "->", "get", "(", "'namespaces'", ",", "new", "Collection", "(", ")", ")", "->", "add", "(", "$", "project", "->", "getNamespace", "(", ")", ")", ";", "foreach", "(", "$", "project", "->", "getFiles", "(", ")", "as", "$", "file", ")", "{", "$", "this", "->", "addElementsOfTypeToNamespace", "(", "$", "project", ",", "$", "file", "->", "getConstants", "(", ")", "->", "getAll", "(", ")", ",", "'constants'", ")", ";", "$", "this", "->", "addElementsOfTypeToNamespace", "(", "$", "project", ",", "$", "file", "->", "getFunctions", "(", ")", "->", "getAll", "(", ")", ",", "'functions'", ")", ";", "$", "this", "->", "addElementsOfTypeToNamespace", "(", "$", "project", ",", "$", "file", "->", "getClasses", "(", ")", "->", "getAll", "(", ")", ",", "'classes'", ")", ";", "$", "this", "->", "addElementsOfTypeToNamespace", "(", "$", "project", ",", "$", "file", "->", "getInterfaces", "(", ")", "->", "getAll", "(", ")", ",", "'interfaces'", ")", ";", "$", "this", "->", "addElementsOfTypeToNamespace", "(", "$", "project", ",", "$", "file", "->", "getTraits", "(", ")", "->", "getAll", "(", ")", ",", "'traits'", ")", ";", "}", "}" ]

[ "{" ]

[ "protected", "function", "addElementsOfTypeToNamespace", "(", "ProjectDescriptor", "$", "project", ",", "array", "$", "elements", ",", "$", "type", ")", "{", "/** @var DescriptorAbstract $element */", "foreach", "(", "$", "elements", "as", "$", "element", ")", "{", "$", "namespaceName", "=", "(", "string", ")", "$", "element", "->", "getNamespace", "(", ")", ";", "// ensure consistency by trimming the slash prefix and then re-appending it.", "$", "namespaceIndexName", "=", "'~\\\\'", ".", "ltrim", "(", "$", "namespaceName", ",", "'\\\\'", ")", ";", "if", "(", "!", "isset", "(", "$", "project", "->", "getIndexes", "(", ")", "->", "elements", "[", "$", "namespaceIndexName", "]", ")", ")", "{", "$", "this", "->", "createNamespaceDescriptorTree", "(", "$", "project", ",", "$", "namespaceName", ")", ";", "}", "/** @var NamespaceDescriptor $namespace */", "$", "namespace", "=", "$", "project", "->", "getIndexes", "(", ")", "->", "elements", "[", "$", "namespaceIndexName", "]", ";", "// replace textual representation with an object representation", "$", "element", "->", "setNamespace", "(", "$", "namespace", ")", ";", "// add element to namespace", "$", "getter", "=", "'get'", ".", "ucfirst", "(", "$", "type", ")", ";", "/** @var Collection $collection */", "$", "collection", "=", "$", "namespace", "->", "$", "getter", "(", ")", ";", "$", "collection", "->", "add", "(", "$", "element", ")", ";", "}", "}" ]

[ "Adds", "the", "given", "elements", "of", "a", "specific", "type", "to", "their", "respective", "Namespace", "Descriptors", "." ]

[ "protected", "function", "createNamespaceDescriptorTree", "(", "ProjectDescriptor", "$", "project", ",", "$", "namespaceName", ")", "{", "$", "parts", "=", "explode", "(", "'\\\\'", ",", "ltrim", "(", "$", "namespaceName", ",", "'\\\\'", ")", ")", ";", "$", "fqnn", "=", "''", ";", "// this method does not use recursion to traverse the tree but uses a pointer that will be overridden with the", "// next item that is to be traversed (child namespace) at the end of the loop.", "$", "pointer", "=", "$", "project", "->", "getNamespace", "(", ")", ";", "foreach", "(", "$", "parts", "as", "$", "part", ")", "{", "$", "fqnn", ".=", "'\\\\'", ".", "$", "part", ";", "if", "(", "$", "pointer", "->", "getChildren", "(", ")", "->", "get", "(", "$", "part", ")", ")", "{", "$", "pointer", "=", "$", "pointer", "->", "getChildren", "(", ")", "->", "get", "(", "$", "part", ")", ";", "continue", ";", "}", "// namespace does not exist, create it", "$", "interimNamespaceDescriptor", "=", "new", "NamespaceDescriptor", "(", ")", ";", "$", "interimNamespaceDescriptor", "->", "setParent", "(", "$", "pointer", ")", ";", "$", "interimNamespaceDescriptor", "->", "setName", "(", "$", "part", ")", ";", "$", "interimNamespaceDescriptor", "->", "setFullyQualifiedStructuralElementName", "(", "$", "fqnn", ")", ";", "// add to the pointer's list of children", "$", "pointer", "->", "getChildren", "(", ")", "->", "set", "(", "$", "part", ",", "$", "interimNamespaceDescriptor", ")", ";", "// add to index", "$", "project", "->", "getIndexes", "(", ")", "->", "elements", "[", "'~'", ".", "$", "fqnn", "]", "=", "$", "interimNamespaceDescriptor", ";", "$", "project", "->", "getIndexes", "(", ")", "->", "get", "(", "'namespaces'", ",", "new", "Collection", "(", ")", ")", "->", "add", "(", "$", "interimNamespaceDescriptor", ")", ";", "// move pointer forward", "$", "pointer", "=", "$", "interimNamespaceDescriptor", ";", "}", "}" ]

[ "Creates", "a", "tree", "of", "NamespaceDescriptors", "based", "on", "the", "provided", "FQNN", "(", "namespace", "name", ")", "." ]

[ "public", "function", "beforeSave", "(", "$", "insert", ")", "{", "if", "(", "parent", "::", "beforeSave", "(", "$", "insert", ")", ")", "{", "if", "(", "!", "$", "this", "->", "id", "&&", "self", "::", "find", "(", ")", "->", "orderBy", "(", "[", "'id'", "=>", "SORT_DESC", "]", ")", "->", "one", "(", ")", "->", "id", "<", "self", "::", "BARRIER", ")", "$", "this", "->", "id", "=", "self", "::", "BARRIER", ";", "return", "true", ";", "}", "else", "return", "false", ";", "}" ]

[ "This", "is", "invoked", "before", "the", "record", "is", "saved", "." ]

[ "static", "function", "getAttributes", "(", "$", "obj", ",", "$", "visibilityFlags", "=", "null", ",", "$", "getterPrefix", "=", "'get'", ",", "$", "useCamelCase", "=", "true", ",", "$", "convertInternalObjects", "=", "false", ")", "{", "if", "(", "!", "isset", "(", "$", "obj", ")", ")", "{", "return", "array", "(", ")", ";", "}", "$", "flags", "=", "null", "===", "$", "visibilityFlags", "?", "self", "::", "allFlags", "(", ")", ":", "$", "visibilityFlags", ";", "$", "attributes", "=", "array", "(", ")", ";", "$", "reflectionObject", "=", "new", "\\", "ReflectionObject", "(", "$", "obj", ")", ";", "$", "currentClass", "=", "new", "\\", "ReflectionClass", "(", "$", "obj", ")", ";", "while", "(", "$", "currentClass", "!==", "false", "&&", "!", "$", "currentClass", "->", "isInterface", "(", ")", ")", "{", "$", "properties", "=", "$", "currentClass", "->", "getProperties", "(", "$", "flags", ")", ";", "foreach", "(", "$", "properties", "as", "$", "property", ")", "{", "$", "attributeName", "=", "$", "property", "->", "getName", "(", ")", ";", "$", "methodName", "=", "$", "getterPrefix", ".", "(", "$", "useCamelCase", "?", "self", "::", "mb_ucfirst", "(", "$", "attributeName", ")", ":", "$", "attributeName", ")", ";", "if", "(", "$", "property", "->", "isPrivate", "(", ")", "||", "$", "property", "->", "isProtected", "(", ")", ")", "{", "if", "(", "$", "reflectionObject", "->", "hasMethod", "(", "$", "methodName", ")", ")", "{", "$", "method", "=", "$", "reflectionObject", "->", "getMethod", "(", "$", "methodName", ")", ";", "if", "(", "$", "method", "->", "isPublic", "(", ")", ")", "{", "$", "attributes", "[", "$", "attributeName", "]", "=", "$", "method", "->", "invoke", "(", "$", "obj", ")", ";", "}", "}", "else", "{", "// maybe has a __call magic method", "$", "attributes", "[", "$", "attributeName", "]", "=", "$", "obj", "->", "{", "$", "methodName", "}", "(", ")", ";", "}", "}", "else", "{", "// public method", "try", "{", "$", "attributes", "[", "$", "attributeName", "]", "=", "$", "obj", "->", "{", "$", "attributeName", "}", ";", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "// Ignore", "}", "}", "}", "// No properties? -> try to retrieve public properties", "if", "(", "count", "(", "$", "properties", ")", "<", "1", ")", "{", "$", "properties", "=", "get_object_vars", "(", "$", "obj", ")", ";", "foreach", "(", "$", "properties", "as", "$", "k", "=>", "$", "v", ")", "{", "$", "attributes", "[", "$", "k", "]", "=", "$", "v", ";", "}", "}", "$", "currentClass", "=", "$", "currentClass", "->", "getParentClass", "(", ")", ";", "}", "if", "(", "$", "convertInternalObjects", ")", "{", "// Analyse all internal objects", "foreach", "(", "$", "attributes", "as", "$", "key", "=>", "$", "value", ")", "{", "if", "(", "is_object", "(", "$", "value", ")", ")", "{", "$", "attributes", "[", "$", "key", "]", "=", "self", "::", "getAttributes", "(", "$", "value", ",", "$", "flags", ",", "$", "getterPrefix", ",", "$", "useCamelCase", ")", ";", "}", "}", "}", "return", "$", "attributes", ";", "}" ]

[ "Retrieve", "names", "and", "values", "from", "the", "attributes", "of", "a", "object", "as", "a", "map", "." ]

[ "static", "function", "getPrivateAttributes", "(", "$", "obj", ",", "$", "getterPrefix", "=", "'get'", ",", "$", "useCamelCase", "=", "true", ")", "{", "return", "self", "::", "getAttributes", "(", "$", "obj", ",", "self", "::", "IS_PRIVATE", ",", "$", "getterPrefix", ",", "$", "useCamelCase", ")", ";", "}" ]

[ "Retrieve", "names", "and", "values", "from", "the", "private", "attributes", "of", "a", "object", "as", "a", "map", ".", "This", "method", "has", "been", "kept", "for", "backward", "compatibility", "." ]