Constructor method which creates a new Template::TT3::Cache object.

use Template::TT3::Cache;

my $cache = Template::TT3::Cache->new();

The size parameter (or cache_size if you prefer your parameters a little more long-winded) can be specified to define a limit to the number of items that the cache will store at any one time.

my $cache = Template::TT3::Cache->new( size => 32 );        # either
my $cache = Template::TT3::Cache->new( cache_size => 32 );  # or

Set size to 0 to explicitly disable any caching.

my $cache = Template::TT3::Cache->new( size => 0 );

The default size value is -1 which indicates an unlimited size for the cache. The Template::TT3::Constants module defines the CACHE_ALL constant for this value.

use Template::TT3::Constants 'CACHE_ALL';

my $cache = Template::TT3::Cache->new( size => CACHE_ALL );

The CACHE_NONE (0) constant is also provided for completeness.

use Template::TT3::Constants 'CACHE_NONE';

my $cache = Template::TT3::Cache->new( size => CACHE_NONE );

You can import both CACHE_NONE and CACHE_ALL by specifying the :cache constant group.

use Template::TT3::Constants ':cache';

Add an item to the cache. The first argument provides a name for the component passed as the second argument, by which it can subsequently be fetched via the get() method.

$cache->set( foo => $foo_component );

Fetch an item from the cache previously stored by calling set(). If the item is not in the cache, either because it was never been put in the cache or because it was, but has subsequently expired, then the method returns undef.

This method deletes all items from the cache and frees the memory associated with the cache slots. It is called automatically by the DESTROY method when the cache object goes out of scope.

For the technically minded, the Least-Recently-Used algorithm implements a doubly linked list of slots. Perl cannot free this data structure automatically due to the circular references between the forward (NEXT) and backward (PREV) references. This method walks the list explciitly deleting all the NEXT/PREV references, allowing the proper cleanup to occur and memory to be repooled.

This is an alias to the clear() method in keeping with other TT3 modules that follow that convention. It is called automatically by the DESTROY method when the cache object goes out of scope and is garbage collected.

You can manually call the destroy() method if you want to, but you probably shouldn't ever need to.

Internal method to insert a cache slot at the head of the linked list. New slots are always inserted at the head of the list. Each time an entry is fetched from the cache, we remove the slot from its current position in the list and re-insert it at the head. Thus, the list remain sorted in most-recently-used to least-recently-used order.

# first and last items in slot are prev/next references which the
# _insert_slot() method will fill in
$self->_insert_slot([undef, $name, $data, undef]);

Internal method to remove a slot from the linked list.

$self->_remove_slot($slot);

Perl calls this method automatically when the cache object goes out of scope. In turn it calls the destroy() method which is a simple alias to the clear() method which releases the memory retained by the cache slots.

Subclasses may want to define the destroy() method to implement different or additional behaviour.