Class::MakeMethods::Standard::Global - Global data


NAME

Class::MakeMethods::Standard::Global - Global data


SYNOPSIS

  package MyClass;
  use Class::MakeMethods::Standard::Global (
    scalar => [ 'foo' ],
    array  => [ 'my_list' ],
    hash   => [ 'my_index' ],
  );
  ...

  MyClass->foo( 'Foozle' );
  print MyClass->foo();
  print MyClass->new(...)->foo(); # same value for any instance
  print MySubclass->foo();        # ... and for any subclass

  MyClass->my_list(0 => 'Foozle', 1 => 'Bang!');
  print MyClass->my_list(1);

  MyClass->my_index('broccoli' => 'Blah!', 'foo' => 'Fiddle');
  print MyClass->my_index('foo');


DESCRIPTION

The Standard::Global suclass of MakeMethods provides basic accessors for shared data.

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 the Class::MakeMethods::Standard manpage for more information.

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 the Class::MakeMethods::Standard manpage and Parameter Syntax in the Class::MakeMethods::Standard manpage for more information.


METHOD GENERATOR TYPES

scalar - Global Accessor

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

Sample declaration and usage:

  package MyClass;
  use Class::MakeMethods::Standard::Global (
    scalar => 'foo',
  );
  ...

  # Store value
  MyClass->foo('Foozle');

  # Retrieve value
  print MyClass->foo;

array - Global Ref Accessor

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

Sample declaration and usage:


  package MyClass;
  use Class::MakeMethods::Standard::Global (
    array => 'bar',
  );
  ...

  # Clear and set contents of list
  print MyClass->bar([ 'Spume', 'Frost' ] );

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

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

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

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

There are also calling conventions for slice and splice operations:

  # Retrieve slice of values by position
  print join(', ', MyClass->bar( undef, [0, 2] ) );

  # Insert an item at position in the array
  MyClass->bar([3], 'Potatoes' );

  # Remove 1 item from position 3 in the array
  MyClass->bar([3, 1], undef );

  # Set a new value at position 2, and return the old value 
  print MyClass->bar([2, 1], 'Froth' );

hash - Global Ref Accessor

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

Sample declaration and usage:

  package MyClass;
  use Class::MakeMethods::Standard::Global (
    hash => 'baz',
  );
  ...

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

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

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

  # Retrive slice of values by position
  print join(', ', MyClass->baz( ['foo', 'bar'] ) );

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

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

object - Global Ref Accessor

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

Sample declaration and usage:

  package MyClass;
  use Class::MakeMethods::Standard::Global (
    object => 'foo',
  );
  ...

  # Store value
  MyClass->foo( Foozle->new() );

  # Retrieve value
  print MyClass->foo;


SEE ALSO

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

See the Class::MakeMethods::Standard manpage for more about this family of subclasses.

 Class::MakeMethods::Standard::Global - Global data