LogicalAbstract::getResults() - Code Metrics - bradcornford/Logical - Measure and Improve Code Quality continuously with Scrutinizer

LogicalAbstract::getResults() A
last analyzed 2020-01-30 11:21 UTC

↳ Parent: LogicalAbstract

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php namespace Cornford\Logical;

use Cornford\Logical\Contracts\LogicalStatementInterface;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;

abstract class LogicalAbstract
{
    /**
     * Logical statement instance.
     *
     * @var \Cornford\Logical\Contracts\LogicalStatementInterface
     */
    protected static $logicalStatementInstance;

    /**
     * Property accessor instance.
     *
     * @var \Symfony\Component\PropertyAccess\PropertyAccessor
     */
    protected static $propertyAccessorInstance;

    /**
     * The input array.
     *
     * @var array
     */
    protected $input = [];

    /**
     * The logic string.
     *
     * @var string
     */
    protected $logic;

    /**
     * The decoded logic statements.
     *
     * @var array
     */
    protected $decodedLogicStatements = [];

    /**
     * The output results.
     *
     * @var array
     */
    protected $results = [];

    /**
     * Construct Logical object.
     *
     * @param array                     $input
     * @param string|null               $logic
     * @param LogicalStatementInterface $logicalStatement
     */
    public function __construct(
        array $input = [],
        $logic = null,
        LogicalStatementInterface $logicalStatement
    ) {
        self::$logicalStatementInstance = $logicalStatement;
        self::$propertyAccessorInstance = PropertyAccess::createPropertyAccessor();
        $this->input = $input;
        $this->logic = $logic;
    }

    /**
     * Set the logical statement instance.
     *
     * @param LogicalStatementInterface $value
     *
     * @return void
     */
    public function setLogicalStatementInstance(LogicalStatementInterface $value)
    {
        self::$logicalStatementInstance = $value;
    }

    /**
     * Get the logic statement instance.
     *
     * @return LogicalStatementInterface
     */
    public function getLogicalStatementInstance()
    {
        return self::$logicalStatementInstance;
    }

    /**
     * Get the property accessor instance.
     *
     * @return PropertyAccessor
     */
    protected function getPropertyAccessorInstance()
    {
        return self::$propertyAccessorInstance;
    }

    /**
     * Set the input value.
     *
     * @param array $value
     *
     * @return void
     */
    public function setInput(array $value = [])
    {
        $this->input = $value;
    }

    /**
     * Get the input value.
     *
     * @return array
     */
    public function getInput()
    {
        return $this->input;
    }

    /**
     * Set the logic value.
     *
     * @param string $value
     *
     * @return void
     */
    public function setLogic($value)
    {
        $this->logic = $value;
    }

    /**
     * Get the logic value.
     *
     * @return string
     */
    public function getLogic()
    {
        return $this->logic;
    }

    /**
     * Set a decoded logic statements value.
     *
     * @param array $value
     *
     * @return void
     */
    protected function setDecodedLogicStatements($value)
    {
        $this->decodedLogicStatements = $value;
    }

    /**
     * Set a decoded logic statement value.
     *
     * @param array $value
     *
     * @return void
     */
    protected function setDecodedLogicStatement($value)
    {
        if (!array_key_exists(key($value), $this->decodedLogicStatements)) {
            $this->decodedLogicStatements[key($value)] = [];
        }

        $this->decodedLogicStatements[key($value)] = array_merge($this->decodedLogicStatements[key($value)], $value);
    }

    /**
     * Get the decoded logic statements value.
     *
     * @return array
     */
    protected function getDecodedLogicStatements()
    {
        return $this->decodedLogicStatements;
    }

    /**
     * Set the results value.
     *
     * @param array $value
     *
     * @return void
     */
    protected function setResults($value)
    {
        $this->results = $value;
    }

    /**
     * Merge the results value with an input results value.
     *
     * @param array $value
     *
     * @return void
     */
    protected function mergeResults($value)
    {
        foreach ($value as $key => $result) {
            if (!array_key_exists($key, $this->results)) {
                $this->results[$key] = $result;
            } else {
                if (!in_array($result, $this->results)) {
                    if (gettype($result) != $this->results[$key]) {
                        $this->results[] = $result;
                    }
                }
            }
        }
    }

    /**
     * Get the results value.
     *
     * @return array
     */
    public function getResults()
    {
        return $this->results;
    }

    /**
     * Reset items.
     *
     * @return self
     */
    public function reset()
    {
        $this->input = [];
        $this->logic = null;
        $this->results = [];
        $this->decodedLogicStatements = [];

        return $this;
    }
}


1			<?php namespace Cornford\Logical;
2
3			use Cornford\Logical\Contracts\LogicalStatementInterface;
4			use Symfony\Component\PropertyAccess\PropertyAccess;
5			use Symfony\Component\PropertyAccess\PropertyAccessor;
6
7			abstract class LogicalAbstract
8			{
9			/**
10			* Logical statement instance.
11			*
12			* @var \Cornford\Logical\Contracts\LogicalStatementInterface
13			*/
14			protected static $logicalStatementInstance;
15
16			/**
17			* Property accessor instance.
18			*
19			* @var \Symfony\Component\PropertyAccess\PropertyAccessor
20			*/
21			protected static $propertyAccessorInstance;
22
23			/**
24			* The input array.
25			*
26			* @var array
27			*/
28			protected $input = [];
29
30			/**
31			* The logic string.
32			*
33			* @var string
34			*/
35			protected $logic;
36
37			/**
38			* The decoded logic statements.
39			*
40			* @var array
41			*/
42			protected $decodedLogicStatements = [];
43
44			/**
45			* The output results.
46			*
47			* @var array
48			*/
49			protected $results = [];
50
51			/**
52			* Construct Logical object.
53			*
54			* @param array $input
55			* @param string\|null $logic
56			* @param LogicalStatementInterface $logicalStatement
57			*/
58			public function __construct(
59			array $input = [],
60			$logic = null,
61			LogicalStatementInterface $logicalStatement
62			) {
63			self::$logicalStatementInstance = $logicalStatement;
64			self::$propertyAccessorInstance = PropertyAccess::createPropertyAccessor();
65			$this->input = $input;
66			$this->logic = $logic;
67			}
68
69			/**
70			* Set the logical statement instance.
71			*
72			* @param LogicalStatementInterface $value
73			*
74			* @return void
75			*/
76			public function setLogicalStatementInstance(LogicalStatementInterface $value)
77			{
78			self::$logicalStatementInstance = $value;
79			}
80
81			/**
82			* Get the logic statement instance.
83			*
84			* @return LogicalStatementInterface
85			*/
86			public function getLogicalStatementInstance()
87			{
88			return self::$logicalStatementInstance;
89			}
90
91			/**
92			* Get the property accessor instance.
93			*
94			* @return PropertyAccessor
95			*/
96			protected function getPropertyAccessorInstance()
97			{
98			return self::$propertyAccessorInstance;
99			}
100
101			/**
102			* Set the input value.
103			*
104			* @param array $value
105			*
106			* @return void
107			*/
108			public function setInput(array $value = [])
109			{
110			$this->input = $value;
111			}
112
113			/**
114			* Get the input value.
115			*
116			* @return array
117			*/
118			public function getInput()
119			{
120			return $this->input;
121			}
122
123			/**
124			* Set the logic value.
125			*
126			* @param string $value
127			*
128			* @return void
129			*/
130			public function setLogic($value)
131			{
132			$this->logic = $value;
133			}
134
135			/**
136			* Get the logic value.
137			*
138			* @return string
139			*/
140			public function getLogic()
141			{
142			return $this->logic;
143			}
144
145			/**
146			* Set a decoded logic statements value.
147			*
148			* @param array $value
149			*
150			* @return void
151			*/
152			protected function setDecodedLogicStatements($value)
153			{
154			$this->decodedLogicStatements = $value;
155			}
156
157			/**
158			* Set a decoded logic statement value.
159			*
160			* @param array $value
161			*
162			* @return void
163			*/
164			protected function setDecodedLogicStatement($value)
165			{
166			if (!array_key_exists(key($value), $this->decodedLogicStatements)) {
167			$this->decodedLogicStatements[key($value)] = [];
168			}
169
170			$this->decodedLogicStatements[key($value)] = array_merge($this->decodedLogicStatements[key($value)], $value);
171			}
172
173			/**
174			* Get the decoded logic statements value.
175			*
176			* @return array
177			*/
178			protected function getDecodedLogicStatements()
179			{
180			return $this->decodedLogicStatements;
181			}
182
183			/**
184			* Set the results value.
185			*
186			* @param array $value
187			*
188			* @return void
189			*/
190			protected function setResults($value)
191			{
192			$this->results = $value;
193			}
194
195			/**
196			* Merge the results value with an input results value.
197			*
198			* @param array $value
199			*
200			* @return void
201			*/
202			protected function mergeResults($value)
203			{
204			foreach ($value as $key => $result) {
205			if (!array_key_exists($key, $this->results)) {
206			$this->results[$key] = $result;
207			} else {
208			if (!in_array($result, $this->results)) {
209			if (gettype($result) != $this->results[$key]) {
210			$this->results[] = $result;
211			}
212			}
213			}
214			}
215			}
216
217			/**
218			* Get the results value.
219			*
220			* @return array
221			*/
222			public function getResults()
223			{
224			return $this->results;
225			}
226
227			/**
228			* Reset items.
229			*
230			* @return self
231			*/
232			public function reset()
233			{
234			$this->input = [];
235			$this->logic = null;
236			$this->results = [];
237			$this->decodedLogicStatements = [];
238
239			return $this;
240			}
241			}
242

bradcornford / Logical

LogicalAbstract::getResults() A last analyzed 2020-01-30 11:21 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

LogicalAbstract::getResults() A
last analyzed 2020-01-30 11:21 UTC