PHPCoord\UnitOfMeasure\Rate

Complexity

Total Complexity

20

Size/Duplication

Total Lines	172
Duplicated Lines	0 %

Test Coverage

Coverage

60.47%

Importance

Changes	2
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getChange()	0	3	1
A	getTime()	0	3	1
A	getUnitName()	0	3	1
A	__toString()	0	3	1
A	getValue()	0	3	1
A	getChangePerYear()	0	3	1
A	getSupportedSRIDsWithHelp()	0	6	1
B	makeUnit()	0	24	9
A	__construct()	0	7	2
A	getSupportedSRIDs()	0	3	1
A	multiply()	0	3	1

<?php

/**
 * PHPCoord.
 *
 * @author Doug Wright
 */
declare(strict_types=1);

namespace PHPCoord\UnitOfMeasure;

use PHPCoord\Exception\InvalidRateException;
use PHPCoord\Exception\UnknownUnitOfMeasureException;
use PHPCoord\UnitOfMeasure\Angle\Angle;
use PHPCoord\UnitOfMeasure\Angle\ArcSecond;
use PHPCoord\UnitOfMeasure\Length\Centimetre;
use PHPCoord\UnitOfMeasure\Length\Metre;
use PHPCoord\UnitOfMeasure\Length\Millimetre;
use PHPCoord\UnitOfMeasure\Scale\PartsPerBillion;
use PHPCoord\UnitOfMeasure\Scale\PartsPerMillion;
use PHPCoord\UnitOfMeasure\Time\Time;
use PHPCoord\UnitOfMeasure\Time\Year;

use function array_map;

class Rate implements UnitOfMeasure
{
    /**
     * Arc-seconds per year
     * =((pi/180) / 3600) radians per year. Year taken to be IUGS definition of 31556925.445 seconds; see UoM code
     * 1029.
     */
    public const EPSG_ARC_SECONDS_PER_YEAR = 'urn:ogc:def:uom:EPSG::1043';

    /**
     * Centimetres per year
     * Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029.
     */
    public const EPSG_CENTIMETRES_PER_YEAR = 'urn:ogc:def:uom:EPSG::1034';

    /**
     * Metres per year
     * Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029.
     */
    public const EPSG_METRES_PER_YEAR = 'urn:ogc:def:uom:EPSG::1042';

    /**
     * Milliarc-seconds per year
     * = ((pi/180) / 3600 / 1000) radians per year. Year taken to be IUGS definition of 31556925.445 seconds; see UoM
     * code 1029.
     */
    public const EPSG_MILLIARC_SECONDS_PER_YEAR = 'urn:ogc:def:uom:EPSG::1032';

    /**
     * Millimetres per year
     * Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029.
     */
    public const EPSG_MILLIMETRES_PER_YEAR = 'urn:ogc:def:uom:EPSG::1027';

    /**
     * Parts per billion per year
     * Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029. Billion is internationally
     * ambiguous, in different languages being 1E+9 and 1E+12. One billion taken here to be 1E+9.
     */
    public const EPSG_PARTS_PER_BILLION_PER_YEAR = 'urn:ogc:def:uom:EPSG::1030';

    /**
     * Parts per million per year
     * Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029.
     */
    public const EPSG_PARTS_PER_MILLION_PER_YEAR = 'urn:ogc:def:uom:EPSG::1041';

    /**
     * @var array<string, array{name: string, help: string}>
     */
    protected static array $sridData = [
        'urn:ogc:def:uom:EPSG::1027' => [
            'name' => 'millimetres per year',
            'help' => 'Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029.',
        ],
        'urn:ogc:def:uom:EPSG::1030' => [
            'name' => 'parts per billion per year',
            'help' => 'Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029. Billion is internationally ambiguous, in different languages being 1E+9 and 1E+12. One billion taken here to be 1E+9.',
        ],
        'urn:ogc:def:uom:EPSG::1032' => [
            'name' => 'milliarc-seconds per year',
            'help' => '= ((pi/180) / 3600 / 1000) radians per year. Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029.',
        ],
        'urn:ogc:def:uom:EPSG::1034' => [
            'name' => 'centimetres per year',
            'help' => 'Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029.',
        ],
        'urn:ogc:def:uom:EPSG::1041' => [
            'name' => 'parts per million per year',
            'help' => 'Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029.',
        ],
        'urn:ogc:def:uom:EPSG::1042' => [
            'name' => 'metres per year',
            'help' => 'Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029.',
        ],
        'urn:ogc:def:uom:EPSG::1043' => [
            'name' => 'arc-seconds per year',
            'help' => '=((pi/180) / 3600) radians per year. Year taken to be IUGS definition of 31556925.445 seconds; see UoM code 1029.',
        ],
    ];

    private UnitOfMeasure $change;

    private Time $time;

    public function __construct(UnitOfMeasure $change, Time $time)
    {
        if ($change instanceof Time) {
            throw new InvalidRateException('A rate is a change per unit of time, the change cannot be time');
        }
        $this->change = $change;
        $this->time = $time;
    }

    public function getChange(): UnitOfMeasure
    {
        return $this->change;
    }

    public function getChangePerYear(): UnitOfMeasure
    {
        return $this->change->divide($this->time->asYears()->getValue());

The method divide() does not exist on PHPCoord\UnitOfMeasure\UnitOfMeasure. It seems like you code against a sub-type of said class. However, the method does not exist in PHPCoord\UnitOfMeasure\Rate. Are you sure you never get one of those?

    }

    public function getTime(): Time
    {
        return $this->time;
    }

    public function getValue(): float
    {
        return $this->change->getValue();
    }

    public function getUnitName(): string
    {
        return $this->change->getUnitName() . ' per ' . $this->time->getUnitName();
    }

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

    public function multiply(float $multiplicand): self
    {
        return new self($this->change->multiply($multiplicand), $this->time);

The method multiply() does not exist on PHPCoord\UnitOfMeasure\UnitOfMeasure. Since it exists in all sub-types, consider adding an abstract or default implementation to PHPCoord\UnitOfMeasure\UnitOfMeasure.

    }

    public static function makeUnit(float $measurement, string $srid): self
    {
        if (!isset(self::$sridData[$srid])) {
            throw new UnknownUnitOfMeasureException($srid);
        }

        switch ($srid) {
            case self::EPSG_ARC_SECONDS_PER_YEAR:
                return new self(new ArcSecond($measurement), new Year(1));
            case self::EPSG_MILLIARC_SECONDS_PER_YEAR:
                return new self(Angle::makeUnit($measurement, Angle::EPSG_MILLIARC_SECOND), new Year(1));
            case self::EPSG_METRES_PER_YEAR:
                return new self(new Metre($measurement), new Year(1));
            case self::EPSG_MILLIMETRES_PER_YEAR:
                return new self(new Millimetre($measurement), new Year(1));
            case self::EPSG_CENTIMETRES_PER_YEAR:
                return new self(new Centimetre($measurement), new Year(1));
            case self::EPSG_PARTS_PER_BILLION_PER_YEAR:
                return new self(new PartsPerBillion($measurement), new Year(1));
            case self::EPSG_PARTS_PER_MILLION_PER_YEAR:
                return new self(new PartsPerMillion($measurement), new Year(1));
        }

        throw new UnknownUnitOfMeasureException($srid); // @codeCoverageIgnore
    }

    /**
     * @return array<string, string>
     */
    public static function getSupportedSRIDs(): array
    {
        return array_map(fn (array $data) => $data['name'], static::$sridData);
    }

    /**
     * @return array<string, array{name: string, help: string}>
     */
    public static function getSupportedSRIDsWithHelp(): array
    {
        return array_map(fn (array $data) => [
            'name' => $data['name'],
            'help' => $data['help'],
        ], static::$sridData);
    }
}