Antlr\Antlr4\Runtime\Atn\LexerATNConfig

Complexity

Total Complexity

13

Size/Duplication

Total Lines	69
Duplicated Lines	0 %

Test Coverage

Coverage

90.32%

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	hashCode()	0	9	1
A	equals()	0	19	5
A	checkNonGreedyDecision()	0	3	3
A	isPassedThroughNonGreedyDecision()	0	3	1
A	__construct()	0	13	2
A	getLexerActionExecutor()	0	3	1

<?php

declare(strict_types=1);

namespace Antlr\Antlr4\Runtime\Atn;

use Antlr\Antlr4\Runtime\Atn\States\ATNState;
use Antlr\Antlr4\Runtime\Atn\States\DecisionState;
use Antlr\Antlr4\Runtime\Comparison\Equality;
use Antlr\Antlr4\Runtime\Comparison\Hasher;
use Antlr\Antlr4\Runtime\PredictionContexts\PredictionContext;

final class LexerATNConfig extends ATNConfig
{
    /** @var LexerActionExecutor|null */
    private $lexerActionExecutor;

    /** @var bool */
    private $passedThroughNonGreedyDecision;

    public function __construct(
        ?self $oldConfig,
        ?ATNState $state,
        ?PredictionContext $context = null,
        ?LexerActionExecutor $executor = null,
        ?int $alt = null
    ) {
        parent::__construct($oldConfig, $state, $context, null, $alt);

        $this->lexerActionExecutor = $executor ?? ($oldConfig->lexerActionExecutor ?? null);
        $this->passedThroughNonGreedyDecision = $oldConfig ?

$oldConfig is of type null, thus it always evaluated to false.

            self::checkNonGreedyDecision($oldConfig, $this->state) :
            false;
    }

    public function getLexerActionExecutor() : ?LexerActionExecutor
    {
        return $this->lexerActionExecutor;
    }

    public function isPassedThroughNonGreedyDecision() : bool
    {
        return $this->passedThroughNonGreedyDecision;
    }

    public function hashCode() : int
    {
        return Hasher::hash(
            $this->state->stateNumber,
            $this->alt,
            $this->context,
            $this->semanticContext,
            $this->passedThroughNonGreedyDecision,
            $this->lexerActionExecutor
        );
    }

    public function equals(object $other) : bool
    {
        if ($this === $other) {
            return true;
        }

        if (!$other instanceof self) {
            return false;
        }

        if (!parent::equals($other)) {
            return false;
        }

        if ($this->passedThroughNonGreedyDecision !== $other->passedThroughNonGreedyDecision) {
            return false;
        }

        return Equality::equals($this->lexerActionExecutor, $other->lexerActionExecutor);
    }

    private static function checkNonGreedyDecision(LexerATNConfig $source, ATNState $target) : bool
    {
        return $source->passedThroughNonGreedyDecision || ($target instanceof DecisionState && $target->nonGreedy);
    }
}