StructureCollection::has() - Code Metrics - Inspection of "First working tests with new approach" - samsonframework/string-condition-tree - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e9cc16...40005e )

by Vitaly

created 2017-04-08 13:49 UTC

StructureCollection::has() A

↳ Parent: StructureCollection

Complexity

Conditions	3
Paths	3

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	3.072

Importance

Changes

Metric	Value
dl	0
loc	10
ccs	4
cts	5
cp	0.8
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	5
nc	3
nop	1
crap	3.072

<?php declare(strict_types=1);
/**
 * Created by Vitaly Iegorov <[email protected]>.
 * on 08.04.17 at 09:08
 */
namespace samsonframework\stringconditiontree\string;

use samsonframework\stringconditiontree\AbstractIterable;

/**
 * Class StructureCollection
 *
 * @author Vitaly Egorov <[email protected]>
 */
class StructureCollection extends AbstractIterable
{
    /** string Internal collection name */
    protected const COLLECTION_NAME = 'structures';

    /** @var Structure[] */
    protected $structures = [];

    /**
     * Create structures collection from array of strings.
     *
     * @param array $strings Strings array
     *
     * @return StructureCollection StructureCollection instance
     *
     * @throws \InvalidArgumentException If collection variable is missing
     */
    public static function fromStringsArray(array $strings): StructureCollection
    {
        // Create internalCollection
        $structureCollection = new StructureCollection();
        foreach ($strings as $string) {
            $structureCollection->structures[$string] = new Structure($string);
        }

        return $structureCollection;
    }

    /**
     * Get collection of StructureCollection instances grouped by longest common prefixes.
     *
     * @return StructureCollection[] Longest common prefixes array of StructureCollection instances
     */
    public function getCommonPrefixesCollection(): array
    {
        $this->sort();

        /** @var StructureCollection[] $commonPrefixes */
        $commonPrefixes = [];

        /** @var Structure[] $usedStructures */
        $usedStructures = [];

        // Iterate sorted character group internalCollection
        foreach ($this->structures as $initialStructure) {
            $oneCommonPrefixFound = false;
            // Iterate all character group internalCollection again
            foreach ($this->structures as $comparedStructure) {
                // Ignore same internalCollection
                if ($initialStructure !== $comparedStructure) {
                    $foundPrefix = $initialStructure->getCommonPrefix($comparedStructure);

                    // If we have found common prefix between two structures
                    if ($foundPrefix !== '') {
                        /**
                         * Try to find if this prefix can be merged into already found common prefix
                         * as our structures collection is already sorted.
                         */
                        $foundPrefixStructure = new Structure($foundPrefix);
                        foreach ($commonPrefixes as $existingPrefix => $structures) {
                            $internalPrefix = (new Structure($existingPrefix))->getCommonPrefix($foundPrefixStructure);
                            if ($internalPrefix !== '') {
                                $foundPrefix = $internalPrefix;
                                break;
                            }
                        }

                        // Create new structure collection with common prefix
                        if (!array_key_exists($foundPrefix, $commonPrefixes)) {
                            $commonPrefixes[$foundPrefix] = new StructureCollection();
                        }

                        $foundInOtherCollection = in_array($comparedStructure, $usedStructures);

                        $newPrefix = substr($comparedStructure->getString(), strlen($foundPrefix));
                        if (!$foundInOtherCollection && strlen($newPrefix)) {
                            $usedStructures[] = $comparedStructure;
                            // Add structure to structure collection
                            $commonPrefixes[$foundPrefix]->addUniqueStructure(new Structure($newPrefix));
                        }

                        $oneCommonPrefixFound = true;
                    }
                }
            }

            if (!$oneCommonPrefixFound) {
                $foundPrefix = $initialStructure->getString();

                // Create new structure collection with common prefix
                if (!array_key_exists($foundPrefix, $commonPrefixes)) {
                    $commonPrefixes[$foundPrefix] = new StructureCollection();
                }

                $foundInOtherCollection = in_array($initialStructure, $usedStructures);

                $newPrefix = substr($initialStructure->getString(), strlen($foundPrefix));
                if (!$foundInOtherCollection && strlen($newPrefix)) {
                    $usedStructures[] = $initialStructure;
                    // Add structure to structure collection
                    $commonPrefixes[$foundPrefix]->addUniqueStructure(new Structure($newPrefix));
                }
            }
        }

        // Sort common prefixes
        $commonPrefixesCollection = new StructureCollection();
        foreach ($commonPrefixes as $prefix => $structures) {
            $commonPrefixesCollection->add(new Structure($prefix));
        }
        $commonPrefixesCollection->sort();

        $final = [];
        foreach ($commonPrefixesCollection as $prefix => $structureCollection) {
            $final[$prefix] = $commonPrefixes[$prefix];
        }

        return $final;
    }

    /**
     * Sort structures.
     *
     * @param bool $ascending Ascending sorting order
     *
     * @return array|Structure|Structure[]
     */
    protected function sort(bool $ascending = true)
    {
        // Sort internalCollection
        uasort($this->structures, function (Structure $initial, Structure $compared) {
            return $initial->compare($compared);
        });

        // Sort descending if needed
        $this->structures = $ascending ? array_reverse($this->structures) : $this->structures;
    }

    /**
     * Add only unique structure to collection.
     *
     * @param Structure $structure Added structure
     */
    public function addUniqueStructure(Structure $structure): void
    {
        if (!$this->has($structure)) {
            $this->add($structure);
        }
    }

    /**
     * @param Structure $structure
     *
     * @return bool
     */
    public function has(Structure $structure): bool
    {
        foreach ($this->structures as $comparedStructure) {
            if ($this->isSameStructure($structure, $comparedStructure)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Compare two structures.
     *
     * @param Structure $initial Initial structure
     * @param Structure $compared Compared structure
     *
     * @return bool True is structures are equal
     */
    protected function isSameStructure(Structure $initial, Structure $compared): bool
    {
        return $initial->getString() === $compared->getString();
    }

    /**
     * Add structure to structure collection.
     *
     * @param Structure $structure Added structure
     */
    public function add(Structure $structure): void
    {
        $this->structures[$structure->getString()] = $structure;
    }
}


1		<?php declare(strict_types=1);
2		/**
3		* Created by Vitaly Iegorov <[email protected]>.
4		* on 08.04.17 at 09:08
5		*/
6		namespace samsonframework\stringconditiontree\string;
7
8		use samsonframework\stringconditiontree\AbstractIterable;
9
10		/**
11		* Class StructureCollection
12		*
13		* @author Vitaly Egorov <[email protected]>
14		*/
15		class StructureCollection extends AbstractIterable
16		{
17		/** string Internal collection name */
18		protected const COLLECTION_NAME = 'structures';
19
20		/** @var Structure[] */
21		protected $structures = [];
22
23		/**
24		* Create structures collection from array of strings.
25		*
26		* @param array $strings Strings array
27		*
28		* @return StructureCollection StructureCollection instance
29		*
30		* @throws \InvalidArgumentException If collection variable is missing
31		*/
32	3	public static function fromStringsArray(array $strings): StructureCollection
33		{
34		// Create internalCollection
35	3	$structureCollection = new StructureCollection();
36	3	foreach ($strings as $string) {
37	3	$structureCollection->structures[$string] = new Structure($string);
38		}
39
40	3	return $structureCollection;
41		}
42
43		/**
44		* Get collection of StructureCollection instances grouped by longest common prefixes.
45		*
46		* @return StructureCollection[] Longest common prefixes array of StructureCollection instances
47		*/
48	2	public function getCommonPrefixesCollection(): array
49		{
50	2	$this->sort();
51
52		/** @var StructureCollection[] $commonPrefixes */
53	2	$commonPrefixes = [];
54
55		/** @var Structure[] $usedStructures */
56	2	$usedStructures = [];
57
58		// Iterate sorted character group internalCollection
59	2	foreach ($this->structures as $initialStructure) {
60	2	$oneCommonPrefixFound = false;
61		// Iterate all character group internalCollection again
62	2	foreach ($this->structures as $comparedStructure) {
63		// Ignore same internalCollection
64	2	if ($initialStructure !== $comparedStructure) {
65	2	$foundPrefix = $initialStructure->getCommonPrefix($comparedStructure);
66
67		// If we have found common prefix between two structures
68	2	if ($foundPrefix !== '') {
69		/**
70		* Try to find if this prefix can be merged into already found common prefix
71		* as our structures collection is already sorted.
72		*/
73	2	$foundPrefixStructure = new Structure($foundPrefix);
74	2	foreach ($commonPrefixes as $existingPrefix => $structures) {
75	2	$internalPrefix = (new Structure($existingPrefix))->getCommonPrefix($foundPrefixStructure);
76	2	if ($internalPrefix !== '') {
77	2	$foundPrefix = $internalPrefix;
78	2	break;
79		}
80		}
81
82		// Create new structure collection with common prefix
83	2	if (!array_key_exists($foundPrefix, $commonPrefixes)) {
84	2	$commonPrefixes[$foundPrefix] = new StructureCollection();
85		}
86
87	2	$foundInOtherCollection = in_array($comparedStructure, $usedStructures);
88
89	2	$newPrefix = substr($comparedStructure->getString(), strlen($foundPrefix));
90	2	if (!$foundInOtherCollection && strlen($newPrefix)) {
91	2	$usedStructures[] = $comparedStructure;
92		// Add structure to structure collection
93	2	$commonPrefixes[$foundPrefix]->addUniqueStructure(new Structure($newPrefix));
94		}
95
96	2	$oneCommonPrefixFound = true;
97		}
98		}
99		}
100
101	2	if (!$oneCommonPrefixFound) {
102	1	$foundPrefix = $initialStructure->getString();
103
104		// Create new structure collection with common prefix
105	1	if (!array_key_exists($foundPrefix, $commonPrefixes)) {
106	1	$commonPrefixes[$foundPrefix] = new StructureCollection();
107		}
108
109	1	$foundInOtherCollection = in_array($initialStructure, $usedStructures);
110
111	1	$newPrefix = substr($initialStructure->getString(), strlen($foundPrefix));
112	1	if (!$foundInOtherCollection && strlen($newPrefix)) {
113		$usedStructures[] = $initialStructure;
114		// Add structure to structure collection
115		$commonPrefixes[$foundPrefix]->addUniqueStructure(new Structure($newPrefix));
116		}
117		}
118		}
119
120		// Sort common prefixes
121	2	$commonPrefixesCollection = new StructureCollection();
122	2	foreach ($commonPrefixes as $prefix => $structures) {
123	2	$commonPrefixesCollection->add(new Structure($prefix));
124		}
125	2	$commonPrefixesCollection->sort();
126
127	2	$final = [];
128	2	foreach ($commonPrefixesCollection as $prefix => $structureCollection) {
129	2	$final[$prefix] = $commonPrefixes[$prefix];
130		}
131
132	2	return $final;
133		}
134
135		/**
136		* Sort structures.
137		*
138		* @param bool $ascending Ascending sorting order
139		*
140		* @return array\|Structure\|Structure[]
141		*/
142		protected function sort(bool $ascending = true)
143		{
144		// Sort internalCollection
145	2	uasort($this->structures, function (Structure $initial, Structure $compared) {
146	2	return $initial->compare($compared);
147	2	});
148
149		// Sort descending if needed
150	2	$this->structures = $ascending ? array_reverse($this->structures) : $this->structures;
151	2	}
152
153		/**
154		* Add only unique structure to collection.
155		*
156		* @param Structure $structure Added structure
157		*/
158	2	public function addUniqueStructure(Structure $structure): void
159		{
160	2	if (!$this->has($structure)) {
161	2	$this->add($structure);
162		}
163	2	}
164
165		/**
166		* @param Structure $structure
167		*
168		* @return bool
169		*/
170	2	public function has(Structure $structure): bool
171		{
172	2	foreach ($this->structures as $comparedStructure) {
173	2	if ($this->isSameStructure($structure, $comparedStructure)) {
174		return true;
175		}
176		}
177
178	2	return false;
179		}
180
181		/**
182		* Compare two structures.
183		*
184		* @param Structure $initial Initial structure
185		* @param Structure $compared Compared structure
186		*
187		* @return bool True is structures are equal
188		*/
189	2	protected function isSameStructure(Structure $initial, Structure $compared): bool
190		{
191	2	return $initial->getString() === $compared->getString();
192		}
193
194		/**
195		* Add structure to structure collection.
196		*
197		* @param Structure $structure Added structure
198		*/
199	2	public function add(Structure $structure): void
200		{
201	2	$this->structures[$structure->getString()] = $structure;
202	2	}
203		}
204

samsonframework / string-condition-tree

Push — master ( e9cc16...40005e )

StructureCollection::has() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like