File Coverage

blib/lib/Cache/SizeAwareMemoryCache.pm
Criterion Covered Total %
statement 48 48 100.0
branch n/a
condition 2 3 66.7
subroutine 19 19 100.0
pod 7 9 77.8
total 76 79 96.2


line stmt bran cond sub pod time code
1             ######################################################################
2             # $Id: SizeAwareMemoryCache.pm,v 1.19 2003/04/15 14:46:24 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::SizeAwareMemoryCache;
13              
14              
15 1     1   19 use strict;
  1         18  
  1         20  
16 1     1   16 use vars qw( @ISA );
  1         11  
  1         17  
17 1     1   14 use Cache::Cache;
  1         9  
  1         17  
18 1     1   34 use Cache::CacheSizer;
  1         11  
  1         23  
19 1     1   156 use Cache::MemoryCache;
  1         11  
  1         26  
20 1     1   18 use Cache::SizeAwareCache qw( $NO_MAX_SIZE );
  1         9  
  1         18  
21              
22              
23             @ISA = qw ( Cache::MemoryCache Cache::SizeAwareCache );
24              
25              
26             my $DEFAULT_MAX_SIZE = $NO_MAX_SIZE;
27              
28              
29             sub Clear
30             {
31 8     8 1 97   return Cache::MemoryCache::Clear( );
32             }
33              
34              
35             sub Purge
36             {
37 2     2 1 38   return Cache::MemoryCache::Purge( );
38             }
39              
40              
41             sub Size
42             {
43 7     7 1 80   return Cache::MemoryCache::Size( );
44             }
45              
46              
47             sub new
48             {
49 3     3 1 1167   my ( $self ) = _new( @_ );
50 3         45   $self->_complete_initialization( );
51 3         46   return $self;
52             }
53              
54              
55             sub get
56             {
57 30     30 1 293   my ( $self, $p_key ) = @_;
58              
59 30         482   $self->_get_cache_sizer( )->update_access_time( $p_key );
60 30         618   return $self->SUPER::get( $p_key );
61             }
62              
63              
64             sub limit_size
65             {
66 2     2 1 20   my ( $self, $p_new_size ) = @_;
67              
68 2         22   $self->_get_cache_sizer( )->limit_size( $p_new_size );
69             }
70              
71              
72             sub set
73             {
74 32     32 1 350   my ( $self, $p_key, $p_data, $p_expires_in ) = @_;
75              
76 32         731   $self->SUPER::set( $p_key, $p_data, $p_expires_in );
77 32         466   $self->_get_cache_sizer( )->limit_size( $self->get_max_size( ) );
78             }
79              
80              
81             sub _new
82             {
83 3     3   30   my ( $proto, $p_options_hash_ref ) = @_;
84 3   66     41   my $class = ref( $proto ) || $proto;
85 3         76   my $self = $class->SUPER::_new( $p_options_hash_ref );
86 3         31   $self->_initialize_cache_sizer( );
87 3         31   return $self;
88             }
89              
90              
91             sub _initialize_cache_sizer
92             {
93 3     3   27   my ( $self ) = @_;
94              
95 3         34   my $max_size = $self->_read_option( 'max_size', $DEFAULT_MAX_SIZE );
96 3         42   $self->_set_cache_sizer( new Cache::CacheSizer( $self, $max_size ) );
97             }
98              
99              
100             sub get_max_size
101             {
102 32     32 0 282   my ( $self ) = @_;
103              
104 32         337   return $self->_get_cache_sizer( )->get_max_size( );
105             }
106              
107              
108             sub set_max_size
109             {
110 1     1 0 11   my ( $self, $p_max_size ) = @_;
111              
112 1         11   $self->_get_cache_sizer( )->set_max_size( $p_max_size );
113             }
114              
115              
116             sub _get_cache_sizer
117             {
118 97     97   973   my ( $self ) = @_;
119              
120 97         1291   return $self->{_Cache_Sizer};
121             }
122              
123              
124             sub _set_cache_sizer
125             {
126 3     3   26   my ( $self, $p_cache_sizer ) = @_;
127              
128 3         33   $self->{_Cache_Sizer} = $p_cache_sizer;
129             }
130              
131              
132             1;
133              
134              
135              
136             __END__
137            
138             =pod
139            
140             =head1 NAME
141            
142             Cache::SizeAwareMemoryCache -- extends Cache::MemoryCache
143            
144             =head1 DESCRIPTION
145            
146             The SizeAwareMemoryCache class adds the ability to dynamically limit
147             the size (in bytes) of a memory based cache. This class also
148             implements the SizeAwareCache interface, providing the 'max_size'
149             option and the 'limit_size( $size )' method.
150            
151             =head1 SYNOPSIS
152            
153             use Cache::SizeAwareMemoryCache;
154            
155             my $cache =
156             new Cache::SizeAwareMemoryCache( { 'namespace' => 'MyNamespace',
157             'default_expires_in' => 600,
158             'max_size' => 10000 } );
159            
160             =head1 METHODS
161            
162             See Cache::Cache and Cache::SizeAwareCache for the API documentation.
163            
164             =head1 OPTIONS
165            
166             See Cache::Cache and Cache::SizeAwareCache for the standard options.
167            
168             =head1 PROPERTIES
169            
170             See Cache::Cache and Cache::SizeAwareCache for the default properties.
171            
172             =head1 SEE ALSO
173            
174             Cache::Cache, Cache::SizeAwareCache, Cache::MemoryCache
175            
176             =head1 AUTHOR
177            
178             Original author: DeWitt Clinton <dewitt@unto.net>
179            
180             Last author: $Author: dclinton $
181            
182             Copyright (C) 2001-2003 DeWitt Clinton
183            
184             =cut
185            
186