Class::MakeMethods::Docs::Catalog - List of Makable Method Types


NAME

Class::MakeMethods::Docs::Catalog - List of Makable Method Types


DESCRIPTION

This document lists the various subclasses of Class::MakeMethods included in this distribution, and the method types each one provides.

See the documentation for each implementation for more details about the features it provides.

For each class, a parenthetical comment indicates whether the methods it generates are applicable to individual blessed objects (Instances), to class data (Global), or both (Any) =head2 Scoping

The final part of the name of a method-generating subclass typically indicates the scope or applicability of the methods it generates

Hash
For object instances based on blessed hashes with named values.

Array
For object instances based on blessed arrays with positional values.

Scalar
For object instances based on blessed scalars with a single value.

InsideOut
For any object instance regardless of underlying data type.

Ref
For any object instance regardless of underlying data type.

Inheritable
For data which can be set at the class, subclass, or instance level.

Class
For class data shared by all instances but different for each subclass

ClassVar
For class data shared by all instances but different for each subclass

ClassInherit
For class data shared by all instances but different for each subclass

Global
For global data shared by a class and all its instances and subclasses

PackageVar
For global data shared by a class and all its instances and subclasses

Universal
# General method types that are widely applicable

Summary Charts

This table shows which scopes are available in each generator family:

  SCOPING          Basic      Standard   Evaled     Composite  Template
  Hash               +          +          +          +          +
  Array              +          +                     +          +
  Scalar                                                         +
  InsideOut                                                      +
  Ref                                                            +
  Inheritable                   +                     +          +
  Class                                                          +
  ClassVar                                                       +
  ClassInherit                                                   +
  Global             +          +                     +          +
  PackageVar                                                     +
  Universal                                           +          +

This table shows which types of methods are typically available in each generator family:

  METHOD           Basic      Standard   Evaled     Composite  Template
  new                +          +                     +          +
  scalar             +          +                     +          +
  string                                                         +
  string_index                                                   +
  number                                                         +
  boolean                                                        +
  boolean_index                                                  +
  bits                                                           +
  array              +          +                     +          +
  struct                                                         +
  hash               +          +                     +          +
  hash_of_arrays                                                 +
  tiedhash                                                       +
  object             +                                +          +
  instance                                                       +
  array_of_objects                                               +
  code                                                           +
  code_or_scalar                                                 +


BASIC CLASSES

Basic::Hash (Instances)

Methods for objects based on blessed hashes. See the Class::MakeMethods::Basic::Hash manpage for details.

Basic::Array (Instances)

Methods for manipulating positional values in arrays. See the Class::MakeMethods::Basic::Array manpage for details.

Basic::Global (Global)

Global methods are not instance-dependent; calling them by class name or from any instance or subclass will consistently access the same value. See the Class::MakeMethods::Basic::Global manpage for details.


STANDARD CLASSES

Standard::Hash (Instances)

Methods for objects based on blessed hashes. See the Class::MakeMethods::Standard::Hash manpage for details.

Standard::Array (Instances)

Methods for manipulating positional values in arrays. See the Class::MakeMethods::Standard::Array manpage for details.

Standard::Global (Global)

Methods for manipulating global data. See the Class::MakeMethods::Standard::Global manpage for details.

Standard::Inheritable (Any)

Methods for manipulating data which may be overridden per class or instance. Uses external data storage, so it works with objects of any underlying data type. See the Class::MakeMethods::Standard::Inheritable manpage for details.


COMPOSITE CLASSES

Composite::Hash (Instances)

Methods for objects based on blessed hashes. See the Class::MakeMethods::Composite::Hash manpage for details.

Composite::Array (Instances)

Methods for manipulating positional values in arrays. See the Class::MakeMethods::Composite::Array manpage for details.

Composite::Global (Global)

Methods for manipulating global data. See the Class::MakeMethods::Composite::Global manpage for details.

Composite::Inheritable (Any)

Methods for manipulating data which may be overridden per class or instance. Uses external data storage, so it works with objects of any underlying data type. See the Class::MakeMethods::Composite::Inheritable manpage for details.

Composite::Universal (Any)

Methods for padding pre- and post-conditions to any class. See the Class::MakeMethods::Composite::Universal manpage for details.


TEMPLATE CLASSES

Template::Universal (Any)

Meta-methods for any type of object. See the Class::MakeMethods::Template::Universal manpage.

Template::Ref (Any Instance)

Methods for deep copies and comparisons. See the Class::MakeMethods::Template::Ref manpage.

Template::Generic (Abstract)

The remaining subclasses inherit a similar collection of templates from Template::Generic, and provide a different type of scoping or binding for the functionality defined by the Generic template. See the Class::MakeMethods::Template::Generic manpage for details.

Template::Hash (Instances)

The most commonly used implementation, for objects based on blessed hashes. See the Class::MakeMethods::Template::Hash manpage.

Template::Array (Instances)

Methods for manipulating positional values in arrays. See the Class::MakeMethods::Template::Array manpage.

Template::Scalar (Instances)

For objects based on blessed scalars. See the Class::MakeMethods::Template::Scalar manpage.

Note that these objects can generally only have one value accessor method, as all such accessors will refer to the same value.

Template::InsideOut (Instances)

Stores values for objects in an external location hashed by identity. See the Class::MakeMethods::Template::InsideOut manpage.

Note that while the below constructor creates and returns scalar references, accessor methods can be created with this implementation for use with any type of object.

Template::Global (Global)

Global methods are not instance-dependent; calling them by class name or from any instance will consistently access the same value. See the Class::MakeMethods::Template::Static manpage.

Template::PackageVar (Global)

PackageVar methods access a variable in the declaring package. Thus, they have the same effect as Static methods, while keeping their value accessible via the symbol table. See the Class::MakeMethods::Template::PackageVar manpage.

Template::Class (Global)

Class methods are similar to Static methods, except that each subclass and its instances will access a distinct value. See the Class::MakeMethods::Template::Class manpage.

Template::ClassVar (Global)

ClassVar methods access a variable in the package on which they are called. Thus, they have the same effect as Class methods, while keeping their value accessible via the symbol table, like PackageVar. See the Class::MakeMethods::Template::ClassVar manpage.

Template::ClassInherit (Global)

ClassInherit methods are an intermediate point between Static and Class methods; subclasses inherit their superclass's value until they set their own value, after which they become distinct. See the Class::MakeMethods::Template::ClassInherit manpage.

Template::Inheritable (Any)

Methods for manipulating data which may be overridden per class or instance. Uses external data storage, so it works with objects of any underlying data type. See the Class::MakeMethods::Template::Inheritable manpage for details.


SEE ALSO

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

 Class::MakeMethods::Docs::Catalog - List of Makable Method Types