gets the limit node

@return bool|LimitNode the node or false
509846
private function getPaginationLimitNode()
    {
        /** @var Query $rqlQuery */
        $rqlQuery = $this->request->attributes->get('rqlQuery');

        if ($rqlQuery instanceof Query && $rqlQuery->getLimit() instanceof LimitNode) {
            return $rqlQuery->getLimit();
        }

        return false;
    }
533739
public function getLimitRules()
    {
        $jsonHelper = new JSONHelper();
        $limits     = $jsonHelper->decodeObject($this->contactClient->getLimits(), 'Limits');

        $this->excludeIrrelevantRules($limits);

        return $this->mergeRules($limits, false);
    }
623786
public function query(SearchNode $node, LimitNode $limitNode = null)
    {
        $client = $this->getClient();

        $query = $client->createQuery($client::QUERY_SELECT);

        // set the weights
        $query->getEDisMax()->setQueryFields($this->solrMap[$this->className]);

        $query->setQuery($this->getSearchTerm($node));

        if ($limitNode instanceof LimitNode) {
            $query->setStart($limitNode->getOffset())->setRows($limitNode->getLimit());
        } else {
            $query->setStart(0)->setRows($this->paginationDefaultLimit);
        }

        $query->setFields(['id']);

        $result = $client->select($query);

        if ($this->requestStack->getCurrentRequest() instanceof Request) {
            $this->requestStack->getCurrentRequest()->attributes->set('totalCount', $result->getNumFound());
            $this->requestStack->getCurrentRequest()->attributes->set('X-Search-Source', 'solr');
        }

        $idList = [];
        foreach ($result as $document) {
            if (isset($document->id)) {
                $idList[] = (string) $document->id;
            } elseif (isset($document->_id)) {
                $idList[] = (string) $document->_id;
            }
        }

        return $idList;
    }
549680
public function getCurrentMax()
	{
		$max = 0;
		/* @var $node Node\NodeInterface */
		foreach ($this->array as $node) {
			$max = max($max, $node->getRightValue());
		}
		return $max;
	}
832455
public function isInsideSubTreeLimit()
    {
        /** @var eZTagsObject[] $path */
        $path = $this->getPath( true, true );

        if ( is_array( $path ) && !empty( $path ) )
        {
            foreach ( $path as $tag )
            {
                if ( $tag->getSubTreeLimitationsCount() > 0 )
                    return true;
            }
        }

        return false;
    }
861169
protected function limit()
    {
        if (($connectionLimit = config('ratchet.connectionLimit')) && $this->connections - 1 >= $connectionLimit) {
            $this->console->info(sprintf('To many connections: %d of %d', $this->connections - 1, $connectionLimit));
            $this->conn->send(trans('ratchet::messages.tooManyConnections'));
            $this->conn->close();
        }

        return $this;
    }
1176137
public function getDesde()
    {
        if (!$this->xml) {
            return false;
        }
        $D = $this->xml->getElementsByTagName('D')->item(0);
        return $D ? (int)$D->nodeValue : false;
    }
911673
public function getRoot() : Node {
        $node = $this;
        while ($node->parent !== null) {
            $node = $node->parent;
        }
        return $node;
    }
916968
public function getLimit()
    {
        $result = null;
        if (isset($this->options['limit'])) {
            $result = $this->options['limit'];
        }

        return $result;
    }
451501
public function getTipo()
    {
        if (!$this->xml) {
            return false;
        }
        $TD = $this->xml->getElementsByTagName('TD')->item(0);
        return $TD ? (int)$TD->nodeValue : false;
    }
488279
function pop(){
		if( ! $this->length ){
			return null;
		}
		if( --$this->length <= 0 ){
			$this->length = 0;
			$this->p = null;
		}
		else {
			$this->p = 0;
		}
		$Node = array_pop( $this->children );
		$Node->pidx = null;
		$Node->depth = 0;
		return $Node;
	}
278284
public function getLimit($max = null)
    {
        $limit = $this->getPage('limit') ?: $this->getPage('size') ?: null;

        if ($limit && $max) {
            $limit = min($max, $limit);
        }

        return $limit;
    }
1284228
protected function isNodeLimited(DataObject $node, $count = null)
    {
        // Singleton root node isn't limited
        if (!$node->ID) {
            return false;
        }

        // Check if limiting is enabled first
        if (!$this->getLimitingEnabled()) {
            return false;
        }

        // Count children for this node and compare to max
        if (!isset($count)) {
            $count = $this->getNumChildren($node);
        }
        return $count > $this->getMaxChildNodes();
    }
426504
private function getRestNode()
    {
        $node = $this->createRootNode('rest');
        return $node
            ->addDefaultsIfNotSet()
            ->children()
                ->scalarNode('root_endpoint')->isRequired()->cannotBeEmpty()->defaultValue('modlr/api')
                    ->validate()
                        ->always(function($v) {
                            $v = $this->formatRestEndpoint($v);
                            return $v;
                        })
                    ->end()
                ->end()
                ->booleanNode('debug')->defaultValue(false)->end()
            ->end()

        ;
    }
1224664
public function getEndPosition() {
        // TODO test invariant - start of next node is end of previous node
        for ($i = \count($childKeys = $this::CHILD_NAMES) - 1; $i >= 0; $i--) {
            $lastChildKey = $childKeys[$i];
            $lastChild = $this->$lastChildKey;

            if (\is_array($lastChild)) {
                $lastChild = \end($lastChild);
            }

            if ($lastChild instanceof Token) {
                return $lastChild->fullStart + $lastChild->length;
            } elseif ($lastChild instanceof Node) {
                return $lastChild->getEndPosition();
            }
        }

        throw new \Exception("Unhandled node type");
    }
821356
public function getEmisor()
    {
        if (!$this->xml) {
            return false;
        }
        $RE = $this->xml->getElementsByTagName('RE')->item(0);
        return $RE ? $RE->nodeValue : false;
    }
92194
protected function getLimit(array $default_limit = array())
    {
        if (empty($default_limit)) {
            $default_limit = $this->config->get('module_cli_limit', array(0, 100));
        }

        $limit = $this->getParam('l');

        if (!isset($limit) || !is_numeric($limit)) {
            return $default_limit;
        }

        $exploded = explode(',', $limit, 2);

        if (count($exploded) == 1) {
            array_unshift($exploded, 0);
        }

        return $exploded;
    }