Linux Certif

Toute la documentation sur la certification Linux LPI

Class::MakeMethods::Evaled::Hash.3pm

NAME

Class::MakeMethods::Evaled::Hash - 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() } = ();
 
 

SEE ALSO

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

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