

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: Plugin.pm</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>#============================================================= -*-Perl-*-
#
# Template::Plugin
#
# DESCRIPTION
#
#   Module defining a base class for a plugin object which can be loaded
#   and instantiated via the USE directive.
#
# AUTHOR
#   Andy Wardley   &lt;abw@wardley.org&gt;
#
# COPYRIGHT
#   Copyright (C) 1996-2022 Andy Wardley.  All Rights Reserved.
#
#   This module is free software; you can redistribute it an/or
#   modify it under the same terms as Perl itself.
#
#============================================================================

package Template::Plugin;

use strict;
use warnings;
use base &#039;Template::Base&#039;;

our $VERSION = &#039;3.106&#039;;
our $DEBUG   = 0 unless defined $DEBUG;
our $ERROR   = &#039;&#039;;
our $AUTOLOAD;


#========================================================================
#                      -----  CLASS METHODS -----
#========================================================================

#------------------------------------------------------------------------
# load()
#
# Class method called when the plugin module is first loaded.  It
# returns the name of a class (by default, its own class) or a prototype
# object which will be used to instantiate new objects.  The new()
# method is then called against the class name (class method) or
# prototype object (object method) to create a new instances of the
# object.
#------------------------------------------------------------------------

sub load {
    return $_[0];
}


#------------------------------------------------------------------------
# new($context, $delegate, @params)
#
# Object constructor which is called by the Template::Context to
# instantiate a new Plugin object.  This base class constructor is
# used as a general mechanism to load and delegate to other Perl
# modules.  The context is passed as the first parameter, followed by
# a reference to a delegate object or the name of the module which
# should be loaded and instantiated.  Any additional parameters passed
# to the USE directive are forwarded to the new() constructor.
#
# A plugin object is returned which has an AUTOLOAD method to delegate
# requests to the underlying object.
#------------------------------------------------------------------------

sub new {
    my $class = shift;
    bless {
    }, $class;
}

#------------------------------------------------------------------------
# fail($error)
#
# Version 1 error reporting function, now replaced by error() inherited
# from Template::Base.  Raises a &quot;deprecated function&quot; warning and then
# calls error().
#------------------------------------------------------------------------

sub fail {
    my $class = shift;
    my ($pkg, $file, $line) = caller();
    warn &quot;Template::Plugin::fail() is deprecated at $file line $line.  Please use error()\n&quot;;
    $class-&gt;error(@_);
}

1;

__END__

=head1 NAME

Template::Plugin - Base class for Template Toolkit plugins

=head1 SYNOPSIS

    package MyOrg::Template::Plugin::MyPlugin;
    use base qw( Template::Plugin );
    use Template::Plugin;
    use MyModule;

    sub new {
        my $class   = shift;
        my $context = shift;
        bless {
            ...
        }, $class;
    }

=head1 DESCRIPTION

A &quot;plugin&quot; for the Template Toolkit is simply a Perl module which
exists in a known package location (e.g. C&lt;Template::Plugin::*&gt;) and
conforms to a regular standard, allowing it to be loaded and used
automatically.

The C&lt;Template::Plugin&gt; module defines a base class from which other
plugin modules can be derived.  A plugin does not have to be derived
from Template::Plugin but should at least conform to its object-oriented
interface.

It is recommended that you create plugins in your own package namespace
to avoid conflict with toolkit plugins.  e.g.

    package MyOrg::Template::Plugin::FooBar;

Use the L&lt;PLUGIN_BASE|Template::Manual::Config#PLUGIN_BASE&gt; option to specify
the namespace that you use. e.g.

    use Template;
    my $template = Template-&gt;new({
        PLUGIN_BASE =&gt; &#039;MyOrg::Template::Plugin&#039;,
    });

=head1 METHODS

The following methods form the basic interface between the Template
Toolkit and plugin modules.

=head2 load($context)

This method is called by the Template Toolkit when the plugin module
is first loaded.  It is called as a package method and thus implicitly
receives the package name as the first parameter.  A reference to the
L&lt;Template::Context&gt; object loading the plugin is also passed.  The
default behaviour for the C&lt;load()&gt; method is to simply return the class
name.  The calling context then uses this class name to call the C&lt;new()&gt;
package method.

    package MyPlugin;

    sub load {               # called as MyPlugin-&gt;load($context)
        my ($class, $context) = @_;
        return $class;       # returns &#039;MyPlugin&#039;
    }

=head2 new($context, @params)

This method is called to instantiate a new plugin object for the C&lt;USE&gt;
directive. It is called as a package method against the class name returned by
L&lt;load()&gt;. A reference to the L&lt;Template::Context&gt; object creating the plugin
is passed, along with any additional parameters specified in the C&lt;USE&gt;
directive.

    sub new {                # called as MyPlugin-&gt;new($context)
        my ($class, $context, @params) = @_;
        bless {
            _CONTEXT =&gt; $context,
        }, $class;           # returns blessed MyPlugin object
    }

=head2 error($error)

This method, inherited from the L&lt;Template::Base&gt; module, is used for
reporting and returning errors.   It can be called as a package method
to set/return the C&lt;$ERROR&gt; package variable, or as an object method to
set/return the object C&lt;_ERROR&gt; member.  When called with an argument, it
sets the relevant variable and returns C&lt;undef.&gt;  When called without an
argument, it returns the value of the variable.

    package MyPlugin;
    use base &#039;Template::Plugin&#039;;

    sub new {
        my ($class, $context, $dsn) = @_;

        return $class-&gt;error(&#039;No data source specified&#039;)
            unless $dsn;

        bless {
            _DSN =&gt; $dsn,
        }, $class;
    }

    package main;

    my $something = MyPlugin-&gt;new()
        || die MyPlugin-&gt;error(), &quot;\n&quot;;

    $something-&gt;do_something()
        || die $something-&gt;error(), &quot;\n&quot;;

=head1 DEEPER MAGIC

The L&lt;Template::Context&gt; object that handles the loading and use of plugins
calls the L&lt;new()&gt; and L&lt;error()&gt; methods against the package name returned by
the L&lt;load()&gt; method. In pseudo-code terms looks something like this:

    $class  = MyPlugin-&gt;load($context);       # returns &#039;MyPlugin&#039;

    $object = $class-&gt;new($context, @params)  # MyPlugin-&gt;new(...)
        || die $class-&gt;error();               # MyPlugin-&gt;error()

The L&lt;load()&gt; method may alternately return a blessed reference to an
object instance.  In this case, L&lt;new()&gt; and L&lt;error()&gt; are then called as
I&lt;object&gt; methods against that prototype instance.

    package YourPlugin;

    sub load {
        my ($class, $context) = @_;
        bless {
            _CONTEXT =&gt; $context,
        }, $class;
    }

    sub new {
        my ($self, $context, @params) = @_;
        return $self;
    }

In this example, we have implemented a &#039;Singleton&#039; plugin.  One object
gets created when L&lt;load()&gt; is called and this simply returns itself for
each call to L&lt;new().&gt;

Another implementation might require individual objects to be created
for every call to L&lt;new(),&gt; but with each object sharing a reference to
some other object to maintain cached data, database handles, etc.
This pseudo-code example demonstrates the principle.

    package MyServer;

    sub load {
        my ($class, $context) = @_;
        bless {
            _CONTEXT =&gt; $context,
            _CACHE   =&gt; { },
        }, $class;
    }

    sub new {
        my ($self, $context, @params) = @_;
        MyClient-&gt;new($self, @params);
    }

    sub add_to_cache   { ... }

    sub get_from_cache { ... }

    package MyClient;

    sub new {
        my ($class, $server, $blah) = @_;
        bless {
            _SERVER =&gt; $server,
            _BLAH   =&gt; $blah,
        }, $class;
    }

    sub get {
        my $self = shift;
        $self-&gt;{ _SERVER }-&gt;get_from_cache(@_);
    }

    sub put {
        my $self = shift;
        $self-&gt;{ _SERVER }-&gt;add_to_cache(@_);
    }

When the plugin is loaded, a C&lt;MyServer&gt; instance is created. The L&lt;new()&gt;
method is called against this object which instantiates and returns a C&lt;MyClient&gt;
object, primed to communicate with the creating C&lt;MyServer&gt;.

=head1 AUTHOR

Andy Wardley E&lt;lt&gt;abw@wardley.orgE&lt;gt&gt; L&lt;http://wardley.org/&gt;

=head1 COPYRIGHT

Copyright (C) 1996-2022 Andy Wardley.  All Rights Reserved.

This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself.

=head1 SEE ALSO

L&lt;Template&gt;, L&lt;Template::Plugins&gt;, L&lt;Template::Context&gt;

=cut

# Local Variables:
# mode: perl
# perl-indent-level: 4
# indent-tabs-mode: nil
# End:
#
# vim: expandtab shiftwidth=4:
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/local/lib64/perl5/Template/Plugin.pm'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fusr%2Flocal%2Flib64%2Fperl5%2FTemplate' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>