1package Tie::Scalar; 2 3our $VERSION = '1.00'; 4 5=head1 NAME 6 7Tie::Scalar, Tie::StdScalar - base class definitions for tied scalars 8 9=head1 SYNOPSIS 10 11 package NewScalar; 12 require Tie::Scalar; 13 14 @ISA = (Tie::Scalar); 15 16 sub FETCH { ... } # Provide a needed method 17 sub TIESCALAR { ... } # Overrides inherited method 18 19 20 package NewStdScalar; 21 require Tie::Scalar; 22 23 @ISA = (Tie::StdScalar); 24 25 # All methods provided by default, so define only what needs be overridden 26 sub FETCH { ... } 27 28 29 package main; 30 31 tie $new_scalar, 'NewScalar'; 32 tie $new_std_scalar, 'NewStdScalar'; 33 34=head1 DESCRIPTION 35 36This module provides some skeletal methods for scalar-tying classes. See 37L<perltie> for a list of the functions required in tying a scalar to a 38package. The basic B<Tie::Scalar> package provides a C<new> method, as well 39as methods C<TIESCALAR>, C<FETCH> and C<STORE>. The B<Tie::StdScalar> 40package provides all the methods specified in L<perltie>. It inherits from 41B<Tie::Scalar> and causes scalars tied to it to behave exactly like the 42built-in scalars, allowing for selective overloading of methods. The C<new> 43method is provided as a means of grandfathering, for classes that forget to 44provide their own C<TIESCALAR> method. 45 46For developers wishing to write their own tied-scalar classes, the methods 47are summarized below. The L<perltie> section not only documents these, but 48has sample code as well: 49 50=over 4 51 52=item TIESCALAR classname, LIST 53 54The method invoked by the command C<tie $scalar, classname>. Associates a new 55scalar instance with the specified class. C<LIST> would represent additional 56arguments (along the lines of L<AnyDBM_File> and compatriots) needed to 57complete the association. 58 59=item FETCH this 60 61Retrieve the value of the tied scalar referenced by I<this>. 62 63=item STORE this, value 64 65Store data I<value> in the tied scalar referenced by I<this>. 66 67=item DESTROY this 68 69Free the storage associated with the tied scalar referenced by I<this>. 70This is rarely needed, as Perl manages its memory quite well. But the 71option exists, should a class wish to perform specific actions upon the 72destruction of an instance. 73 74=back 75 76=head1 MORE INFORMATION 77 78The L<perltie> section uses a good example of tying scalars by associating 79process IDs with priority. 80 81=cut 82 83use Carp; 84use warnings::register; 85 86sub new { 87 my $pkg = shift; 88 $pkg->TIESCALAR(@_); 89} 90 91# "Grandfather" the new, a la Tie::Hash 92 93sub TIESCALAR { 94 my $pkg = shift; 95 if ($pkg->can('new') and $pkg ne __PACKAGE__) { 96 warnings::warnif("WARNING: calling ${pkg}->new since ${pkg}->TIESCALAR is missing"); 97 $pkg->new(@_); 98 } 99 else { 100 croak "$pkg doesn't define a TIESCALAR method"; 101 } 102} 103 104sub FETCH { 105 my $pkg = ref $_[0]; 106 croak "$pkg doesn't define a FETCH method"; 107} 108 109sub STORE { 110 my $pkg = ref $_[0]; 111 croak "$pkg doesn't define a STORE method"; 112} 113 114# 115# The Tie::StdScalar package provides scalars that behave exactly like 116# Perl's built-in scalars. Good base to inherit from, if you're only going to 117# tweak a small bit. 118# 119package Tie::StdScalar; 120@ISA = (Tie::Scalar); 121 122sub TIESCALAR { 123 my $class = shift; 124 my $instance = shift || undef; 125 return bless \$instance => $class; 126} 127 128sub FETCH { 129 return ${$_[0]}; 130} 131 132sub STORE { 133 ${$_[0]} = $_[1]; 134} 135 136sub DESTROY { 137 undef ${$_[0]}; 138} 139 1401; 141