ex10.pm:

package ex10;

use Hash::Util;

sub new {
    my $self = {};
    $self->{ATTR_ABXCDEFG} = 1;
    $self->{ATTR_ABCXDEFG} = 2;
    $self->{ATTR_ABCDXEFG} = 3;
    $self->{ATTR_ABCDEXFG} = 4;
    $self->{ATTR_ABCDEFXG} = 5;
    bless($self);
    Hash::Util::lock_keys(%{$self});
    return $self;
}

sub do_something_1 {
    my $self = shift;
    $self->{ATTR_ABCXDEFG} = 10;
}

sub do_something_2 {
    my $self = shift;
    print $self->{ATTR_ABCXDEFG};
}

sub do_something_3 {
    my $self = shift;
    $self->{ATTR_AXBCDEFG} = 10;
}

sub do_something_4 {
    my $self = shift;
    print $self->{ATTR_AXBCDEFG};
}

1;

ex10.pl:

use ex10;

$e = new ex10;
$e->do_something_1;
$e->do_something_2;
$e->do_something_3; #see what will happen, if you comment out this
$e->do_something_4; #try to comment out this
[download]

That's exactly what I want, pg++.

sub get_attr { $_[0]->{'attr'} }
sub set_attr { $_[0]->{'attr'} = $_[1] }
[download]

I like to use AUTOLOAD for my accessors like:

sub AUTOLOAD {
  my $self = shift;
  return unless ref($self);
    
  # lets find out what the mysterious missing func is
  my ($attribute) = $AUTOLOAD =~ m/.*::(.*)/;

  # this is our psuedo get/set
  # we can make this as simple or complex as we want
  if( my $value = shift ){ ### we have an argument

    # if attribute exists
    # this is our sort of rudimentary access control
    # so we can't create arbitrary attributes
    if( exists $self->{$attribute} ){
      $self->{$attribute} = $value;
    }elsif( exists $self->{ lc($attribute) } ){
      # double check caller didn't mean lower case
      $self->{ lc($attribute) } = $value;
    }else{
      # we can put assignment code here if 
      # we want to be able to automatically
      # create object attributes on the fly
    }
    # here is a good place to call your commit()
    # or write() method if applicable
    $self->write();
  }else{ # must be an get type call
    return $self->{$attribute} if exists $self->{$attribute};
    return $self->{lc($attribute)} if exists $self->{lc($attribute)};
  }# end if/elsif/else value = shift 
}
[download]


Update: BrentDax is spot on

"Never be afraid to try something new. Remember, amateurs built the ark. Professionals built the Titanic."

   if( $self­->{$a­ttrib­ute} ){

That will fail if $self->{$attribute} is set to zero, the empty string, or undef. Perhaps this would work better:

   if(exists $self->{$attribute}) {

=cut
--Brent Dax
There is no sig.

-- Hofmator

Tie::StrictHash

Provides key checking for references but provides functionality to ensure you don't unintentionally create a new key. Also controls clearing of the Hash.

Feedback: Strongly-typed "Pascal records" module

This was a module I just recently posted. It's purpose was to prevent exactly those types of finger-fault errors, but it goes farther in that it allows Perl to ensure you assign the type of data you intended to any particular Hash key. That catches errors such as assigning: $hash{product_list}=$a_product; When what you really meant was: $hash{product_list}=[$a_product];.

Andy

@_="the journeyman larry disciple keeps learning\n"=~/(.)/gs,
print(map$_[$_-77],unpack(q=c*=,q@QSdM[]uRMNV^[ni_\[N]eki^y@))
[download]

use strict;

my $bar = 'bar';

my $foo{$bar} = 1;
my $foo{$bear} = 1; # gives a compile error
[download]

Tie::SecureHash is another module that can help you with this.

You might also want to consider Abigail-II's inside out objects as an alternate implementation mechanism for your classes.

"Inside Out Objects" (at least afaik, they're Abigail-IIs invention) also address and solve this problem. I'm currently doing any Object like that, it makes typos impossible, causing compile time errors.

Follow this node to get the idea.

update: correct terminology defined by inventor applied. Thanks to Abigail-II.

"Inside Out Objects" is indeed the correct term for this technique.

Abigail

You don't have to abuse anyone ;-)

Using Tie::Hash::Approx suffices.

regards,

janx

I think doing approximate string matches for hash keys in objects would be the programmer's equivalent to playing Russian Roulette. Bad idea.

Well, if there is an exact match, it's no roulette. There are quite simple techniques to verify a hash key actually exists. In fact, like janx noted above, there's Tie::Hash::Approx by our very own OeufMayo which does pretty much just that :)

Tie::Hash::Approx - Approximative match of hash keys using String::Approx

Greetz
Beatnik
... Quidquid perl dictum sit, altum viditur.

... or Tie::Hash::Cannabinol for fun ;^}

davorg is (sometimes) an evil man. Whenever somebody brings up this subject I always am reminded of his talk introducing Symbol::Approx::Sub and friends - and smile evilly.

Evil? Me? Surely you're thinking of someone else :)

Is this the talk you mean?

• Perl for the People
--
<http://www.dave.org.uk>

"The first rule of Perl club is you do not talk about Perl club."
-- Chip Salzenberg

use fields qw/this_key that_key other_key/;
[download]

"use field" and pseudo hash is definitely what I want to avoid, as it is obsoleted, and the syntax affects the way you coding too much.

I would agree that the new "Hash::Util::lock_keys()" is a neater approch (pg++), but I didn't see anything in the perl 5.8 man page for "fields" to indicate that it was being depricated -- so where did you hear that it is "obsoleted"? (Just curious. I'm sure this pragma has been used by many who were not so offended by it as you seem to be, and they'd want to know...)

Artist