139 lines
3.2 KiB
Perl
139 lines
3.2 KiB
Perl
package Tie::Scalar;
|
|
|
|
=head1 NAME
|
|
|
|
Tie::Scalar, Tie::StdScalar - base class definitions for tied scalars
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
package NewScalar;
|
|
require Tie::Scalar;
|
|
|
|
@ISA = (Tie::Scalar);
|
|
|
|
sub FETCH { ... } # Provide a needed method
|
|
sub TIESCALAR { ... } # Overrides inherited method
|
|
|
|
|
|
package NewStdScalar;
|
|
require Tie::Scalar;
|
|
|
|
@ISA = (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<perltie> for a list of the functions required in tying a scalar to a
|
|
package. The basic B<Tie::Scalar> package provides a C<new> method, as well
|
|
as methods C<TIESCALAR>, C<FETCH> and C<STORE>. The B<Tie::StdScalar>
|
|
package provides all the methods specified in L<perltie>. It inherits from
|
|
B<Tie::Scalar> and causes scalars tied to it to behave exactly like the
|
|
built-in scalars, allowing for selective overloading of methods. The C<new>
|
|
method is provided as a means of grandfathering, for classes that forget to
|
|
provide their own C<TIESCALAR> method.
|
|
|
|
For developers wishing to write their own tied-scalar classes, the methods
|
|
are summarized below. The L<perltie> section not only documents these, but
|
|
has sample code as well:
|
|
|
|
=over
|
|
|
|
=item TIESCALAR classname, LIST
|
|
|
|
The method invoked by the command C<tie $scalar, classname>. Associates a new
|
|
scalar instance with the specified class. C<LIST> would represent additional
|
|
arguments (along the lines of L<AnyDBM_File> and compatriots) needed to
|
|
complete the association.
|
|
|
|
=item FETCH this
|
|
|
|
Retrieve the value of the tied scalar referenced by I<this>.
|
|
|
|
=item STORE this, value
|
|
|
|
Store data I<value> in the tied scalar referenced by I<this>.
|
|
|
|
=item DESTROY this
|
|
|
|
Free the storage associated with the tied scalar referenced by I<this>.
|
|
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<perltie> section uses a good example of tying scalars by associating
|
|
process IDs with priority.
|
|
|
|
=cut
|
|
|
|
use Carp;
|
|
|
|
sub new {
|
|
my $pkg = shift;
|
|
$pkg->TIESCALAR(@_);
|
|
}
|
|
|
|
# "Grandfather" the new, a la Tie::Hash
|
|
|
|
sub TIESCALAR {
|
|
my $pkg = shift;
|
|
if (defined &{"{$pkg}::new"}) {
|
|
carp "WARNING: calling ${pkg}->new since ${pkg}->TIESCALAR is missing"
|
|
if $^W;
|
|
$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 = (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;
|