lib/Tie/Scalar.pm

   1 package Tie::Scalar;
   2
   3 our $VERSION = '1.00';
   4
   5 =head1 NAME
   6
   7 Tie::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
  36 This module provides some skeletal methods for scalar-tying classes. See
  37 L<perltie> for a list of the functions required in tying a scalar to a
  38 package. The basic B<Tie::Scalar> package provides a C<new> method, as well
  39 as methods C<TIESCALAR>, C<FETCH> and C<STORE>. The B<Tie::StdScalar>
  40 package provides all the methods specified in  L<perltie>. It inherits from
  41 B<Tie::Scalar> and causes scalars tied to it to behave exactly like the
  42 built-in scalars, allowing for selective overloading of methods. The C<new>
  43 method is provided as a means of grandfathering, for classes that forget to
  44 provide their own C<TIESCALAR> method.
  45
  46 For developers wishing to write their own tied-scalar classes, the methods
  47 are summarized below. The L<perltie> section not only documents these, but
  48 has sample code as well:
  49
  50 =over
  51
  52 =item TIESCALAR classname, LIST
  53
  54 The method invoked by the command C<tie $scalar, classname>. Associates a new
  55 scalar instance with the specified class. C<LIST> would represent additional
  56 arguments (along the lines of L<AnyDBM_File> and compatriots) needed to
  57 complete the association.
  58
  59 =item FETCH this
  60
  61 Retrieve the value of the tied scalar referenced by I<this>.
  62
  63 =item STORE this, value
  64
  65 Store data I<value> in the tied scalar referenced by I<this>.
  66
  67 =item DESTROY this
  68
  69 Free the storage associated with the tied scalar referenced by I<this>.
  70 This is rarely needed, as Perl manages its memory quite well. But the
  71 option exists, should a class wish to perform specific actions upon the
  72 destruction of an instance.
  73
  74 =back
  75
  76 =head1 MORE INFORMATION
  77
  78 The L<perltie> section uses a good example of tying scalars by associating
  79 process IDs with priority.
  80
  81 =cut
  82
  83 use Carp;
  84 use warnings::register;
  85
  86 sub new {
  87     my $pkg = shift;
  88     $pkg->TIESCALAR(@_);
  89 }
  90
  91 # "Grandfather" the new, a la Tie::Hash
  92
  93 sub TIESCALAR {
  94     my $pkg = shift;
  95     if (defined &{"{$pkg}::new"}) {
  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
 104 sub FETCH {
 105     my $pkg = ref $_[0];
 106     croak "$pkg doesn't define a FETCH method";
 107 }
 108
 109 sub 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 #
 119 package Tie::StdScalar;
 120 @ISA = (Tie::Scalar);
 121
 122 sub TIESCALAR {
 123     my $class = shift;
 124     my $instance = shift || undef;
 125     return bless \$instance => $class;
 126 }
 127
 128 sub FETCH {
 129     return ${$_[0]};
 130 }
 131
 132 sub STORE {
 133     ${$_[0]} = $_[1];
 134 }
 135
 136 sub DESTROY {
 137     undef ${$_[0]};
 138 }
 139
 140 1;