Returns a copy of this path with the given number of segments removed from the beginning.

@param int $count
@return Path
518650
public function removeFirstSegments($count) {
		$segments = new ArrayObject();
		for ($i = $count; $i < $this->segmentCount(); $i++) {
			$segments->push($this->segments[$i]);
		}
		return new Path($segments->join('/'));
	}
98896
public function first(int $count = 1) : Collection
    {
        $i = 0;
        $new = [];
        foreach ($this as $k => $v) {
            if (++$i > $count) {
                break;
            }
            $new[$k] = $v;
        }
        return new static($new);
    }
246950
public function deleteFirst($value, int $count = 1): int
    {
        return $this->handle->lRem($this->name, $value, $count);
    }
1337853
public function onlyTrashedItems($count = false)
    {
        if (!$this->hasSoftDeleting()) {
            throw new \Exception('Model does not have Soft Deleting');
        }

        $this->query = $this->model->newQuery()->onlyTrashed();

        return $this->query($count);
    }
995394
public function spacers(int $count = 1): Writer
    {
        for ($x = 0; $x < $count; $x++) {
            $this->spacer();
        }

        return $this;
    }
337492
protected function getRandomString($count)
    {
        // This string MUST stay FS safe, avoid special chars
        $base = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-';
        $ret = '';
        $strlen = strlen($base);
        for ($i = 0; $i < $count; ++$i) {
            $ret .= $base[random_int(0, $strlen - 1)];
        }

        return $ret;
    }
898010
public function read(int $count): string
    {
        $data = $this->doRead($this->offset, $count);
        $this->offset += $count;
        return $data;
    }
1076090
public function split(int $count = 1): self
    {
        return $this->chunk((int) ceil($this->count() / $count));
    }
771298
public function hit($count = 1)
	{
		if (file_exists($this->path))
		{
			$expires = $this->getPathContent('expires');
			if ( ! is_null($expires))
			{
				$hits = $this->getPathContent('hits');
				$hits += $count;
				if ($hits > $this->hits)
				{
					// we reached the limit
					return false;
				}
				$size = $this->writePathContent($expires, $hits);

				return $size !== false;
			}
		}

		// first hit
		$expires = time() + $this->seconds;
		$size    = $this->writePathContent($expires, $count);

		return $size !== false;
	}
1272088
public static function getValues($count)
    {
        if (!Int::is($count) || $count < 1) {
            throw new \InvalidArgumentException("The \$count parameter must be of type int and greater than zero.");
        }

        $ret = [];
        $flag = 1;
        for ($i = 0; $i < $count; $i++) {
            $ret[] = $flag;
            $flag <<= 1;
        }

        return $ret;
    }
751428
private function readLinearRings($count)
    {
        $rings = array();

        for ($i = 0; $i < $count; $i++) {
            $rings[] = $this->readPoints($this->readCount());
        }

        return $rings;
    }
177956
protected function progressBar($count)
    {
        if($this->console) {
            return $this->console->getOutput()->createProgressBar($count);
        }
        else {
            return new NullProgressBar;
        }
    }
758516
public function incrementAndInvoice(int $count = 1)
    {
        $this->incrementQuantity($count);
        $this->user->invoice();

        return $this;
    }
165743
protected function removeDotsFromPath(){        
        if($this->parentLink !==null){
            $newUri = \GuzzleHttp\Psr7\UriResolver::resolve($this->parentLink,$this);
        }else{
            $newUri = $this;
        }
        $finalPath = \GuzzleHttp\Psr7\UriResolver::removeDotSegments($newUri->getPath());
        
        return $finalPath;
    }
1140584
public function takeLast(int $count)
    {
        return $this->wrap(function (Iterator $data) use ($count) {
            // From the end of the collection
            $limit = max(0, $count);
            $chunk = [];

            foreach ($data as $key => $datum) {
                $chunk[] = [$key, $datum];
                if (count($chunk) > $limit) {
                    array_shift($chunk);
                }
            }

            foreach ($chunk as $item) {
                [$key, $datum] = $item;
                yield $key => $datum;
            }
        });
    }
752263
public function newLine($count = 1) {

        // send out any escaping to implement anything sitting in the desired state
        $this->outputEscapeSequence();

        // if the $count is greater than one
        if (is_int($count) && $count > 1) {

            // send out the \n $count times
            for ($i=0; $i<$count; ++$i) {

                // echo the newline character
                $this->output("\n");
            }

        } else {
            // the parameter might be one or something crazy, just output one
            // echo the new line character
            $this->output("\n");
        }

        // fire the handler that indicates the cursor is sent to the left margin
        $this->carriageReturn();

        // chaining
        return $this;
    }
457157
public function prepend($segment)
    {
        $segments = is_array($segment) ? $segment : func_get_args();

        $newPath = $this->path->copy();

        foreach (array_reverse($segments) as $segment) {
            $newPath->prepend($segment);
        }

        return $this->replicate(['path' => $newPath]);
    }