Matthew Simon Cavalletto > Class-MakeMethods-1.009 > Class::MakeMethods::Basic::Array

Download:
Class-MakeMethods-1.009.tar.gz

Dependencies

Annotate this POD

CPAN RT

New  1
Open  2
View/Report Bugs
Module Version: 1   Source   Latest Release: Class-MakeMethods-1.01

NAME ^

Class::MakeMethods::Basic::Array - Basic array methods

SYNOPSIS ^

  package MyObject;
  use Class::MakeMethods::Basic::Array (
    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 Basic::Array subclass of MakeMethods provides a basic constructor and accessors for blessed-array 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::Basic 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::Basic for more syntax information.

About Positional Accessors

Each accessor method claims the next available spot in the array to store its value in.

The mapping between method names and array positions is stored in a hash named %FIELDS in the target package. When the first positional accessor is defined for a package, its %FIELDS are initialized by searching its inheritance tree.

Caution: Subclassing packages that use positional accessors is somewhat fragile, since you may end up with two distinct methods assigned to the same position. Specific cases to avoid are:

METHOD GENERATOR TYPES ^

new - Constructor

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

Sample declaration and usage:

  package MyObject;
  use Class::MakeMethods::Basic::Array (
    new => 'new',
  );
  ...
  
  # Bare constructor
  my $empty = MyObject->new();
  
  # Constructor with initial sequence of method calls
  my $obj = MyObject->new( foo => 'Foozle', bar => 'Barbados' );
  
  # Copy with overriding sequence of method calls
  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:

Sample declaration and usage:

  package MyObject;
  use Class::MakeMethods::Basic::Array (
    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:

Sample declaration and usage:

  package MyObject;
  use Class::MakeMethods::Basic::Array (
    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);
  
  # Retrieve slice of values by position
  print join(', ', $obj->bar( [0, 2] ) );
  
  # 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:

Sample declaration and usage:

  package MyObject;
  use Class::MakeMethods::Basic::Array (
    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');
  
  # Retrieve slice of values by position
  print join(', ', $obj->baz( ['foo', 'bar'] ) );
  
  # 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::Basic for more about this family of subclasses.

syntax highlighting: