inner "nested" classes?

[Average_Joe]

Hello PHP people,

Was wondering if PHP5 had some sort of "nested class" functionality.

I'm trying to figure out how to return an object (with a private
constructor) that has access to variables in another class.

Something like:

$obj = $factory->getObject("123 4");

Where getObject() is the ONLY way to get an instance of $obj.

$obj has access to private data from the $factory object.

Kind of like inner and anonymous classes in java I guess.

Any approach to doing this in PHP5?

Jamie
--
http://www.geniegate.com Custom web programming
User Management Solutions Perl / PHP / Java / UNIX

[Zurab Davitiani]

Average_Joe wrote:

Simple example:

Say you've got:

<?php
class Invoice() { .. }

class Item() { ... }

// You want to do:

$item = $invoice->getItem("P100" );

echo $item->title();

echo $item->getInvoice()->title(); // get the invoice title.

?>

The idea here is that at no point can anything except Invoice() generate
an instance of Item. (Item has a private constructor)
OK, that's close to how I imagined it as well. In this case, you would make
sure that Item constructor was only called from Invoice class, or throw an
exception. I cannot think of another way to do this other than with
debug_backtrace which is really a workaround (or a hack) for this, not a
language feature.

Since the check would be already done, the Item constructor need not be
private in this case. Indeed if it was, Invoice wouldn't be able to
construct it since the call would come from global namespace.
Furthermore. Say Item is an interface or abstract class, the actual items
are different, but all of them implement an "Item" interface. This way,
you could have a Clothing Item, Electronics Item, etc.. each with
methods specific to the item type. You also can be reasonably assured
that all Item()'s haven't been constructed outside an Invoice().
In order to make sure this works with abstract classes, you would have to
call the parent constructor explicitly. Also, you would have to allow the
parent constructor to complete instantiation - i.e. not throw an exception
- when it's called from a __construct function of a class whose parent
class is "Item". You can use get_parent_clas s for that.

Also, it's not pretty but every derived class would have to have a similar
check in its constructor. You may create a common method for this in parent
that's inherited by derived classes, but backtrace values would have to
come from constructor function and passed to that method.
You know when working with the code that each Item must have a parent
Invoice instance, down the road, if an Item required access to stuff in
the Invoice class (such as a is_sales_tax() method ?) You would be able
to access it, w/out giving access to other areas of the application. (So
that if is_sales_tax() were to change, (lets say sales tax became
dependant on country or something) you would know it was accessed ONLY
in Invoice() and any Item's it generated, making changes easier)
This is more or less easier to implement. When calling the Item constructor
from Invoice (or through a separate method), pass $this and set it as
Item's parent property; then refer back to it from the Item class by
calling $this->getParent() or $this->parent.
Aside from this, PHP5 is looking really _really_ good. :-)

I would have preferred multiple inheritance to interfaces.