Thnaks
Tanvir.

Thanks a Lot.

class MSSSimpleXML {

const URL = 1;
const STRING = 2;
const SIMPLEXML = 3;

…

function MSSSimpleXML($data, $mode=self::STRING ) {

switch ($mode)
{
case self::STRING:
…
break;

case self::URL:
…
break;

case self::SIMPLEXML:
…
break;
}
}
…
}

Makes default constructor assume STRING.

Usage:

// constructor where data is xml in string form
$xml = new MSSSimpleXML( $data );

// same
$xml = new MSSSimpleXML( $data, MSSSimpleXML::STRING );

// constructor where data is url pointing to xml
$xml = new MSSSimpleXML( $data, MSSSimpleXML::URL );

// constructor where data is SimpleXMLElement object
$xml = new MSSSimpleXML( $data, MSSSimpleXML::SIMPLEXML );

If you had additional arguments that varied by mode you could add an associative array of arguments…

peace,
-Forsyth

class MSSSimpleXML {
const URL = 1;
const STRING = 2;
const SIMPLEXML = 3;

function MSSSimpleXML( $xml, $mode ) {
…
}
}

Usage:

…
new MSSSimpleXML( $xml, MSSSimpleXML::STRING );
…

Would be cleaner I think.

The magic methods make me feel a bit queasy.

One solution that dawned on me this morning is to keep a single method but add booleans to dictate the “type”.

For example, my original constructor:

class MSSSimpleXML {
function MSSSimpleXML($data, $isURL = FALSE) {
…
}
}

The purpose of this class is to wrap a SimpleXMLElement object. The constructor allowed you to say whether $data was a URL or an XML string.

Now I wanted a constructor that would allow you to construct a MSSSimpleXML object from a php SimpleXMLElement.

Constructor overloading would have been perfect but instead settled on this:

function MSSSimpleXML($data, $isURL = FALSE, $isSimpleXML = FALSE)

The constructor now has three modes:

1. Build an object from an XML string ($data=[the string], $isURL=FALSE, $isSimpleXML=FALSE)

2. Build an object from a URL that points to XML ($data=[the URL], $isURL=TRUE, $isSimpleXML=FALSE)

3. Build an object from a SimpleXMLElement object ($data=[the SimpleXMLElement instance, $isURL=FALSE, $isSimpleXML=TRUE)

Not terribly beautiful. (It would have to be late and I’d have to be drunk to…)

But…very simple — which is what PHP is all about.

peace,
-Forsyth

Please clean up blog entries. I posted some PHP code but it didn’t escape the content so greater than and less than signs for example are rendering the code for Polad incorrectly. Also, the blog posts an entry *before* you enter the captcha which defeats the purpose of having a captcha. Consequently, there are 2 almost identical blog posts– second one is correct.

Okay here is the code again….

class Word {
	// ...
}

class ExtWord extends Word {
	// ...
}

class MyClass {

	// Method Signature Overloading (Polymorphism)
	function __call($method, $parameters) {
		foreach (get_class_methods(__CLASS__) as $class_method) {
			if (preg_match('/'.$method.'\d+/', $class_method)) {
				$reflect_method = new ReflectionMethod(__CLASS__, $class_method);
				if (count($parameters) == $reflect_method->getNumberOfParameters()) {
					$class_parameters = $reflect_method->getParameters();
					for ($p=0; $p<count($parameters); $p++) {
						if (get_class($parameters[$p]) == $class_parameters[$p]->getClass()->getName()) {
							if ($p == count($parameters)-1) {
								call_user_func_array(array(&$this, $class_method), $parameters);
								break 2; // Method Signature Match
							}
						} else {
							break;
						}
					}
				}
			}
		}
	}

	function hello2(Word $word) {
		// ...
	}

	function hello3(ExtWord $extWord) {
		// ...
	}
}

$myClass = new MyClass();

$myClass->hello(new Word());
$myClass->hello(new ExtWord());

Polad, if you still cannot copy the code correctly then shoot me an email at michaelnino.com and I’d be glad to reply with code or chat!

Mike :-)