MyCache - A distributed cache based on GeeCache

// Map constains all hashed keys
type Map struct {
	hash     Hash           // Hash function
	replicas int            // Virtual node multiple
	keys     []int          // Sorted
	hashMap  map[int]string // Mapping Table of Virtual Node and Real Node
}

// New creates a Map instance
func New(replicas int, fn Hash) *Map 

// Add adds some keys to the hash.
func (m *Map) Add(keys ...string)

// Get gets the closest item in the hash to the provided key.
func (m *Map) Get(key string) string

// Cache is a LRU/FIFO cache. It is not safe for concurrent access.
type Cache struct {
	eliminationstrategy int
	maxBytes            int64
	nbytes              int64
	ll                  *list.List
	cache               map[string]*list.Element
	// optional and executed when an entry is purged.
	OnEvicted func(key string, value Value)
}

// New is the Constructor of Cache
func New(maxBytes int64, eliminationstrategy int, onEvicted func(string, Value)) *Cache

// Get look ups a key's value
func (c *Cache) Get(key string) (value Value, ok bool) 

// Add adds a value to the cache.
func (c *Cache) Add(key string, value Value)

type Group struct {
	mu sync.Mutex // protects m
	m  map[string]*call
}

// Do only initiate one request to the same key
func (g *Group) Do(key string, fn func() (interface{}, error)) (interface{}, error)

// A ByteView holds an immutable view of bytes.
type ByteView struct {
	b []byte
}

// Len returns the view's length
func (v ByteView) Len() int

// ByteSlice returns a copy of the data as a byte slice.
func (v ByteView) ByteSlice() []byte

// String returns the data as a string, making a copy if necessary.
func (v ByteView) String() string 

type cache struct {
	mu         sync.Mutex
	es         int
	esCache    *eliminationstrategy.Cache
	cacheBytes int64
}

// Add() includes New()
func (c *cache) Add(key string, value ByteView)

func (c *cache) Get(key string) (value ByteView, ok bool)

// A Getter loads data for a key.
type Getter interface {
	Get(key string) ([]byte, error)
}

// A GetterFunc implements Getter with a function.
type GetterFunc func(key string) ([]byte, error)

// Get implements Getter interface function
func (f GetterFunc) Get(key string) ([]byte, error) {
return f(key)
}

// A Group is a cache namespace and associated data loaded spread over
type Group struct {
    name      string
    getter    Getter
    mainCache cache
    peers     PeerPicker
    // use singleflight.Group to make sure that each key is only fetched once
    loader *singleflight.Group
}

// NewGroup create a new instance of Group
func NewGroup(name string, es int, cacheBytes int64, getter Getter) *Group

// GetGroup returns the named group previously created with NewGroup, or
// nil if there's no such group.
func GetGroup(name string) *Group

// Get value for a key from cache
func (g *Group) Get(key string) (ByteView, error)

// RegisterPeers registers a PeerPicker for choosing remote peer
func (g *Group) RegisterPeers(peers PeerPicker)