mro.3

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

methods from \f(CW\*(C`UNIVERSAL\*(C'\fR and its parents.
.ie n .Sh "mro::set_mro($classname, $type)"
.el .Sh "mro::set_mro($classname, \f(CW$type\fP)"
.IX Subsection "mro::set_mro($classname, $type)"
Sets the \s-1MRO\s0 of the given class to the \f(CW$type\fR argument (either
\&\f(CW\*(C`c3\*(C'\fR or \f(CW\*(C`dfs\*(C'\fR).
.Sh "mro::get_mro($classname)"
.IX Subsection "mro::get_mro($classname)"
Returns the \s-1MRO\s0 of the given class (either \f(CW\*(C`c3\*(C'\fR or \f(CW\*(C`dfs\*(C'\fR).
.Sh "mro::get_isarev($classname)"
.IX Subsection "mro::get_isarev($classname)"
Gets the \f(CW\*(C`mro_isarev\*(C'\fR for this class, returned as an
arrayref of class names.  These are every class that \*(L"isa\*(R"
the given class name, even if the isa relationship is
indirect.  This is used internally by the \s-1MRO\s0 code to
keep track of method/MRO cache invalidations.
.PP
Currently, this list only grows, it never shrinks.  This
was a performance consideration (properly tracking and
deleting isarev entries when someone removes an entry
from an \f(CW@ISA\fR is costly, and it doesn't happen often
anyways).  The fact that a class which no longer truly
\&\*(L"isa\*(R" this class at runtime remains on the list should be
considered a quirky implementation detail which is subject
to future change.  It shouldn't be an issue as long as
you're looking at this list for the same reasons the
core code does: as a performance optimization
over having to search every class in existence.
.PP
As with \f(CW\*(C`mro::get_mro\*(C'\fR above, \f(CW\*(C`UNIVERSAL\*(C'\fR is special.
\&\f(CW\*(C`UNIVERSAL\*(C'\fR (and parents') isarev lists do not include
every class in existence, even though all classes are
effectively descendants for method inheritance purposes.
.Sh "mro::is_universal($classname)"
.IX Subsection "mro::is_universal($classname)"
Returns a boolean status indicating whether or not
the given classname is either \f(CW\*(C`UNIVERSAL\*(C'\fR itself,
or one of \f(CW\*(C`UNIVERSAL\*(C'\fR's parents by \f(CW@ISA\fR inheritance.
.PP
Any class for which this function returns true is
\&\*(L"universal\*(R" in the sense that all classes potentially
inherit methods from it.
.PP
For similar reasons to \f(CW\*(C`isarev\*(C'\fR above, this flag is
permanent.  Once it is set, it does not go away, even
if the class in question really isn't universal anymore.
.Sh "\fImro::invalidate_all_method_caches()\fP"
.IX Subsection "mro::invalidate_all_method_caches()"
Increments \f(CW\*(C`PL_sub_generation\*(C'\fR, which invalidates method
caching in all packages.
.Sh "mro::method_changed_in($classname)"
.IX Subsection "mro::method_changed_in($classname)"
Invalidates the method cache of any classes dependent on the
given class.  This is not normally necessary.  The only
known case where pure perl code can confuse the method
cache is when you manually install a new constant
subroutine by using a readonly scalar value, like the
internals of constant do.  If you find another case,
please report it so we can either fix it or document
the exception here.
.Sh "mro::get_pkg_gen($classname)"
.IX Subsection "mro::get_pkg_gen($classname)"
Returns an integer which is incremented every time a
real local method in the package \f(CW$classname\fR changes,
or the local \f(CW@ISA\fR of \f(CW$classname\fR is modified.
.PP
This is intended for authors of modules which do lots
of class introspection, as it allows them to very quickly
check if anything important about the local properties
of a given class have changed since the last time they
looked.  It does not increment on method/\f(CW@ISA\fR
changes in superclasses.
.PP
It's still up to you to seek out the actual changes,
and there might not actually be any.  Perhaps all
of the changes since you last checked cancelled each
other out and left the package in the state it was in
before.
.PP
This integer normally starts off at a value of \f(CW1\fR
when a package stash is instantiated.  Calling it
on packages whose stashes do not exist at all will
return \f(CW0\fR.  If a package stash is completely
deleted (not a normal occurence, but it can happen
if someone does something like \f(CW\*(C`undef %PkgName::\*(C'\fR),
the number will be reset to either \f(CW0\fR or \f(CW1\fR,
depending on how completely package was wiped out.
.Sh "next::method"
.IX Subsection "next::method"
This is somewhat like \f(CW\*(C`SUPER\*(C'\fR, but it uses the C3 method
resolution order to get better consistency in multiple
inheritance situations.  Note that while inheritance in
general follows whichever \s-1MRO\s0 is in effect for the
given class, \f(CW\*(C`next::method\*(C'\fR only uses the C3 \s-1MRO\s0.
.PP
One generally uses it like so:
.PP
.Vb 5
\&  sub some_method {
\&    my $self = shift;
\&    my $superclass_answer = $self\->next::method(@_);
\&    return $superclass_answer + 1;
\&  }
.Ve
.PP
Note that you don't (re\-)specify the method name.
It forces you to always use the same method name
as the method you started in.
.PP
It can be called on an object or a class, of course.
.PP
The way it resolves which actual method to call is:
.IP "1." 4
First, it determines the linearized C3 \s-1MRO\s0 of
the object or class it is being called on.
.IP "2." 4
Then, it determines the class and method name
of the context it was invoked from.
.IP "3." 4
Finally, it searches down the C3 \s-1MRO\s0 list until
it reaches the contextually enclosing class, then
searches further down the \s-1MRO\s0 list for the next
method with the same name as the contextually
enclosing method.
.PP
Failure to find a next method will result in an
exception being thrown (see below for alternatives).
.PP
This is substantially different than the behavior
of \f(CW\*(C`SUPER\*(C'\fR under complex multiple inheritance.
(This becomes obvious when one realizes that the
common superclasses in the C3 linearizations of
a given class and one of its parents will not
always be ordered the same for both.)
.PP
\&\fBCaveat\fR: Calling \f(CW\*(C`next::method\*(C'\fR from methods defined outside the class:
.PP
There is an edge case when using \f(CW\*(C`next::method\*(C'\fR from within a subroutine
which was created in a different module than the one it is called from. It
sounds complicated, but it really isn't. Here is an example which will not
work correctly:
.PP
.Vb 1
\&  *Foo::foo = sub { (shift)\->next::method(@_) };
.Ve
.PP
The problem exists because the anonymous subroutine being assigned to the
\&\f(CW*Foo::foo\fR glob will show up in the call stack as being called
\&\f(CW\*(C`_\|_ANON_\|_\*(C'\fR and not \f(CW\*(C`foo\*(C'\fR as you might expect. Since \f(CW\*(C`next::method\*(C'\fR uses
\&\f(CW\*(C`caller\*(C'\fR to find the name of the method it was called in, it will fail in
this case.
.PP
But fear not, there's a simple solution. The module \f(CW\*(C`Sub::Name\*(C'\fR will
reach into the perl internals and assign a name to an anonymous subroutine
for you. Simply do this:
.PP
.Vb 2
\&  use Sub::Name \*(Aqsubname\*(Aq;
\&  *Foo::foo = subname \*(AqFoo::foo\*(Aq => sub { (shift)\->next::method(@_) };
.Ve
.PP
and things will Just Work.
.Sh "next::can"
.IX Subsection "next::can"
This is similar to \f(CW\*(C`next::method\*(C'\fR, but just returns either a code
reference or \f(CW\*(C`undef\*(C'\fR to indicate that no further methods of this name
exist.
.Sh "maybe::next::method"
.IX Subsection "maybe::next::method"
In simple cases, it is equivalent to:
.PP
.Vb 1
\&   $self\->next::method(@_) if $self\->next_can;
.Ve
.PP
But there are some cases where only this solution
works (like \f(CW\*(C`goto &maybe::next::method\*(C'\fR);
.SH "SEE ALSO"
.IX Header "SEE ALSO"
.Sh "The original Dylan paper"
.IX Subsection "The original Dylan paper"
.IP "<http://www.webcom.com/haahr/dylan/linearization\-oopsla96.html>" 4
.IX Item "<http://www.webcom.com/haahr/dylan/linearization-oopsla96.html>"
.Sh "The prototype Perl 6 Object Model uses C3"
.IX Subsection "The prototype Perl 6 Object Model uses C3"
.PD 0
.IP "<http://svn.openfoundry.org/pugs/perl5/Perl6\-MetaModel/>" 4
.IX Item "<http://svn.openfoundry.org/pugs/perl5/Perl6-MetaModel/>"
.PD
.Sh "Parrot now uses C3"
.IX Subsection "Parrot now uses C3"
.IP "<http://aspn.activestate.com/ASPN/Mail/Message/perl6\-internals/2746631>" 4
.IX Item "<http://aspn.activestate.com/ASPN/Mail/Message/perl6-internals/2746631>"
.PD 0
.IP "<http://use.perl.org/~autrijus/journal/25768>" 4
.IX Item "<http://use.perl.org/~autrijus/journal/25768>"
.PD
.Sh "Python 2.3 \s-1MRO\s0 related links"
.IX Subsection "Python 2.3 MRO related links"
.IP "<http://www.python.org/2.3/mro.html>" 4
.IX Item "<http://www.python.org/2.3/mro.html>"
.PD 0
.IP "<http://www.python.org/2.2.2/descrintro.html#mro>" 4
.IX Item "<http://www.python.org/2.2.2/descrintro.html#mro>"
.PD
.Sh "C3 for TinyCLOS"
.IX Subsection "C3 for TinyCLOS"
.IP "<http://www.call\-with\-current\-continuation.org/eggs/c3.html>" 4
.IX Item "<http://www.call-with-current-continuation.org/eggs/c3.html>"
.Sh "Class::C3"
.IX Subsection "Class::C3"
.PD 0
.IP "Class::C3" 4
.IX Item "Class::C3"
.PD
.SH "AUTHOR"
.IX Header "AUTHOR"
Brandon L. Black, <[e-mail]>
.PP
Based on Stevan Little's Class::C3