Divides this list into a list of smaller-chunked lists
@param int $size Size of each chunked list
@return \static
501940
public function chunk($size){
		
		$outer = new static();
		$chunks = \array_chunk($this->_Arr, $size);
		
		foreach($chunks as $chunk){
			$outer->pushBack(new static($chunk));
		}
		
		return $outer;
		
	}
384315
public function size($size = null)
    {
        /* To do: function should be called ratio() */
        if (is_null($size)) {
            if (isset($this->size_attribute)) {
                return $this->size_attribute;
            } else {
                return;
            }
        }
        $size = $this->parseSize($size)->raw;
        $this->size_attribute = $size;
        $this->todo('resize');

        return $this;
    }
1094402
public function withSizes(array $sizes)
    {
        $res = clone $this;

        $res->sizes = $res->fillArrayInput($sizes);

        return $res;
    }
1373668
public function setSize($size)
	{
		$this->size = $size;
		$this->pixelRatio = round($size / 5);

		return $this;
	}
637721
public function chunk($size, $preserveKeys = null)
    {
        return $this->bindNewInstance(
            array_map([$this, 'bindNewInstance'], array_chunk($this->convertArray($this), $size, $preserveKeys))
        );
    }
1333715
public function setSize($size) {
		if (is_int($size)) {
			return $this->addToMemberCtrl($this->mClass, CssRef::sizes("input-group")[$size],CssRef::sizes("input-group"));
		}
		return $this->addToMemberCtrl($this->mClass, $size, CssRef::sizes("input-group"));
	}
13352
public function setSize($size)
    {
        if (null === $size) {
            return $this;
        }

        $this->size = $size;
        $this->pixelRatio = (int) round($size / 5);

        return $this;
    }
995373
public function chunk($size): CollectionInterface
    {
        if (!($size > 0)) {
            return $this::make([]);
        }
        return $this->wrap(function (Iterator $data) use ($size) {
            $chunk = [];
            $count = 0;
            foreach ($data as $key => $item) {
                $chunk[$key] = $item;
                $count++;

                if ($count >= $size) {
                    yield $this::make($chunk);
                    $chunk = [];
                    $count = 0;
                }
            }

            if ($count) {
                yield $this::make($chunk);
            }
        });
    }
1039919
public function limit($size) {
        LimitImpl::limit($this->context, $size);
        return new ExecRule($this->context);
    }
990728
public function chunk(int $size, bool $preserveKeys = false): ArrayCollection
    {
        $chunks = [];

        foreach (array_chunk($this->items, $size, $preserveKeys) as $chunk) {
            $chunks[] = new static($chunk);
        }

        return new static($chunks);
    }
32173
public function withMaximumSizeInBytes($size) {
		$size = (int) $size;

		if ($size > $this->maxTotalSize) {
			throw new TotalSizeExceededError();
		}

		$this->maxIndividualSize = $size;

		return $this;
	}
1279537
public function divide($width, $height=null)
    {
        if ($width instanceof Size) {
            $height = $width->height();
            $width = $width->width();
        }

        $height = $height ? $height : $width;

        return new static($this->width()/$width, $this->height()/$height);
    }
540314
public function setFileSize($size)
    {
        if ($size === null) {
            $this->fileSize = null;

            return $this;
        }

        if (!is_numeric($size)) {
            throw new InvalidArgumentException('File size must be an integer or a float.');
        }

        $this->fileSize = $size;

        return $this;
    }
972697
public function chunk($size): Collection
    {
        $chunks = [];

        foreach (array_chunk($this->items, (int) $size, true) as $chunk) {
            $chunks[] = new static($chunk);
        }

        return new static($chunks);
    }
983639
public function displayTableCell($size = null)
    {
        if (empty($size)) {
            $this->attributes->addAttributeClass('d-table-cell');
        } elseif (in_array($size, ['xs', 'sm', 'md', 'lg', 'xl'])) {
            $this->attributes->addAttributeClass('d-' . $size . '-table-cell');
        }

        return $this;
    }
866768
public function setChunkSize($size)
    {
        if(static::MODE == 'cli' && is_numeric($size))
        {
            $this->chunkSize = (int)$size;
        }
        elseif(static::MODE == 'web')
        {
            throw new Exception('Chunk size is not supported on web mode');
        }
        else
        {
            throw new Exception("$size is not a valid chunk size");
        }

        return $this;
    }
1302524
public function setBlockSize($size)
    {
        if ($size <= 1) {
            throw new \InvalidArgumentException("Pixel Size Must Be Greater Than One");
        }
        $this->size = (int) abs($size);

        return $this;
    }