Column - Code Metrics - Inspection of "ColumnLink/Aciton now tries to create link to data..." - ublaboo/datagrid - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fe6898...6997a4 )

by Pavel

created 2016-02-25 10:34 UTC

Column B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	440
Duplicated Lines	2.05 %

Coupling/Cohesion

Components	4
Dependencies	4

Importance

Changes	6
Bugs	1	Features	1

Metric	Value
wmc	45
c	6
b	1
f	1
lcom	4
cbo	4
dl	9
loc	440
rs	8.3673

30 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	render()	9	25	5
A	setTemplateEscaping()	0	6	1
A	isTemplateEscaped()	0	4	1
A	setSortable()	0	6	1
A	isSortable()	0	4	1
A	getColumnName()	0	4	1
A	getColumnValue()	0	4	1
A	getName()	0	4	1
A	setReplacement()	0	6	1
A	hasReplacements()	0	4	1
A	applyReplacements()	0	10	4
B	setRenderer()	0	24	5
A	setRendererOnCondition()	0	4	1
A	getRenderer()	0	4	1
A	setTemplate()	0	7	1
A	getTemplateVariables()	0	4	1
A	hasTemplate()	0	4	1
A	getTemplate()	0	4	1
A	isSortedBy()	0	4	1
A	setSort()	0	6	1
A	getSortNext()	0	10	3
A	isSortAsc()	0	4	1
A	setAlign()	0	6	1
A	hasAlign()	0	4	1
A	getAlign()	0	4	1
A	setEditableCallback()	0	6	1
A	getEditableCallback()	0	4	1
A	isEditable()	0	4	1
A	createLink()	0	16	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Column often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Column, and based on these observations, apply Extract Interface, too.

<?php

/**
 * @copyright   Copyright (c) 2015 ublaboo <[email protected]>
 * @author      Pavel Janda <[email protected]>
 * @package     Ublaboo
 */

namespace Ublaboo\DataGrid\Column;

use Nette\InvalidArgumentException;
use Ublaboo;
use Ublaboo\DataGrid\Row;
use Ublaboo\DataGrid\Exception\DataGridException;

abstract class Column extends Ublaboo\DataGrid\Object
{

	/**
	 * @var string
	 */
	protected $column;

	/**
	 * @var string
	 */
	protected $name;

	/**
	 * @var array
	 */
	protected $replacements = [];

	/**
	 * @var Renderer|NULL
	 */
	protected $renderer;

	/**
	 * @var string
	 */
	protected $template;

	/**
	 * @var boolean
	 */
	protected $is_sortable = FALSE;

	/**
	 * @var array
	 */
	protected $sort;

	/**
	 * @var bool
	 */
	protected $template_escaping = TRUE;

	/**
	 * @var string
	 */
	protected $align;

	/**
	 * @var array
	 */
	protected $template_variables;

	/**
	 * @var callable
	 */
	protected $editable_callback;


	/**
	 * @param string $column
	 * @param string $name
	 */
	public function __construct($column, $name)
	{
		$this->column = $column;
		$this->name = $name;
	}


	/**
	 * Render row item into template
	 * @param  Row   $row
	 * @return mixed
	 */
	public function render(Row $row)
	{
		/**
		 * Renderer function may be used
		 */
		if ($renderer = $this->getRenderer()) {

			if (!$renderer->getConditionCallback()) {
				return call_user_func_array($renderer->getCallback(), [$row->getItem()]);
			}

			if (call_user_func_array($renderer->getConditionCallback(), [$row->getItem()])) {
				return call_user_func_array($renderer->getCallback(), [$row->getItem()]);
			}
		}

		/**
		 * Or replacements may be applied
		 */
		list($do_replace, $replaced) = $this->applyReplacements($row);
		if ($do_replace) {
			return $replaced;
		}

		return $this->getColumnValue($row);
	}


	/**
	 * Should be column values escaped in latte?
	 * @param boolean $template_escaping
	 */
	public function setTemplateEscaping($template_escaping = TRUE)
	{
		$this->template_escaping = (bool) $template_escaping;

		return $this;
	}


	public function isTemplateEscaped()
	{
		return $this->template_escaping;
	}


	/**
	 * Set column sortable or not
	 * @param bool $sortable
	 */
	public function setSortable($sortable = TRUE)
	{
		$this->is_sortable = (bool) $sortable;

		return $this;
	}


	/**
	 * Tell whether column is sortable
	 * @return boolean
	 */
	public function isSortable()
	{
		return $this->is_sortable;
	}


	/**
	 * Get column name
	 * @return string
	 */
	public function getColumnName()
	{
		return $this->column;
	}


	/**
	 * Get column value of row item
	 * @param  Row   $row
	 * @return mixed
	 */
	public function getColumnValue(Row $row)
	{
		return $row->getValue($this->column);
	}


	public function getName()
	{
		return $this->name;
	}


	/**
	 * Set column replacements
	 * @param  array $replacements
	 * @return Column
	 */
	public function setReplacement(array $replacements)
	{
		$this->replacements = $replacements;

		return $this;
	}


	/**
	 * Tell whether columns has replacements
	 * @return boolean
	 */
	public function hasReplacements()
	{
		return (bool) $this->replacements;
	}


	/**
	 * Apply replacements
	 * @param  Row   $row
	 * @return array
	 */
	public function applyReplacements(Row $row)
	{
		$value = $row->getValue($this->column);

		if ((is_scalar($value) || is_null($value)) && isset($this->replacements[$value])) {
			return [TRUE, $this->replacements[$value]];
		}

		return [FALSE, NULL];
	}


	/**
	 * Set renderer callback and (it may be optional - the condition callback will decide)
	 * @param callable $renderer
	 */
	public function setRenderer($renderer, $condition_callback = NULL)
	{
		if ($this->hasReplacements()) {
			throw new DataGridException(
				"Use either Column::setReplacement() or Column::setRenderer, not both."
			);
		}

		if (!is_callable($renderer)) {
			throw new DataGridException(
				"Renderer (method Column::setRenderer()) must be callable."
			);
		}

		if (NULL != $condition_callback && !is_callable($condition_callback)) {
			throw new DataGridException(
				"Renderer (method Column::setRenderer()) must be callable."
			);
		}

		$this->renderer = new Renderer($renderer, $condition_callback);

		return $this;
	}


	/**
	 * Set renderer callback just if condition is truthy
	 * @param callable $renderer
	 */
	public function setRendererOnCondition($renderer, $condition_callback)
	{
		return $this->setRenderer($renderer, $condition_callback);
	}


	/**
	 * Return custom renderer callback
	 * @return Renderer|null
	 */
	public function getRenderer()
	{
		return $this->renderer;
	}


	/**
	 * Column may have its own template
	 * @param string $template
	 */
	public function setTemplate($template, array $template_variables = [])
	{
		$this->template = $template;
		$this->template_variables = $template_variables;

		return $this;
	}


	/**
	 * Column can have variables that will be passed to custom template scope
	 * @return array
	 */
	public function getTemplateVariables()
	{
		return $this->template_variables;
	}


	/**
	 * Tell whether column has its owntemplate
	 * @return bool
	 */
	public function hasTemplate()
	{
		return (bool) $this->template;
	}


	/**
	 * Get column template path
	 * @return string
	 */
	public function getTemplate()
	{
		return $this->template;
	}


	/**
	 * Tell whether data source is sorted by this collumn
	 * @return boolean
	 */
	public function isSortedBy()
	{
		return (bool) $this->sort;
	}


	/**
	 * Tell column his sorting options
	 * @param array $sort
	 */
	public function setSort(array $sort)
	{
		$this->sort = $sort[$this->column];

		return $this;
	}


	/**
	 * What sorting will be applied after next click?
	 * @return array
	 */
	public function getSortNext()
	{
		if ($this->sort == 'ASC') {
			return [$this->column => 'DESC'];
		} else if ($this->sort == 'DESC') {
			return [$this->column => NULL];
		}

		return [$this->column => 'ASC'];
	}


	/**
	 * Is sorting ascending?
	 * @return boolean
	 */
	public function isSortAsc()
	{
		return $this->sort == 'ASC';
	}


	/**
	 * Set column alignment
	 * @param string $align
	 */
	public function setAlign($align)
	{
		$this->align = (string) $align;

		return $this;
	}


	/**
	 * Has column some alignment?
	 * @return boolean [description]
	 */
	public function hasAlign()
	{
		return (bool) $this->align;
	}


	/**
	 * Get column alignment
	 * @return string
	 */
	public function getAlign()
	{
		return $this->align;
	}


	/**
	 * Set callback that will be called after inline editing
	 * @param callable $editable_callback
	 */
	public function setEditableCallback(callable $editable_callback)
	{
		$this->editable_callback = $editable_callback;

		return $this;
	}


	/**
	 * Return callback that is used after inline editing
	 * @return callable
	 */
	public function getEditableCallback()
	{
		return $this->editable_callback;
	}


	/**
	 * Is column editable?
	 * @return boolean
	 */
	public function isEditable()
	{
		return (bool) $this->getEditableCallback();
	}


	/**
	 * Create link to custom destination
	 * @param  string $href
	 * @param  array  $params
	 * @return string
	 * @throws DataGridHasToBeAttachedToPresenterComponentException
	 * @throws InvalidArgumentException
	 */
	protected function createLink($href, $params)
	{
		try {
			$parent = $this->grid->getParent();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

			return $parent->link($href, $params);
		} catch (DataGridHasToBeAttachedToPresenterComponentException $e) {

			$parent = $this->grid->getPresenter();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

		} catch (InvalidArgumentException $e) {
			$parent = $this->grid->getPresenter();
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}

		}

		return $parent->link($href, $params);
	}

}


1		<?php
2
3		/**
4		* @copyright Copyright (c) 2015 ublaboo <[email protected]>
5		* @author Pavel Janda <[email protected]>
6		* @package Ublaboo
7		*/
8
9		namespace Ublaboo\DataGrid\Column;
10
11		use Nette\InvalidArgumentException;
12		use Ublaboo;
13		use Ublaboo\DataGrid\Row;
14		use Ublaboo\DataGrid\Exception\DataGridException;
15
16		abstract class Column extends Ublaboo\DataGrid\Object
17		{
18
19		/**
20		* @var string
21		*/
22		protected $column;
23
24		/**
25		* @var string
26		*/
27		protected $name;
28
29		/**
30		* @var array
31		*/
32		protected $replacements = [];
33
34		/**
35		* @var Renderer\|NULL
36		*/
37		protected $renderer;
38
39		/**
40		* @var string
41		*/
42		protected $template;
43
44		/**
45		* @var boolean
46		*/
47		protected $is_sortable = FALSE;
48
49		/**
50		* @var array
51		*/
52		protected $sort;
53
54		/**
55		* @var bool
56		*/
57		protected $template_escaping = TRUE;
58
59		/**
60		* @var string
61		*/
62		protected $align;
63
64		/**
65		* @var array
66		*/
67		protected $template_variables;
68
69		/**
70		* @var callable
71		*/
72		protected $editable_callback;
73
74
75		/**
76		* @param string $column
77		* @param string $name
78		*/
79		public function __construct($column, $name)
80		{
81		$this->column = $column;
82		$this->name = $name;
83		}
84
85
86		/**
87		* Render row item into template
88		* @param Row $row
89		* @return mixed
90		*/
91		public function render(Row $row)
92		{
93		/**
94		* Renderer function may be used
95		*/
96	View Code Duplication	if ($renderer = $this->getRenderer()) {
		0 ignored issues – show Duplication introduced 2016-02-01 16:07 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
97		if (!$renderer->getConditionCallback()) {
98		return call_user_func_array($renderer->getCallback(), [$row->getItem()]);
99		}
100
101		if (call_user_func_array($renderer->getConditionCallback(), [$row->getItem()])) {
102		return call_user_func_array($renderer->getCallback(), [$row->getItem()]);
103		}
104		}
105
106		/**
107		* Or replacements may be applied
108		*/
109		list($do_replace, $replaced) = $this->applyReplacements($row);
110		if ($do_replace) {
111		return $replaced;
112		}
113
114		return $this->getColumnValue($row);
115		}
116
117
118		/**
119		* Should be column values escaped in latte?
120		* @param boolean $template_escaping
121		*/
122		public function setTemplateEscaping($template_escaping = TRUE)
123		{
124		$this->template_escaping = (bool) $template_escaping;
125
126		return $this;
127		}
128
129
130		public function isTemplateEscaped()
131		{
132		return $this->template_escaping;
133		}
134
135
136		/**
137		* Set column sortable or not
138		* @param bool $sortable
139		*/
140		public function setSortable($sortable = TRUE)
141		{
142		$this->is_sortable = (bool) $sortable;
143
144		return $this;
145		}
146
147
148		/**
149		* Tell whether column is sortable
150		* @return boolean
151		*/
152		public function isSortable()
153		{
154		return $this->is_sortable;
155		}
156
157
158		/**
159		* Get column name
160		* @return string
161		*/
162		public function getColumnName()
163		{
164		return $this->column;
165		}
166
167
168		/**
169		* Get column value of row item
170		* @param Row $row
171		* @return mixed
172		*/
173		public function getColumnValue(Row $row)
174		{
175		return $row->getValue($this->column);
176		}
177
178
179		public function getName()
180		{
181		return $this->name;
182		}
183
184
185		/**
186		* Set column replacements
187		* @param array $replacements
188		* @return Column
189		*/
190		public function setReplacement(array $replacements)
191		{
192		$this->replacements = $replacements;
193
194		return $this;
195		}
196
197
198		/**
199		* Tell whether columns has replacements
200		* @return boolean
201		*/
202		public function hasReplacements()
203		{
204		return (bool) $this->replacements;
205		}
206
207
208		/**
209		* Apply replacements
210		* @param Row $row
211		* @return array
212		*/
213		public function applyReplacements(Row $row)
214		{
215		$value = $row->getValue($this->column);
216
217		if ((is_scalar($value) \|\| is_null($value)) && isset($this->replacements[$value])) {
218		return [TRUE, $this->replacements[$value]];
219		}
220
221		return [FALSE, NULL];
222		}
223
224
225		/**
226		* Set renderer callback and (it may be optional - the condition callback will decide)
227		* @param callable $renderer
228		*/
229		public function setRenderer($renderer, $condition_callback = NULL)
230		{
231		if ($this->hasReplacements()) {
232		throw new DataGridException(
233		"Use either Column::setReplacement() or Column::setRenderer, not both."
234		);
235		}
236
237		if (!is_callable($renderer)) {
238		throw new DataGridException(
239		"Renderer (method Column::setRenderer()) must be callable."
240		);
241		}
242
243		if (NULL != $condition_callback && !is_callable($condition_callback)) {
244		throw new DataGridException(
245		"Renderer (method Column::setRenderer()) must be callable."
246		);
247		}
248
249		$this->renderer = new Renderer($renderer, $condition_callback);
250
251		return $this;
252		}
253
254
255		/**
256		* Set renderer callback just if condition is truthy
257		* @param callable $renderer
258		*/
259		public function setRendererOnCondition($renderer, $condition_callback)
260		{
261		return $this->setRenderer($renderer, $condition_callback);
262		}
263
264
265		/**
266		* Return custom renderer callback
267		* @return Renderer\|null
268		*/
269		public function getRenderer()
270		{
271		return $this->renderer;
272		}
273
274
275		/**
276		* Column may have its own template
277		* @param string $template
278		*/
279		public function setTemplate($template, array $template_variables = [])
280		{
281		$this->template = $template;
282		$this->template_variables = $template_variables;
283
284		return $this;
285		}
286
287
288		/**
289		* Column can have variables that will be passed to custom template scope
290		* @return array
291		*/
292		public function getTemplateVariables()
293		{
294		return $this->template_variables;
295		}
296
297
298		/**
299		* Tell whether column has its owntemplate
300		* @return bool
301		*/
302		public function hasTemplate()
303		{
304		return (bool) $this->template;
305		}
306
307
308		/**
309		* Get column template path
310		* @return string
311		*/
312		public function getTemplate()
313		{
314		return $this->template;
315		}
316
317
318		/**
319		* Tell whether data source is sorted by this collumn
320		* @return boolean
321		*/
322		public function isSortedBy()
323		{
324		return (bool) $this->sort;
325		}
326
327
328		/**
329		* Tell column his sorting options
330		* @param array $sort
331		*/
332		public function setSort(array $sort)
333		{
334		$this->sort = $sort[$this->column];
335
336		return $this;
337		}
338
339
340		/**
341		* What sorting will be applied after next click?
342		* @return array
343		*/
344		public function getSortNext()
345		{
346		if ($this->sort == 'ASC') {
347		return [$this->column => 'DESC'];
348		} else if ($this->sort == 'DESC') {
349		return [$this->column => NULL];
350		}
351
352		return [$this->column => 'ASC'];
353		}
354
355
356		/**
357		* Is sorting ascending?
358		* @return boolean
359		*/
360		public function isSortAsc()
361		{
362		return $this->sort == 'ASC';
363		}
364
365
366		/**
367		* Set column alignment
368		* @param string $align
369		*/
370		public function setAlign($align)
371		{
372		$this->align = (string) $align;
373
374		return $this;
375		}
376
377
378		/**
379		* Has column some alignment?
380		* @return boolean [description]
381		*/
382		public function hasAlign()
383		{
384		return (bool) $this->align;
385		}
386
387
388		/**
389		* Get column alignment
390		* @return string
391		*/
392		public function getAlign()
393		{
394		return $this->align;
395		}
396
397
398		/**
399		* Set callback that will be called after inline editing
400		* @param callable $editable_callback
401		*/
402		public function setEditableCallback(callable $editable_callback)
403		{
404		$this->editable_callback = $editable_callback;
405
406		return $this;
407		}
408
409
410		/**
411		* Return callback that is used after inline editing
412		* @return callable
413		*/
414		public function getEditableCallback()
415		{
416		return $this->editable_callback;
417		}
418
419
420		/**
421		* Is column editable?
422		* @return boolean
423		*/
424		public function isEditable()
425		{
426		return (bool) $this->getEditableCallback();
427		}
428
429
430		/**
431		* Create link to custom destination
432		* @param string $href
433		* @param array $params
434		* @return string
435		* @throws DataGridHasToBeAttachedToPresenterComponentException
436		* @throws InvalidArgumentException
437		*/
438		protected function createLink($href, $params)
439		{
440		try {
441		$parent = $this->grid->getParent();
		0 ignored issues – show Documentation introduced 2016-02-25 10:55 UTC by Report Bug Copy Issue Report The property `grid` does not exist on `object<Ublaboo\DataGrid\Column\Column>`. Since you implemented `__get`, maybe consider adding a @property annotation. Since your code implements the magic getter `_get`, this function will be called for any read access on an undefined variable. You can add the `@property` annotation to your class or interface to document the existence of this variable. <?php /** * @property int $x * @property int $y * @property string $text */ class MyLabel { private $properties; private $allowedProperties = array('x', 'y', 'text'); public function __get($name) { if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) { return $properties[$name]; } else { return null; } } public function __set($name, $value) { if (in_array($name, $this->allowedProperties)) { $properties[$name] = $value; } else { throw new \LogicException("Property $name is not defined."); } } } If the property has read access only, you can use the @property-read annotation instead. Of course, you may also just have mistyped another name, in which case you should fix the error. See also the PhpDoc documentation for @property. Loading history...
442
443		return $parent->link($href, $params);
444		} catch (DataGridHasToBeAttachedToPresenterComponentException $e) {
		0 ignored issues – show Bug introduced 2016-02-22 07:53 UTC by Report Bug Copy Issue Report The class `Ublaboo\DataGrid\Column\...enterComponentException` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
445		$parent = $this->grid->getPresenter();
		0 ignored issues – show Documentation introduced 2016-02-25 10:55 UTC by Report Bug Copy Issue Report The property `grid` does not exist on `object<Ublaboo\DataGrid\Column\Column>`. Since you implemented `__get`, maybe consider adding a @property annotation. Since your code implements the magic getter `_get`, this function will be called for any read access on an undefined variable. You can add the `@property` annotation to your class or interface to document the existence of this variable. <?php /** * @property int $x * @property int $y * @property string $text */ class MyLabel { private $properties; private $allowedProperties = array('x', 'y', 'text'); public function __get($name) { if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) { return $properties[$name]; } else { return null; } } public function __set($name, $value) { if (in_array($name, $this->allowedProperties)) { $properties[$name] = $value; } else { throw new \LogicException("Property $name is not defined."); } } } If the property has read access only, you can use the @property-read annotation instead. Of course, you may also just have mistyped another name, in which case you should fix the error. See also the PhpDoc documentation for @property. Loading history...
446
447		} catch (InvalidArgumentException $e) {
448		$parent = $this->grid->getPresenter();
		0 ignored issues – show Documentation introduced 2016-02-25 10:55 UTC by Report Bug Copy Issue Report The property `grid` does not exist on `object<Ublaboo\DataGrid\Column\Column>`. Since you implemented `__get`, maybe consider adding a @property annotation. Since your code implements the magic getter `_get`, this function will be called for any read access on an undefined variable. You can add the `@property` annotation to your class or interface to document the existence of this variable. <?php /** * @property int $x * @property int $y * @property string $text */ class MyLabel { private $properties; private $allowedProperties = array('x', 'y', 'text'); public function __get($name) { if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) { return $properties[$name]; } else { return null; } } public function __set($name, $value) { if (in_array($name, $this->allowedProperties)) { $properties[$name] = $value; } else { throw new \LogicException("Property $name is not defined."); } } } If the property has read access only, you can use the @property-read annotation instead. Of course, you may also just have mistyped another name, in which case you should fix the error. See also the PhpDoc documentation for @property. Loading history...
449
450		}
451
452		return $parent->link($href, $params);
453		}
454
455		}
456

ublaboo / datagrid