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

Completed

Push — master ( 605ec5...e9cc16 )

by Vitaly

created 2017-04-08 12:42 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	5
CRAP Score	3

Importance

Changes

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

<?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 = [];

        // 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 = false;
                        foreach ($commonPrefixes as $prefix => $collection) {
                            if ($collection->has($comparedStructure)) {
                                $foundInOtherCollection = true;
                            }
                        }

                        $newPrefix = substr($comparedStructure->getString(), strlen($foundPrefix));
                        if (!$foundInOtherCollection && strlen($newPrefix)) {
                            // 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 = false;
                foreach ($commonPrefixes as $prefix => $collection) {
                    if ($collection->has($initialStructure)) {
                        $foundInOtherCollection = true;
                    }
                }

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

        return $commonPrefixes;
    }

    /**
     * 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;
    }

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

    /**
     * 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		// Iterate sorted character group internalCollection
56	2	foreach ($this->structures as $initialStructure) {
57	2	$oneCommonPrefixFound = false;
58		// Iterate all character group internalCollection again
59	2	foreach ($this->structures as $comparedStructure) {
60		// Ignore same internalCollection
61	2	if ($initialStructure !== $comparedStructure) {
62	2	$foundPrefix = $initialStructure->getCommonPrefix($comparedStructure);
63
64		// If we have found common prefix between two structures
65	2	if ($foundPrefix !== '') {
66		/**
67		* Try to find if this prefix can be merged into already found common prefix
68		* as our structures collection is already sorted.
69		*/
70	2	$foundPrefixStructure = new Structure($foundPrefix);
71	2	foreach ($commonPrefixes as $existingPrefix => $structures) {
72	2	$internalPrefix = (new Structure($existingPrefix))->getCommonPrefix($foundPrefixStructure);
73	2	if ($internalPrefix !== '') {
74	2	$foundPrefix = $internalPrefix;
75	2	break;
76		}
77		}
78
79		// Create new structure collection with common prefix
80	2	if (!array_key_exists($foundPrefix, $commonPrefixes)) {
81	2	$commonPrefixes[$foundPrefix] = new StructureCollection();
82		}
83
84	2	$foundInOtherCollection = false;
85	2	foreach ($commonPrefixes as $prefix => $collection) {
86	2	if ($collection->has($comparedStructure)) {
87		$foundInOtherCollection = true;
88		}
89		}
90
91	2	$newPrefix = substr($comparedStructure->getString(), strlen($foundPrefix));
92	2	if (!$foundInOtherCollection && strlen($newPrefix)) {
93		// Add structure to structure collection
94	2	$commonPrefixes[$foundPrefix]->addUniqueStructure(new Structure($newPrefix));
95		}
96
97	2	$oneCommonPrefixFound = true;
98		}
99		}
100		}
101
102	2	if (!$oneCommonPrefixFound) {
103	1	$foundPrefix = $initialStructure->getString();
104
105		// Create new structure collection with common prefix
106	1	if (!array_key_exists($foundPrefix, $commonPrefixes)) {
107	1	$commonPrefixes[$foundPrefix] = new StructureCollection();
108		}
109
110	1	$foundInOtherCollection = false;
111	1	foreach ($commonPrefixes as $prefix => $collection) {
112	1	if ($collection->has($initialStructure)) {
113		$foundInOtherCollection = true;
114		}
115		}
116
117	1	$newPrefix = substr($initialStructure->getString(), strlen($foundPrefix));
118	1	if (!$foundInOtherCollection && strlen($newPrefix)) {
119		// Add structure to structure collection
120		$commonPrefixes[$foundPrefix]->addUniqueStructure(new Structure($newPrefix));
121		}
122		}
123		}
124
125	2	return $commonPrefixes;
126		}
127
128		/**
129		* Sort structures.
130		*
131		* @param bool $ascending Ascending sorting order
132		*
133		* @return array\|Structure\|Structure[]
134		*/
135		protected function sort(bool $ascending = true)
136		{
137		// Sort internalCollection
138	2	uasort($this->structures, function (Structure $initial, Structure $compared) {
139	2	return $initial->compare($compared);
140	2	});
141
142		// Sort descending if needed
143	2	$this->structures = $ascending ? array_reverse($this->structures) : $this->structures;
144	2	}
145
146		/**
147		* @param Structure $structure
148		*
149		* @return bool
150		*/
151	2	public function has(Structure $structure): bool
152		{
153	2	foreach ($this->structures as $comparedStructure) {
154	2	if ($this->isSameStructure($structure, $comparedStructure)) {
155	2	return true;
156		}
157		}
158
159	2	return false;
160		}
161
162		/**
163		* Compare two structures.
164		*
165		* @param Structure $initial Initial structure
166		* @param Structure $compared Compared structure
167		*
168		* @return bool True is structures are equal
169		*/
170	2	protected function isSameStructure(Structure $initial, Structure $compared): bool
171		{
172	2	return $initial->getString() === $compared->getString();
173		}
174
175		/**
176		* Add only unique structure to collection.
177		*
178		* @param Structure $structure Added structure
179		*/
180	2	public function addUniqueStructure(Structure $structure): void
181		{
182	2	if (!$this->has($structure)) {
183	2	$this->add($structure);
184		}
185	2	}
186
187		/**
188		* Add structure to structure collection.
189		*
190		* @param Structure $structure Added structure
191		*/
192	2	public function add(Structure $structure): void
193		{
194	2	$this->structures[$structure->getString()] = $structure;
195	2	}
196		}
197

samsonframework / string-condition-tree

Push — master ( 605ec5...e9cc16 )

StructureCollection::has() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like