DatabaseDomain.php

Go to the documentation of this file.

<?php
class DatabaseDomain {
    private $database;
    private $schema;
    private $prefix;

    private $equivalentString;

    public function __construct( $database, $schema, $prefix ) {
        if ( $database !== null && ( !is_string( $database ) || !strlen( $database ) ) ) {
            throw new InvalidArgumentException( "Database must be null or a non-empty string." );
        }
        $this->database = $database;
        if ( $schema !== null && ( !is_string( $schema ) || !strlen( $schema ) ) ) {
            throw new InvalidArgumentException( "Schema must be null or a non-empty string." );
        }
        $this->schema = $schema;
        if ( !is_string( $prefix ) ) {
            throw new InvalidArgumentException( "Prefix must be a string." );
        }
        $this->prefix = $prefix;
    }

    public static function newFromId( $domain ) {
        if ( $domain instanceof self ) {
            return $domain;
        }

        $parts = array_map( [ __CLASS__, 'decode' ], explode( '-', $domain ) );

        $schema = null;
        $prefix = '';

        if ( count( $parts ) == 1 ) {
            $database = $parts[0];
        } elseif ( count( $parts ) == 2 ) {
            list( $database, $prefix ) = $parts;
        } elseif ( count( $parts ) == 3 ) {
            list( $database, $schema, $prefix ) = $parts;
        } else {
            throw new InvalidArgumentException( "Domain has too few or too many parts." );
        }

        if ( $database === '' ) {
            $database = null;
        }

        return new self( $database, $schema, $prefix );
    }

    public static function newUnspecified() {
        return new self( null, null, '' );
    }

    public function equals( $other ) {
        if ( $other instanceof DatabaseDomain ) {
            return (
                $this->database === $other->database &&
                $this->schema === $other->schema &&
                $this->prefix === $other->prefix
            );
        }

        return ( $this->getId() === $other );
    }

    public function getDatabase() {
        return $this->database;
    }

    public function getSchema() {
        return $this->schema;
    }

    public function getTablePrefix() {
        return $this->prefix;
    }

    public function getId() {
        if ( $this->equivalentString === null ) {
            $this->equivalentString = $this->convertToString();
        }

        return $this->equivalentString;
    }

    private function convertToString() {
        $parts = [ $this->database ];
        if ( $this->schema !== null ) {
            $parts[] = $this->schema;
        }
        if ( $this->prefix != '' ) {
            $parts[] = $this->prefix;
        }

        return implode( '-', array_map( [ __CLASS__, 'encode' ], $parts ) );
    }

    private static function encode( $decoded ) {
        $encoded = '';

        $length = strlen( $decoded );
        for ( $i = 0; $i < $length; ++$i ) {
            $char = $decoded[$i];
            if ( $char === '-' ) {
                $encoded .= '?h';
            } elseif ( $char === '?' ) {
                $encoded .= '??';
            } else {
                $encoded .= $char;
            }
        }

        return $encoded;
    }

    private static function decode( $encoded ) {
        $decoded = '';

        $length = strlen( $encoded );
        for ( $i = 0; $i < $length; ++$i ) {
            $char = $encoded[$i];
            if ( $char === '?' ) {
                $nextChar = isset( $encoded[$i + 1] ) ? $encoded[$i + 1] : null;
                if ( $nextChar === 'h' ) {
                    $decoded .= '-';
                    ++$i;
                } elseif ( $nextChar === '?' ) {
                    $decoded .= '?';
                    ++$i;
                } else {
                    $decoded .= $char;
                }
            } else {
                $decoded .= $char;
            }
        }

        return $decoded;
    }

    function __toString() {
        return $this->getId();
    }
}