[%# # IMPORTANT NOTE # This documentation is generated automatically from source # templates. Any changes you make here may be lost. # # The 'docsrc' documentation source bundle is available for download # from http://www.template-toolkit.org/docs.html and contains all # the source templates, XML files, scripts, etc., from which the # documentation for the Template Toolkit is built. -%] [% META book = 'Modules' page = 'Plugin' %] [% WRAPPER toc; PROCESS tocitem title ="SYNOPSIS" subs = []; PROCESS tocitem title ="DESCRIPTION" subs = []; PROCESS tocitem title ="PLUGIN API" subs = []; PROCESS tocitem title ="DEEPER MAGIC" subs = []; PROCESS tocitem title ="Template::Plugin Delegation" subs = []; PROCESS tocitem title ="AUTHOR" subs = []; PROCESS tocitem title ="VERSION" subs = []; PROCESS tocitem title ="COPYRIGHT" subs = []; PROCESS tocitem title ="SEE ALSO" subs = []; END %] [% WRAPPER section title="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;
    }
[%- END %] [% WRAPPER section title="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',
    });
[%- END %] [% WRAPPER section title="PLUGIN API" -%]

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

[%- END %] [% WRAPPER section title="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.

[%- END %] [% WRAPPER section title="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 featured that caused more trouble than good. You can easily add your own AUTOLOAD method to perform delegation if you require this kind of functionality.

[%- END %] [% WRAPPER section title="AUTHOR" -%]

Andy Wardley <abw@andywardley.com>

[% ttlink('http://www.andywardley.com/', 'http://www.andywardley.com/') -%]

[%- END %] [% WRAPPER section title="VERSION" -%]

2.53, distributed as part of the Template Toolkit version 2.08, released on 30 July 2002.

[%- END %] [% WRAPPER section title="COPYRIGHT" -%]
  Copyright (C) 1996-2002 Andy Wardley.  All Rights Reserved.
  Copyright (C) 1998-2002 Canon Research Centre Europe Ltd.

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

[%- END %] [% WRAPPER section title="SEE ALSO" -%]

[% ttlink('Template', 'Template') -%], [% ttlink('Template::Plugins', 'Template::Plugins') -%], [% ttlink('Template::Context', 'Template::Context') -%]

[%- END %]