Concat requests accessor

@return ConcatRequests
768197
public function concats()
    {
        if (is_null($this->concatRequests)) {
            $this->concatRequests = new ConcatRequests($this->client);
        }

        return $this->concatRequests;
    }
1254753
public function add()
    {
        $args = func_get_args();

        if (count($args) == 1) {
            list($middleware) = $args;
            if (!is_null($this->currentGroup)) {
                //middlewares no group
                $this->groupMiddlewares[$this->currentGroup][] = $middleware;
            } else {
                //middlewares na rota
                $lastRoute = $this->findLastRoute();
                $lastRoute->addMiddleware($middleware);
            }

        } elseif(count($args) > 1) {
            list($routeNames, $middlewares) = $args;
            foreach ($routeNames as $routeName) {
                if (isset($this->middlewares[$routeName])) {
                    $currentMiddlewares = $this->middlewares[$routeName];
                    $this->middlewares[$routeName] = array_merge($middlewares, $currentMiddlewares);
                } else {
                    $this->middlewares[$routeName] = $middlewares;
                }
            }
        }
        return $this;
    }
768635
public static function all() {
        $request = array_merge(self::paramFilter($_GET), self::paramFilter($_POST));
        return $request;
    }
881675
public function composeUri($params)
    {
        $ret   = [];

        foreach ($params as $param => $values) {
            $internal = $param;
            if ($external = $this->translateKeyOutput($param)) {
                $param = $external;
            }
            $ret[$param] = [];
            foreach ($values as $value) {
                if ($external = $this->translateValueOutput($internal, $value)) {
                    $value = $external;
                }
                $ret[$param][] = $value;
            }
        }

        return http_build_query($ret);
    }
1190921
private function order()
    {
        $result = [];

        $data = $this->request;

        if ($data['table1'] > $data['table2']) {
            $result['first'] = $data['table2'];
            $result['second'] = $data['table1'];
        } else {
            $result['first'] = $data['table1'];
            $result['second'] = $data['table2'];
        }

        return $result;
    }
291680
public function getResponseHeaders() {
        $requestHeaders = [];

        if ($this->headers instanceof \ArrayAccess) {
            while ($this->headers->valid()) {
                $requestHeaders[$this->headers->key()] = $this->headers->current();
                $this->headers->next();
            }
        }

        return $requestHeaders;
    }
771003
function() {
      return _.reduce(arguments, function(acc, elem) {
        if (_.isArguments(elem)) {
          return concat.call(acc, slice.call(elem));
        }
        else {
          return concat.call(acc, elem);
        }
      }, []);
    }
503538
public function add()
    {
        $data = (array)$this->request->getData();
        if (!empty($data['group_id'])) {
            $data['owner_model'] = 'Groups';
            $data['owner_foreign_key'] = $data['group_id'];
        } elseif (!empty($data['user_id'])) {
            $data['owner_model'] = 'Users';
            $data['owner_foreign_key'] = $data['user_id'];
        } else {
            throw new InvalidArgumentException("Missing user or group!");
        }

        $data['creator'] = $this->Auth->user('id');
        $permission = $this->Permissions->newEntity();
        if ($this->request->is('post')) {
            $permission = $this->Permissions->patchEntity($permission, $data);
            $this->Permissions->save($permission) ?
                $this->Flash->success((string)__('The  permission has been saved.')) :
                $this->Flash->error((string)__('The  permission could not be saved. Please, try again.'));

            return $this->redirect($this->referer());
        }
        $users[''] = '';
        asort($users);
        $types[''] = '';
        foreach (PermissionsTable::ALLOWED_ACTIONS as $action) {
            $types[$action] = Inflector::humanize($action);
        }
        $this->set(compact('permission', 'users', 'types'));
        $this->set('_serialize', ['permission']);
    }
729105
private function addMappings()
    {
        $indicesSettings = $this->indexSettings->getIndicesConfig();

        foreach ($this->_data as $requestName => $requestConfig) {
            $index = $requestConfig['index'];
            $this->_data[$requestName]['mapping'] = $indicesSettings[$index]['mapping'];
        }

        return $this;
    }
265760
public function getSelect()
    {
        $concat = null;

        foreach ($this->fieldDescriptors as $fieldDescriptor) {
            if (null == $concat) {
                $concat = $fieldDescriptor->getSelect();
            } else {
                $concat = 'CONCAT(' . $concat . ', CONCAT(\'' . $this->glue . '\', ' . $fieldDescriptor->getSelect() . '))';
            }
        }

        return $concat;
    }
1352750
public function concat()
	{
		$args = func_get_args();
		$str = $this->str;
		foreach ($args as $arg)
		{
			$str .= (string) $arg;
		}
		return new static($str);
	}
586652
protected function _buildRequest()
    {
        $this->_request = $this->_factory
            ->getNewCancelBuildRequest($this->_api, $this->_order)
            ->build();
        return $this;
    }
704806
public static function popRequest()
    {
        $removed = array_pop(static::$_requests);
        $last = end(static::$_requests);
        if ($last) {
            static::setRequestContext($last);
            reset(static::$_requests);
        }

        return $removed;
    }
797350
public function getDispatchAction()
    {
        $args = $this->request->getAsArray('args');
        $arg = array_shift($args);
        if (preg_match('/^(\w+\.\w+)$/', $arg, $matches)) {
            $action = $matches[1];
            return $action;
        }
    }
992404
public function cacheAction(Request $request)
    {
        $parameters = $request->get('parameters', []);

        if ($request->get('token') !== $this->computeHash($parameters)) {
            throw new AccessDeniedHttpException('Invalid token');
        }

        $subRequest = Request::create('', 'get', $parameters, $request->cookies->all(), [], $request->server->all());

        $controller = $this->resolver->getController($subRequest);

        $subRequest->attributes->add(['_controller' => $parameters['controller']]);
        $subRequest->attributes->add($parameters['parameters']);

        $arguments = $this->argumentResolver->getArguments($subRequest, $controller);

        return \call_user_func_array($controller, $arguments);
    }
702965
function concat() {
  const args = Array.from(arguments).filter(e => e != null);
  const baseArray = Array.isArray(args[0]) ? args[0] : [args[0]];
  return Array.prototype.concat.apply(baseArray, args.slice(1));
}
1324585
public function getDispatchAction()
    {
        $params = $this->request->getAll();
        foreach (array_keys($params) as $key) {
            if (preg_match('/^dispatch-(.+)/', $key, $matches)) {
                $action = str_replace('-', '.', $matches[1]);
                return $action;
            }
        }
    }