SaxParser - Code Metrics - Inspection of "Merge pull request #501 from geekwright/php710a3" - XOOPS/XoopsCore - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3e5da4...d14e75 )

by Michael

created 2016-07-14 08:51 UTC

SaxParser B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	373
Duplicated Lines	2.68 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

32.42%

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
dl	10
loc	373
ccs	36
cts	111
cp	0.3242
rs	8.295
c	3
b	0
f	0
wmc	42
lcom	2
cbo	1

25 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	16	1
A	getCurrentLevel()	0	4	1
A	setCaseFolding()	0	7	1
A	useIsoEncoding()	0	5	1
A	useAsciiEncoding()	0	5	1
A	useUtfEncoding()	0	5	1
A	getCurrentTag()	0	4	1
A	getParentTag()	0	7	2
B	parse()	0	23	5
A	free()	0	4	1
A	getXmlError()	0	4	1
A	addTagHandler()	0	11	3
A	handleBeginElement()	5	10	3
A	handleEndElement()	5	10	3
A	handleCharacterData()	0	9	4
A	handleProcessingInstruction()	0	6	1
A	handleDefault()	0	4	1
A	handleUnparsedEntityDecl()	0	4	1
A	handleNotationDecl()	0	4	1
A	handleExternalEntityRef()	0	4	1
A	handleBeginElementDefault()	0	3	1
A	handleEndElementDefault()	0	3	1
A	handleCharacterDataDefault()	0	3	1
A	setErrors()	0	4	1
A	getErrors()	0	14	4

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 SaxParser 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 SaxParser, and based on these observations, apply Extract Interface, too.

<?php

/**
 *
 * Location: xml/SaxParser.class
 *
 * Provides basic functionality to read and parse XML documents.  Subclasses
 * must implement all the their custom handlers by using add* function methods.
 * They may also use the handle*() methods to parse a specific XML begin and end
 * tags, but this is not recommended as it is more difficult.
 *
 * Copyright &copy; 2001 eXtremePHP.  All rights reserved.
 *
 * @author Ken Egervari
 */

class SaxParser
{
    public $level;
    public $parser;

    public $isCaseFolding;
    public $targetEncoding;

    /* Custom Handler Variables */
    public $tagHandlers = array();

    /* Tag stack */
    public $tags = array();

    /* Xml Source Input */
    public $xmlInput;

    public $errors = array();

    /**
     * Creates a SaxParser object using a FileInput to represent the stream
     * of XML data to parse.  Use the static methods createFileInput or
     * createStringInput to construct xml input source objects to supply
     * to the constructor, or the implementor can construct them individually.
     *
     * @param $input
     */
    public function __construct(&$input)
    {
        $this->level = 0;
        $this->parser = xml_parser_create('UTF-8');
        xml_set_object($this->parser, $this);
        $this->input = $input;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->setCaseFolding(false);
        $this->useUtfEncoding();
        xml_set_element_handler($this->parser, 'handleBeginElement', 'handleEndElement');
        xml_set_character_data_handler($this->parser, 'handleCharacterData');
        xml_set_processing_instruction_handler($this->parser, 'handleProcessingInstruction');
        xml_set_default_handler($this->parser, 'handleDefault');
        xml_set_unparsed_entity_decl_handler($this->parser, 'handleUnparsedEntityDecl');
        xml_set_notation_decl_handler($this->parser, 'handleNotationDecl');
        xml_set_external_entity_ref_handler($this->parser, 'handleExternalEntityRef');
    }

    /*---------------------------------------------------------------------------
        Property Methods
    ---------------------------------------------------------------------------*/

    /**
     * @return int
     */
    public function getCurrentLevel()
    {
        return $this->level;
    }

    /**
     * @param boolean $isCaseFolding
     * @return void
     */
    public function setCaseFolding($isCaseFolding)
    {
        assert(is_bool($isCaseFolding));

        $this->isCaseFolding = $isCaseFolding;
        xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, $this->isCaseFolding);
    }

    /**
     * @return void
     */
    public function useIsoEncoding()
    {
        $this->targetEncoding = 'ISO-8859-1';
        xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, $this->targetEncoding);
    }

    /**
     * @return void
     */
    public function useAsciiEncoding()
    {
        $this->targetEncoding = 'US-ASCII';
        xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, $this->targetEncoding);
    }

    /**
     * @return void
     */
    public function useUtfEncoding()
    {
        $this->targetEncoding = 'UTF-8';
        xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, $this->targetEncoding);
    }

    /**
     * Returns the name of the xml tag being parsed
     * @return string
     */
    public function getCurrentTag()
    {
        return $this->tags[count($this->tags) - 1];
    }

    public function getParentTag()
    {
        if (isset($this->tags[count($this->tags) - 2])) {
            return $this->tags[count($this->tags) - 2];
        }
        return false;
    }


    /*---------------------------------------------------------------------------
        Parser methods
    ---------------------------------------------------------------------------*/

    /**
     * @return bool
     */
    public function parse()
    {
        if (!is_resource($this->input)) {
            if (!xml_parse($this->parser, $this->input)) {
                $this->setErrors($this->getXmlError());
                return false;
            }
            //if (!$fp = fopen($this->input, 'r')) {
            //    $this->setErrors('Could not open file: '.$this->input);
            //    return false;
            //}
        } else {
            while ($data = fread($this->input, 4096)) {
                if (!xml_parse($this->parser, str_replace("'", "&apos;", $data), feof($this->input))) {
                    $this->setErrors($this->getXmlError());
                    fclose($this->input);
                    return false;
                }
            }
            fclose($this->input);
        }
        return true;
    }

    /**
     * @return void
     */
    public function free()
    {
        xml_parser_free($this->parser);
    }

    /**
     * @private
     * @return string
     */
    public function getXmlError()
    {
        return sprintf("XmlParse error: %s at line %d", xml_error_string(xml_get_error_code($this->parser)), xml_get_current_line_number($this->parser));
    }

    /*---------------------------------------------------------------------------
        Custom Handler Methods
    ---------------------------------------------------------------------------*/

    /**
     * Adds a callback function to be called when a tag is encountered.<br>
     * @param XmlTagHandler $tagHandler
     * @return void
     */
    public function addTagHandler(XmlTagHandler $tagHandler)
    {
        $name = $tagHandler->getName();
        if (is_array($name)) {
            foreach ($name as $n) {
                $this->tagHandlers[$n] = $tagHandler;
            }
        } else {
            $this->tagHandlers[$name] = $tagHandler;
        }
    }


    /*---------------------------------------------------------------------------
        Private Handler Methods
    ---------------------------------------------------------------------------*/

    /**
     * Callback function that executes whenever a the start of a tag
     * occurs when being parsed.
     * @param int    $parser          The handle to the parser.
     * @param string $tagName         The name of the tag currently being parsed.
     * @param array  $attributesArray The list of attributes associated with the tag.
     * @private
     * @return void
     */
    public function handleBeginElement($parser, $tagName, $attributesArray)
    {
        array_push($this->tags, $tagName);
        $this->level++;
        if (isset($this->tagHandlers[$tagName]) && is_subclass_of($this->tagHandlers[$tagName], 'xmltaghandler')) {
            $this->tagHandlers[$tagName]->handleBeginElement($this, $attributesArray);
        } else {
            $this->handleBeginElementDefault($parser, $tagName, $attributesArray);
        }
    }

    /**
     * Callback function that executes whenever the end of a tag
     * occurs when being parsed.
     * @param int    $parser  The handle to the parser.
     * @param string $tagName The name of the tag currently being parsed.
     * @private
     * @return void
     */
    public function handleEndElement($parser, $tagName)
    {
        array_pop($this->tags);
        if (isset($this->tagHandlers[$tagName]) && is_subclass_of($this->tagHandlers[$tagName], 'xmltaghandler')) {
            $this->tagHandlers[$tagName]->handleEndElement($this);
        } else {
            $this->handleEndElementDefault($parser, $tagName);
        }
        $this->level--;
    }

    /**
     * Callback function that executes whenever character data is encountered
     * while being parsed.
     * @param int    $parser The handle to the parser.
     * @param string $data   Character data inside the tag
     * @return void
     */
    public function handleCharacterData($parser, $data)
    {
        $tagHandler = isset($this->tagHandlers[$this->getCurrentTag()]) ? $this->tagHandlers[$this->getCurrentTag()] : null;
        if (null != $tagHandler && is_subclass_of($tagHandler, 'xmltaghandler')) {
            $tagHandler->handleCharacterData($this, $data);
        } else {
            $this->handleCharacterDataDefault($parser, $data);
        }
    }

    /**
     * @param int $parser The handle to the parser.
     * @param $target
     * @param $data
     * @return void
     */
    public function handleProcessingInstruction($parser, &$target, &$data)

    {
        //        if($target == 'php') {
        //            eval($data);
        //        }
    }

    /**
     * @param $parser
     * @param $data
     * @return void
     */
    public function handleDefault($parser, $data)

    {

    }

    /**
     * @param $parser
     * @param $entityName
     * @param $base
     * @param $systemId
     * @param $publicId
     * @param $notationName
     * @return void
     */
    public function handleUnparsedEntityDecl($parser, $entityName, $base, $systemId, $publicId, $notationName)

    {

    }

    /**
     * @param $parser
     * @param $notationName
     * @param $base
     * @param $systemId
     * @param $publicId
     * @return void
     */
    public function handleNotationDecl($parser, $notationName, $base, $systemId, $publicId)

    {

    }

    /**
     * @param $parser
     * @param $openEntityNames
     * @param $base
     * @param $systemId
     * @param $publicId
     * @return void
     */
    public function handleExternalEntityRef($parser, $openEntityNames, $base, $systemId, $publicId)

    {

    }

    /**
     * The default tag handler method for a tag with no handler
     *
     * @param $parser
     * @param $tagName
     * @param $attributesArray
     * @return void
     */
    public function handleBeginElementDefault($parser, $tagName, $attributesArray)

    {
    }

    /**
     * The default tag handler method for a tag with no handler
     *
     * @param $parser
     * @param $tagName
     * @return void
     */
    public function handleEndElementDefault($parser, $tagName)

    {
    }

    /**
     * The default tag handler method for a tag with no handler
     *
     * @abstract
     *
     * @param $parser
     * @param $data
     * @return void
     */
    public function handleCharacterDataDefault($parser, $data)

    {
    }

    /**
     * Sets error messages
     *
     * @param    string $error    string    an error message
     */
    public function setErrors($error)
    {
        $this->errors[] = trim($error);
    }

    /**
     * Gets all the error messages
     *
     * @param bool $ashtml return as html?
     * @return mixed
     */
    public function getErrors($ashtml = true)
    {
        if (!$ashtml) {
            return $this->errors;
        } else {
            $ret = '';
            if (count($this->errors) > 0) {
                foreach ($this->errors as $error) {
                    $ret .= $error . '<br />';
                }
            }
            return $ret;
        }
    }
}


1			<?php
2
3			/**
4			*
5			* Location: xml/SaxParser.class
6			*
7			* Provides basic functionality to read and parse XML documents. Subclasses
8			* must implement all the their custom handlers by using add* function methods.
9			* They may also use the handle*() methods to parse a specific XML begin and end
10			* tags, but this is not recommended as it is more difficult.
11			*
12			* Copyright © 2001 eXtremePHP. All rights reserved.
13			*
14			* @author Ken Egervari
15			*/
16
17			class SaxParser
18			{
19			public $level;
20			public $parser;
21
22			public $isCaseFolding;
23			public $targetEncoding;
24
25			/* Custom Handler Variables */
26			public $tagHandlers = array();
27
28			/* Tag stack */
29			public $tags = array();
30
31			/* Xml Source Input */
32			public $xmlInput;
33
34			public $errors = array();
35
36			/**
37			* Creates a SaxParser object using a FileInput to represent the stream
38			* of XML data to parse. Use the static methods createFileInput or
39			* createStringInput to construct xml input source objects to supply
40			* to the constructor, or the implementor can construct them individually.
41			*
42			* @param $input
43			*/
44	60		public function __construct(&$input)
45			{
46	60		$this->level = 0;
47	60		$this->parser = xml_parser_create('UTF-8');
48	60		xml_set_object($this->parser, $this);
49	60		$this->input = $input;
			0 ignored issues – show Bug introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The property `input` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
50	60		$this->setCaseFolding(false);
51	60		$this->useUtfEncoding();
52	60		xml_set_element_handler($this->parser, 'handleBeginElement', 'handleEndElement');
53	60		xml_set_character_data_handler($this->parser, 'handleCharacterData');
54	60		xml_set_processing_instruction_handler($this->parser, 'handleProcessingInstruction');
55	60		xml_set_default_handler($this->parser, 'handleDefault');
56	60		xml_set_unparsed_entity_decl_handler($this->parser, 'handleUnparsedEntityDecl');
57	60		xml_set_notation_decl_handler($this->parser, 'handleNotationDecl');
58	60		xml_set_external_entity_ref_handler($this->parser, 'handleExternalEntityRef');
59	60		}
60
61			/*---------------------------------------------------------------------------
62			Property Methods
63			---------------------------------------------------------------------------*/
64
65			/**
66			* @return int
67			*/
68	4		public function getCurrentLevel()
69			{
70	4		return $this->level;
71			}
72
73			/**
74			* @param boolean $isCaseFolding
75			* @return void
76			*/
77	60		public function setCaseFolding($isCaseFolding)
78			{
79	60		assert(is_bool($isCaseFolding));
80
81	60		$this->isCaseFolding = $isCaseFolding;
82	60		xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, $this->isCaseFolding);
83	60		}
84
85			/**
86			* @return void
87			*/
88			public function useIsoEncoding()
89			{
90			$this->targetEncoding = 'ISO-8859-1';
91			xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, $this->targetEncoding);
92			}
93
94			/**
95			* @return void
96			*/
97			public function useAsciiEncoding()
98			{
99			$this->targetEncoding = 'US-ASCII';
100			xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, $this->targetEncoding);
101			}
102
103			/**
104			* @return void
105			*/
106	60		public function useUtfEncoding()
107			{
108	60		$this->targetEncoding = 'UTF-8';
109	60		xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, $this->targetEncoding);
110	60		}
111
112			/**
113			* Returns the name of the xml tag being parsed
114			* @return string
115			*/
116			public function getCurrentTag()
117			{
118			return $this->tags[count($this->tags) - 1];
119			}
120
121	11		public function getParentTag()
122			{
123	11		if (isset($this->tags[count($this->tags) - 2])) {
124	11		return $this->tags[count($this->tags) - 2];
125			}
126			return false;
127			}
128
129
130			/*---------------------------------------------------------------------------
131			Parser methods
132			---------------------------------------------------------------------------*/
133
134			/**
135			* @return bool
136			*/
137			public function parse()
138			{
139			if (!is_resource($this->input)) {
140			if (!xml_parse($this->parser, $this->input)) {
141			$this->setErrors($this->getXmlError());
142			return false;
143			}
144			//if (!$fp = fopen($this->input, 'r')) {
145			// $this->setErrors('Could not open file: '.$this->input);
146			// return false;
147			//}
148			} else {
149			while ($data = fread($this->input, 4096)) {
150			if (!xml_parse($this->parser, str_replace("'", "'", $data), feof($this->input))) {
151			$this->setErrors($this->getXmlError());
152			fclose($this->input);
153			return false;
154			}
155			}
156			fclose($this->input);
157			}
158			return true;
159			}
160
161			/**
162			* @return void
163			*/
164			public function free()
165			{
166			xml_parser_free($this->parser);
167			}
168
169			/**
170			* @private
171			* @return string
172			*/
173			public function getXmlError()
174			{
175			return sprintf("XmlParse error: %s at line %d", xml_error_string(xml_get_error_code($this->parser)), xml_get_current_line_number($this->parser));
176			}
177
178			/*---------------------------------------------------------------------------
179			Custom Handler Methods
180			---------------------------------------------------------------------------*/
181
182			/**
183			* Adds a callback function to be called when a tag is encountered.<br>
184			* @param XmlTagHandler $tagHandler
185			* @return void
186			*/
187	60		public function addTagHandler(XmlTagHandler $tagHandler)
188			{
189	60		$name = $tagHandler->getName();
190	60		if (is_array($name)) {
191	35		foreach ($name as $n) {
192	35		$this->tagHandlers[$n] = $tagHandler;
193			}
194			} else {
195	60		$this->tagHandlers[$name] = $tagHandler;
196			}
197	60		}
198
199
200			/*---------------------------------------------------------------------------
201			Private Handler Methods
202			---------------------------------------------------------------------------*/
203
204			/**
205			* Callback function that executes whenever a the start of a tag
206			* occurs when being parsed.
207			* @param int $parser The handle to the parser.
208			* @param string $tagName The name of the tag currently being parsed.
209			* @param array $attributesArray The list of attributes associated with the tag.
210			* @private
211			* @return void
212			*/
213			public function handleBeginElement($parser, $tagName, $attributesArray)
214			{
215			array_push($this->tags, $tagName);
216			$this->level++;
217		View Code Duplication	if (isset($this->tagHandlers[$tagName]) && is_subclass_of($this->tagHandlers[$tagName], 'xmltaghandler')) {
218			$this->tagHandlers[$tagName]->handleBeginElement($this, $attributesArray);
219			} else {
220			$this->handleBeginElementDefault($parser, $tagName, $attributesArray);
221			}
222			}
223
224			/**
225			* Callback function that executes whenever the end of a tag
226			* occurs when being parsed.
227			* @param int $parser The handle to the parser.
228			* @param string $tagName The name of the tag currently being parsed.
229			* @private
230			* @return void
231			*/
232			public function handleEndElement($parser, $tagName)
233			{
234			array_pop($this->tags);
235		View Code Duplication	if (isset($this->tagHandlers[$tagName]) && is_subclass_of($this->tagHandlers[$tagName], 'xmltaghandler')) {
236			$this->tagHandlers[$tagName]->handleEndElement($this);
237			} else {
238			$this->handleEndElementDefault($parser, $tagName);
239			}
240			$this->level--;
241			}
242
243			/**
244			* Callback function that executes whenever character data is encountered
245			* while being parsed.
246			* @param int $parser The handle to the parser.
247			* @param string $data Character data inside the tag
248			* @return void
249			*/
250			public function handleCharacterData($parser, $data)
251			{
252			$tagHandler = isset($this->tagHandlers[$this->getCurrentTag()]) ? $this->tagHandlers[$this->getCurrentTag()] : null;
253			if (null != $tagHandler && is_subclass_of($tagHandler, 'xmltaghandler')) {
254			$tagHandler->handleCharacterData($this, $data);
255			} else {
256			$this->handleCharacterDataDefault($parser, $data);
257			}
258			}
259
260			/**
261			* @param int $parser The handle to the parser.
262			* @param $target
263			* @param $data
264			* @return void
265			*/
266			public function handleProcessingInstruction($parser, &$target, &$data)
			0 ignored issues – show Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$parser` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$target` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$data` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
267			{
268			// if($target == 'php') {
269			// eval($data);
270			// }
271			}
272
273			/**
274			* @param $parser
275			* @param $data
276			* @return void
277			*/
278			public function handleDefault($parser, $data)
			0 ignored issues – show Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$parser` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$data` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
279			{
280
281			}
282
283			/**
284			* @param $parser
285			* @param $entityName
286			* @param $base
287			* @param $systemId
288			* @param $publicId
289			* @param $notationName
290			* @return void
291			*/
292			public function handleUnparsedEntityDecl($parser, $entityName, $base, $systemId, $publicId, $notationName)
			0 ignored issues – show Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$parser` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$entityName` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$base` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$systemId` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$publicId` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$notationName` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
293			{
294
295			}
296
297			/**
298			* @param $parser
299			* @param $notationName
300			* @param $base
301			* @param $systemId
302			* @param $publicId
303			* @return void
304			*/
305			public function handleNotationDecl($parser, $notationName, $base, $systemId, $publicId)
			0 ignored issues – show Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$parser` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$notationName` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$base` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$systemId` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$publicId` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
306			{
307
308			}
309
310			/**
311			* @param $parser
312			* @param $openEntityNames
313			* @param $base
314			* @param $systemId
315			* @param $publicId
316			* @return void
317			*/
318			public function handleExternalEntityRef($parser, $openEntityNames, $base, $systemId, $publicId)
			0 ignored issues – show Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$parser` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$openEntityNames` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$base` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$systemId` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$publicId` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
319			{
320
321			}
322
323			/**
324			* The default tag handler method for a tag with no handler
325			*
326			* @param $parser
327			* @param $tagName
328			* @param $attributesArray
329			* @return void
330			*/
331			public function handleBeginElementDefault($parser, $tagName, $attributesArray)
			0 ignored issues – show Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$parser` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$tagName` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$attributesArray` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
332			{
333			}
334
335			/**
336			* The default tag handler method for a tag with no handler
337			*
338			* @param $parser
339			* @param $tagName
340			* @return void
341			*/
342			public function handleEndElementDefault($parser, $tagName)
			0 ignored issues – show Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$parser` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$tagName` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
343			{
344			}
345
346			/**
347			* The default tag handler method for a tag with no handler
348			*
349			* @abstract
350			*
351			* @param $parser
352			* @param $data
353			* @return void
354			*/
355			public function handleCharacterDataDefault($parser, $data)
			0 ignored issues – show Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$parser` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history... Unused Code introduced 2015-12-12 03:50 UTC by Report Bug Copy Issue Report The parameter `$data` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
356			{
357			}
358
359			/**
360			* Sets error messages
361			*
362			* @param string $error string an error message
363			*/
364			public function setErrors($error)
365			{
366			$this->errors[] = trim($error);
367			}
368
369			/**
370			* Gets all the error messages
371			*
372			* @param bool $ashtml return as html?
373			* @return mixed
374			*/
375			public function getErrors($ashtml = true)
376			{
377			if (!$ashtml) {
378			return $this->errors;
379			} else {
380			$ret = '';
381			if (count($this->errors) > 0) {
382			foreach ($this->errors as $error) {
383			$ret .= $error . '<br />';
384			}
385			}
386			return $ret;
387			}
388			}
389			}
390

XOOPS / XoopsCore