CacheLib

require 'cache_lib'

cache = CacheLib.create :basic
cache = CacheLib::Basic::Cache.new
# Thread safe
cache = CacheLib.safe_create :basic
cache = CacheLib::Basic::SafeCache.new

cache = CacheLib.create :fifo, 100
cache = CacheLib::FIFO::Cache.new(100)
# Thread safe
cache = CacheLib.safe_create :fifo, 100
cache = CacheLib::FIFO::SafeCache.new(100)

cache = CacheLib.create :lru, 100
cache = CacheLib::LRU::Cache.new(100)
# Thread safe
cache = CacheLib.safe_create :lru, 100
cache = CacheLib::LRU::SafeCache.new(100)

cache = CacheLib.create :ttl, 100, 5 * 60
cache = CacheLib::TTL::Cache.new(100, 5 * 60)
# Thread safe
cache = CacheLib.safe_create :ttl, 100, 5 * 60
cache = CacheLib::TTL::SafeCache.new(100, 5 * 60)

cache = CacheLib.create :lirs, 95, 5
cache = CacheLib::LIRS::Cache.new(95, 5)
# Thread safe
cache = CacheLib.safe_create :lirs, 95, 5
cache = CacheLib::LIRS::SafeCache.new(95, 5)

# #get is the primary method for accessing the cache.
# It requires a key and block that will generate the value that is stored
# if the key is not cached.
cache.get(:a) { 'Apple' }
# => 'Apple'
cache.get(:b) { 'Beethoven' }
# => 'Beethoven'
cache.get(:a) { 'Apricot' }
# => 'Apple'

# #store takes a key and value and implements the functionality of Hash#store.
# Will refresh key priority in LRU, TTL and LIRS caches.
cache.store(:c, 'Chopin')
# => 'Chopin'
cache.store(:a, 'Mozart')
# => 'Mozart'

# []= is equivalent to #store.
cache[:d] = 'Denmark'
# => 'Denmark'

# #lookup takes a key and returns either the value if the key is cached or nil if it is not.
# Will refresh key priority in LRU, TTL and LIRS caches.
cache.lookup(:c)
# => 'Chopin'
cache.lookup(:t)
# => nil

# [] is equivalent to .lookup.
cache[:a]
# => 'Mozart'

# #fetch is similar to #lookup,
# but takes an optional block that will execute if the key is not cached.
cache.fetch(:c)
# => 'Chopin'
cache.fetch(:r) { 21 * 2 }
# => 42

# #peek is similar to lookup but will NOT refresh the key priority.
cache.peek(:c)
# => 'Chopin'
cache.peek(:t)
# => nil

# #swap will replace a value on a currently cached key.
# Returns nil if the key is currently not cached.
cache.swap(:c, 'Chopin')
# => 'Chopin'
cache.swap(:w, 'Mozart')
# => nil

# #evict takes a key and will remove the key from the cache and return the associated value.
# Returns nil is the key is not cached.
cache.evict(:d)
# => 'Denmark'
cache.evict(:r)
# => nil

# ALIAS: #delete

# .each takes each key value pair and applies the given block to them.
cache.each { |_, value| puts value }
# => 'Chopin'
# => 'Mozart'
# => 'Beethoven'

# .key? takes a key and returns true if it is cached and false if it is not.
cache.key?(:a)
# => true
cache.key?(:g)
# => false

# ALIAS: #has_key? and #member?

# #to_a returns an array of arrays of key value pairs that are cached.
# Basic, FIFO and LIRS are insertion ordered while LRU and TTL are recency ordered,
# starting with the newest.
cache.to_a
# => [[:c, 'Chopin'], [:a, 'Mozart'], [:b, 'Beethoven']]

# #keys returns an array of the keys that are cached.
cache.keys
# => [:c, :a, :b]

# #values returns an array of the values that are cached.
cache.values
# => ['Chopin', 'Mozart', 'Beethoven']

# #size returns the current number of items that are cached.
cache.size
# => 3

# ALIAS: #length

# #count functions like the Hash#count.
cache.count { |_, value| value == 'Chopin' }
# => 1

# #expire will trigger a ttl based eviction in caches which make use of ttl
cache.expire
# => nil

# #raw returns clone of the internal

# e.g.
cache = CacheLib.create :lirs, 95, 5
# LIRS cache does not use a ttl, so the value is discarded and nil is returned.
cache.ttl = 6 * 60
# => nil

# Basic (does not use limit)
cache.limit = 90
# => nil

# FIFO, LRU and TTL
cache.limit = 90
# => 90

# LIRS
cache.limit = 85, 5
# => [85, 5]

# Basic, FIFO, LRU and LIRS (does not use ttl)
cache.ttl = 6 * 60
# => nil

# TTL
cache.ttl = 6 * 60
# => 360