Class::MakeMethods::Evaled::Hash (3pm)

  package MyObject;
  use Class::MakeMethods::Evaled::Hash (
    new => 'new',
    scalar => [ 'foo', 'bar' ],
    array => 'my_list',
    hash => 'my_index',
  );
  ...

  # Constructor
  my $obj = MyObject->new( foo => 'Foozle' );

  # Scalar Accessor
  print $obj->foo();

  $obj->bar('Barbados');
  print $obj->bar();

  # Array accessor
  $obj->my_list(0 => 'Foozle', 1 => 'Bang!');
  print $obj->my_list(1);

  # Hash accessor
  $obj->my_index('broccoli' => 'Blah!', 'foo' => 'Fiddle');
  print $obj->my_index('foo');

The Evaled::Hash subclass of MakeMethods provides a simple constructor and accessors for blessed-hash object instances.

Calling Conventions

When you \*(C`use\*(C' this package, the method names you provide as arguments cause subroutines to be generated and installed in your module.

See \*(L"Calling Conventions\*(R" in Class::MakeMethods::Standard for a summary, or \*(L"\s-1USAGE\s0\*(R" in Class::MakeMethods for full details.

Declaration Syntax

To declare methods, pass in pairs of a method-type name followed by one or more method names. Valid method-type names for this package are listed in \*(L"\s-1METHOD\s0 \s-1GENERATOR\s0 \s-1TYPES\s0\*(R".

See \*(L"Declaration Syntax\*(R" in Class::MakeMethods::Standard for more syntax information.

new - Constructor

For each method name passed, returns a subroutine with the following characteristics:

• If called as a class method, makes a new hash and blesses it into that class.

• If called on a hash-based instance, makes a copy of it and blesses the copy into the same class as the original instance.

• If passed a list of key-value pairs, appends them to the new hash. These arguments override any copied values, and later arguments with the same name will override earlier ones.

• Returns the new instance.

Sample declaration and usage:

package MyObject; use Class::MakeMethods::Evaled::Hash ( new => 'new', ); ...

# Bare constructor my $empty = MyObject->new();

# Constructor with initial values my $obj = MyObject->new( foo => 'Foozle', bar => 'Barbados' );

# Copy with overriding value my $copy = $obj->new( bar => 'Bob' );

scalar - Instance Accessor

For each method name passed, uses a closure to generate a subroutine with the following characteristics:

• Must be called on a hash-based instance.

• Uses the method name as a hash key to access the related value for each instance.

• If called without any arguments returns the current value.

• If called with an argument, stores that as the value, and returns it,

Sample declaration and usage:

package MyObject; use Class::MakeMethods::Evaled::Hash ( scalar => 'foo', ); ...

# Store value $obj->foo('Foozle');

# Retrieve value print $obj->foo;

array - Instance Ref Accessor

For each method name passed, uses a closure to generate a subroutine with the following characteristics:

• Must be called on a hash-based instance.

• Uses the method name as a hash key to access the related value for each instance.

• The value for each instance will be a reference to an array (or undef).

• If called without any arguments, returns the current array-ref value (or undef).

• If called with one argument, uses that argument as an index to retrieve from the referenced array, and returns that value (or undef).

• If called with a list of index-value pairs, stores the value at the given index in the referenced array. If the instance's value was previously undefined, a new array is autovivified. The current value in each position will be overwritten, and later arguments with the same index will override earlier ones. Returns the current array-ref value.

Sample declaration and usage:

package MyObject; use Class::MakeMethods::Evaled::Hash ( array => 'bar', ); ...

# Set values by position $obj->bar(0 => 'Foozle', 1 => 'Bang!');

# Positions may be overwritten, and in any order $obj->bar(2 => 'And Mash', 1 => 'Blah!');

# Retrieve value by position print $obj->bar(1);

# Direct access to referenced array print scalar @{ $obj->bar() };

# Reset the array contents to empty @{ $obj->bar() } = ();

hash - Instance Ref Accessor

For each method name passed, uses a closure to generate a subroutine with the following characteristics:

• Must be called on a hash-based instance.

• Uses the method name as a hash key to access the related value for each instance.

• The value for each instance will be a reference to a hash (or undef).

• If called without any arguments, returns the current hash-ref value (or undef).

• If called with one argument, uses that argument as an index to retrieve from the referenced hash, and returns that value (or undef).

• If called with a list of key-value pairs, stores the value under the given key in the referenced hash. If the instance's value was previously undefined, a new hash is autovivified. The current value under each key will be overwritten, and later arguments with the same key will override earlier ones. Returns the current hash-ref value.

Sample declaration and usage:

package MyObject; use Class::MakeMethods::Evaled::Hash ( hash => 'baz', ); ...

# Set values by key $obj->baz('foo' => 'Foozle', 'bar' => 'Bang!');

# Values may be overwritten, and in any order $obj->baz('broccoli' => 'Blah!', 'foo' => 'Fiddle');

# Retrieve value by key print $obj->baz('foo');

# Direct access to referenced hash print keys %{ $obj->baz() };

# Reset the hash contents to empty @{ $obj->baz() } = ();

See Class::MakeMethods for general information about this distribution.

See Class::MakeMethods::Evaled for more about this family of subclasses.