Condorcet\Result

Complexity

Total Complexity

42

Size/Duplication

Total Lines	204
Duplicated Lines	0 %

Test Coverage

Coverage

89.01%

Importance

Changes

0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	offsetGet()	0	2	1
A	addWarning()	0	5	1
A	getCondorcetWinner()	0	2	1
A	count()	0	2	1
A	offsetExists()	0	2	1
C	makeUserResult()	0	23	7
A	getWarning()	0	14	4
A	getLoser()	0	2	1
A	getWinner()	0	2	1
B	getResultAsArray()	0	15	6
A	getStats()	0	2	1
A	getCondorcetLoser()	0	2	1
A	getResultAsString()	0	3	1
A	__construct()	0	12	1
A	getResultAsInternalKey()	0	3	1
A	getBuildTimeStamp()	0	2	1
A	getOriginalArrayWithString()	0	3	1
A	getCondorcetElectionGeneratorVersion()	0	2	1
A	offsetSet()	0	2	1
A	getMethod()	0	2	1
A	offsetUnset()	0	2	1
A	valid()	0	2	2
A	rewind()	0	2	1
A	current()	0	2	1
A	key()	0	2	1
A	getClassGenerator()	0	2	1
A	next()	0	2	1

<?php
/*
    Condorcet PHP Class, with Schulze Methods and others !

    By Julien Boudry - MIT LICENSE (Please read LICENSE.txt)
    https://github.com/julien-boudry/Condorcet
*/
declare(strict_types=1);

namespace Condorcet;

use Condorcet\CondorcetException;
use Condorcet\CondorcetVersion;
use Condorcet\Election;
use Condorcet\Util;
use Condorcet\Vote;


class Result implements \ArrayAccess, \Countable, \Iterator 
{
    use CondorcetVersion;

    // Implement Iterator

    function rewind() :void {

It is generally recommended to explicitly declare the visibility for methods.

        reset($this->_UserResult);
    }

    function current () {

It is generally recommended to explicitly declare the visibility for methods.

        return current($this->_UserResult);
    }

    function key () : int {

It is generally recommended to explicitly declare the visibility for methods.

        return key($this->_UserResult);

The expression return key($this->_UserResult) could return the type null|string which is incompatible with the type-hinted return integer. Consider adding an additional type-check to rule them out.

    }

    function next () : void {

It is generally recommended to explicitly declare the visibility for methods.

        next($this->_UserResult);
    }

    function valid () : bool {

It is generally recommended to explicitly declare the visibility for methods.

        return (key($this->_UserResult) === null) ? false : true;
    }

    // Implement ArrayAccess

    public function offsetSet ($offset, $value) : void {
        throw new CondorcetException (0,"Can't change a result");
    }

    public function offsetExists ($offset) : bool {
        return isset($this->_UserResult[$offset]);
    }

    public function offsetUnset ($offset) : void {
        throw new CondorcetException (0,"Can't change a result");
    }

    public function offsetGet ($offset) {
        return $this->_UserResult[$offset] ?? null;
    }

    // Implement Countable

    public function count () : int {
        return count($this->_UserResult);
    }


/////////// CONSTRUCTOR ///////////

    protected $_Result;
    protected $_UserResult;
    protected $_stringResult;
    protected $_CondorcetWinner;
    protected $_CondorcetLoser;

    protected $_Stats;

    protected $_warning = [];

    protected $_BuildTimeStamp;
    protected $_fromMethod;
    protected $_byClass;
    protected $_ElectionCondorcetVersion;


    public function __construct (string $fromMethod, string $byClass, Election $election, array $result, $stats)
    {
        $this->_Result = $result;
        $this->_UserResult = $this->makeUserResult($election);
        $this->_stringResult = $this->getResultAsArray(true);
        $this->_Stats = $stats;
        $this->_fromMethod = $fromMethod;
        $this->_byClass = $byClass;
        $this->_ElectionCondorcetVersion = $election->getObjectVersion();
        $this->_CondorcetWinner = $election->getWinner();
        $this->_CondorcetLoser = $election->getLoser();
        $this->_BuildTimeStamp = microtime(true);
    }


/////////// Get Result ///////////

    public function getResultAsArray (bool $convertToString = false) : array
    {
        $r = $this->_UserResult;

        foreach ($r as &$rank) :
            if (count($rank) === 1) :
                $rank = ($convertToString) ? (string) $rank[0] : $rank[0];
            elseif ($convertToString) :
                foreach ($rank as &$subRank) :
                    $subRank = (string) $subRank;
                endforeach;
            endif;
        endforeach;

        return $r;
    }

    public function getResultAsString ()
    {
        return Vote::getRankingAsString($this->getResultAsArray(true));
    }

    public function getOriginalArrayWithString () : array
    {
        return $this->_stringResult;
    }

    public function getResultAsInternalKey () : array
    {
        return $this->_Result;
    }

    public function getStats () {
        return $this->_Stats;
    }

    public function getWinner () {
        return Util::format($this[1],false);
    }

    public function getLoser () {
        return Util::format($this[count($this)],false);
    }

    public function getCondorcetWinner () {
        return $this->_CondorcetWinner;
    }

    public function getCondorcetLoser () {
        return $this->_CondorcetLoser;
    }

    protected function makeUserResult (Election $election) : array
    {
        $userResult = [];

        foreach ( $this->_Result as $key => $value ) :
            if (is_array($value)) :
                foreach ($value as $candidate_key) :
                    $userResult[$key][] = $election->getCandidateId($candidate_key);
                endforeach;
            elseif (is_null($value)) :
                $userResult[$key] = null;
            else :
                $userResult[$key][] = $election->getCandidateId($value);
            endif;
        endforeach;

        foreach ( $userResult as $key => $value ) :
            if (is_null($value)) :
                $userResult[$key] = null;
            endif;
        endforeach;

        return $userResult;
    }


/////////// Get & Set MetaData ///////////

    public function addWarning (int $type, string $msg = null) : bool
    {
        $this->_warning[] = ['type' => $type, 'msg' => $msg];

        return true;
    }

    public function getWarning ($type = null) : array
    {
        if ($type === null) :
            return $this->_warning;
        else :
            $r = [];

            foreach ($this->_warning as $oneWarning) :
                if ($oneWarning['type'] === (int) $type) :
                    $r[] = $oneWarning;
                endif;
            endforeach;

            return $r;
        endif;
    }

    public function getClassGenerator () : string {
        return $this->_byClass;
    }

    public function getMethod () : string {
        return $this->_fromMethod;
    }

    public function getBuildTimeStamp () : float {
        return (float) $this->_BuildTimeStamp;
    }

    public function getCondorcetElectionGeneratorVersion () : string {
        return $this->_ElectionCondorcetVersion;
    }

}