Class: UniCache

Inherits:

Hash

• Object
• Hash
• UniCache

show all

Defined in:

lib/unicache.rb

Overview

require 'unicache'

# Create cache with size 2.
c = UniCache.new( 2 )

# Register callbacks for some events (two for hit).
c.registerCallback( :hit, Proc.new{ |k,v| puts  "Hit:   #{k}:#{v}" } )
c.registerCallback( :hit, Proc.new{ |k,v| puts  "Found: #{k}:#{v}" } )
c.registerCallback( :miss, Proc.new{ |k,v| puts "Miss:  #{k}:<NA>" } )

# Set some values.
c[0] = 'foo'   # set 0 as 'foo'
c.put( 'bar', 'foo' )

# Get (or try to get) some values.
a = c[ 'bar' ] # hit, a == 'foo'
b = c.get( 0 ) # hit, b == 'foo'
c.get( 'foo' ) # miss
c.get( 2 )     # miss

Hit:   bar:foo
Found: bar:foo
Hit:   0:foo
Found: 0:foo
Miss:  foo:<NA>
Miss:  2:<NA>

Defined Under Namespace

Classes: CallbackError, Error, FetchError, LruEviction, RemoveError, SizeError

Instance Attribute Summary (collapse)

• - (Object) lock readonly

  Access lock.

• - (Object) size readonly

  Cache size.

Instance Method Summary (collapse)

• - (Object) [](key)

  Get operator.

• - (Object) []=(key, value)

  Put operator.

• - (Object) clear

  Clear all Cache entries.

• - (Boolean) exist?(key)

  Get Cache entry existance by key (no effect to eviction).

• - (Object) get(key) { ... }

  Get Cache entry by key or return nil if not in Cache.

• - (Object) hash_get_op
• - (Object) hash_set_op
• - (Object) hash_store
• - (UniCache) initialize(size, evict = LruEviction.new) constructor

  Cache initialization.

• - (Object) peek(key)

  Get Cache entry by key (no effect to eviction).

• - (Object) put(key, value)

  Put new entry to the Cache.

• - (Object) registerCallback(type, proc)

  Register a callback to be executed on Cache event.

• - (Object) remove(key = nil)

  Remove oldest Cache entry (Least Recently Used) or given.

• - (Object) removeCallback(type = nil)

  Remove all callbacks for type or all.

• - (Object) resize(size)

  Resize the Cache.

• - (Object) setEviction(evict)

  Set the eviction policy.

• - (Object) store

  Dummy definition for "store" just for removal.

68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

# File 'lib/unicache.rb', line 68

def initialize( size, evict = LruEviction.new )
    super()

    @lock = Mutex.new

    resize( size )

    setEviction( evict )

    # See: registerCallback.
    @callbacks = {}

    @callbackType = [ :getdata,
                      :add, :replace, :put, :overwrite,
                      :remove, :valueremove, :hit, :miss,
                      :peek ]
    
    @callbackType.each do |type|
        @callbacks[ type ] = []
    end

end

62
63
64

# File 'lib/unicache.rb', line 62

def lock
  @lock
end

59
60
61

# File 'lib/unicache.rb', line 59

def size
  @size
end

162
163
164

# File 'lib/unicache.rb', line 162

def []( key )
    get( key )
end

137
138
139

# File 'lib/unicache.rb', line 137

def []=( key, value )
    self.put( key, value )
end

287
288
289
290
291
292
293
294

# File 'lib/unicache.rb', line 287

def clear
    @lock.lock
    self.each do |k,v|
        removeEntry( k )
    end
    @evict.clear
    @lock.unlock
end

180
181
182
183
184
185
186

# File 'lib/unicache.rb', line 180

def exist?( key )
    if peek( key )
        true
    else
        false
    end
end

153
154
155
156
157
158

# File 'lib/unicache.rb', line 153

def get( key, &blk )
    @lock.lock
    ret = _get( key, &blk )
    @lock.unlock
    ret 
end

101

# File 'lib/unicache.rb', line 101

alias :hash_get_op :[]

100

# File 'lib/unicache.rb', line 100

alias :hash_set_op :[]=

103

# File 'lib/unicache.rb', line 103

alias :hash_store :store

170
171
172
173

# File 'lib/unicache.rb', line 170

def peek( key )
    runCallbacks( :peek, key )
    hash_fetch( key, nil )
end

128
129
130
131
132
133

# File 'lib/unicache.rb', line 128

def put( key, value )
    @lock.lock
    ret = _put( key, value )
    @lock.unlock
    ret 
end

registerCallback( :add,
  Proc.new do |k,v,o| puts "Key: #{k} with value #{v} added" end

263
264
265
266
267
268
269

# File 'lib/unicache.rb', line 263

def registerCallback( type, proc )
    if proc.kind_of?( Proc ) && @callbackType.index( type )
        @callbacks[ type ].push proc
    else
        raise CallbackError, "UniCache: Trying to register invalid callback..."
    end
end

193
194
195
196
197
198

# File 'lib/unicache.rb', line 193

def remove( key = nil )
    @lock.lock
    ret = _remove( key )
    @lock.unlock
    ret
end

275
276
277
278
279
280
281
282
283

# File 'lib/unicache.rb', line 275

def removeCallback( type = nil )
    if type
        @callbacks[ type ] = []
    else
        @callbackType.each do |type|
            @callbacks[ type ] = []
        end
    end
end

204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222

# File 'lib/unicache.rb', line 204

def resize( size )
    
    raise SizeError, "UniCache: Size must be bigger than 0" unless size > 0

    @lock.lock

    # Remove entries that does not fit anymore.
    if @size && size < @size
        ( @size - size ).times do
            _remove
        end
    end

    ret = @size = size

    @lock.unlock

    ret
end

95
96
97

# File 'lib/unicache.rb', line 95

def setEviction( evict )
    @evict = evict
end

117

# File 'lib/unicache.rb', line 117

def store(); end