package Tie::Scalar; our $VERSION = '1.00'; =head1 NAME Tie::Scalar, Tie::StdScalar - base class definitions for tied scalars =head1 SYNOPSIS package NewScalar; require Tie::Scalar; @ISA = qw(Tie::Scalar); sub FETCH { ... } # Provide a needed method sub TIESCALAR { ... } # Overrides inherited method package NewStdScalar; require Tie::Scalar; @ISA = qw(Tie::StdScalar); # All methods provided by default, so define only what needs be overridden sub FETCH { ... } package main; tie $new_scalar, 'NewScalar'; tie $new_std_scalar, 'NewStdScalar'; =head1 DESCRIPTION This module provides some skeletal methods for scalar-tying classes. See L for a list of the functions required in tying a scalar to a package. The basic B package provides a C method, as well as methods C, C and C. The B package provides all the methods specified in L. It inherits from B and causes scalars tied to it to behave exactly like the built-in scalars, allowing for selective overloading of methods. The C method is provided as a means of grandfathering, for classes that forget to provide their own C method. For developers wishing to write their own tied-scalar classes, the methods are summarized below. The L section not only documents these, but has sample code as well: =over 4 =item TIESCALAR classname, LIST The method invoked by the command C. Associates a new scalar instance with the specified class. C would represent additional arguments (along the lines of L and compatriots) needed to complete the association. =item FETCH this Retrieve the value of the tied scalar referenced by I. =item STORE this, value Store data I in the tied scalar referenced by I. =item DESTROY this Free the storage associated with the tied scalar referenced by I. This is rarely needed, as Perl manages its memory quite well. But the option exists, should a class wish to perform specific actions upon the destruction of an instance. =back =head1 MORE INFORMATION The L section uses a good example of tying scalars by associating process IDs with priority. =cut use Carp; use warnings::register; sub new { my $pkg = shift; $pkg->TIESCALAR(@_); } # "Grandfather" the new, a la Tie::Hash sub TIESCALAR { my $pkg = shift; if ($pkg->can('new') and $pkg ne __PACKAGE__) { warnings::warnif("WARNING: calling ${pkg}->new since ${pkg}->TIESCALAR is missing"); $pkg->new(@_); } else { croak "$pkg doesn't define a TIESCALAR method"; } } sub FETCH { my $pkg = ref $_[0]; croak "$pkg doesn't define a FETCH method"; } sub STORE { my $pkg = ref $_[0]; croak "$pkg doesn't define a STORE method"; } # # The Tie::StdScalar package provides scalars that behave exactly like # Perl's built-in scalars. Good base to inherit from, if you're only going to # tweak a small bit. # package Tie::StdScalar; @ISA = qw(Tie::Scalar); sub TIESCALAR { my $class = shift; my $instance = shift || undef; return bless \$instance => $class; } sub FETCH { return ${$_[0]}; } sub STORE { ${$_[0]} = $_[1]; } sub DESTROY { undef ${$_[0]}; } 1;