On Thu, Nov 15, 2001 at 05:49:34PM -0800, John Rudd wrote:
> So, for example, lets say I have an object $foo, which is an instance of
> Class A. In one method, foo tries to access an instance variable of
> $bar, an instance of Class B (not inherited from Class A).
This is a naughty thing to do. $bar should have a set of accessor
methods if you're really worried. Read on.
> If $bar's instance variables are somehow hidden
Looks like the whole "an object is just a hash reference" paradigm
might be mutating some to allow better data hiding. There was a big
thread on perl6-language about this just recently.
> I could then have the Class B auto(vivify|glob) routine perform
> checks on the identity and heritage of $foo, and then decide what to
> do about the request.
There's a whole host of modules that make writing accessors cheap,
Class::Accessor and Class::Struct for example. Once you're inside an
accessor method you can do whatever access checking you like.
If I'm reading the tea leaves correctly, Perl 6 will address this sort
of thing with some variation on slots. So you can declare "for *this*
list of instance variables, make me some simple accessors". So
C<$foo->bar = 'this'> == C<$foo->{bar} = 'this'>. So rather than
using AUTOVIVIFIY you'd use slots and accessor methods.
In theory, these slots should be closer to the speed of a regular
hash than accessor methods currently are in perl5.
> That way you could choose to impliment Smalltalk or C++ style
> protections (public, private, protected, etc)
Last I checked Smalltalk had no privacy protection.
> So, for Smalltalk type semantics, if $foo != $bar, the
> request will throw some sort of exeption indicating that $foo isn't
> allowed to see $bar's instance variables. But, if $foo == $bar, then
> the actual value will be found and returned.
.... Smalltalk? not allowed? You sure about that? Or is this
something you hacked together with doesNotExist?
> The question in my brain, since I don't know perl's internals in very
> much detail, is how hard is it to figure out who the caller was?
caller(). Or is something more involved?
> It's not just a matter of knowing what package the invoking
> subroutine belonged to, because instances of the same class might
> have have access to eachother's instance variables (ala Smalltalk).
> It further complicates things if you want to extend it to include
> C++ style "friend" functions (I don't, but others might).
die "Sorry, private method" unless caller eq ref $self;
die "Sorry, protected method" unless caller->isa(ref $self);
die "Sorry, you're not my friend"
unless exists $self->{_my_friends}{caller()};
That about covers basic method privacy.
> (yes, I know you can emulate class variables via package globals like
> $Class::blah, but I'm trying to look at it in a more uniform point of
> view so that you can fully treat Classes themselves as being objects)
Class::Data::Inheritable anyone? :)
--
Michael G. Schwern <[EMAIL PROTECTED]> http://www.pobox.com/~schwern/
Perl Quality Assurance <[EMAIL PROTECTED]> Kwalitee Is Job One
"You killed my fish?"
"Why does that pickle you?"
http://sluggy.com/d/010204.html
