File Coverage

blib/lib/Cache/SizeAwareFileCache.pm
Criterion Covered Total %
statement 51 51 100.0
branch n/a
condition 2 3 66.7
subroutine 19 19 100.0
pod 7 9 77.8
total 79 82 96.3


line stmt bran cond sub pod time code
1             ######################################################################
2             # $Id: SizeAwareFileCache.pm,v 1.29 2003/04/15 14:46:23 dclinton Exp $
3             # Copyright (C) 2001-2003 DeWitt Clinton All Rights Reserved
4             #
5             # Software distributed under the License is distributed on an "AS
6             # IS" basis, WITHOUT WARRANTY OF ANY KIND, either expressed or
7             # implied. See the License for the specific language governing
8             # rights and limitations under the License.
9             ######################################################################
10              
11              
12             package Cache::SizeAwareFileCache;
13              
14              
15 1     1   15 use strict;
  1         18  
  1         16  
16 1     1   15 use vars qw( @ISA );
  1         9  
  1         14  
17 1     1   43 use Cache::CacheSizer;
  1         10  
  1         21  
18 1     1   17 use Cache::CacheUtils qw( Static_Params );
  1         10  
  1         16  
19 1     1   38 use Cache::FileCache;
  1         11  
  1         28  
20 1     1   19 use Cache::SizeAwareCache qw( $NO_MAX_SIZE );
  1         11  
  1         38  
21              
22              
23             @ISA = qw ( Cache::FileCache Cache::SizeAwareCache );
24              
25              
26             my $DEFAULT_MAX_SIZE = $NO_MAX_SIZE;
27              
28              
29             sub Clear
30             {
31 8     8 1 129   my ( $p_optional_cache_root ) = Static_Params( @_ );
32              
33 8         176   Cache::FileCache::Clear( $p_optional_cache_root );
34             }
35              
36              
37             sub Purge
38             {
39 2     2 1 32   my ( $p_optional_cache_root ) = Static_Params( @_ );
40              
41 2         30   Cache::FileCache::Purge( $p_optional_cache_root );
42             }
43              
44              
45             sub Size
46             {
47 7     7 1 95   my ( $p_optional_cache_root ) = Static_Params( @_ );
48              
49 7         95   return Cache::FileCache::Size( $p_optional_cache_root );
50             }
51              
52              
53             sub new
54             {
55 3     3 1 1125   my ( $self ) = _new( @_ );
56 3         44   $self->_complete_initialization( );
57 3         47   return $self;
58             }
59              
60              
61             sub get
62             {
63 30     30 1 349   my ( $self, $p_key ) = @_;
64              
65 30         709   $self->_get_cache_sizer( )->update_access_time( $p_key );
66 30         1382   return $self->SUPER::get( $p_key );
67             }
68              
69              
70             sub limit_size
71             {
72 2     2 1 22   my ( $self, $p_new_size ) = @_;
73              
74 2         23   $self->_get_cache_sizer( )->limit_size( $p_new_size );
75             }
76              
77              
78              
79             sub set
80             {
81 32     32 1 363   my ( $self, $p_key, $p_data, $p_expires_in ) = @_;
82              
83 32         748   $self->SUPER::set( $p_key, $p_data, $p_expires_in );
84 32         3060   $self->_get_cache_sizer( )->limit_size( $self->get_max_size( ) );
85             }
86              
87              
88              
89             sub _new
90             {
91 3     3   30   my ( $proto, $p_options_hash_ref ) = @_;
92 3   66     42   my $class = ref( $proto ) || $proto;
93 3         88   my $self = $class->SUPER::_new( $p_options_hash_ref );
94 3         74   $self->_initialize_cache_sizer( );
95 3         30   return $self;
96             }
97              
98              
99             sub _initialize_cache_sizer
100             {
101 3     3   31   my ( $self ) = @_;
102              
103 3         37   my $max_size = $self->_read_option( 'max_size', $DEFAULT_MAX_SIZE );
104 3         57   $self->_set_cache_sizer( new Cache::CacheSizer( $self, $max_size ) );
105             }
106              
107              
108             sub get_max_size
109             {
110 32     32 0 302   my ( $self ) = @_;
111              
112 32         314   return $self->_get_cache_sizer( )->get_max_size( );
113             }
114              
115              
116             sub set_max_size
117             {
118 1     1 0 11   my ( $self, $p_max_size ) = @_;
119              
120 1         13   $self->_get_cache_sizer( )->set_max_size( $p_max_size );
121             }
122              
123              
124             sub _get_cache_sizer
125             {
126 97     97   961   my ( $self ) = @_;
127              
128 97         2663   return $self->{_Cache_Sizer};
129             }
130              
131              
132             sub _set_cache_sizer
133             {
134 3     3   27   my ( $self, $p_cache_sizer ) = @_;
135              
136 3         33   $self->{_Cache_Sizer} = $p_cache_sizer;
137             }
138              
139              
140              
141              
142             1;
143              
144              
145             __END__
146            
147             =pod
148            
149             =head1 NAME
150            
151             Cache::SizeAwareFileCache -- extends Cache::FileCache
152            
153             =head1 DESCRIPTION
154            
155             The SizeAwareFileCache class adds the ability to dynamically limit the
156             size (in bytes) of a file system based cache. This class also
157             implements the SizeAwareCache interface, providing the 'max_size'
158             option and the 'limit_size( $size )' method.
159            
160             =head1 SYNOPSIS
161            
162             use Cache::SizeAwareFileCache;
163            
164             my $cache =
165             new Cache::SizeAwareFileCache( { 'namespace' => 'MyNamespace',
166             'default_expires_in' => 600,
167             'max_size' => 10000 } );
168            
169             =head1 METHODS
170            
171             See Cache::Cache and Cache::SizeAwareCache for the API documentation.
172            
173             =head1 OPTIONS
174            
175             See Cache::Cache and Cache::SizeAwareCache for the standard options.
176            
177             =head1 PROPERTIES
178            
179             See Cache::Cache and Cache::SizeAwareCache for the default properties.
180            
181             =head1 SEE ALSO
182            
183             Cache::Cache, Cache::SizeAwareCache, Cache::FileCache
184            
185             =head1 AUTHOR
186            
187             Original author: DeWitt Clinton <dewitt@unto.net>
188            
189             Also: Portions of this code are a rewrite of David Coppit's excellent
190             extentions to the original File::Cache
191            
192             Last author: $Author: dclinton $
193            
194             Copyright (C) 2001-2003 DeWitt Clinton
195            
196             =cut
197