/**
* Returns the variants of a locale.
*
* @return CArrayObject The locale's variants of type `CUStringObject` (always uppercased).
*/
public function variants()
{
assert('$this->hasVariants()', vs(isset($this), get_defined_vars()));
$variants = Locale::getAllVariants($this->m_name);
if (is_cmap($variants)) {
return oop_a(CArray::fromPArray($variants));
} else {
return oop_a(CArray::make());
}
}
protected static function recurseValueBeforeFiltering($value, $inputFilterOrFilterCollection, &$success, $currDepth)
{
assert('$inputFilterOrFilterCollection instanceof CInputFilter || ' . 'is_collection($inputFilterOrFilterCollection)', vs(isset($this), get_defined_vars()));
if ($currDepth == self::$ms_maxRecursionDepth) {
$success = false;
return;
}
$currDepth++;
if (!is_cmap($value)) {
// Only interested in PHP arrays.
return $value;
}
if (is_carray($inputFilterOrFilterCollection)) {
// The output value is expected to be a CArray; the keys in the arrived PHP array should be sequential.
if (!CMap::areKeysSequential($value)) {
$success = false;
return;
}
$value = CArray::fromPArray($value);
$len = CArray::length($value);
if ($len != CArray::length($inputFilterOrFilterCollection)) {
$success = false;
return;
}
for ($i = 0; $i < $len; $i++) {
$inputValue = $value[$i];
$inputFilterElement = $inputFilterOrFilterCollection[$i];
$inputValue = self::recurseValueBeforeFiltering($inputValue, $inputFilterElement, $success, $currDepth);
if (!$success) {
return;
}
$value[$i] = $inputValue;
}
} else {
if (is_cmap($inputFilterOrFilterCollection)) {
// The output value is expected to be a CMap; already got one.
foreach ($value as $inputKey => &$inputValue) {
if (!CMap::hasKey($inputFilterOrFilterCollection, $inputKey)) {
$success = false;
return;
}
$inputFilterElement = $inputFilterOrFilterCollection[$inputKey];
$inputValue = self::recurseValueBeforeFiltering($inputValue, $inputFilterElement, $success, $currDepth);
if (!$success) {
return;
}
}
unset($inputValue);
} else {
$success = false;
return;
}
}
return $value;
}
public function testFromPArray()
{
$map = [0 => "a", 1 => "b", 3 => "c", 9 => "d"];
$array = CArray::fromPArray($map);
$this->assertTrue(CArray::equals($array, CArray::fromElements("a", "b", "c", "d")));
}
public function leaveNode(PhpParser\Node $node)
{
if ($node instanceof PhpParser\Node\Stmt\Class_ || $node instanceof PhpParser\Node\Stmt\Trait_) {
$this->m_numEnteredClassesOrTraits--;
} else {
if ($node instanceof PhpParser\Node\Stmt\Interface_) {
$this->m_numEnteredInterfaces--;
} else {
if ($node instanceof PhpParser\Node\Stmt\ClassMethod) {
$numEnteredMethods = $this->m_numEnteredMethods;
$this->m_numEnteredMethods--;
if (!($this->m_numEnteredClassesOrTraits == 1 && $this->m_numEnteredInterfaces == 0 && $numEnteredMethods == 1 && $this->m_numEnteredClosures == 0 && $this->m_numEnteredFunctions == 0)) {
return;
}
$method = $node;
if ($method->isProtected() && !$this->m_wrapProtectedMethods && !$this->m_isTrait || $method->isPrivate() && !$this->m_wrapPrivateMethods && !$this->m_isTrait || $method->isAbstract()) {
return;
}
if (!isset($method->stmts) || CMap::isEmpty($method->stmts)) {
return;
}
$hasParams = false;
$params = CArray::make();
$hasParamsByRef = false;
$paramsByRef = CArray::make();
if (isset($method->params) && !CMap::isEmpty($method->params)) {
$hasParams = true;
$params = CArray::fromPArray($method->params);
$paramsByRef = CArray::filter($params, function ($param) {
return $param->byRef;
});
$hasParamsByRef = !CArray::isEmpty($paramsByRef);
}
$method->stmts[0]->setAttribute("_imFirstStmtInMethodOrFunction", true);
$method->stmts[CMap::length($method->stmts) - 1]->setAttribute("_imLastStmtInMethodOrFunction", true);
$statements = [$method];
$methodFirstLastStmtVisitor = new CMethodOrFunctionFirstLastStmtVisitor($hasParams, $params, $hasParamsByRef, $paramsByRef);
$traverser = new PhpParser\NodeTraverser();
$traverser->addVisitor($methodFirstLastStmtVisitor);
$statements = $traverser->traverse($statements);
$method = $statements[0];
$returnVisitor = new CReturnVisitor($hasParams, $params, $hasParamsByRef, $paramsByRef, $method->byRef, CReturnVisitor::SUBJ_METHOD);
$traverser = new PhpParser\NodeTraverser();
$traverser->addVisitor($returnVisitor);
$statements = $traverser->traverse($statements);
return $statements;
} else {
if ($node instanceof PhpParser\Node\Expr\Closure) {
$this->m_numEnteredClosures--;
} else {
if ($node instanceof PhpParser\Node\Stmt\Function_) {
$this->m_numEnteredFunctions--;
}
}
}
}
}
}
/**
* Returns all the values assigned to a specified long option with which the script was run,
* e.g. "--option=value1 --option=value2".
*
* @param string $optionName The name of the option, excluding "-".
*
* @return CArrayObject The values of the option specified, where each value is of type `CUStringObject`.
*/
public static function valuesForLongOption($optionName)
{
assert('is_cstring($optionName)', vs(isset($this), get_defined_vars()));
assert('self::hasLongOptionWithValue($optionName)', vs(isset($this), get_defined_vars()));
$opt = getopt("", ["{$optionName}:"]);
$values = $opt[$optionName];
return oop_a(is_cmap($values) ? CArray::fromPArray($values) : CArray::fromElements($values));
}
/**
* Sends a message to the recipient(s).
*
* @param reference $failedAddresses **OPTIONAL. OUTPUT.** After the method is called with this parameter
* provided, the parameter's value, which is of type `CArrayObject`, is an array containing the email addresses of
* the recipients who failed to receive the message.
*
* @return int The number of recipients who have successfully received the message.
*/
public function send(&$failedAddresses = null)
{
assert('isset($this->m_swiftMailer) && isset($this->m_swiftMessage)', vs(isset($this), get_defined_vars()));
assert('(isset($this->m_from) || isset($this->m_sender) || isset($this->m_returnAddress)) && ' . '(isset($this->m_to) || isset($this->m_cc) || isset($this->m_bcc))', vs(isset($this), get_defined_vars()));
$message = $this->m_swiftMessage;
if (isset($this->m_from)) {
$message->setFrom($this->m_from);
}
if (isset($this->m_to)) {
$message->setTo($this->m_to);
}
if (isset($this->m_cc)) {
$message->setCc($this->m_cc);
}
if (isset($this->m_bcc)) {
$message->setBcc($this->m_bcc);
}
if (isset($this->m_sender)) {
$message->setSender($this->m_sender);
}
if (isset($this->m_returnAddress)) {
$message->setReturnPath($this->m_returnAddress);
}
if (isset($this->m_replyAddress)) {
$message->setReplyTo($this->m_replyAddress);
}
if (isset($this->m_body)) {
if (CString::equals($this->m_bodyType, CMimeType::PLAIN_TEXT)) {
$this->m_body = $this->maybeWrapText($this->m_body);
}
$message->setBody($this->m_body, $this->m_bodyType);
}
if (isset($this->m_altBodiesAndTypes)) {
$len = CArray::length($this->m_altBodiesAndTypes);
for ($i = 0; $i < $len; $i++) {
$bodyAndType = $this->m_altBodiesAndTypes[$i];
$body = $bodyAndType[0];
$type = $bodyAndType[1];
if (CString::equals($type, CMimeType::PLAIN_TEXT)) {
$body = $this->maybeWrapText($body);
}
$message->addPart($body, $type);
}
}
$paFailedAddresses;
$res = $this->m_swiftMailer->send($message, $paFailedAddresses);
if (is_cmap($paFailedAddresses)) {
$failedAddresses = oop_a(CArray::fromPArray($paFailedAddresses));
}
$res = is_int($res) ? $res : 0;
return $res;
}
/**
* Returns the names of the time zones that are known for a specified country.
*
* If the country's code is not recognized for any reason, the entire list of the known time zone names is
* returned.
*
* @param string $countryCode The two-letter code of the country, as provided by ISO 3166.
*
* @return CArrayObject The known time zone names for the country specified, of type `CUStringObject`.
*/
public static function knownNamesForCountry($countryCode)
{
assert('is_cstring($countryCode)', vs(isset($this), get_defined_vars()));
$paNames = DateTimeZone::listIdentifiers(DateTimeZone::PER_COUNTRY, $countryCode);
$paNames = CMap::filter($paNames, "CTimeZone::isNameIcuCompatible");
$names = CArray::fromPArray($paNames);
if (is_cmap($paNames) && !CArray::isEmpty($names)) {
return oop_a($names);
} else {
return oop_a(self::knownNames());
}
}
/**
* Extracts and returns the values from a map, as an array.
*
* @param map $map The map to be looked into.
*
* @return CArray The map's values.
*/
public static function values($map)
{
assert('is_cmap($map)', vs(isset($this), get_defined_vars()));
return CArray::fromPArray($map);
}
/**
* @ignore
*/
function _to_oop_tp($value)
{
// Only used with OOP wrapping for third-party components.
if (is_array($value)) {
foreach ($value as &$mapValue) {
$mapValue = _to_oop_tp($mapValue);
}
unset($mapValue);
if (!CMap::areKeysSequential($value)) {
$value = oop_m($value);
} else {
$value = oop_a(CArray::fromPArray($value));
}
return $value;
}
if ($value instanceof SplFixedArray) {
$len = CArray::length($value);
for ($i = 0; $i < $len; $i++) {
$value[$i] = _to_oop_tp($value[$i]);
}
return oop_a($value);
}
return $value;
}
/**
* Returns the paths to the subdirectories found by a wildcard pattern.
*
* Wildcard patterns use "\*" to match zero or more arbitrary characters, except the character of "/", and "?" to
* match any single arbitrary character, again except the character of "/". For example, "\*.png" pattern searches
* for all PNG images in the *current* directory, and "/path/to/any\*subdir/\*thumb-year-201?\*" searches for all
* thumbnail images dated by the years of 2010-2019 and that are contained in the directories with a path matching
* the rest of the pattern. Distinct from regular expressions, wildcard patterns need to be anchored at both ends,
* so if the pattern in the last example was not concluded with "\*", no images would be found. Wildcards also
* support character classes, such as "[abc]" and "[0-9]" as well as "[^abc]" and "[^0-9]", which however is only a
* small portion of what regular expressions can do.
*
* To also search among the subdirectories that are contained in the subdirectories of the specified wildcard
* pattern and so on, you can use `findDirectoriesRecursive` method.
*
* The returned paths are always absolute.
*
* @param string $wildcardPattern The wildcard pattern to be used for searching.
* @param bool $sort **OPTIONAL. Default is** `false`. Tells whether the returned paths should be sorted, in the
* ascending order.
*
* @return CArrayObject The paths to the subdirectories found by the wildcard pattern specified.
*
* @link #method_findDirectoriesRecursive findDirectoriesRecursive
*/
public static function findDirectories($wildcardPattern, $sort = false)
{
assert('is_cstring($wildcardPattern) && is_bool($sort)', vs(isset($this), get_defined_vars()));
$wildcardPattern = CFilePath::frameworkPath($wildcardPattern);
$paSearchRes = glob($wildcardPattern, GLOB_NOSORT | GLOB_ONLYDIR);
assert('is_cmap($paSearchRes)', vs(isset($this), get_defined_vars()));
$searchRes = CArray::fromPArray($paSearchRes);
if ($sort) {
CArray::sortUStringsNatCi($searchRes);
}
return oop_a($searchRes);
}
/**
* Converts a PHP's associative array or an OOP map into an OOP array.
*
* @param map $map The PHP's associative array or the OOP map to be converted.
*
* @return CArrayObject The resulting array.
*/
public static function fromPArray($map)
{
return self::fromSplArray(CArray::fromPArray($map));
}
protected static function recurseQueryValueAfterParsing($value, $currDepth)
{
if ($currDepth == self::$ms_maxRecursionDepth) {
return $value;
}
$currDepth++;
if (!is_cmap($value)) {
// Only interested in PHP's associative arrays.
return $value;
}
if (CMap::areKeysSequential($value)) {
$value = CArray::fromPArray($value);
$len = CArray::length($value);
for ($i = 0; $i < $len; $i++) {
$value[$i] = self::recurseQueryValueAfterParsing($value[$i], $currDepth);
}
return oop_a($value);
} else {
foreach ($value as &$mapValue) {
$mapValue = self::recurseQueryValueAfterParsing($mapValue, $currDepth);
}
unset($mapValue);
return oop_m($value);
}
}
protected static function recurseValueAfterDecoding($value, $currDepth)
{
if ($currDepth == self::$ms_maxRecursionDepth) {
return $value;
}
$currDepth++;
if (is_string($value)) {
return $value;
}
if (is_object($value)) {
$value = (array) $value;
foreach ($value as &$valueInMap) {
$valueInMap = self::recurseValueAfterDecoding($valueInMap, $currDepth);
}
unset($valueInMap);
$value = oop_m($value);
} else {
if (is_array($value)) {
$value = CArray::fromPArray($value);
$len = CArray::length($value);
for ($i = 0; $i < $len; $i++) {
$value[$i] = self::recurseValueAfterDecoding($value[$i], $currDepth);
}
$value = oop_a($value);
}
}
return $value;
}
