Re: Choosing between AUTOLOAD vs Delegation

Please help me to identify whether I should stick with AUTOLOAD or should I move to Class::Delegator class.

Three thoughts come to mind reading your post:

The word "should" implies some law, rule or at least good reason for, doing something.
That reason could be because of your organisation rules: how would a bunch of strangers on the internet know those?
Or the reason could be efficiency or ease of maintenance of the implementation: trading a single simple subroutine for 150+ subroutines doesn't seem to be a good reason.
Or perhaps you think that what you have is not OO enough: allowing such academic criteria to override your own assessment is a very bad choice.
It strikes me that whilst inheritance is way overused, this is actually tailor made for it.
If your current mechanism works, and doesn't cause you problems, stay with it.
I might make one change though. Assuming that only one type of connection will be used in any given application:
```
sub AUTOLOAD {
    my $connection = $device->getConnection();
    {
        no strict 'refs';
        *{ __PACKAGE__ . '::' . $methodname } = $connect->can( $method
+name );
    }
    return $connection->$methodName (..); // when called for getVersio
+n, $methodName will become the "getVersion"
}
[download]
```
Now, the AUTOLOAD process will only be used the first time a method is called, which could effect a nice performance boost if many calls are made to some methods.

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

Comment on Re: Choosing between AUTOLOAD vs Delegation Download Code

Replies are listed 'Best First'.
Re^2: Choosing between AUTOLOAD vs Delegation by tobyink (Canon) on Mar 12, 2012 at 17:41 UTC
I agree with your: `{ __PACKAGE__ . '::' . $methodname } = $connect->can( $methodname );` [download] ... in principle, but in practice it has a subtle bug. (OK, there's the `$connect` versus `$connection` typo too, but we'll ignore that as strict mode should make it obvious.) The first time the autoloaded method is called, the connection object is passed to the method as its invocant. Subsequent calls will get the device as the invocant. What should be used is something more like: `sub AUTOLOAD { no strict 'refs'; {__PACKAGE__.'::'.$methodname} = sub { (shift)->getConnection->$methodname(@_) }; return (shift)->getConnection->$methodname(@_); }` [download] Also it's worth noting that whenever you write an `AUTOLOAD` method, it's worth considering writing a `can` method, because the default method inherited from `UNIVERSAL::can` ignores autoloaded methods. Class::AutoloadCAN explains the issues around `AUTOLOAD` and `can` and offers a solution. Personally I've found Class::AutoloadCAN a little buggy myself and ended up re-implementing it on a module-by-module basis (e.g. these `__autoload`, `can` and `AUTOLOAD` methods). `perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'`	[reply] [d/l] [select]

Replies are listed 'Best First'.

Re^2: Choosing between AUTOLOAD vs Delegation
by tobyink (Canon) on Mar 12, 2012 at 17:41 UTC

I agree with your:

*{ __PACKAGE__ . '::' . $methodname } = $connect->can( $methodname );
[download]

... in principle, but in practice it has a subtle bug. (OK, there's the $connect versus $connection typo too, but we'll ignore that as strict mode should make it obvious.)

The first time the autoloaded method is called, the connection object is passed to the method as its invocant. Subsequent calls will get the device as the invocant.

What should be used is something more like:

sub AUTOLOAD
{
   no strict 'refs';
   *{__PACKAGE__.'::'.$methodname} = sub {
      (shift)->getConnection->$methodname(@_)
   };
   return (shift)->getConnection->$methodname(@_);
}
[download]

Also it's worth noting that whenever you write an AUTOLOAD method, it's worth considering writing a can method, because the default method inherited from UNIVERSAL::can ignores autoloaded methods.

Class::AutoloadCAN explains the issues around AUTOLOAD and can and offers a solution. Personally I've found Class::AutoloadCAN a little buggy myself and ended up re-implementing it on a module-by-module basis (e.g. these __autoload, can and AUTOLOAD methods).

perl -E'sub Monkey::do{say$_,for@_,do{($monkey=[caller(0)]->[3])=~s{::}{ }and$monkey}}"Monkey say"->Monkey::do'

[reply]
[d/l]
[select]