HtmlTable::compile_once() - Code Metrics - Inspection of "mergeIdentiqualValues + toDelete on Table" - phpMv/phpMv-UI - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0a6efd...18e8f7 )

by Jean-Christophe

created 2017-11-04 00:29 UTC

HtmlTable::compile_once() A

↳ Parent: HtmlTable

Complexity

Conditions	3
Paths	4

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	3
eloc	6
nc	4
nop	2

<?php

namespace Ajax\semantic\html\collections\table;

use Ajax\semantic\html\base\HtmlSemDoubleElement;
use Ajax\semantic\html\content\table\HtmlTableContent;
use Ajax\semantic\html\base\constants\Variation;
use Ajax\JsUtils;

use Ajax\service\JArray;
use Ajax\semantic\html\content\table\HtmlTR;
use Ajax\semantic\html\collections\table\traits\TableTrait;
use Ajax\semantic\html\content\table\HtmlTD;
use Ajax\semantic\html\base\constants\TextAlignment;

/**
 * Semantic HTML Table component
 * @author jc
 *
 */
class HtmlTable extends HtmlSemDoubleElement {
	use TableTrait;
	private $_colCount;
	private $_compileParts;
	private $_footer;
	private $_afterCompileEvents;
	private $_activeRowSelector;

	public function __construct($identifier, $rowCount, $colCount) {
		parent::__construct($identifier, "table", "ui table");
		$this->content=array ();
		$this->setRowCount($rowCount, $colCount);
		$this->_variations=[ Variation::CELLED,Variation::PADDED,Variation::COMPACT ];
		$this->_compileParts=["thead","tbody","tfoot"];
		$this->_afterCompileEvents=[];
	}

	/**
	 * Returns/create eventually a part of the table corresponding to the $key : thead, tbody or tfoot
	 * @param string $key
	 * @return HtmlTableContent
	 */
	public function getPart($key) {
		if (\array_key_exists($key, $this->content) === false) {
			$this->content[$key]=new HtmlTableContent("", $key);
			if ($key !== "tbody") {
				$this->content[$key]->setRowCount(1, $this->_colCount);
			}
		}
		return $this->content[$key];
	}

	protected function _getFirstPart(){
		if(isset($this->content["thead"])){
			return $this->content["thead"];
		}
		return $this->content["tbody"];
	}


	/**
	 * Returns/create eventually the body of the table
	 * @return HtmlTableContent
	 */
	public function getBody() {
		return $this->getPart("tbody");
	}

	/**
	 * Returns the number of rows (TR)
	 * @return int
	 */
	public function getRowCount() {
		return $this->getPart("tbody")->count();
	}

	/**
	 * Returns/create eventually the header of the table
	 * @return HtmlTableContent
	 */
	public function getHeader() {
		return $this->getPart("thead");
	}

	/**
	 * Returns/create eventually the footer of the table
	 * @return \Ajax\semantic\html\content\table\HtmlTableContent
	 */
	public function getFooter() {
		return $this->getPart("tfoot");
	}

	/**
	 * Checks if the part corresponding to $key exists
	 * @param string $key
	 * @return boolean
	 */
	public function hasPart($key) {
		return \array_key_exists($key, $this->content) === true;
	}

	/**
	 *
	 * @param int $rowCount
	 * @param int $colCount
	 * @return HtmlTableContent
	 */
	public function setRowCount($rowCount, $colCount) {
		$this->_colCount=$colCount;
		return $this->getBody()->setRowCount($rowCount, $colCount);
	}

	/**
	 * Returns the cell (HtmlTD) at position $row,$col
	 * @param int $row
	 * @param int $col
	 * @return HtmlTD
	 */
	public function getCell($row, $col) {
		return $this->getBody()->getCell($row, $col);
	}

	/**
	 * Retuns the row at $rowIndex
	 * @param int $rowIndex
	 * @return HtmlTR
	 */
	public function getRow($rowIndex) {
		return $this->getBody()->getRow($rowIndex);
	}

	/**
	 * Adds a new row and sets $values to his cols
	 * @param array $values
	 * @return HtmlTR
	 */
	public function addRow($values=array()) {
		$row=$this->getBody()->addRow($this->_colCount);
		$row->setValues(\array_values($values));
		return $row;
	}

	/**
	 * adds and returns a new row
	 * @return HtmlTR
	 */
	public function newRow() {
		return $this->getBody()->newRow($this->_colCount);
	}

	/**
	 * Sets the tbody values
	 * @param array $values values in an array of array
	 * @return HtmlTable
	 */
	public function setValues($values=array()) {
		$this->getBody()->setValues($values);
		return $this;
	}

	/**
	 * Sets the header values
	 * @param array $values
	 * @return HtmlTableContent
	 */
	public function setHeaderValues($values=array()) {
		return $this->getHeader()->setValues($values);
	}

	/**
	 * Sets the footer values
	 * @param array $values
	 * @return HtmlTableContent
	 */
	public function setFooterValues($values=array()) {
		return $this->getFooter()->setValues($values);
	}

	/**
	 * Sets values to the col at index $colIndex
	 * @param int $colIndex
	 * @param array $values
	 * @return HtmlTable
	 */
	public function setColValues($colIndex, $values=array()) {
		$this->getBody()->setColValues($colIndex, $values);
		return $this;
	}

	/**
	 * Sets values to the row at index $rowIndex
	 * @param int $rowIndex
	 * @param array $values
	 * @return HtmlTable
	 */
	public function setRowValues($rowIndex, $values=array()) {
		$this->getBody()->setRowValues($rowIndex, $values);
		return $this;
	}

	public function addColVariations($colIndex, $variations=array()) {
		return $this->getBody()->addColVariations($colIndex, $variations);
	}

	/**
	 * Sets the col alignment to center
	 * @param int $colIndex
	 * @return HtmlTable
	 */
	public function colCenter($colIndex) {
		return $this->colAlign($colIndex, "colCenter");
	}

	/**
	 * Sets the col alignment to right
	 * @param int $colIndex
	 * @return HtmlTable
	 */
	public function colRight($colIndex) {
		return $this->colAlign($colIndex, "colRight");
	}

	/**
	 * Sets col alignment to left
	 * @param int $colIndex
	 * @return HtmlTable
	 */
	public function colLeft($colIndex) {
		return $this->colAlign($colIndex, "colLeft");
	}

	public function setColAlignment($colIndex,$alignment){
		switch ($alignment){
			case TextAlignment::LEFT:
				$function="colLeft";
				break;
			case TextAlignment::RIGHT:
				$function="colRight";
				break;
			case TextAlignment::CENTER:
				$function="colCenter";
				break;
			default:$function="colLeft";
switch ($expr) {
    default:
        doSomething(); //right
        break;
}


switch ($expr) {
    default:

        doSomething(); //wrong
        break;
}
		}
		$this->colAlign($colIndex, $function);
		return $this;
	}

	private function colAlign($colIndex, $function) {
		if (\is_array($colIndex)) {
			foreach ( $colIndex as $cIndex ) {
				$this->colAlign($cIndex, $function);
			}
		} else {
			if ($this->hasPart("thead")) {
				$this->getHeader()->$function($colIndex);
			}
			$this->getBody()->$function($colIndex);
		}
		return $this;
	}

	/**
	 * Applies a format on each cell when $callback returns true
	 * @param callable $callback function with the cell as parameter, must return a boolean
	 * @param string $format css class to apply
	 * @return HtmlTable
	 */
	public function conditionalCellFormat($callback, $format) {
		$this->getBody()->conditionalCellFormat($callback, $format);
		return $this;
	}

	/**
	 * Applies a format on each row when $callback returns true
	 * @param callable $callback function with the row as parameter, must return a boolean
	 * @param string $format css class to apply
	 * @return HtmlTable
	 */
	public function conditionalRowFormat($callback, $format) {
		$this->getBody()->conditionalRowFormat($callback, $format);
		return $this;
	}

	/**
	 * Applies a callback function on each cell
	 * @param callable $callback
	 * @return HtmlTable
	 */
	public function applyCells($callback) {
		$this->getBody()->applyCells($callback);
		return $this;
	}

	/**
	 * Applies a callback function on each row
	 * @param callable $callback
	 * @return HtmlTable
	 */
	public function applyRows($callback) {
		$this->getBody()->applyRows($callback);
		return $this;
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see HtmlSemDoubleElement::compile()
	 */
	public function compile(JsUtils $js=NULL, &$view=NULL) {
		if(\sizeof($this->_compileParts)<3){
			$this->_template="%content%";
			$this->refresh();
		}
		$this->content=JArray::sortAssociative($this->content, $this->_compileParts);
		return parent::compile($js, $view);
	}

	protected function compile_once(JsUtils $js=NULL, &$view=NULL) {
		parent::compile_once($js,$view);
		if ($this->propertyContains("class", "sortable")) {
			$this->addEvent("execute", "$('#" . $this->identifier . "').tablesort().data('tablesort').sort($('th.default-sort'));");
		}
		if(isset($this->_activeRowSelector)){
			$this->_activeRowSelector->compile();
		}
	}

	/**
	 *
	 * {@inheritDoc}
	 *
	 * @see BaseHtml::fromDatabaseObject()
	 */
	public function fromDatabaseObject($object, $function) {
		$result=$function($object);
		if (\is_array($result)) {
			$result= $this->addRow($function($object));
		} else {
			$result= $this->getBody()->_addRow($result);
		}
		if(isset($this->_afterCompileEvents["onNewRow"])){
			if(\is_callable($this->_afterCompileEvents["onNewRow"]))
				$this->_afterCompileEvents["onNewRow"]($result,$object);
		}
		return $result;
	}

	/**
	 * Sets the parts of the Table to compile
	 * @param array $parts array of thead,tbody,tfoot
	 * @return HtmlTable
	 */
	public function setCompileParts($parts=["tbody"]) {
		$this->_compileParts=$parts;
		return $this;
	}

	public function refresh(){
		$this->_footer=$this->getFooter();
		$this->addEvent("execute", '$("#'.$this->identifier.' tfoot").replaceWith("'.\addslashes($this->_footer).'");');
	}

	public function run(JsUtils $js){
		$result= parent::run($js);
		if(isset($this->_footer))
			$this->_footer->run($js);
		return $result;
	}

	/**
	 * The callback function called after the insertion of each row when fromDatabaseObjects is called
	 * callback function takes the parameters $row : the row inserted and $object: the instance of model used
	 * @param callable $callback
	 * @return HtmlTable
	 */
	public function onNewRow($callback) {
		$this->_afterCompileEvents["onNewRow"]=$callback;
		return $this;
	}

	/**
	 * Defines how a row is selectable
	 * @param string $class
	 * @param string $event
	 * @param boolean $multiple
	 * @return HtmlTable
	 */
	public function setActiveRowSelector($class="active",$event="click",$multiple=false){
		$this->_activeRowSelector=new ActiveRow($this,$class,$event,$multiple);
		return $this;
	}

	public function hideColumn($colIndex){
		if(isset($this->content["thead"])){
			$this->content["thead"]->hideColumn($colIndex);
		}
		$this->content["tbody"]->hideColumn($colIndex);
		if(isset($this->content["tfoot"])){
			$this->content["tfoot"]->hideColumn($colIndex);
		}
		return $this;
	}

	public function setColWidth($colIndex,$width){
		$part=$this->_getFirstPart();
		if($part!==null && $part->count()>0)
			$part->getCell(0, $colIndex)->setWidth($width);
		return $this;
	}

	public function setColWidths($widths){
		$part=$this->_getFirstPart();
		if($part!==null && $part->count()>0){
			$count=$part->getColCount();
			if(!\is_array($widths)){
				$widths=\array_fill(0, $count, $widths);
			}
			$max=\min(\sizeof($widths),$count);
			for($i=0;$i<$max;$i++){
				$part->getCell(0, $i)->setWidth($widths[$i]);
			}
		}
		return $this;
	}

	public function mergeIdentiqualValues($colIndex,$function="strip_tags"){
		$body=$this->getBody();
		$body->mergeIdentiqualValues($colIndex,$function);
		return $this;
	}
}


1			<?php
2
3			namespace Ajax\semantic\html\collections\table;
4
5			use Ajax\semantic\html\base\HtmlSemDoubleElement;
6			use Ajax\semantic\html\content\table\HtmlTableContent;
7			use Ajax\semantic\html\base\constants\Variation;
8			use Ajax\JsUtils;
9
10			use Ajax\service\JArray;
11			use Ajax\semantic\html\content\table\HtmlTR;
12			use Ajax\semantic\html\collections\table\traits\TableTrait;
13			use Ajax\semantic\html\content\table\HtmlTD;
14			use Ajax\semantic\html\base\constants\TextAlignment;
15
16			/**
17			* Semantic HTML Table component
18			* @author jc
19			*
20			*/
21			class HtmlTable extends HtmlSemDoubleElement {
22			use TableTrait;
23			private $_colCount;
24			private $_compileParts;
25			private $_footer;
26			private $_afterCompileEvents;
27			private $_activeRowSelector;
28
29			public function __construct($identifier, $rowCount, $colCount) {
30			parent::__construct($identifier, "table", "ui table");
31			$this->content=array ();
32			$this->setRowCount($rowCount, $colCount);
33			$this->_variations=[ Variation::CELLED,Variation::PADDED,Variation::COMPACT ];
34			$this->_compileParts=["thead","tbody","tfoot"];
35			$this->_afterCompileEvents=[];
36			}
37
38			/**
39			* Returns/create eventually a part of the table corresponding to the $key : thead, tbody or tfoot
40			* @param string $key
41			* @return HtmlTableContent
42			*/
43			public function getPart($key) {
44			if (\array_key_exists($key, $this->content) === false) {
45			$this->content[$key]=new HtmlTableContent("", $key);
46			if ($key !== "tbody") {
47			$this->content[$key]->setRowCount(1, $this->_colCount);
48			}
49			}
50			return $this->content[$key];
51			}
52
53			protected function _getFirstPart(){
54			if(isset($this->content["thead"])){
55			return $this->content["thead"];
56			}
57			return $this->content["tbody"];
58			}
59
60
61			/**
62			* Returns/create eventually the body of the table
63			* @return HtmlTableContent
64			*/
65			public function getBody() {
66			return $this->getPart("tbody");
67			}
68
69			/**
70			* Returns the number of rows (TR)
71			* @return int
72			*/
73			public function getRowCount() {
74			return $this->getPart("tbody")->count();
75			}
76
77			/**
78			* Returns/create eventually the header of the table
79			* @return HtmlTableContent
80			*/
81			public function getHeader() {
82			return $this->getPart("thead");
83			}
84
85			/**
86			* Returns/create eventually the footer of the table
87			* @return \Ajax\semantic\html\content\table\HtmlTableContent
88			*/
89			public function getFooter() {
90			return $this->getPart("tfoot");
91			}
92
93			/**
94			* Checks if the part corresponding to $key exists
95			* @param string $key
96			* @return boolean
97			*/
98			public function hasPart($key) {
99			return \array_key_exists($key, $this->content) === true;
100			}
101
102			/**
103			*
104			* @param int $rowCount
105			* @param int $colCount
106			* @return HtmlTableContent
107			*/
108			public function setRowCount($rowCount, $colCount) {
109			$this->_colCount=$colCount;
110			return $this->getBody()->setRowCount($rowCount, $colCount);
111			}
112
113			/**
114			* Returns the cell (HtmlTD) at position $row,$col
115			* @param int $row
116			* @param int $col
117			* @return HtmlTD
118			*/
119			public function getCell($row, $col) {
120			return $this->getBody()->getCell($row, $col);
121			}
122
123			/**
124			* Retuns the row at $rowIndex
125			* @param int $rowIndex
126			* @return HtmlTR
127			*/
128			public function getRow($rowIndex) {
129			return $this->getBody()->getRow($rowIndex);
130			}
131
132			/**
133			* Adds a new row and sets $values to his cols
134			* @param array $values
135			* @return HtmlTR
136			*/
137			public function addRow($values=array()) {
138			$row=$this->getBody()->addRow($this->_colCount);
139			$row->setValues(\array_values($values));
140			return $row;
141			}
142
143			/**
144			* adds and returns a new row
145			* @return HtmlTR
146			*/
147			public function newRow() {
148			return $this->getBody()->newRow($this->_colCount);
149			}
150
151			/**
152			* Sets the tbody values
153			* @param array $values values in an array of array
154			* @return HtmlTable
155			*/
156			public function setValues($values=array()) {
157			$this->getBody()->setValues($values);
158			return $this;
159			}
160
161			/**
162			* Sets the header values
163			* @param array $values
164			* @return HtmlTableContent
165			*/
166			public function setHeaderValues($values=array()) {
167			return $this->getHeader()->setValues($values);
168			}
169
170			/**
171			* Sets the footer values
172			* @param array $values
173			* @return HtmlTableContent
174			*/
175			public function setFooterValues($values=array()) {
176			return $this->getFooter()->setValues($values);
177			}
178
179			/**
180			* Sets values to the col at index $colIndex
181			* @param int $colIndex
182			* @param array $values
183			* @return HtmlTable
184			*/
185			public function setColValues($colIndex, $values=array()) {
186			$this->getBody()->setColValues($colIndex, $values);
187			return $this;
188			}
189
190			/**
191			* Sets values to the row at index $rowIndex
192			* @param int $rowIndex
193			* @param array $values
194			* @return HtmlTable
195			*/
196			public function setRowValues($rowIndex, $values=array()) {
197			$this->getBody()->setRowValues($rowIndex, $values);
198			return $this;
199			}
200
201			public function addColVariations($colIndex, $variations=array()) {
202			return $this->getBody()->addColVariations($colIndex, $variations);
203			}
204
205			/**
206			* Sets the col alignment to center
207			* @param int $colIndex
208			* @return HtmlTable
209			*/
210			public function colCenter($colIndex) {
211			return $this->colAlign($colIndex, "colCenter");
212			}
213
214			/**
215			* Sets the col alignment to right
216			* @param int $colIndex
217			* @return HtmlTable
218			*/
219			public function colRight($colIndex) {
220			return $this->colAlign($colIndex, "colRight");
221			}
222
223			/**
224			* Sets col alignment to left
225			* @param int $colIndex
226			* @return HtmlTable
227			*/
228			public function colLeft($colIndex) {
229			return $this->colAlign($colIndex, "colLeft");
230			}
231
232			public function setColAlignment($colIndex,$alignment){
233			switch ($alignment){
234			case TextAlignment::LEFT:
235			$function="colLeft";
236			break;
237			case TextAlignment::RIGHT:
238			$function="colRight";
239			break;
240			case TextAlignment::CENTER:
241			$function="colCenter";
242			break;
243			default:$function="colLeft";
			0 ignored issues – show Coding Style introduced 2017-10-21 17:13 UTC by Report Bug Copy Issue Report The default body in a switch statement must start on the line following the statement. According to the PSR-2, the body of a default statement must start on the line immediately following the statement. switch ($expr) { default: doSomething(); //right break; } switch ($expr) { default: doSomething(); //wrong break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
244			}
245			$this->colAlign($colIndex, $function);
246			return $this;
247			}
248
249			private function colAlign($colIndex, $function) {
250			if (\is_array($colIndex)) {
251			foreach ( $colIndex as $cIndex ) {
252			$this->colAlign($cIndex, $function);
253			}
254			} else {
255			if ($this->hasPart("thead")) {
256			$this->getHeader()->$function($colIndex);
257			}
258			$this->getBody()->$function($colIndex);
259			}
260			return $this;
261			}
262
263			/**
264			* Applies a format on each cell when $callback returns true
265			* @param callable $callback function with the cell as parameter, must return a boolean
266			* @param string $format css class to apply
267			* @return HtmlTable
268			*/
269			public function conditionalCellFormat($callback, $format) {
270			$this->getBody()->conditionalCellFormat($callback, $format);
271			return $this;
272			}
273
274			/**
275			* Applies a format on each row when $callback returns true
276			* @param callable $callback function with the row as parameter, must return a boolean
277			* @param string $format css class to apply
278			* @return HtmlTable
279			*/
280			public function conditionalRowFormat($callback, $format) {
281			$this->getBody()->conditionalRowFormat($callback, $format);
282			return $this;
283			}
284
285			/**
286			* Applies a callback function on each cell
287			* @param callable $callback
288			* @return HtmlTable
289			*/
290			public function applyCells($callback) {
291			$this->getBody()->applyCells($callback);
292			return $this;
293			}
294
295			/**
296			* Applies a callback function on each row
297			* @param callable $callback
298			* @return HtmlTable
299			*/
300			public function applyRows($callback) {
301			$this->getBody()->applyRows($callback);
302			return $this;
303			}
304
305			/**
306			*
307			* {@inheritDoc}
308			*
309			* @see HtmlSemDoubleElement::compile()
310			*/
311			public function compile(JsUtils $js=NULL, &$view=NULL) {
312			if(\sizeof($this->_compileParts)<3){
313			$this->_template="%content%";
314			$this->refresh();
315			}
316			$this->content=JArray::sortAssociative($this->content, $this->_compileParts);
317			return parent::compile($js, $view);
318			}
319
320			protected function compile_once(JsUtils $js=NULL, &$view=NULL) {
321			parent::compile_once($js,$view);
322			if ($this->propertyContains("class", "sortable")) {
323			$this->addEvent("execute", "$('#" . $this->identifier . "').tablesort().data('tablesort').sort($('th.default-sort'));");
324			}
325			if(isset($this->_activeRowSelector)){
326			$this->_activeRowSelector->compile();
327			}
328			}
329
330			/**
331			*
332			* {@inheritDoc}
333			*
334			* @see BaseHtml::fromDatabaseObject()
335			*/
336			public function fromDatabaseObject($object, $function) {
337			$result=$function($object);
338			if (\is_array($result)) {
339			$result= $this->addRow($function($object));
340			} else {
341			$result= $this->getBody()->_addRow($result);
342			}
343			if(isset($this->_afterCompileEvents["onNewRow"])){
344			if(\is_callable($this->_afterCompileEvents["onNewRow"]))
345			$this->_afterCompileEvents["onNewRow"]($result,$object);
346			}
347			return $result;
348			}
349
350			/**
351			* Sets the parts of the Table to compile
352			* @param array $parts array of thead,tbody,tfoot
353			* @return HtmlTable
354			*/
355			public function setCompileParts($parts=["tbody"]) {
356			$this->_compileParts=$parts;
357			return $this;
358			}
359
360			public function refresh(){
361			$this->_footer=$this->getFooter();
362			$this->addEvent("execute", '$("#'.$this->identifier.' tfoot").replaceWith("'.\addslashes($this->_footer).'");');
363			}
364
365			public function run(JsUtils $js){
366			$result= parent::run($js);
367			if(isset($this->_footer))
368			$this->_footer->run($js);
369			return $result;
370			}
371
372			/**
373			* The callback function called after the insertion of each row when fromDatabaseObjects is called
374			* callback function takes the parameters $row : the row inserted and $object: the instance of model used
375			* @param callable $callback
376			* @return HtmlTable
377			*/
378			public function onNewRow($callback) {
379			$this->_afterCompileEvents["onNewRow"]=$callback;
380			return $this;
381			}
382
383			/**
384			* Defines how a row is selectable
385			* @param string $class
386			* @param string $event
387			* @param boolean $multiple
388			* @return HtmlTable
389			*/
390			public function setActiveRowSelector($class="active",$event="click",$multiple=false){
391			$this->_activeRowSelector=new ActiveRow($this,$class,$event,$multiple);
392			return $this;
393			}
394
395			public function hideColumn($colIndex){
396			if(isset($this->content["thead"])){
397			$this->content["thead"]->hideColumn($colIndex);
398			}
399			$this->content["tbody"]->hideColumn($colIndex);
400			if(isset($this->content["tfoot"])){
401			$this->content["tfoot"]->hideColumn($colIndex);
402			}
403			return $this;
404			}
405
406			public function setColWidth($colIndex,$width){
407			$part=$this->_getFirstPart();
408			if($part!==null && $part->count()>0)
409			$part->getCell(0, $colIndex)->setWidth($width);
410			return $this;
411			}
412
413			public function setColWidths($widths){
414			$part=$this->_getFirstPart();
415			if($part!==null && $part->count()>0){
416			$count=$part->getColCount();
417			if(!\is_array($widths)){
418			$widths=\array_fill(0, $count, $widths);
419			}
420			$max=\min(\sizeof($widths),$count);
421			for($i=0;$i<$max;$i++){
422			$part->getCell(0, $i)->setWidth($widths[$i]);
423			}
424			}
425			return $this;
426			}
427
428			public function mergeIdentiqualValues($colIndex,$function="strip_tags"){
429			$body=$this->getBody();
430			$body->mergeIdentiqualValues($colIndex,$function);
431			return $this;
432			}
433			}
434

phpMv / phpMv-UI

Push — master ( 0a6efd...18e8f7 )

HtmlTable::compile_once() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like