@param int $diskQuote disk limit (in bytes)

@return Client
9714
public function setDiskQuote(int $diskQuote)
    {
        $this->diskQuote = $diskQuote;

        $this->hostConfig = array_merge($this->hostConfig, ['DiskQuota ' => $diskQuote]);

        return $this;
    }
227510
public function allocate($filesize)
    {
        $result = @ftp_alloc($this->connection, $filesize);
        
        if ($result === false) {
            throw new Exception('Unable to allocate');
        }

        return $this;
    }
1354310
public function setLimit(int $limit, ?int $offset = null): self
    {
        $this->limit = $limit;
        if ($offset !== null) {
            $this->setOffset($offset);
        }

        return $this;
    }
765977
public function get()
    {
        $disks = [];

        $result = $this->connection->newQuery()->from(Classes::WIN32_LOGICALDISK)->get();

        foreach($result as $disk) {
            $disks[] = new HardDisk($disk);
        }

        return $disks;
    }
570071
public function takeUpTo(int $limit): ISeq
    {
        return $this->clone()
            ->addModifier(self::TAKE_UP_TO, $limit)
            ->setIsInfinite(false);
    }
734002
public function maxLength($len, $comment = "", $encoding = "utf-8")
	{
		if ($this->isValid)
		{
			if (iconv_strlen($this->val, $encoding) > $len)
				self::addMessage($comment);
		}
		return $this;
	}
875543
public function limits($limits = NULL) {
        if (isset($limits)) {
            if (is_int($limits)) {
                $this->setLimits($limits);
                return $this;
            }
        }
        return $this->getLimits();
    }
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;
    }
1336797
public function uploaded($limit = 20, $offset = 0)
	{
		return (new Disk\Resource\Collection(function($parameters) {
			$response = $this->send((new Request($this->uri->withPath($this->uri->getPath().'resources/last-uploaded')
				->withQuery(http_build_query($parameters, null, '&')), 'GET')));

			if ($response->getStatusCode() == 200)
			{
				$response = json_decode($response->getBody(), true);

				if (isset($response['items']))
				{
					return array_map(function($item) {
						return new Disk\Resource\Closed($item, $this, $this->uri);
					}, $response['items']);
				}
			}

			return [];
		}))
			->setLimit($limit, $offset);
	}
15365
public function disk($disk)
    {
        try {
            $this->storage = Storage::disk($disk);
        } catch (\Exception $exception) {
            if (!array_key_exists($disk, config('filesystems.disks'))) {
                admin_error(
                    'Config error.',
                    "Disk [$disk] not configured, please add a disk config in `config/filesystems.php`."
                );

                return $this;
            }

            throw $exception;
        }

        return $this;
    }
30248
public function getRidOfMagicQuotes()
    {
        if (CKFINDER_CONNECTOR_PHP_MODE<6 && get_magic_quotes_gpc()) {
            if (!empty($_GET)) {
                $this->stripQuotes($_GET);
            }
            if (!empty($_POST)) {
                $this->stripQuotes($_POST);
            }
            if (!empty($_COOKIE)) {
                $this->stripQuotes($_COOKIE);
            }
            if (!empty($_FILES)) {
                while (list($k,$v) = each($_FILES)) {
                    if (isset($_FILES[$k]['name'])) {
                        $this->stripQuotes($_FILES[$k]['name']);
                    }
                }
            }
        }
    }
1245434
protected function hydrateQuoteWithShipment($quoteTransfer)
    {
        if ($quoteTransfer->getShipment()) {
            return $quoteTransfer;
        }

        $shipmentTransfer = new ShipmentTransfer();

        $methods = $this->shipmentClient->getAvailableMethods($quoteTransfer)->getMethods();

        if ($shippingMethod = reset($methods)) {
            $shippingMethod->setStoreCurrencyPrice(static::DEFAULT_SHIPPING_PRICE);
            $shipmentTransfer->setMethod($shippingMethod);
            $shipmentTransfer->setShipmentSelection($shippingMethod->getIdShipmentMethod());
            $quoteTransfer->setShipment($shipmentTransfer);

            return $quoteTransfer;
        }

        $shipmentTransfer->setMethod(
            (new ShipmentMethodTransfer())
                ->setCarrierName(static::CARRIER_NAME)
                ->setStoreCurrencyPrice(static::DEFAULT_SHIPPING_PRICE)
        );
        $quoteTransfer->setShipment($shipmentTransfer);

        return $quoteTransfer;
    }
718147
public function setLimit($limit)
    {
        if ($limit < 1 || !is_int($limit)) {
            throw new \InvalidArgumentException('setLimit() accepts only integers greater 0.', 1263387249);
        }
        $this->limit = $limit;

        return $this;
    }
785332
public function limit( $count = null ) {
			
			if ( null === $count || is_int( $count ) ) {
			
				if ( null !== $count && $count >= 0 ) {
					
					return $count === $this->len
						? $this
						: new static( array_slice( $this->items, 0, $count ) );
				
				} else
				if ( $many === null || $many === -1 ) {
				
					return $this;
				
				} else {
				
					throw new \browserfs\Exception('Invalid argument $count: Expected int[-1..length] | null' );
				
				}
			} else {

				throw new \browserfs\Exception('Invalid argument $count: Expected int[-1..length] | null');
			
			}

		}
847525
public function limit($value)
    {
        $property = $this->unions ? 'unionLimit' : 'limit';

        if ($value >= 0) {
            $this->{$property} = $value;
        }

        return $this;
    }
1351873
public function setLimit(int $limit)
    {
        $this->limit = $limit;
        if ($this->limit < $this->batchSize) {
            $this->batchSize = $this->limit;
        }

        return $this;
    }
1121655
public function create($limit = 500, $source = null, $destination = './')
    {
        if (!$destination || trim($destination) == '') {
            $destination = './';
        }

        $this->_rglobRead($source, $input);
        $maxinput = count($input);
        $splitinto = (($maxinput / $limit) > round($maxinput / $limit, 0)) ? round($maxinput / $limit, 0) + 1 : round($maxinput / $limit, 0);

        for ($i = 0; $i < $splitinto; ++$i) {
            $this->_zip(array_slice($input, ($i * $limit), $limit, true), $i, $destination);
        }

        unset($input);

        return;
    }