Scans the parameters list for the "lines" parameter and uses
it to set the number of lines to be returned in the filtered stream.

@return void
194347
private function initialize()
    {
        $params = $this->getParameters();
        if ($params !== null) {
            foreach ($params as $param) {
                if (self::LINES_KEY === $param->getName()) {
                    $this->lines = (int) $param->getValue();
                    continue;
                }
                if (self::SKIP_KEY === $param->getName()) {
                    $this->lines = (int) $param->getValue();
                    continue;
                }
            }
        }
    }
239375
public function getLines() : int
    {
        return $this->classes
            ->map(function ($class) {
                return $class->getFileName();
            })
            ->pipe(function ($classes) {
                return app(Analyser::class)->countFiles($classes->all(), false)['loc'];
            });
    }
1087944
protected function cleanupParameters()
    {
        $parser = new Parser();
        $params = $this->getParameters();
        foreach ($params as $key => $value) {
            if (is_string($value)) {
                $params[$key] = $parser->parse($value);
            }
        }
        $this->setParameters($params);
    }
594716
protected function fill()
    {
        $readFilterCallback = $this->readFilterCallback;
        $this->buffer .= $readFilterCallback($this->stream->read(self::BUFFER_SIZE));

        if ($this->stream->eof()) {
            $this->buffer .= $readFilterCallback();
        }
    }
89896
public function next()
    {
        $this->valid       = !$this->inputStream->eof();
        $this->currentLine = $this->inputStream->readLine();
        $this->lineNumber++;
    }
310883
def filter_all(self, line):
        
        lines = [None] * 5
        for filter_type in range(5):  # range save more than 'optimised' order
            res = copyBarray(line)
            self._filter_scanline(filter_type, line, res)
            res.insert(0, filter_type)
            lines[filter_type] = res
        return lines
761202
public function setLines(array $lines)
    {
        $translator = $this->factory->getTranslator();

        if ($translator instanceof Translator) {
            $translator->setLines($lines);
        }
    }
323012
private function setStreamClient()
    {
        $language = $this->language ?? '';
        $keywords = $this->keywords ?? [];
        $users    = $this->users    ?? [];
        
        if (empty($keywords) && empty($users)) {
            throw new EmptyRequiredParamsException(
                'The keywords to listen or the Users to track it mustn\'t be empty.'
            );
        }
        
        $this->streamClient->post(self::FILTER_METHOD, [
            'form_params' => [
                'language' => $language,
                'track'    =>  implode(',', $keywords),
                'follow'   => implode(',', $users),
            ],
        ]);
    }
743352
private function parseParameterValues()
    {
        $this->filterParameters = $this->parseOperators($this->filterParameters);
        foreach ($this->dataParameters as $key => $input) {
            $this->dataParameters[$key] = $this->parseValue($input);
        }
    }
519479
public function paging()
    {
        $limit = (int) $this->request->input('length') > 0 ? $this->request->input('length') : 10;
        if (is_callable($this->limitCallback)) {
            $this->query->limit($limit);
            call_user_func_array($this->limitCallback, [$this->query]);
        } else {
            $this->query->skip($this->request->input('start'))->take($limit);
        }
    }
386288
protected function nextLine()
    {
        if ($this->lineNumber < count($this->lines)) {
            return $this->lines[$this->lineNumber++];
        }
        return false;
    }
42151
protected function initializeIterator()
    {
        $this->results = $this->getResults();
        $this->resultsCounter = \count($this->results);
    }
700521
private function _setParams()
	{
		foreach ($_GET as $key => $value) {
			$this->_params[$key] = $this->_sanitize($value);
		}

		foreach ($_POST as $key => $value) {
			$_POST[$key] = $this->_sanitize($value);
		}

		$nbElements = count($this->_requestVars);
		if ($nbElements > 3) {
			$i = 2;
			while ($i < $nbElements and $i + 1 < $nbElements) {
				if (ctype_digit($this->_requestVars[$i])) {
					$i += 2;
					continue;
				}

				$this->_params[$this->_requestVars[$i]] = $this->_sanitize($this->_requestVars[$i + 1]);
				$i += 2;
			}
		}

		if ($nbElements > 2) {
			$i = 2;
			while ($i < $nbElements) {
				$this->_params[$i - 2] = $this->_sanitize($this->_requestVars[$i]);
				$i++;
			}
		}

		return $this;
	}
477569
public function load()
    {
        $this->ensureFileIsReadable();

        $filePath = $this->filePath;
        $lines = $this->readLinesFromFile($filePath);
        foreach ($lines as $line_number => $line) {
            if (!$this->isComment($line) && $this->looksLikeSetter($line)) {
                $this->setEnvironmentVariable($line, $line_number);
            }
        }

        return $lines;
    }
1253583
protected function scanModels()
    {
        $scans = $this->modelScans();

        if (empty($scans)) {
            return;
        }

        $scanner = $this->app->make('annotations.model.scanner');

        $scanner->setClassesToScan($scans);

        file_put_contents(
          $this->finder->getScannedModelsPath(), '<?php '.$scanner->getModelDefinitions()
        );
    }
702890
public function next(){
		$this->lines[$this->index]->next();
		if( !$this->lines[$this->index]->valid() ){
			$this->index++;
		}
	}
23398
public function setDataByIndex($line, $data)
    {
        $this->data[$line] = $data;
        $this->filteredData = null;
    }