PHPCoord\EPSG\Repository

Complexity

Total Complexity

31

Size/Duplication

Total Lines	256
Duplicated Lines	0 %

Test Coverage

Coverage

17.65%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getCoordinateSystems()	0	29	4
A	getCoordinateSystemAxes()	0	29	4
A	getPrimeMeridians()	0	26	4
A	getEllipsoids()	0	32	5
A	getUnitsOfMeasure()	0	28	4
A	getConnection()	0	8	2
A	getCoordinateReferenceSystems()	0	34	4
A	getDatums()	0	30	4

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

namespace PHPCoord\EPSG;

use SQLite3;

/**
 * @internal
 */
class Repository
{
    /** @var SQLite3 */
    private static $connection;

    /** @var array */
    private static $unitsOfMeasureData = [];

    /** @var array */
    private static $primeMeridianData = [];

    /** @var array */
    private static $ellipsoidData = [];

    /** @var array */
    private static $datumData = [];

    /** @var array */
    private static $coordinateSystemData = [];

    /** @var array */
    private static $coordinateSystemAxisData = [];

    /** @var array */
    private static $coordinateReferenceSystemData = [];

    private function getConnection(): SQLite3
    {
        if (!static::$connection instanceof SQLite3) {

static::connection is always a sub-type of SQLite3.

Since $connection is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $connection to at least protected.

            static::$connection = new SQLite3(__DIR__ . '/../../resources/epsg/epsg.sqlite', SQLITE3_OPEN_READONLY);
            static::$connection->enableExceptions(true);
        }

        return static::$connection;
    }

    public function getEllipsoids(bool $includeDeprecated = false): array
    {
        if (!static::$ellipsoidData) {

The expression static::ellipsoidData of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

Since $ellipsoidData is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $ellipsoidData to at least protected.

            $connection = $this->getConnection();
            $sql = '
            SELECT
                el.ellipsoid_code,
                el.ellipsoid_name,
                el.semi_major_axis,
                el.semi_minor_axis,
                el.inv_flattening,
                el.uom_code
            FROM epsg_ellipsoid el
        ';

            if ($includeDeprecated === false) {
                $sql .= ' WHERE el.deprecated = 0';
            }

            $result = $connection->query($sql);

            while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
                // some ellipsoids are defined via inverse flattening and the DB doesn't store the calculated data...
                if (!$row['semi_minor_axis']) {
                    $row['semi_minor_axis'] = $row['semi_major_axis'] - ($row['semi_major_axis'] / $row['inv_flattening']);
                }

                static::$ellipsoidData[$row['ellipsoid_code']] = $row;
            }
        }

        return static::$ellipsoidData;
    }

    public function getDatums(bool $includeDeprecated = false): array
    {
        if (!static::$datumData) {

The expression static::datumData of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

Since $datumData is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $datumData to at least protected.

            $connection = $this->getConnection();
            $sql = "
            SELECT
                d.datum_code,
                d.datum_name,
                d.datum_type,
                d.ellipsoid_code,
                d.prime_meridian_code,
                d.conventional_rs_code,
                d.frame_reference_epoch,
                d.deprecated
            FROM epsg_datum d
            WHERE d.datum_type != 'engineering'
        ";

            if ($includeDeprecated === false) {
                $sql .= ' WHERE d.deprecated = 0';
            }

            $result = $connection->query($sql);

            while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
                static::$datumData[$row['datum_code']] = $row;
            }
        }

        return static::$datumData;
    }

    public function getUnitsOfMeasure(bool $includeDeprecated = false): array
    {
        if (!static::$unitsOfMeasureData) {

Since $unitsOfMeasureData is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $unitsOfMeasureData to at least protected.

The expression static::unitsOfMeasureData of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            $connection = $this->getConnection();
            $sql = '
            SELECT
                m.uom_code,
                m.unit_of_meas_name,
                m.unit_of_meas_type,
                m.target_uom_code,
                m.factor_b,
                m.factor_c,
                m.deprecated
            FROM epsg_unitofmeasure m
            ';

            if ($includeDeprecated === false) {
                $sql .= ' AND m.deprecated = 0';
            }

            $result = $connection->query($sql);

            while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
                static::$unitsOfMeasureData[$row['uom_code']] = $row;
            }
        }

        return static::$unitsOfMeasureData;
    }

    public function getPrimeMeridians(bool $includeDeprecated = false): array
    {
        if (!static::$primeMeridianData) {

Since $primeMeridianData is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $primeMeridianData to at least protected.

The expression static::primeMeridianData of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            $connection = $this->getConnection();
            $sql = '
            SELECT
                p.prime_meridian_code,
                p.prime_meridian_name,
                p.greenwich_longitude,
                p.uom_code,
                p.deprecated
            FROM epsg_primemeridian p
            ';

            if ($includeDeprecated === false) {
                $sql .= ' AND p.deprecated = 0';
            }

            $result = $connection->query($sql);

            while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
                static::$primeMeridianData[$row['prime_meridian_code']] = $row;
            }
        }

        return static::$primeMeridianData;
    }

    public function getCoordinateSystems(bool $includeDeprecated = false): array
    {
        if (!static::$coordinateSystemData) {

The expression static::coordinateSystemData of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

Since $coordinateSystemData is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $coordinateSystemData to at least protected.

            $connection = $this->getConnection();
            $sql = "
            SELECT
                cs.coord_sys_code,
                cs.coord_sys_name,
                cs.coord_sys_type,
                cs.dimension,
                cs.deprecated
            FROM epsg_coordinatesystem cs
            JOIN epsg_coordinatereferencesystem crs ON crs.coord_sys_code = cs.coord_sys_code AND crs.coord_ref_sys_kind != 'engineering'
            WHERE cs.coord_sys_type != 'ordinal'
            ";

            if ($includeDeprecated === false) {
                $sql .= ' AND cs.deprecated = 0';
            }

            $result = $connection->query($sql);

            while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
                $row['axes'] = $this->getCoordinateSystemAxes()[$row['coord_sys_code']];
                static::$coordinateSystemData[$row['coord_sys_code']] = $row;
            }
        }

        return static::$coordinateSystemData;
    }

    public function getCoordinateReferenceSystems(bool $includeDeprecated = false): array
    {
        if (!static::$coordinateReferenceSystemData) {

The expression static::coordinateReferenceSystemData of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

Since $coordinateReferenceSystemData is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $coordinateReferenceSystemData to at least protected.

            $connection = $this->getConnection();
            $sql = "
            SELECT
                crs.coord_ref_sys_code,
                crs.coord_ref_sys_kind,
                crs.coord_ref_sys_name,
                crs.coord_sys_code,
                crs.datum_code,
                crs.base_crs_code,
                crs.projection_conv_code,
                crs.cmpd_horizcrs_code,
                crs.cmpd_vertcrs_code,
                crs.deprecated
            FROM epsg_coordinatereferencesystem crs
            WHERE crs.coord_ref_sys_kind NOT IN ('engineering', 'derived')
            AND (crs.cmpd_horizcrs_code IS NULL OR crs.cmpd_horizcrs_code NOT IN (SELECT coord_ref_sys_code FROM epsg_coordinatereferencesystem WHERE coord_ref_sys_kind = 'engineering'))
            AND (crs.cmpd_vertcrs_code IS NULL OR crs.cmpd_vertcrs_code NOT IN (SELECT coord_ref_sys_code FROM epsg_coordinatereferencesystem WHERE coord_ref_sys_kind = 'engineering'))
            ";

            if ($includeDeprecated === false) {
                $sql .= ' AND crs.deprecated = 0';
            }

            $result = $connection->query($sql);

            while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
                static::$coordinateReferenceSystemData[$row['coord_ref_sys_code']] = $row;
            }
        }

        return static::$coordinateReferenceSystemData;
    }

    private function getCoordinateSystemAxes(): array
    {
        if (!static::$coordinateSystemAxisData) {

The expression static::coordinateSystemAxisData of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

Since $coordinateSystemAxisData is declared private, accessing it with static will lead to errors in possible sub-classes; you can either use self, or increase the visibility of $coordinateSystemAxisData to at least protected.

            $connection = $this->getConnection();
            $sql = '
            SELECT
                a.coord_sys_code,
                a.coord_axis_orientation,
                a.coord_axis_abbreviation,
                an.coord_axis_name,
                a.uom_code,
                a.coord_axis_order
            FROM epsg_coordinateaxis a
            JOIN epsg_coordinateaxisname an on a.coord_axis_name_code = an.coord_axis_name_code
            ORDER BY a.coord_axis_order
            ';

            $result = $connection->query($sql);

            while ($row = $result->fetchArray(SQLITE3_ASSOC)) {
                if (isset(static::$coordinateSystemAxisData[$row['coord_sys_code']])) {
                    static::$coordinateSystemAxisData[$row['coord_sys_code']][] = $row;
                } else {
                    static::$coordinateSystemAxisData[$row['coord_sys_code']] = [$row];
                }
            }
        }

        return static::$coordinateSystemAxisData;
    }
}