Letournel\PathFinder\Core\NodePath

Complexity

Total Complexity

21

Size/Duplication

Total Lines	113
Duplicated Lines	15.93 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	3
A	count()	0	4	1
A	current()	0	4	1
A	key()	0	4	1
A	next()	0	4	1
A	rewind()	0	5	1
A	valid()	0	4	1
A	getKey()	0	4	1
A	getKeys()	0	4	1
A	computeLength()	18	18	3
A	contains()	0	12	3
A	getStartNode()	0	4	1
A	getEndNode()	0	4	1
A	toString()	0	10	2

<?php

namespace Letournel\PathFinder\Core;

use Letournel\PathFinder\Distance;

class NodePath implements \Countable, \Iterator
{
    private
        $path,

It is generally advisable to only define one property per statement.

The visibility should be declared for property $path.

        $valid;
    
    public function __construct(array $path)
    {
        $this->path = array();
        $this->valid = true;
        foreach($path as $node)
        {
            if($node instanceof Node)
            {
                $this->path[$node->getId()] = $node;
            }
        }
    }
    
    public function count()
    {
        return count($this->path);
    }
    
    public function current()
    {
        return current($this->path);
    }
    
    public function key()
    {
        return key($this->path);
    }
    
    public function next()
    {
        $this->valid = (next($this->path) !== false);
    }
    
    public function rewind()
    {
        reset($this->path);
        $this->valid = true;
    }
    
    public function valid()
    {
        return $this->valid;
    }
    
    public function getKey($key)
    {
        return $this->path[$key];
    }
    
    public function getKeys()
    {
        return array_keys($this->path);
    }
    
    public function computeLength(Distance $distance)

This method seems to be duplicated in your project.

    {
        $length = 0;
        $prevNode = null;
        foreach($this->path as $node)
        {
            if($prevNode === null)
            {
                $prevNode = $node;
                continue;
            }
            
            $length += $distance->compute($prevNode, $node);
            $prevNode = $node;
        }
        
        return $length;
    }
    
    public function contains(Node $needleNode)
    {
        foreach($this->path as $node)
        {
            if($node->toString() == $needleNode->toString())
            {
                return true;
            }
        }
        
        return false;
    }
    
    public function getStartNode()
    {
        return reset($this->path);
    }
    
    public function getEndNode()
    {
        return end($this->path);
    }
    
    public function toString()
    {
        $nodesString = array();
        foreach($this->path as $node)
        {
            $nodesString[] = $node->toString();
        }
        
        return implode('->', $nodesString);
    }
}