Remove a previously added size.

@param array|Size $size

@return $this
764814
public function removeSize($size)
    {
        $size = is_array($size) ? new Size($size[0], $size[1]) : $size;
        $key = "$size";

        if (isset($this->sizes[$key])) {
            unset($this->sizes[$key]);
        }

        if (isset($this->sizeUrls[$key])) {
            unset($this->sizeUrls[$key]);
        }

        return $this;
    }
61779
public function setSize($size) {
		foreach ( $this->elements as $element ) {
			$element->setSize($size);
		}
		if (is_int($size)) {
			return $this->addToPropertyUnique("class", CssRef::sizes("btn-group")[$size], CssRef::sizes("btn-group"));
		}
		return $this->addToPropertyCtrl("class", $size, CssRef::sizes("btn-group"));
	}
844585
public static function size(string $name, int $size = 12)
    {
        $instance = new static();

        $instance->group['name'] = $name;
        $instance->group['size'] = $size;

        return $instance;
    }
1194636
public function subtract(Size $size): Size
    {
        $result = $this->bit - $size->get('b');

        if (0 > $result) {
            throw new \OutOfBoundsException('Could not subtract, the result would be less than 0.');
        }

        $this->bit = $result;

        return $this;
    }
379406
public function truncate($size)
    {
        if($this->isWritable())
        {
            if($this->getType() == 'memory')
            {
                if ($this->_length > $size) {
                    $this->_resource = substr($this->_resource, 0, $size);
                } else {
                    $this->_resource = str_pad($this->_resource, $size, "\0", STR_PAD_RIGHT);
                }
            }
            else return parent::truncate($size);

            return true;
        }

        return false;
    }
902779
public function truncate($size)
    {
        if($resource = $this->getResource())
        {
            if($this->isWritable()) {
                return @ftruncate($resource, $size);
            }
        }

        return false;
    }
178386
public function setSize(int $size) : self
    {
        $this->getField()->addAttribute('size', (string) $size);

        return $this;
    }
1250132
public function fitsInto(Size $size)
    {
        return ($this->width <= $size->width) && ($this->height <= $size->height);
    }
432466
public function truncate($offset, $size)
	{
		/* @var $node Node\NodeInterface */
		foreach ($this->array as $node) {
			if ($node->getLeftValue() >= $offset) {
				$this->moveNode($node, - $size, 0, 0);
			}
			if ($node->getRightValue() >= $offset) {
				$this->moveNode($node, 0, - $size, 0);
			}
		}
	}
870536
public function images(array $sizes = [])
    {
        if (empty($sizes)) {
            return $this;
        }

        $this->images = (new ImageSize($sizes, $this->app['filter']))
            ->register();

        return $this;
    }
1198689
public function pad($size, $value)
    {
        try {
            $arr = array_pad($this->val(), $size, $value);
        } catch (\ErrorException $e) {
            throw new ArrayObjectException($e->getMessage());
        }

        $this->val($arr);

        return $this;
    }
1039919
public function limit($size) {
        LimitImpl::limit($this->context, $size);
        return new ExecRule($this->context);
    }
635142
public function setPagination($offset, $size)
    {
        if (is_int($offset)) {
            $this->query->setFrom($offset);
        }

        if (is_int($size)) {
            $this->query->setSize($size);
        }

        return $this;
    }
220016
public function chunk($size)
    {
        $chunked = array_chunk($this->array, $size);

        return new static(array_map(function ($item) {
            return new static($item);
        }, $chunked));
    }
1014796
public function displayNone($size = null)
    {
        if (empty($size)) {
            $this->attributes->addAttributeClass('d-none');
        } elseif (in_array($size, ['xs', 'sm', 'md', 'lg', 'xl'])) {
            $this->attributes->addAttributeClass('d-' . $size . '-none');
        }

        return $this;
    }
13352
public function setSize($size)
    {
        if (null === $size) {
            return $this;
        }

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

        return $this;
    }
482152
public function &expectedDatasetSize($size)
    {
        if (in_array($size, [FieldInterface::SIZE_TINY, FieldInterface::SIZE_SMALL, FieldInterface::SIZE_MEDIUM, FieldInterface::SIZE_NORMAL, FieldInterface::SIZE_BIG])) {
            $this->expected_dataset_size = $size;

            if ($this->id_field instanceof IntegerField && $this->id_field->getSize() != $this->expected_dataset_size) {
                $this->id_field = null; // Reset ID field so it can be recreated with the new size
            }
        } else {
            throw new InvalidArgumentException("Value '$size' is not a valid dataset size");
        }

        return $this;
    }