Class::MakeMethods::Evaled::Hash(3) Typical hash methods

SYNOPSIS


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');

DESCRIPTION

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

Calling Conventions

When you "use" this package, the method names you provide as arguments cause subroutines to be generated and installed in your module.

See ``Calling Conventions'' in Class::MakeMethods::Standard for a summary, or ``USAGE'' 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 ``METHOD GENERATOR TYPES''.

See ``Declaration Syntax'' in Class::MakeMethods::Standard for more syntax information.

METHOD GENERATOR TYPES

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() } = ();

LAST SEARCHED