ccache: github.com/karlseguin/ccache Index | Files

package ccache

import "github.com/karlseguin/ccache"

An LRU cached aimed at high concurrency

An LRU cached aimed at high concurrency

Index

Package Files

bucket.go cache.go configuration.go item.go layeredbucket.go layeredcache.go secondarycache.go

Variables

var NilTracked = new(nilItem)

type Cache Uses

type Cache struct {
    *Configuration
    // contains filtered or unexported fields
}

func New Uses

func New(config *Configuration) *Cache

Create a new cache with the specified configuration See ccache.Configure() for creating a configuration

func (*Cache) Clear Uses

func (c *Cache) Clear()

this isn't thread safe. It's meant to be called from non-concurrent tests

func (*Cache) Delete Uses

func (c *Cache) Delete(key string) bool

Remove the item from the cache, return true if the item was present, false otherwise.

func (*Cache) Fetch Uses

func (c *Cache) Fetch(key string, duration time.Duration, fetch func() (interface{}, error)) (*Item, error)

Attempts to get the value from the cache and calles fetch on a miss (missing or stale item). If fetch returns an error, no value is cached and the error is returned back to the caller.

func (*Cache) Get Uses

func (c *Cache) Get(key string) *Item

Get an item from the cache. Returns nil if the item wasn't found. This can return an expired item. Use item.Expired() to see if the item is expired and item.TTL() to see how long until the item expires (which will be negative for an already expired item).

func (*Cache) Replace Uses

func (c *Cache) Replace(key string, value interface{}) bool

Replace the value if it exists, does not set if it doesn't. Returns true if the item existed an was replaced, false otherwise. Replace does not reset item's TTL

func (*Cache) Set Uses

func (c *Cache) Set(key string, value interface{}, duration time.Duration)

Set the value in the cache for the specified duration

func (*Cache) Stop Uses

func (c *Cache) Stop()

Stops the background worker. Operations performed on the cache after Stop is called are likely to panic

func (*Cache) TrackingGet Uses

func (c *Cache) TrackingGet(key string) TrackedItem

Used when the cache was created with the Track() configuration option. Avoid otherwise

type Configuration Uses

type Configuration struct {
    // contains filtered or unexported fields
}

func Configure Uses

func Configure() *Configuration

Creates a configuration object with sensible defaults Use this as the start of the fluent configuration: e.g.: ccache.New(ccache.Configure().MaxSize(10000))

func (*Configuration) Buckets Uses

func (c *Configuration) Buckets(count uint32) *Configuration

Keys are hashed into % bucket count to provide greater concurrency (every set requires a write lock on the bucket). Must be a power of 2 (1, 2, 4, 8, 16, ...) [16]

func (*Configuration) DeleteBuffer Uses

func (c *Configuration) DeleteBuffer(size uint32) *Configuration

The size of the queue for items which should be deleted. If the queue fills up, calls to Delete() will block

func (*Configuration) GetsPerPromote Uses

func (c *Configuration) GetsPerPromote(count int32) *Configuration

Give a large cache with a high read / write ratio, it's usually unnecessary to promote an item on every Get. GetsPerPromote specifies the number of Gets a key must have before being promoted [3]

func (*Configuration) ItemsToPrune Uses

func (c *Configuration) ItemsToPrune(count uint32) *Configuration

The number of items to prune when memory is low [500]

func (*Configuration) MaxSize Uses

func (c *Configuration) MaxSize(max int64) *Configuration

The max size for the cache [5000]

func (*Configuration) OnDelete Uses

func (c *Configuration) OnDelete(callback func(item *Item)) *Configuration

OnDelete allows setting a callback function to react to ideam deletion. This typically allows to do a cleanup of resources, such as calling a Close() on cached object that require some kind of tear-down.

func (*Configuration) PromoteBuffer Uses

func (c *Configuration) PromoteBuffer(size uint32) *Configuration

The size of the queue for items which should be promoted. If the queue fills up, promotions are skipped [1024]

func (*Configuration) Track Uses

func (c *Configuration) Track() *Configuration

By turning tracking on and using the cache's TrackingGet, the cache won't evict items which you haven't called Release() on. It's a simple reference counter.

type Item Uses

type Item struct {
    // contains filtered or unexported fields
}

func (*Item) Expired Uses

func (i *Item) Expired() bool

func (*Item) Expires Uses

func (i *Item) Expires() time.Time

func (*Item) Extend Uses

func (i *Item) Extend(duration time.Duration)

func (*Item) Release Uses

func (i *Item) Release()

func (*Item) TTL Uses

func (i *Item) TTL() time.Duration

func (*Item) Value Uses

func (i *Item) Value() interface{}

type LayeredCache Uses

type LayeredCache struct {
    *Configuration
    // contains filtered or unexported fields
}

func Layered Uses

func Layered(config *Configuration) *LayeredCache

See ccache.Configure() for creating a configuration

func (*LayeredCache) Clear Uses

func (c *LayeredCache) Clear()

this isn't thread safe. It's meant to be called from non-concurrent tests

func (*LayeredCache) Delete Uses

func (c *LayeredCache) Delete(primary, secondary string) bool

Remove the item from the cache, return true if the item was present, false otherwise.

func (*LayeredCache) DeleteAll Uses

func (c *LayeredCache) DeleteAll(primary string) bool

Deletes all items that share the same primary key

func (*LayeredCache) Fetch Uses

func (c *LayeredCache) Fetch(primary, secondary string, duration time.Duration, fetch func() (interface{}, error)) (*Item, error)

Attempts to get the value from the cache and calles fetch on a miss. If fetch returns an error, no value is cached and the error is returned back to the caller.

func (*LayeredCache) Get Uses

func (c *LayeredCache) Get(primary, secondary string) *Item

Get an item from the cache. Returns nil if the item wasn't found. This can return an expired item. Use item.Expired() to see if the item is expired and item.TTL() to see how long until the item expires (which will be negative for an already expired item).

func (*LayeredCache) GetOrCreateSecondaryCache Uses

func (c *LayeredCache) GetOrCreateSecondaryCache(primary string) *SecondaryCache

Get the secondary cache for a given primary key. This operation will never return nil. In the case where the primary key does not exist, a new, underlying, empty bucket will be created and returned.

func (*LayeredCache) Replace Uses

func (c *LayeredCache) Replace(primary, secondary string, value interface{}) bool

Replace the value if it exists, does not set if it doesn't. Returns true if the item existed an was replaced, false otherwise. Replace does not reset item's TTL nor does it alter its position in the LRU

func (*LayeredCache) Set Uses

func (c *LayeredCache) Set(primary, secondary string, value interface{}, duration time.Duration)

Set the value in the cache for the specified duration

func (*LayeredCache) Stop Uses

func (c *LayeredCache) Stop()

func (*LayeredCache) TrackingGet Uses

func (c *LayeredCache) TrackingGet(primary, secondary string) TrackedItem

Used when the cache was created with the Track() configuration option. Avoid otherwise

type SecondaryCache Uses

type SecondaryCache struct {
    // contains filtered or unexported fields
}

func (*SecondaryCache) Delete Uses

func (s *SecondaryCache) Delete(secondary string) bool

Delete a secondary key. The semantics are the same as for LayeredCache.Delete

func (*SecondaryCache) Fetch Uses

func (s *SecondaryCache) Fetch(secondary string, duration time.Duration, fetch func() (interface{}, error)) (*Item, error)

Fetch or set a secondary key. The semantics are the same as for LayeredCache.Fetch

func (*SecondaryCache) Get Uses

func (s *SecondaryCache) Get(secondary string) *Item

Get the secondary key. The semantics are the same as for LayeredCache.Get

func (*SecondaryCache) Replace Uses

func (s *SecondaryCache) Replace(secondary string, value interface{}) bool

Replace a secondary key. The semantics are the same as for LayeredCache.Replace

func (*SecondaryCache) Set Uses

func (s *SecondaryCache) Set(secondary string, value interface{}, duration time.Duration) *Item

Set the secondary key to a value. The semantics are the same as for LayeredCache.Set

func (*SecondaryCache) TrackingGet Uses

func (c *SecondaryCache) TrackingGet(secondary string) TrackedItem

Track a secondary key. The semantics are the same as for LayeredCache.TrackingGet

type Sized Uses

type Sized interface {
    Size() int64
}

type TrackedItem Uses

type TrackedItem interface {
    Value() interface{}
    Release()
    Expired() bool
    TTL() time.Duration
    Expires() time.Time
    Extend(duration time.Duration)
}

Package ccache imports 5 packages (graph) and is imported by 38 packages. Updated 2018-07-22. Refresh now. Tools for package owners.