Type.php

<?php declare(strict_types = 1);
 
namespace DaveRandom\CallbackValidator;
 
abstract class Type
{
    const WEAK = 0x01;
 
    const NULLABLE  = 0x02;
 
    const REFERENCE = 0x04;
 
    public $typeName;
 
    public $isNullable;
 
    public $isByReference;
 
    public $isWeak;
 
    public $allowsCovariance;
 
    public $allowsContravariance;
 
    protected function __construct($typeName, $flags, $allowsCovariance, $allowsContravariance)
    {
        $this->typeName = $typeName !== null
            ? (string)$typeName
            : null;
 
        $this->isNullable = (bool)($flags & self::NULLABLE);
        $this->isByReference = (bool)($flags & self::REFERENCE);
        $this->isWeak = (bool)($flags & self::WEAK);
        $this->allowsCovariance = (bool)$allowsCovariance;
        $this->allowsContravariance = (bool)$allowsContravariance;
    }
 
    public function isSatisfiedBy($typeName, $nullable, $byReference)
    {
        // By-ref must always be the same
        if ($byReference xor $this->isByReference) {
            return false;
        }
 
        // Candidate is exact match to prototype
        if ($typeName === $this->typeName && $nullable === $this->isNullable) {
            return true;
        }
 
        // Test for a covariant match
        if ($this->allowsCovariance
            && MatchTester::isMatch($this->typeName, $this->isNullable, $typeName, $nullable, $this->isWeak)) {
            return true;
        }
 
        // Test for a contravariant match
        if ($this->allowsContravariance
            && MatchTester::isMatch($typeName, $nullable, $this->typeName, $this->isNullable, $this->isWeak)) {
            return true;
        }
 
        // In weak mode, allow castable scalars as long as nullability matches (invariant)
        return $this->isWeak
            && $nullable === $this->isNullable
        && $typeName !== null
        && $this->typeName !== null
        && MatchTester::isWeakScalarMatch($typeName, $this->typeName);
    }
}