sub Parent::factory {
    my $type = shift;
    # ...
    $type->new(@_);
}
[download]

/s

educated_foo wrote:
From reading the "Scenario" section of the pod, this sounds like "factory methods."

Yes, it can definitely be used that way, but it can do more too. It supports simple "has-a" relationships, "factory" relationships, and "uses" relationships.

Also, you're talking about "parent" or "child" - it seems like you're thinking of @ISA inheritance, but Class::Container is focused primarily on containment relationships.

Assuming you really did mean containment relationships, if I used a bottom-up approach like the one you're suggesting, I'd have to manage lots of bottom-level objects instead of just one top-level object. That seems very inconvenient. It is supported by Class::Container if you want to do that, though - you can affect a contained object "wheel" (of class "Wheel") when creating the "car" (of class "Car") by any of these three approaches:

• pass constructor parameters for the default "Wheel" class to the "Car" constructor
• pass a "wheel_class" parameter to the "Car" constructor that could change the wheel's class to "My::Wheel", optionally including any additional parameters that "My::Wheel" takes
• pass an already-created "wheel" object to the "Car" constructor
-Ken

Reading the POD the only thing that wasn't clear to me was what the "parse" key in the hash passed to valid_params() does. Also, how does the Params::Validate tie-in work exactly? Perhaps you could add an example.

-sam

Hi Sam,

I'm not sure it's very similar to Class::MethodMaker. I had a hard time wading through MethodMaker's docs, though - what part do you mean by "advanced composition support"?

The "parse" key doesn't do anything - the remarks after that example say that unknown parameters like "parse" are just ignored. In Mason, it's actually used to parse things from the httpd.conf file, but Class::Container knows nothing about this.

-Ken

Class::MethodMaker has a method maker called "object" that declares a slot to be of a particular object type. For example:

use Class::MethodMaker
    new_hash_init => 'new',
    object        => [ HTML::Mason::Lexer => 'lexer' ];
[download]

You can then choose to proxy selected methods from the contained class. For example, to create a class called CGI::Simple that contains a CGI.pm object in a slot called 'query' and proxies new() and param() to it:

package CGI::Simple;

use Class::MethodMaker
    new_hash_init => 'new',
    object        => [ CGI => {
                                 slot       => 'query',
                                 comp_mthds => [ 'new',
                                                 'param' ],
                               }
                      ];
[download]

This seems just nextdoor to your module to me.

-sam

This looks like a good way to work towards writing patterns in perl - this reminded me of the Composite pattern (as described by Gamma et Al). Is this the idea?

It appears that the top down approach you have taken (with delayed build) is a good way to manage object proliferation - are you planning to add support for object re-use as per the Flyweight pattern? What about Iterators and Visitors???

Are there any robust implementations of such things already in existence?