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.

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