Innmind\Server\Status\Server\Memory\Bytes

Complexity

Total Complexity

28

Size/Duplication

Total Lines	143
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
C	__construct()	0	49	8
A	toInt()	0	4	1
A	__toString()	0	4	1
B	fromString()	0	24	4
C	fromUnit()	0	45	14

<?php
declare(strict_types = 1);

namespace Innmind\Server\Status\Server\Memory;

use Innmind\Server\Status\Exception\{
    BytesCannotBeNegative,
    UnknownBytesFormat
};
use Innmind\Immutable\Str;

final class Bytes
{
    public const BYTES = 1024;
    public const KILOBYTES = 1024 ** 2;
    public const MEGABYTES = 1024 ** 3;
    public const GIGABYTES = 1024 ** 4;
    public const TERABYTES = 1024 ** 5;
    public const PETABYTES = 1024 ** 6;

    private $value;
    private $string;

    public function __construct(int $value)
    {
        if ($value < 0) {
            throw new BytesCannotBeNegative;
        }

        $this->value = $value;

        switch (true) {
            case $value < self::BYTES:
                $this->string = $value.'B';
                break;

            case $value < self::KILOBYTES:
                $this->string = sprintf(
                    '%sKB',
                    round($value/self::BYTES, 3)
                );
                break;

            case $value < self::MEGABYTES:
                $this->string = sprintf(
                    '%sMB',
                    round($value/self::KILOBYTES, 3)
                );
                break;

            case $value < self::GIGABYTES:
                $this->string = sprintf(
                    '%sGB',
                    round($value/self::MEGABYTES, 3)
                );
                break;

            case $value < self::TERABYTES:
                $this->string = sprintf(
                    '%sTB',
                    round($value/self::GIGABYTES, 3)
                );
                break;

            case $value < self::PETABYTES:
                $this->string = sprintf(
                    '%sPB',
                    round($value/self::TERABYTES, 3)
                );
                break;
        }
    }

    public function toInt(): int
    {
        return $this->value;
    }

    public function __toString(): string
    {
        return $this->string;
    }

    public static function fromString(string $bytes): self
    {
        if ($bytes === (string) (int) $bytes) {
            return new self((int) $bytes);
        }

        $bytes = new Str($bytes);

        if ($bytes->length() < 2) {
            throw new UnknownBytesFormat;
        }

        try {
            return self::fromUnit(
                $bytes->substring(0, -1),
                $bytes->substring(-1)
            );
        } catch (UnknownBytesFormat $e) {
            return self::fromUnit(
                $bytes->substring(0, -2),
                $bytes->substring(-2)
            );
        }
    }

    private static function fromUnit(Str $bytes, Str $unit): self
    {
        if ($bytes->length() === 0) {
            throw new UnknownBytesFormat;
        }

        switch ((string) $unit) {
            case 'B':
            case 'Bi':
                $multiplier = 1;
                break;

            case 'K':
            case 'Ki':
                $multiplier = Bytes::BYTES;
                break;

            case 'M':
            case 'Mi':
                $multiplier = Bytes::KILOBYTES;
                break;

            case 'G':
            case 'Gi':
                $multiplier = Bytes::MEGABYTES;
                break;

            case 'T':
            case 'Ti':
                $multiplier = Bytes::GIGABYTES;
                break;

            case 'P':
            case 'Pi':
                $multiplier = Bytes::TERABYTES;
                break;

            default:
                throw new UnknownBytesFormat;
        }

        return new self(
            (int) (((float) (string) $bytes) * $multiplier)
        );
    }
}