Mistralys\WidthsCalculator\Calculator

Complexity

Total Complexity

30

Size/Duplication

Total Lines	258
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	getDefaultOptions()	0	6	1
A	getMaxTotal()	0	3	1
A	create()	0	3	1
A	__construct()	0	11	2
A	getOperations()	0	3	1
A	setFloatValues()	0	4	1
A	getMaxMinWidth()	0	3	1
A	setMinWidth()	0	14	2
A	setMaxTotal()	0	4	1
A	getValues()	0	19	3
A	fixOverflow()	0	4	1
A	isIntegerMode()	0	3	1
A	addColumn()	0	8	1
A	getPixelValues()	0	13	2
A	getColumns()	0	3	1
A	convertToInteger()	0	9	3
A	calculate()	0	18	3
A	getMinWidth()	0	3	1
A	fillMissing()	0	4	1
A	fillLeftover()	0	4	1
A	removeSurplus()	0	4	1

<?php
/**
 * File containing the {@see Mistralys\WidthsCalculator\Calculator} class.
 *
 * @package WidthsCalculator
 * @see Mistralys\WidthsCalculator\Calculator
 */

declare (strict_types=1);

namespace Mistralys\WidthsCalculator;

use AppUtils\Traits_Optionable;
use AppUtils\Interface_Optionable;
use Mistralys\WidthsCalculator\Calculator\Column;
use Mistralys\WidthsCalculator\Calculator\Operations;
use Mistralys\WidthsCalculator\Calculator\OverflowFixer;
use Mistralys\WidthsCalculator\Calculator\SurplusRemover;
use Mistralys\WidthsCalculator\Calculator\MissingFiller;
use Mistralys\WidthsCalculator\Calculator\LeftoverFiller;

/**
 * Calculates percent-based column widths given a list of
 * column names with user width values.
 *
 * Columns with 0 width are filled automatically with
 * the leftover percent. Values out of bounds are 
 * normalized proportionally, allowing the use of an
 * arbitrary numbering system to convert to percent.
 *
 * @package WidthsCalculator
 * @author Sebastian Mordziol <s.mordziol@mistralys.eu>
 */
class Calculator implements Interface_Optionable
{
    public const ERROR_INVALID_MIN_WIDTH = 61501;
    
    use Traits_Optionable;
    
   /**
    * @var Column[]
    */
    private $columns = array();
    
   /**
    * @var boolean
    */
    private $calculated = false;
    
   /**
    * @var Operations
    */
    private $operations;
    
   /**
    * @param array<string,float> $columnValues
    */
    private function __construct(array $columnValues)
    {
        foreach($columnValues as $name => $value)
        {
            $this->addColumn(
                (string)$name, 
                floatval($value)
            );
        }
        
        $this->operations = new Operations($this);
    }
    
   /**
    * Creates an instance of the calculator.
    * 
    * @param array<string,float> $columnValues
    * @return Calculator
    */
    public static function create(array $columnValues) : Calculator
    {
        return new Calculator($columnValues);
    }
    
   /**
    * @return array<string,mixed>
    */
    public function getDefaultOptions(): array
    {
        return array(
            'maxTotal' => 100,
            'minPerCol' => 1,
            'integerValues' => true
        );
    }
    
    public function getMaxTotal() : float
    {
        return floatval($this->getOption('maxTotal'));
    }
    
    public function setMaxTotal(float $total) : Calculator
    {
        $this->setOption('maxTotal', $total);
        return $this;
    }
    
    public function getOperations() : Operations
    {
        return $this->operations;
    }
    
    public function setFloatValues(bool $enable=true) : Calculator
    {
        $this->setOption('integerValues', !$enable);
        return $this;
    }
    
   /**
    * Sets the minimum width to enforce for columns, 
    * when there already are other columns that take
    * up all the available width.
    * 
    * @param float $width
    * @return Calculator
    */
    public function setMinWidth(float $width) : Calculator
    {
        $max = $this->getMaxMinWidth();
        
        if($width > $max)
        {
            throw new \Exception(
                sprintf('Minimum width cannot be set above %s.', number_format($max, 4)),
                self::ERROR_INVALID_MIN_WIDTH
            );
        }
        
        $this->setOption('minPerCol', $width);
        return $this;
    }
    
    public function getMaxMinWidth() : float
    {
        return $this->getMaxTotal() / $this->operations->countColumns();
    }
    
    private function addColumn(string $name, float $value) : void
    {
        $col = new Column(
            $name,
            $value
        );
        
        $this->columns[] = $col;
    }
    
   /**
    * Retrieves the minimum width for columns, in percent.
    * @return float
    */
    public function getMinWidth() : float
    {
        return floatval($this->getOption('minPerCol'));
    }
    
    private function calculate() : void
    {
        if($this->calculated)
        {
            return;
        }
        
        if($this->operations->calcTotal() > $this->getMaxTotal())
        {
            $this->fixOverflow();
        }
        
        $this->fillMissing();
        $this->removeSurplus();
        $this->convertToInteger();
        $this->fillLeftover();
        
        $this->calculated = true;
    }
    
   /**
    * Adjusts the individual column values to match
    * the expected output format, for example ensuring
    * integer values if we are in integer mode.
    */
    private function convertToInteger() : void
    {
        // convert all columns to integer values as required
        if($this->isIntegerMode())
        {
            foreach($this->columns as $col)
            {
                $val = intval(floor($col->getValue()));
                $col->setValue(floatval($val));
            }
        }
    }
    
   /**
    * Retrieves the updated list of column values, 
    * retaining the original keys.
    * 
    * @return array<string,int|float>
    */
    public function getValues() : array
    {
        $this->calculate();
        
        $result = array();
        
        foreach($this->columns as $col)
        {
            $val = $col->getValue();
            
            if($this->isIntegerMode())
            {
                $val = intval($val);
            }
            
            $result[$col->getName()] = $val;
        }
        
        return $result;
    }
    
    public function isIntegerMode() : bool
    {
        return $this->getBoolOption('integerValues');
    }
    
   /**
    * Retrieves the column values as pixel values, based on
    * the target available pixel width.
    * 
    * @param int $targetWidth
    * @return array<string,int>
    */
    public function getPixelValues(int $targetWidth) : array
    {
        $calc = self::create($this->getValues());
        $calc->setMaxTotal($targetWidth);
        $values = $calc->getValues();

        $result = array();
        foreach($values as $name => $value)
        {
            $result[$name] = (int)$value;
        }
        
        return $result;
    }
    
   /**
    * @return Column[]
    */
    public function getColumns() : array 
    {
        return $this->columns;
    }
    
    private function removeSurplus() : void
    {
        $surplus = new SurplusRemover($this);
        $surplus->remove();
    }
    
   /**
    * Detects any leftover percentages that still need
    * to be filled, in case we are not at 100% yet. It
    * distributes the missing percentages evenly over the
    * available columns, from the last one upwards.
    */
    private function fillLeftover() : void
    {
        $filler = new LeftoverFiller($this);
        $filler->fill();
    }
    
    private function fillMissing() : void
    {
        $filling = new MissingFiller($this);
        $filling->fill();
    }
    
    private function fixOverflow() : void
    {
        $overflow = new OverflowFixer($this);
        $overflow->fix();
    }
}