perltie.1

视频监控网络部分的协议ddns,的模块的实现代码,请大家大胆指正.

\&            $f, length $him{$f};
\&    }
.Ve
.PP
In our tied hash DotFiles example, we use a regular
hash for the object containing several important
fields, of which only the \f(CW\*(C`{LIST}\*(C'\fR field will be what the
user thinks of as the real hash.
.IP "\s-1USER\s0" 5
.IX Item "USER"
whose dot files this object represents
.IP "\s-1HOME\s0" 5
.IX Item "HOME"
where those dot files live
.IP "\s-1CLOBBER\s0" 5
.IX Item "CLOBBER"
whether we should try to change or remove those dot files
.IP "\s-1LIST\s0" 5
.IX Item "LIST"
the hash of dot file names and content mappings
.PP
Here's the start of \fIDotfiles.pm\fR:
.PP
.Vb 5
\&    package DotFiles;
\&    use Carp;
\&    sub whowasi { (caller(1))[3] . \*(Aq()\*(Aq }
\&    my $DEBUG = 0;
\&    sub debug { $DEBUG = @_ ? shift : 1 }
.Ve
.PP
For our example, we want to be able to emit debugging info to help in tracing
during development.  We keep also one convenience function around
internally to help print out warnings; \fIwhowasi()\fR returns the function name
that calls it.
.PP
Here are the methods for the DotFiles tied hash.
.IP "\s-1TIEHASH\s0 classname, \s-1LIST\s0" 4
.IX Xref "TIEHASH"
.IX Item "TIEHASH classname, LIST"
This is the constructor for the class.  That means it is expected to
return a blessed reference through which the new object (probably but not
necessarily an anonymous hash) will be accessed.
.Sp
Here's the constructor:
.Sp
.Vb 9
\&    sub TIEHASH {
\&        my $self = shift;
\&        my $user = shift || $>;
\&        my $dotdir = shift || \*(Aq\*(Aq;
\&        croak "usage: @{[&whowasi]} [USER [DOTDIR]]" if @_;
\&        $user = getpwuid($user) if $user =~ /^\ed+$/;
\&        my $dir = (getpwnam($user))[7]
\&                || croak "@{[&whowasi]}: no user $user";
\&        $dir .= "/$dotdir" if $dotdir;
\&
\&        my $node = {
\&            USER    => $user,
\&            HOME    => $dir,
\&            LIST    => {},
\&            CLOBBER => 0,
\&        };
\&
\&        opendir(DIR, $dir)
\&                || croak "@{[&whowasi]}: can\*(Aqt opendir $dir: $!";
\&        foreach $dot ( grep /^\e./ && \-f "$dir/$_", readdir(DIR)) {
\&            $dot =~ s/^\e.//;
\&            $node\->{LIST}{$dot} = undef;
\&        }
\&        closedir DIR;
\&        return bless $node, $self;
\&    }
.Ve
.Sp
It's probably worth mentioning that if you're going to filetest the
return values out of a readdir, you'd better prepend the directory
in question.  Otherwise, because we didn't \fIchdir()\fR there, it would
have been testing the wrong file.
.IP "\s-1FETCH\s0 this, key" 4
.IX Xref "FETCH"
.IX Item "FETCH this, key"
This method will be triggered every time an element in the tied hash is
accessed (read).  It takes one argument beyond its self reference: the key
whose value we're trying to fetch.
.Sp
Here's the fetch for our DotFiles example.
.Sp
.Vb 6
\&    sub FETCH {
\&        carp &whowasi if $DEBUG;
\&        my $self = shift;
\&        my $dot = shift;
\&        my $dir = $self\->{HOME};
\&        my $file = "$dir/.$dot";
\&
\&        unless (exists $self\->{LIST}\->{$dot} || \-f $file) {
\&            carp "@{[&whowasi]}: no $dot file" if $DEBUG;
\&            return undef;
\&        }
\&
\&        if (defined $self\->{LIST}\->{$dot}) {
\&            return $self\->{LIST}\->{$dot};
\&        } else {
\&            return $self\->{LIST}\->{$dot} = \`cat $dir/.$dot\`;
\&        }
\&    }
.Ve
.Sp
It was easy to write by having it call the Unix \fIcat\fR\|(1) command, but it
would probably be more portable to open the file manually (and somewhat
more efficient).  Of course, because dot files are a Unixy concept, we're
not that concerned.
.IP "\s-1STORE\s0 this, key, value" 4
.IX Xref "STORE"
.IX Item "STORE this, key, value"
This method will be triggered every time an element in the tied hash is set
(written).  It takes two arguments beyond its self reference: the index at
which we're trying to store something, and the value we're trying to put
there.
.Sp
Here in our DotFiles example, we'll be careful not to let
them try to overwrite the file unless they've called the \fIclobber()\fR
method on the original object reference returned by \fItie()\fR.
.Sp
.Vb 7
\&    sub STORE {
\&        carp &whowasi if $DEBUG;
\&        my $self = shift;
\&        my $dot = shift;
\&        my $value = shift;
\&        my $file = $self\->{HOME} . "/.$dot";
\&        my $user = $self\->{USER};
\&
\&        croak "@{[&whowasi]}: $file not clobberable"
\&            unless $self\->{CLOBBER};
\&
\&        open(F, "> $file") || croak "can\*(Aqt open $file: $!";
\&        print F $value;
\&        close(F);
\&    }
.Ve
.Sp
If they wanted to clobber something, they might say:
.Sp
.Vb 3
\&    $ob = tie %daemon_dots, \*(Aqdaemon\*(Aq;
\&    $ob\->clobber(1);
\&    $daemon_dots{signature} = "A true daemon\en";
.Ve
.Sp
Another way to lay hands on a reference to the underlying object is to
use the \fItied()\fR function, so they might alternately have set clobber
using:
.Sp
.Vb 2
\&    tie %daemon_dots, \*(Aqdaemon\*(Aq;
\&    tied(%daemon_dots)\->clobber(1);
.Ve
.Sp
The clobber method is simply:
.Sp
.Vb 4
\&    sub clobber {
\&        my $self = shift;
\&        $self\->{CLOBBER} = @_ ? shift : 1;
\&    }
.Ve
.IP "\s-1DELETE\s0 this, key" 4
.IX Xref "DELETE"
.IX Item "DELETE this, key"
This method is triggered when we remove an element from the hash,
typically by using the \fIdelete()\fR function.  Again, we'll
be careful to check whether they really want to clobber files.
.Sp
.Vb 2
\&    sub DELETE   {
\&        carp &whowasi if $DEBUG;
\&
\&        my $self = shift;
\&        my $dot = shift;
\&        my $file = $self\->{HOME} . "/.$dot";
\&        croak "@{[&whowasi]}: won\*(Aqt remove file $file"
\&            unless $self\->{CLOBBER};
\&        delete $self\->{LIST}\->{$dot};
\&        my $success = unlink($file);
\&        carp "@{[&whowasi]}: can\*(Aqt unlink $file: $!" unless $success;
\&        $success;
\&    }
.Ve
.Sp
The value returned by \s-1DELETE\s0 becomes the return value of the call
to \fIdelete()\fR.  If you want to emulate the normal behavior of \fIdelete()\fR,
you should return whatever \s-1FETCH\s0 would have returned for this key.
In this example, we have chosen instead to return a value which tells
the caller whether the file was successfully deleted.
.IP "\s-1CLEAR\s0 this" 4
.IX Xref "CLEAR"
.IX Item "CLEAR this"
This method is triggered when the whole hash is to be cleared, usually by
assigning the empty list to it.
.Sp
In our example, that would remove all the user's dot files!  It's such a
dangerous thing that they'll have to set \s-1CLOBBER\s0 to something higher than
1 to make it happen.
.Sp
.Vb 10
\&    sub CLEAR    {
\&        carp &whowasi if $DEBUG;
\&        my $self = shift;
\&        croak "@{[&whowasi]}: won\*(Aqt remove all dot files for $self\->{USER}"
\&            unless $self\->{CLOBBER} > 1;
\&        my $dot;
\&        foreach $dot ( keys %{$self\->{LIST}}) {
\&            $self\->DELETE($dot);
\&        }
\&    }
.Ve
.IP "\s-1EXISTS\s0 this, key" 4
.IX Xref "EXISTS"
.IX Item "EXISTS this, key"
This method is triggered when the user uses the \fIexists()\fR function
on a particular hash.  In our example, we'll look at the \f(CW\*(C`{LIST}\*(C'\fR
hash element for this:
.Sp
.Vb 6
\&    sub EXISTS   {
\&        carp &whowasi if $DEBUG;
\&        my $self = shift;
\&        my $dot = shift;
\&        return exists $self\->{LIST}\->{$dot};
\&    }
.Ve
.IP "\s-1FIRSTKEY\s0 this" 4
.IX Xref "FIRSTKEY"
.IX Item "FIRSTKEY this"
This method will be triggered when the user is going
to iterate through the hash, such as via a \fIkeys()\fR or \fIeach()\fR
call.
.Sp
.Vb 6
\&    sub FIRSTKEY {
\&        carp &whowasi if $DEBUG;
\&        my $self = shift;
\&        my $a = keys %{$self\->{LIST}};          # reset each() iterator
\&        each %{$self\->{LIST}}
\&    }
.Ve
.IP "\s-1NEXTKEY\s0 this, lastkey" 4
.IX Xref "NEXTKEY"
.IX Item "NEXTKEY this, lastkey"
This method gets triggered during a \fIkeys()\fR or \fIeach()\fR iteration.  It has a
second argument which is the last key that had been accessed.  This is
useful if you're carrying about ordering or calling the iterator from more
than one sequence, or not really storing things in a hash anywhere.
.Sp
For our example, we're using a real hash so we'll do just the simple
thing, but we'll have to go through the \s-1LIST\s0 field indirectly.
.Sp
.Vb 5
\&    sub NEXTKEY  {
\&        carp &whowasi if $DEBUG;
\&        my $self = shift;
\&        return each %{ $self\->{LIST} }
\&    }
.Ve
.IP "\s-1SCALAR\s0 this" 4
.IX Xref "SCALAR"
.IX Item "SCALAR this"
This is called when the hash is evaluated in scalar context. In order
to mimic the behaviour of untied hashes, this method should return a
false value when the tied hash is considered empty. If this method does
not exist, perl will make some educated guesses and return true when
the hash is inside an iteration. If this isn't the case, \s-1FIRSTKEY\s0 is
called, and the result will be a false value if \s-1FIRSTKEY\s0 returns the empty
list, true otherwise.
.Sp
However, you should \fBnot\fR blindly rely on perl always doing the right 
thing. Particularly, perl will mistakenly return true when you clear the 
hash by repeatedly calling \s-1DELETE\s0 until it is empty. You are therefore 
advised to supply your own \s-1SCALAR\s0 method when you want to be absolutely 
sure that your hash behaves nicely in scalar context.
.Sp
In our example we can just call \f(CW\*(C`scalar\*(C'\fR on the underlying hash
referenced by \f(CW\*(C`$self\->{LIST}\*(C'\fR:
.Sp
.Vb 5
\&    sub SCALAR {
\&        carp &whowasi if $DEBUG;
\&        my $self = shift;
\&        return scalar %{ $self\->{LIST} }
\&    }
.Ve
.IP "\s-1UNTIE\s0 this" 4
.IX Xref "UNTIE"
.IX Item "UNTIE this"
This is called when \f(CW\*(C`untie\*(C'\fR occurs.  See "The \f(CW\*(C`untie\*(C'\fR Gotcha" below.
.IP "\s-1DESTROY\s0 this" 4
.IX Xref "DESTROY"
.IX Item "DESTROY this"
This method is triggered when a tied hash is about to go out of
scope.  You don't really need it unless you're trying to add debugging
or have auxiliary state to clean up.  Here's a very simple function:
.Sp
.Vb 3
\&    sub DESTROY  {
\&        carp &whowasi if $DEBUG;
\&    }
.Ve
.PP
Note that functions such as \fIkeys()\fR and \fIvalues()\fR may return huge lists
when used on large objects, like \s-1DBM\s0 files.  You may prefer to use the
\&\fIeach()\fR function to iterate over such.  Example:
.PP
.Vb 7
\&    # print out history file offsets
\&    use NDBM_File;
\&    tie(%HIST, \*(AqNDBM_File\*(Aq, \*(Aq/usr/lib/news/history\*(Aq, 1, 0);
\&    while (($key,$val) = each %HIST) {
\&        print $key, \*(Aq = \*(Aq, unpack(\*(AqL\*(Aq,$val), "\en";
\&    }
\&    untie(%HIST);
.Ve
.Sh "Tying FileHandles"
.IX Xref "filehandle, tying"
.IX Subsection "Tying FileHandles"
This is partially implemented now.
.PP
A class implementing a tied filehandle should define the following
methods: \s-1TIEHANDLE\s0, at least one of \s-1PRINT\s0, \s-1PRINTF\s0, \s-1WRITE\s0, \s-1READLINE\s0, \s-1GETC\s0,
\&\s-1READ\s0, and possibly \s-1CLOSE\s0, \s-1UNTIE\s0 and \s-1DESTROY\s0.  The class can also provide: \s-1BINMODE\s0,
\&\s-1OPEN\s0, \s-1EOF\s0, \s-1FILENO\s0, \s-1SEEK\s0, \s-1TELL\s0 \- if the corresponding perl operators are
used on the handle.
.PP
When \s-1STDERR\s0 is tied, its \s-1PRINT\s0 method will be called to issue warnings
and error messages.  This feature is temporarily disabled during the call, 
which means you can use \f(CW\*(C`warn()\*(C'\fR inside \s-1PRINT\s0 without starting a recursive
loop.  And just like \f(CW\*(C`_\|_WARN_\|_\*(C'\fR and \f(CW\*(C`_\|_DIE_\|_\*(C'\fR handlers, \s-1STDERR\s0's \s-1PRINT\s0
method may be called to report parser errors, so the caveats mentioned under 
\&\*(L"%SIG\*(R" in perlvar apply.
.PP
All of this is especially useful when perl is embedded in some other 
program, where output to \s-1STDOUT\s0 and \s-1STDERR\s0 may have to be redirected