PHP Arrays::toArray方法代码示例

 public static function callFunction($functionName, $parameters)
 {
     $db = self::getInstance();
     $bindParams = Arrays::toArray($parameters);
     $paramsQueryString = implode(',', array_pad(array(), sizeof($bindParams), '?'));
     return Arrays::first($db->query("SELECT {$functionName}({$paramsQueryString})", $parameters)->fetch());
 }

 public function __construct($httpCode, $errors, $headers = array())
 {
     $this->_httpCode = $httpCode;
     $this->_errors = Arrays::toArray($errors);
     $this->_headers = $headers;
     $firstError = Arrays::first($this->_errors);
     parent::__construct($firstError->getMessage(), $firstError->getCode());
 }

function showSuccess(array $notices = array())
{
    if (Session::has('messages') || $notices) {
        $sessionMessages = Arrays::filterNotBlank(Arrays::toArray(Session::get('messages')));
        $notices = array_merge($sessionMessages, $notices);
        $noticeView = new View('success_alert');
        $noticeView->notices = $notices;
        return $noticeView->render();
    }
    return null;
}

 private function getKeyAndValueArguments($args)
 {
     if (count($args) == 1 && is_array($args[0])) {
         $args = $args[0];
     }
     if (count($args) < 2) {
         throw new InvalidArgumentException('Method needs at least two arguments: key and value');
     }
     $value = array_pop($args);
     $keys = Arrays::toArray($args);
     return array($keys, $value);
 }

function selectTag($name, array $items = array(), $value, array $attributes = array(), $promptOption = null)
{
    $value = Arrays::toArray($value);
    $attr = _prepareAttributes($attributes, array('name' => $name));
    $optionsString = '';
    if ($promptOption) {
        $items = array(null => $promptOption) + $items;
    }
    foreach ($items as $optionValue => $optionName) {
        $optionsString .= optionTag($optionValue, $optionName, $value);
    }
    return '<select ' . $attr . '>' . $optionsString . '</select>';
}

 /**
  * @param Relation[] $relations
  * @param string|string[]|null $aliases
  * @return RelationWithAlias[]
  */
 public static function associateRelationsWithAliases(array $relations, $aliases)
 {
     $aliases = Arrays::toArray($aliases);
     if (count($relations) < count($aliases)) {
         throw new InvalidArgumentException("More aliases than relations in join");
     }
     $relationWithAliases = array();
     foreach ($relations as $index => $relation) {
         $alias = Arrays::getValue($aliases, $index, Arrays::getValue($aliases, $relation->getName()));
         $relationWithAliases[] = new RelationWithAlias($relation, $alias);
     }
     return $relationWithAliases;
 }

 public function revertProperty($keys)
 {
     $keys = Arrays::toArray($keys);
     $config =& $this->_config;
     $overriddenConfig =& $this->_overriddenConfig;
     $overriddenKey = null;
     foreach ($keys as $key) {
         if (!array_key_exists($key, $overriddenConfig)) {
             throw new InvalidArgumentException('Cannot revert. No configuration override for: ' . Objects::toString($keys));
         }
         $config =& $config[$key];
         if (is_array($overriddenConfig[$key])) {
             $overriddenConfig =& $overriddenConfig[$key];
         } else {
             $overriddenKey = $key;
         }
     }
     $config = $overriddenConfig[$overriddenKey];
 }

 private static function addRoute($method, $uri, $action, $requireAction = true, $options = array(), $isResource = false)
 {
     $methods = Arrays::toArray($method);
     if (self::$isDebug && $requireAction && self::$validate && self::existRouteRule($methods, $uri)) {
         $methods = implode(', ', $methods);
         throw new InvalidArgumentException('Route rule for method ' . $methods . ' and URI "' . $uri . '" already exists');
     }
     $elements = explode('#', $action);
     $controller = Arrays::first($elements);
     $actionToRule = Arrays::getValue($elements, 1);
     $routeRule = new RouteRule($method, $uri, $controller, $actionToRule, $requireAction, $options, $isResource);
     if ($routeRule->hasRequiredAction()) {
         throw new InvalidArgumentException('Route rule ' . $uri . ' required action');
     }
     self::$routes[] = $routeRule;
     foreach ($methods as $method) {
         self::$routeKeys[$method . $uri] = true;
     }
 }

 /**
  * @param $columns
  * @param int $type
  * @return ModelQueryBuilder
  */
 public function select($columns, $type = PDO::FETCH_NUM)
 {
     $this->_selectModel = false;
     $this->_query->selectColumns = Arrays::toArray($columns);
     $this->_query->selectType = $type;
     return $this;
 }

 /**
  * @return $this
  */
 private function types()
 {
     $ns = $this->builder->getNs();
     $typesElement = $this->createElement('types');
     $schemaElement = $this->createElementWithAttributes('xsd:schema', ['targetNamespace' => $ns, 'xmlns' => $ns]);
     foreach ($this->builder->getMethods() as $method) {
         $typesForParameters = $this->XMLStyle->generateTypes($this->DOMDocument, $method->getParameters(), $this->XMLSoapVersion);
         $typesForReturn = $this->XMLStyle->generateTypes($this->DOMDocument, Arrays::toArray($method->getReturn()), $this->XMLSoapVersion);
         $types = array_merge($typesForParameters, $typesForReturn);
         foreach ($types as $type) {
             $schemaElement->appendChild($type);
         }
     }
     $typesElement->appendChild($schemaElement);
     $this->definitionsRootNode->appendChild($typesElement);
     return $this;
 }

 private function wrapAsNotices($messages, $url)
 {
     $array = Arrays::toArray($messages);
     return Arrays::map($array, function ($msg) use($url) {
         return new Notice($msg, $url);
     });
 }

 /** Executes a native sql and returns an array of model objects created by passing every result row to the model constructor.
  * @param $nativeSql - database specific sql
  * @param array $params - bind parameters
  * @return Model[]
  */
 public static function findBySql($nativeSql, $params = array())
 {
     $meta = static::metaInstance();
     $results = $meta->_modelDefinition->db->query($nativeSql, Arrays::toArray($params))->fetchAll();
     return Arrays::map($results, function ($row) use($meta) {
         return $meta->newInstance($row);
     });
 }

 /**
  * @test
  */
 public function toArrayShouldReturnArrayWithOneElementForEmptyString()
 {
     // when
     $result = Arrays::toArray('');
     // then
     $this->assertEquals(array(''), $result);
 }

 public function __construct($sql, $parameters = array())
 {
     $this->sql = $sql;
     $this->values = $parameters === NULL ? array(null) : Arrays::toArray($parameters);
 }

 public static function getControllerNamespace()
 {
     $controllerPath = Config::getValue('namespace', 'controller');
     return $controllerPath ? Arrays::toArray($controllerPath) : array("\\Application\\Controller\\");
 }