{@inheritdoc}
The Composer's verbosity levels match with the Spress's verbosity levels.
In this implementation, the param `size` is unused.
348990
public function overwrite($messages, $newline = true, $size = null, $verbosity = self::NORMAL)
    {
        $this->io->overwrite($messages, $newline, $verbosity);
    }
536436
public void setSize(UnsignedInteger64 size) {
		this.size = size;

		// Set the flag
		if (size != null) {
			flags |= SSH_FILEXFER_ATTR_SIZE;
		} else {
			flags ^= SSH_FILEXFER_ATTR_SIZE;
		}
	}
262204
function set_font_size($size)
    {
        $this->__font_size_calculated = false;
        //see __set and __get, on all assignments clear cache, not needed on direct set through __set
        $this->_prop_cache["font_size"] = null;
        $this->_props["font_size"] = $size;
    }
433389
public void setSizeRefsByMsgSize(boolean sizeByMsgSize)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setSizeRefsByMsgSize", Boolean.valueOf(sizeByMsgSize));

        this._sizeRefsByMsgSize = sizeByMsgSize;

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setSizeRefsByMsgSize");
    }
421591
private function factorizeSizes($size, $limit)
    {
        $coef = self::MIB_BYTES;
        $coefFactor = self::KIB_BYTES;

        $limitAsString = (string) ($limit / $coef);

        // Restrict the limit to 2 decimals (without rounding! we
        // need the precise value)
        while (self::moreDecimalsThan($limitAsString, 2)) {
            $coef /= $coefFactor;
            $limitAsString = (string) ($limit / $coef);
        }

        // Convert size to the same measure, but round to 2 decimals
        $sizeAsString = (string) round($size / $coef, 2);

        // If the size and limit produce the same string output
        // (due to rounding), reduce the coefficient
        while ($sizeAsString === $limitAsString) {
            $coef /= $coefFactor;
            $limitAsString = (string) ($limit / $coef);
            $sizeAsString = (string) round($size / $coef, 2);
        }

        return [$limitAsString, self::$suffixes[$coef]];
    }
1067199
public function setWriteBuffer($size)
    {
        if (!is_resource($this->fp)) {
            return $this->raiseError('not connected');
        }

        $returned = stream_set_write_buffer($this->fp, $size);
        if ($returned === 0) {
            return true;
        }

        return $this->raiseError('Cannot set write buffer.');
    }
993373
function generateSizeParam(sizes) {
  return sizes.map(size => size.join(DIMENSION_SEPARATOR)).join(SIZE_SEPARATOR);
}
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;
    }
431445
function getSize()
    {
        if (!$this->_assertUsable())
            return null;

        $size  = null;
        if ($uri = $this->getMetadata('uri'))
            ## clear the stat cache of stream URI
            clearstatcache(true, $uri);

        $stats = fstat($this->rHandler);
        if (isset($stats['size']))
            $size = $stats['size'];

        return $size;
    }
343546
protected function updateSize($size) {
		$size = sprintf('%' . self::SHM_DATA_OFFSET . 'd', intval($size));
		return !!$this->write(0, $size);
	}
254837
private function setSize($size): void
    {
        if (false === is_int($size)) {
            throw new \InvalidArgumentException('Upload file size must be an integer');
        }

        $this->size = $size;
    }
642600
public function setSize($size = null) {
        $this->_size = is_int($size)? $size : self::DEFAULT_SIZE;
    }
246061
def formatted_size
      @formats.rcompact!
      sz = size
      fs = @formats.size
      fs > sz ? fs : sz
    end
902779
public function truncate($size)
    {
        if($resource = $this->getResource())
        {
            if($this->isWritable()) {
                return @ftruncate($resource, $size);
            }
        }

        return false;
    }
152827
public static void appendElapsedAndSize(
            StringBuilder buf, long startTimeNanos, long endTimeNanos, long size) {
        appendElapsed(buf, startTimeNanos, endTimeNanos);
        buf.append(", ");
        appendSize(buf, size);
    }
821438
private function migrateSize(?string $size): ?string
    {
        if ($size === null) {
            return null;
        }


        $columns = array_map(
            function (array $column) {
                if ($column['width'] === 'auto') {
                    $column['width'] = 'equal';
                }

                return $column;
            },
            StringUtil::deserialize($size, true)
        );

        return serialize($columns);
    }
1325645
protected function parseVerbosity($level = null)
    {
        if (isset($this->verbosityMap[$level])) {
            $level = $this->verbosityMap[$level];
        } elseif (! is_int($level)) {
            $level = $this->verbosity;
        }

        return $level;
    }