PHP CString::toInt方法代码示例

 /**
  * Creates a parsed URL from a URL string.
  *
  * The URL string is expected to be by all means valid, with characters being percent-encoded where it is required
  * by the URL standard and without any leading or trailing whitespace. It is only when the URL string does not
  * indicate any protocol that the URL may still be considered valid and the default protocol is assigned to the
  * URL, which is "http".
  *
  * @param  string $url The URL string.
  */
 public function __construct($url)
 {
     assert('is_cstring($url)', vs(isset($this), get_defined_vars()));
     assert('self::isValid($url, true)', vs(isset($this), get_defined_vars()));
     $this->m_url = $url;
     $parsedUrl = parse_url($url);
     assert('is_cmap($parsedUrl)', vs(isset($this), get_defined_vars()));
     // should not rise for a valid URL
     // Protocol (scheme).
     if (CMap::hasKey($parsedUrl, "scheme")) {
         $this->m_hasProtocol = true;
         $this->m_protocol = $parsedUrl["scheme"];
         // Normalize by converting to lowercase.
         $this->m_normProtocol = CString::toLowerCase($this->m_protocol);
     } else {
         $this->m_hasProtocol = false;
         $this->m_normProtocol = self::DEFAULT_PROTOCOL;
         if (!CMap::hasKey($parsedUrl, "host")) {
             // Most likely, `parse_url` function has not parsed the host because the protocol (scheme) is absent
             // and there are no "//" in the front, so try parsing the host with the default protocol in the URL.
             $parsedUrl = parse_url(self::ensureProtocol($url));
             assert('is_cmap($parsedUrl)', vs(isset($this), get_defined_vars()));
             CMap::remove($parsedUrl, "scheme");
         }
     }
     // Host (domain).
     $this->m_hostIsInBrackets = false;
     if (CMap::hasKey($parsedUrl, "host")) {
         $this->m_host = $parsedUrl["host"];
         if (CRegex::find($this->m_host, "/^\\[.*\\]\\z/")) {
             // Most likely, an IPv6 enclosed in "[]".
             $this->m_hostIsInBrackets = true;
             $this->m_host = CString::substr($this->m_host, 1, CString::length($this->m_host) - 2);
         }
         // Normalize by converting to lowercase.
         $this->m_normHost = CString::toLowerCase($this->m_host);
     } else {
         // Same as invalid.
         assert('false', vs(isset($this), get_defined_vars()));
     }
     // Port.
     if (CMap::hasKey($parsedUrl, "port")) {
         $this->m_hasPort = true;
         $this->m_port = $parsedUrl["port"];
         // Should be `int`, but look into the type just in case.
         if (is_cstring($this->m_port)) {
             $this->m_port = CString::toInt($this->m_port);
         }
     } else {
         $this->m_hasPort = false;
     }
     // Path.
     if (CMap::hasKey($parsedUrl, "path")) {
         $this->m_hasPath = true;
         $this->m_path = $parsedUrl["path"];
         // Normalize by replacing percent-encoded bytes of unreserved characters with their literal equivalents and
         // ensuring that all percent-encoded parts are in uppercase.
         $pathDelimitersReEsc = CRegex::enterTd(self::$ms_delimiters);
         $this->m_normPath = CRegex::replaceWithCallback($this->m_path, "/[^{$pathDelimitersReEsc}]+/", function ($matches) {
             return CUrl::enterTdNew(CUrl::leaveTdNew($matches[0]));
         });
     } else {
         $this->m_hasPath = false;
         $this->m_normPath = "/";
     }
     $this->m_urlPath = new CUrlPath($this->m_normPath);
     // Query string.
     $this->m_hasQuery = false;
     if (CMap::hasKey($parsedUrl, "query")) {
         $this->m_hasQuery = true;
         $this->m_queryString = $parsedUrl["query"];
         $parsingWasFruitful;
         $this->m_urlQuery = new CUrlQuery($this->m_queryString, $parsingWasFruitful);
         if ($parsingWasFruitful) {
             $this->m_hasQuery = true;
             $this->m_normQueryString = $this->m_urlQuery->queryString(true);
         }
     }
     // Fragment ID.
     if (CMap::hasKey($parsedUrl, "fragment")) {
         $this->m_hasFragmentId = true;
         $this->m_fragmentId = $parsedUrl["fragment"];
         // Normalize by replacing percent-encoded bytes of unreserved characters with their literal equivalents and
         // ensuring that all percent-encoded parts are in uppercase.
         $fiDelimitersReEsc = CRegex::enterTd(self::$ms_delimiters);
         $this->m_normFragmentId = CRegex::replaceWithCallback($this->m_fragmentId, "/[^{$fiDelimitersReEsc}]+/", function ($matches) {
             // Use the newer flavor of percent-encoding.
             return CUrl::enterTdNew(CUrl::leaveTdNew($matches[0]));
         });
     } else {
//.........这里部分代码省略.........

 protected static function timeToComponentsInTimeZone(CTime $time, $timeZone, &$year, &$month, &$day, &$hour, &$minute, &$second, &$millisecond, &$dayOfWeek)
 {
     $FTime = $time->FTime();
     $UTime = $time->UTime();
     $MTime = $time->MTime();
     $negMsCase = false;
     if ($FTime < 0.0 && $MTime != 0) {
         $negMsCase = true;
         $UTime--;
     }
     $time = self::timeToStringInTimeZone(new self($UTime), "Y,m,d,H,i,s,w", $timeZone);
     $components = CString::split($time, ",");
     $year = CString::toInt($components[0]);
     $month = CString::toInt($components[1]);
     $day = CString::toInt($components[2]);
     $hour = CString::toInt($components[3]);
     $minute = CString::toInt($components[4]);
     $second = CString::toInt($components[5]);
     $dayOfWeek = CString::toInt($components[6]);
     if (!$negMsCase) {
         $millisecond = $MTime;
     } else {
         $millisecond = $MTime + 1000;
     }
 }

 /**
  * @ignore
  */
 public static function maybeUpdateThirdParty()
 {
     if (!self::isInCliMode()) {
         // This method can be run in CLI mode only.
         assert('false', vs(isset($this), get_defined_vars()));
         return false;
     }
     $updates = CConfiguration::option("updates");
     $updatesAreEnabled = $updates["enable"];
     if ($updatesAreEnabled) {
         $minTimeBetweenDoUpdatesDays = $updates["minTimeBetweenDoUpdatesDays"];
         $components = $updates["components"];
         assert('is_int($minTimeBetweenDoUpdatesDays)', vs(isset($this), get_defined_vars()));
         // Logging.
         $logging = $updates["logging"];
         $loggingIsEnabled = $logging["enable"];
         $logFp = $logging["logFilePath"];
         if ($loggingIsEnabled) {
             assert('!CString::isEmpty($logFp)', vs(isset($this), get_defined_vars()));
             $logFp = CFilePath::frameworkPath($logFp);
             CShell::setLogging($logFp);
         }
         // Mailing.
         $mailing = $updates["mailing"];
         $mailingIsEnabled = $mailing["enable"];
         if ($mailingIsEnabled) {
             $adminMail = CConfiguration::option("admin.mail");
             $to = $adminMail["to"];
             $from = $adminMail["from"];
             $transport = $adminMail["transport"];
             assert('!CString::isEmpty($to) && !CString::isEmpty($from) && !CString::isEmpty($transport)', vs(isset($this), get_defined_vars()));
             $mail;
             if (CString::equalsCi($transport, "smtp")) {
                 $smtpOutgoingServer = $adminMail["smtpOutgoingServer"];
                 $smtpUsername = $adminMail["smtpUsername"];
                 $smtpPassword = $adminMail["smtpPassword"];
                 assert('!CString::isEmpty($smtpOutgoingServer) && !CString::isEmpty($smtpUsername) && ' . '!CString::isEmpty($smtpPassword)', vs(isset($this), get_defined_vars()));
                 $mail = CMail::makeSmtp($smtpOutgoingServer, $smtpUsername, $smtpPassword, $from, $to);
             } else {
                 if (CString::equalsCi($transport, "system")) {
                     $mail = CMail::makeSystem($from, $to);
                 } else {
                     assert('false', vs(isset($this), get_defined_vars()));
                 }
             }
             CShell::setMailing($mail);
         }
         $thirdPartyDp = $GLOBALS["PHRED_PATH_TO_THIRD_PARTY"];
         $lastUpdateTimeFp = CFilePath::add($thirdPartyDp, self::$ms_thirdPartyLastUpdateTimeFn);
         // Read the file containing the Unix seconds of the last update time stamp (if exists) and compare that
         // time with the current time.
         $numDaysSinceLastUpdate;
         if (CFile::exists($lastUpdateTimeFp)) {
             $lastUpdateTime = new CTime(CString::toInt(CFile::read($lastUpdateTimeFp)));
             $currTime = CTime::now();
             if ($lastUpdateTime->isBefore($currTime)) {
                 $numDaysSinceLastUpdate = $currTime->diffInDays($lastUpdateTime);
                 if ($numDaysSinceLastUpdate < $minTimeBetweenDoUpdatesDays) {
                     // It is too early for updates yet.
                     return false;
                 }
             } else {
                 assert('false', vs(isset($this), get_defined_vars()));
             }
         }
         $date = CShell::currentDate();
         CShell::say("Started on {$date}.");
         if (isset($numDaysSinceLastUpdate)) {
             CShell::say("It has been {$numDaysSinceLastUpdate} day(s) since last successful update.");
         }
         $concurrLockFp = CFilePath::add($thirdPartyDp, self::$ms_thirdPartyConcurrLockFn);
         // Try locking the operation.
         if (!self::setLock($concurrLockFp, false)) {
             assert('false', vs(isset($this), get_defined_vars()));
             CShell::onError(false, "Could not obtain a lock on the operation.");
             CShell::writeToLog("\n");
             return false;
         }
         $phpConfigNeedsReload = false;
         $totalNumComponents = CMap::length($components);
         $numComponentsUpdated = 0;
         // The Browser Capabilities Project (BrowsCap).
         if (CMap::hasKey($components, "browsCap")) {
             $browsCap = $components["browsCap"];
             $skip = $browsCap["skip"];
             if (!$skip) {
                 CShell::say("Updating the Browser Capabilities Project (BrowsCap) ...");
                 $lookupFileUrl = $browsCap["lookupFileUrl"];
                 assert('!CString::isEmpty($lookupFileUrl)', vs(isset($this), get_defined_vars()));
                 // Component-related constants.
                 static $s_configOptName = "browscap";
                 static $s_lookupFileDownloadTimeoutSeconds = 120;
                 if (self::hasConfigOption($s_configOptName)) {
                     $browsCapLookupFp = CString::trim(self::configOption($s_configOptName));
                     if (!CString::isEmpty($browsCapLookupFp)) {
                         $browsCapDp = CFilePath::directory($browsCapLookupFp);
                         CShell::say("Downloading a BrowsCap lookup file from '{$lookupFileUrl}' ...");
//.........这里部分代码省略.........

 /**
  * Returns the code point of a specified character, as an integer.
  *
  * @param  string $char The character.
  *
  * @return int The Unicode code point of the character.
  */
 public static function toCharCode($char)
 {
     assert('is_cstring($char)', vs(isset($this), get_defined_vars()));
     assert('self::length($char) == 1', vs(isset($this), get_defined_vars()));
     return CString::toInt(CString::hexToDec(CString::substr(self::toEscString($char), 2)));
 }

 /**
  * Returns the value of a specified long option with which the script was run, as an integer value.
  *
  * @param  string $optionName The name of the option, excluding "-".
  *
  * @return int The value of the option specified.
  */
 public static function valueForLongOptionInt($optionName)
 {
     assert('is_cstring($optionName)', vs(isset($this), get_defined_vars()));
     return CString::toInt(self::valueForLongOption($optionName));
 }

 /**
  * Returns the number of redirections that took place while processing the request.
  *
  * This method can be called for HTTP requests only.
  *
  * @return int The number of redirections that took place.
  */
 public function requestNumRedirections()
 {
     assert('$this->isHttp() && $this->m_done && !$this->m_hasError', vs(isset($this), get_defined_vars()));
     $key = "redirect_count";
     if (CMap::hasKey($this->m_requestSummary, $key)) {
         $value = $this->m_requestSummary[$key];
         return is_int($value) || is_float($value) ? (int) $value : CString::toInt($value);
     } else {
         return 0;
     }
 }

 /**
  * Filters a string or a collection of strings according to the expected output type(s) and returns the output
  * value(s).
  *
  * @param  mixed $inputStringOrDecodedCollection The string to be filtered or the array or map containing the
  * strings to be filtered. If the parameter's value is a JSON-encoded string, the output value is going to be
  * either an array or map.
  * @param  reference $success **OUTPUT.** After the method is called, the value of this parameter tells whether
  * the filtering was successful.
  *
  * @return mixed The output value or a collection of values of the expected type(s) after having been put through
  * the filter.
  */
 public function filter($inputStringOrDecodedCollection, &$success)
 {
     assert('is_cstring($inputStringOrDecodedCollection) || is_collection($inputStringOrDecodedCollection)', vs(isset($this), get_defined_vars()));
     $success = true;
     if ($this->m_expectedType != self::CARRAY && $this->m_expectedType != self::CMAP) {
         // The expected output type is not a collection; the input value must be of string type.
         if (!is_cstring($inputStringOrDecodedCollection)) {
             $success = false;
             return oop_x($this->m_defaultValue);
         }
         $inputString = $inputStringOrDecodedCollection;
         if ($this->m_expectedType == self::BOOL || $this->m_expectedType == self::INT || $this->m_expectedType == self::FLOAT || $this->m_expectedType == self::EMAIL || $this->m_expectedType == self::URL || $this->m_expectedType == self::IP) {
             // Trim the input string on both sides from whitespace, including Unicode whitespace and control
             // characters.
             $trimmingSubjectRe = CUString::TRIMMING_AND_SPACING_NORM_SUBJECT_RE;
             $inputString = CRegex::remove($inputString, "/^({$trimmingSubjectRe})+|({$trimmingSubjectRe})+\\z/u");
         }
         // Pre-process the string for integer and floating-point types.
         $looksLikeHex;
         if ($this->m_expectedType == self::INT || $this->m_expectedType == self::FLOAT) {
             if (CString::startsWith($inputString, "+")) {
                 // Remove the plus sign.
                 $inputString = CString::substr($inputString, 1);
             }
             $looksLikeHex = CRegex::find($inputString, "/^-?0x/i");
             if ($this->m_allowLeadingZeros && !($this->m_expectedType == self::INT && $this->m_allowHex && $looksLikeHex)) {
                 // Remove any leading zeros (except for special cases).
                 $inputString = CRegex::replace($inputString, "/^(\\D*)0*(?!\\b)/", "\$1");
             }
             if ($this->m_allowComma) {
                 $inputString = CRegex::remove($inputString, "/,(?=\\d{3}\\b)/");
             }
         }
         // Validate and sanitize the value according to its expected type.
         if ($this->m_expectedType == self::BOOL) {
             if (!CRegex::find($inputString, "/^(1|true|yes|on|0|false|no|off)\\z/i")) {
                 $success = false;
                 return $this->m_defaultValue;
             }
             return CString::equals($inputString, "1") || CString::equalsCi($inputString, "true") || CString::equalsCi($inputString, "yes") || CString::equalsCi($inputString, "on");
         }
         if ($this->m_expectedType == self::INT) {
             $value;
             if (!($this->m_allowHex && $looksLikeHex)) {
                 // Regular.
                 if (!CRegex::find($inputString, "/^-?(?!0(?!\\b))\\d+\\z/")) {
                     $success = false;
                     return $this->m_defaultValue;
                 }
                 $value = CString::toInt($inputString);
             } else {
                 // Hex.
                 if (!CRegex::find($inputString, "/^-?0x[0-9A-F]+\\z/i")) {
                     $success = false;
                     return $this->m_defaultValue;
                 }
                 $value = CString::toIntFromHex($inputString);
             }
             if (isset($this->m_intValidMin) && $value < $this->m_intValidMin || isset($this->m_intValidMax) && $value > $this->m_intValidMax) {
                 $success = false;
                 return $this->m_defaultValue;
             }
             if (isset($this->m_intClampingMin) && $value < $this->m_intClampingMin) {
                 $value = $this->m_intClampingMin;
             }
             if (isset($this->m_intClampingMax) && $value > $this->m_intClampingMax) {
                 $value = $this->m_intClampingMax;
             }
             return $value;
         }
         if ($this->m_expectedType == self::FLOAT) {
             if (!CRegex::find($inputString, "/^-?(?!0(?!\\b))\\d*\\.?\\d+(e[\\-+]?\\d+)?\\z/i")) {
                 $success = false;
                 return $this->m_defaultValue;
             }
             $value = CString::toFloat($inputString);
             if (isset($this->m_floatValidMin) && $value < $this->m_floatValidMin || isset($this->m_floatValidMax) && $value > $this->m_floatValidMax) {
                 $success = false;
                 return $this->m_defaultValue;
             }
             if (isset($this->m_floatClampingMin) && $value < $this->m_floatClampingMin) {
                 $value = $this->m_floatClampingMin;
             }
             if (isset($this->m_floatClampingMax) && $value > $this->m_floatClampingMax) {
                 $value = $this->m_floatClampingMax;
             }
             return $value;
//.........这里部分代码省略.........