On Apache
Under GNU General Public License
2012-05-25 02:37 @38.107.179.237 Crawled by CCBot/1.0 (+http://www.commoncrawl.org/bot.html)
Template::Plugin(3pm) User Contributed Perl Documentation Template::Plugin(3pm)
NAME
Template::Plugin - Base class for Template Toolkit plugins
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;
}
DESCRIPTION
A "plugin" for the Template Toolkit is simply a Perl module which exists in a known
package location (e.g. Template::Plugin::*) and conforms to a regular standard, allowing
it to be loaded and used automatically.
The Template::Plugin 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 PLUGIN_BASE option to specify the namespace that you use. e.g.
use Template;
my $template = Template->new({
PLUGIN_BASE => 'MyOrg::Template::Plugin',
});
PLUGIN API
The following methods form the basic interface between the Template Toolkit and plugin
modules.
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 Template::Context object loading the plugin is
also passed. The default behaviour for the load() method is to simply return the
class name. The calling context then uses this class name to call the new() package
method.
package MyPlugin;
sub load { # called as MyPlugin->load($context)
my ($class, $context) = @_;
return $class; # returns 'MyPlugin'
}
new($context, @params)
This method is called to instantiate a new plugin object for the USE directive. It is
called as a package method against the class name returned by load(). A reference to
the Template::Context object creating the plugin is passed, along with any additional
parameters specified in the USE directive.
sub new { # called as MyPlugin->new($context)
my ($class, $context, @params) = @_;
bless {
_CONTEXT => $context,
}, $class; # returns blessed MyPlugin object
}
error($error)
This method, inherited from the Template::Base module, is used for reporting and
returning errors. It can be called as a package method to set/return the $ERROR
package variable, or as an object method to set/return the object _ERROR member. When
called with an argument, it sets the relevant variable and returns undef. When called
without an argument, it returns the value of the variable.
sub new {
my ($class, $context, $dsn) = @_;
return $class->error('No data source specified')
unless $dsn;
bless {
_DSN => $dsn,
}, $class;
}
...
my $something = MyModule->new()
|| die MyModule->error(), "\n";
$something->do_something()
|| die $something->error(), "\n";
DEEPER MAGIC
The Template::Context object that handles the loading and use of plugins calls the new()
and error() methods against the package name returned by the load() method. In pseudo-
code terms, it might look something like this:
$class = MyPlugin->load($context); # returns 'MyPlugin'
$object = $class->new($context, @params) # MyPlugin->new(...)
|| die $class->error(); # MyPlugin->error()
The load() method may alterately return a blessed reference to an object instance. In
this case, new() and error() are then called as object methods against that prototype
instance.
package YourPlugin;
sub load {
my ($class, $context) = @_;
bless {
_CONTEXT => $context,
}, $class;
}
sub new {
my ($self, $context, @params) = @_;
return $self;
}
In this example, we have implemented a 'Singleton' plugin. One object gets created when
load() is called and this simply returns itself for each call to new().
Another implementation might require individual objects to be created for every call to
new(), 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 => $context,
_CACHE => { },
}, $class;
}
sub new {
my ($self, $context, @params) = @_;
MyClient->new($self, @params);
}
sub add_to_cache { ... }
sub get_from_cache { ... }
package MyClient;
sub new {
my ($class, $server, $blah) = @_;
bless {
_SERVER => $server,
_BLAH => $blah,
}, $class;
}
sub get {
my $self = shift;
$self->{ _SERVER }->get_from_cache(@_);
}
sub put {
my $self = shift;
$self->{ _SERVER }->add_to_cache(@_);
}
When the plugin is loaded, a MyServer instance is created. The new() method is called
against this object which instantiates and returns a MyClient object, primed to
communicate with the creating MyServer.
Template::Plugin Delegation
As of version 2.01, the Template::Plugin module no longer provides an AUTOLOAD method to
delegate to other objects or classes. This was a badly designed feature that caused more
trouble than good. You can easily add your own AUTOLOAD method to perform delegation if
you require this kind of functionality.
AUTHOR
Andy Wardley <abw AT wardley.org>
<http://wardley.org/|http://wardley.org/>
VERSION
2.7, distributed as part of the Template Toolkit version 2.19, released on 27 April 2007.
COPYRIGHT
Copyright (C) 1996-2007 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.
SEE ALSO
Template, Template::Plugins, Template::Context
perl v5.10.0 2007-04-27 Template::Plugin(3pm)
Generated by $Id: phpMan.php,v 4.49 2006/02/26 13:18:18 chedong Exp $ Author: Che Dong
On Apache
Under GNU General Public License
2012-05-25 02:37 @38.107.179.237 Crawled by CCBot/1.0 (+http://www.commoncrawl.org/bot.html)