NetObject::__get() - Code Metrics - Inspection of "VoidFramework 4.0.0dev" - winforms-php/VoidFramework - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Branch — dev (e0c5fc)

by Observer
created 2019-10-26 15:07 UTC
NetObject::__get() B

↳ Parent: NetObject
Complexity

Conditions	11
Paths	10
Size

Total Lines	51
Code Lines	29
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	29
c	0
b	0
f	0
dl	0
loc	51
rs	7.3166
cc	11
nc	10
nop	1
How to fix Long Method Complexity

<?php

namespace VoidEngine;

use VoidCore;
filter:
    dependency_paths: ["lib/*"]

class NetObject implements \ArrayAccess
{
    protected int $selector = 0;
    // protected ?string $name = null;
    // protected bool $isCollection = false;

    public function __construct ($name, $assembly = false, ...$args)
    {
        foreach ($args as $id => $arg)
            $args[$id] = EngineAdditions::uncoupleSelector ($arg);
        
        if (is_int ($name) && VoidCore::objectExists ($name))
            $this->selector = $name;

        elseif (is_string ($name))
            $this->selector = VoidCore::createObject ($name, $assembly, ...$args);

        else throw new \Exception ('Incorrect params passed');

        /*$this->isCollection = $this->getType ()
            ->isSubclassOf (VoidCore::typeof ('System.Collectons.Generic.ICollection'));*/
    }

    public function dispose (): void
    {
        VoidCore::removeObjects ($this->selector);
    }

    # Основные магические методы

    public function __get (string $name)
    {
        switch (strtolower ($name))
        {
            case 'count':
            case 'length':
                try
                {
                    return $this->getProperty ('Count');
                }

                catch (\WinformsException $e)
filter:
    dependency_paths: ["lib/*"]
                {
                    return $this->getProperty ('Length');
                }
            break;

            case 'list':
                $size = $this->count;

                $list = [];
                
				for ($i = 0; $i < $size; ++$i)
                    $list[] = EngineAdditions::coupleSelector (VoidCore::getArrayValue ($this->selector, $i));
                
                return $list;
            break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            case 'names':
                $size  = $this->count;
                $names = [];
                
                for ($i = 0; $i < $size; ++$i)
                    try
                    {
                        $names[] = VoidCore::getProperty (VoidCore::getArrayValue ($this->selector, [$i, VC_OBJECT]), 'Text');

                    }

                    catch (\WinformsException $e)
                    {
                        $names[] = VoidCore::getArrayValue ($this->selector, [$i, VC_STRING]);

                    }
                
                return $names;
            break;
        }

        if (method_exists ($this, $method = 'get_'. $name))
            return $this->$method ();

        return isset ($this->$name) ?
            $this->$name : EngineAdditions::coupleSelector ($this->getProperty ($name));
    }

    public function __set (string $name, $value): void
    {
        if (substr ($name, -5) == 'Event')
            Events::setEvent ($this->selector, substr ($name, 0, -5), $value);

        elseif (method_exists ($this, $method = 'set_'. $name))
            $this->$method ($value);
        
        else $this->setProperty ($name, EngineAdditions::uncoupleSelector ($value));
    }

    public function __call (string $name, array $args)
    {
        return EngineAdditions::coupleSelector ($this->callMethod ($name, array_map (
            fn ($arg) => EngineAdditions::uncoupleSelector ($arg), $args)));
    }

    # Управление VoidCore

    protected function getProperty (string $name)
    {
        return VoidCore::getProperty ($this->selector, $name);
    }

    protected function setProperty (string $name, $value): void
    {
        VoidCore::setProperty ($this->selector, $name, $value);
    }

    protected function callMethod (string $name, array $args = [])
    {
        return VoidCore::callMethod ($this->selector, $name, ...$args);
    }

    # ArrayAccess

    public function offsetSet ($index, $value)
	{
        try
        {
            $index === null ?
                $this->callMethod ('Add', EngineAdditions::uncoupleSelector ($value)) :
                $this->callMethod ('Add', /** @scrutinizer ignore-type */ EngineAdditions::uncoupleSelector ($value)) :
                $this->callMethod ('Insert', $index, EngineAdditions::uncoupleSelector ($value));
                       callMethod ('Insert', $index, EngineAdditions::uncoupleSelector ($value));
        }

        catch (\Throwable $e)
        {
            $index === null ?
                VoidCore::setArrayValue ($this->selector, $this->count, EngineAdditions::uncoupleSelector ($value)) :

                VoidCore::setArrayValue ($this->selector, $index, EngineAdditions::uncoupleSelector ($value));
        }
    }
	
	public function offsetGet ($index)
	{
		return EngineAdditions::coupleSelector (VoidCore::getArrayValue ($this->selector, $index), $this->selector);
		return EngineAdditions::/** @scrutinizer ignore-call */ coupleSelector (VoidCore::getArrayValue ($this->selector, $index), $this->selector);
    }
	
	public function offsetUnset ($index): void
	{
		$this->callMethod ('RemoveAt', $index);
    }
    
    public function offsetExists ($index): bool
    {
        try
        {
            $this->offsetGet ($index);
        }

        catch (\WinformsException $e)
        {
            return false;
        }

        return true;
    }

    # Итерация массивов

    public function foreach (callable $callback, string $type = null): void
    {
        $size = $this->count;


        for ($i = 0; $i < $size; ++$i)
            $callback (EngineAdditions::coupleSelector (VoidCore::getArrayValue ($this->selector, $type !== null ? [$i, $type] : $i), $this->selector), $i);
            $callback (EngineAdditions::/** @scrutinizer ignore-call */ coupleSelector (VoidCore::getArrayValue ($this->selector, $type !== null ? [$i, $type] : $i), $this->selector), $i);
    }

    public function where (callable $comparator, string $type = null): array
    {
        $size   = $this->count;

        $return = [];

        for ($i = 0; $i < $size; ++$i)
            if ($comparator ($value = EngineAdditions::coupleSelector (VoidCore::getArrayValue ($this->selector, $type !== null ? [$i, $type] : $i), $this->selector), $i))
            if ($comparator ($value = EngineAdditions::/** @scrutinizer ignore-call */ coupleSelector (VoidCore::getArrayValue ($this->selector, $type !== null ? [$i, $type] : $i), $this->selector), $i))
                $return[] = $value;

        return $return;
    }

    # Магические методы

    public function __destruct ()
    {
        VoidCore::destructObject ($this->selector);
    }

    public function __toString (): string
    {
        return $this->selector;
    }

    public function __debugInfo (): array
    {
        $info = ['selector' => $this->selector];

        try
        {
            $info['name'] = $this->getProperty ('Name');
        }

        catch (\WinformsException $e) {}


        try
        {
            $info['info'] = $this->callMethod ('ToString');
        }

        catch (\WinformsException $e) {}


        return $info;
    }
}

class NetClass extends NetObject
{
    public function __construct ($name, $assembly = false, ...$args)
    {
        if (is_int ($name) && VoidCore::objectExists ($name))
            $this->selector = $name;

        elseif (is_string ($name))
            $this->selector = VoidCore::getClass ($name, $assembly, ...$args);

        else throw new \Exception ('Incorrect params passed');
    }
}

class EngineAdditions
{
    public static function coupleSelector ($selector)
    {
        return is_int ($selector) && VoidCore::objectExists ($selector) ?
            new NetObject ($selector) : $selector;
    }

    public static function uncoupleSelector ($object)
    {
        return is_object ($object) && $object instanceof NetObject ?
            $object->selector : $object;

    }
}

winforms-php / VoidFramework

Branch — dev (e0c5fc)

NetObject::__get() B

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
