Object Oriented Programming

[DarrylMillar]

Okay, I really need some help here, lol. This may be a bit long, but it's really important that I get this going soon.

Basically, what I'm trying to do is build an API that has built-in and extendable sub-API classes.

API is a class, and within are some basic functions that all of the sub-APIs need to call, like confGetKey, ect. Now, all of the sub-APIs should be contained within the main API class, so calling something in a subAPI would work like $API->subAPI->someFunction();.

Now, here's were it gets tricky. As I already said, subAPI needs to make calls to some base API functions. So, subAPI->someFunction(); needs to get a confKey from the base class using the function confGetKey. Also, inside some of subAPI's functions, calls need to be made to other subAPIs. The thing is, all of these sub-APIs have their own properties, and only one of each should be made.

So, my initial idea, was to do something like this:

$API->subAPI = new subAPI(&$API);

Then, in subAPI's constructor, the reference to $API would be stored, and then I would make a call like $this->API->otherSubAPI->function inside of the sub-API. But, and maybe I did it wrong, I was getting call-time pass-by-reference errors, and then it told me that I was calling a method of a non-object.

So, that's my dilemma. I've read a bunch of tutorials and articles on OOP in PHP, and have yet to find a suitable way to create this kind of hierarchy.

Is there any other decent ways to do this that don't require hacks and work-arounds? I want this to be a very very solid API/framework that will basically be self contained.

Thank you in advance for any advice you can offer.

Regards,

Darryl Millar

[DarrylMillar]

Okay, I've got something figured out here.

<?php
class mainClass
{
	var $testVariable = 'testVariable.  ';
	var $testClassContainer;

function mainClassFunction()
{
	print('mainClassFunction was called.  ');
}
}

class testClass
{
	var $mainClassContainer;

function setMainClass($mainClassReference)
{
	$this->mainClassContainer = $mainClassReference;
}

function testClassFunction()
{
	print('testClassFunction was called.  ');

	// Call mainClass->mainClassFunction
	$this->mainClassContainer->mainClassFunction();

	// Print mainClass->testVariable
	print($this->mainClassContainer->testVariable);
}
}

$mainClass = new mainClass;
$mainClass->testClassContainer = new testClass;
$mainClass->testClassContainer->setMainClass(&$mainClass);

$mainClass->testClassContainer->testClassFunction();
print('Execution complete.');
?>

Results in:
testClassFunction was called. mainClassFunction was called. testVariable. Execution complete.

So, that works. Is that the best method to use?

[swr]

This:

$this->mainClassContainer = $mainClassReference;

should use =& instead. Where you have "= new ..." should also use =& (although it probably doesn't matter in this case, it's better to be consistent). Always use =& when assigning objects, unless you're absolutely sure you want a copy. Also, it's recommended to use & in the function definition, rather than the function call.

$API->subAPI = new subAPI(&$API); should have worked. What "call-time pass-by-reference errors" were you getting?

When you get messages about calling a method on a non-object, it's almost always because you're doing $foo->bar() where $foo is null.