some update...

README.md

@@ -52,16 +52,16 @@ func main() {
 ## Interface
 
 ```go
-// CacheFace interface definition
-type CacheFace interface {
+// Cache interface definition
+type Cache interface {
 	// basic op
 	Has(key string) bool
 	Get(key string) interface{}
-	Set(key string, val interface{}, ttl time.Duration) error
+	Set(key string, val interface{}, ttl time.Duration) (err error)
 	Del(key string) error
 	// multi op
-	GetMulti(keys []string) []interface{}
-	SetMulti(mv map[string]interface{}, ttl time.Duration) error
+	GetMulti(keys []string) map[string]interface{}
+	SetMulti(values map[string]interface{}, ttl time.Duration) (err error)
 	DelMulti(keys []string) error
 	// clear
 	Clear() error

cache.go

@@ -8,8 +8,8 @@ import (
 	"time"
 )
 
-// CacheFace interface definition
-type CacheFace interface {
+// Cache interface definition
+type Cache interface {
 	// basic op
 	Has(key string) bool
 	Get(key string) interface{}
@@ -74,33 +74,33 @@ var (
  *************************************************************/
 
 // default cache driver manager instance
-var manager = NewManager()
+var defMgr = NewManager()
 
 // Register driver to manager instance
-func Register(name string, driver CacheFace) *CacheManager {
-	manager.SetDefName(name)
-	manager.Register(name, driver)
-	return manager
+func Register(name string, driver Cache) *Manager {
+	defMgr.SetDefName(name)
+	defMgr.Register(name, driver)
+	return defMgr
 }
 
 // SetDefName set default driver name
 func SetDefName(driverName string) {
-	manager.SetDefName(driverName)
+	defMgr.SetDefName(driverName)
 }
 
 // Use returns a driver instance
-func Use(driverName string) CacheFace {
-	return manager.drivers[driverName]
+func Use(driverName string) Cache {
+	return defMgr.drivers[driverName]
 }
 
-// Manager get default cache manager instance
-func Manager() *CacheManager {
-	return manager
+// DefMgr get default cache manager instance
+func DefMgr() *Manager {
+	return defMgr
 }
 
 // Default get default cache driver instance
-func Default() CacheFace {
-	return manager.Default()
+func Default() Cache {
+	return defMgr.Default()
 }
 
 /*************************************************************
@@ -109,40 +109,40 @@ func Default() CacheFace {
 
 // Has cache key
 func Has(key string) bool {
-	return manager.Default().Has(key)
+	return defMgr.Default().Has(key)
 }
 
 // Get value by key
 func Get(key string) interface{} {
-	return manager.Default().Get(key)
+	return defMgr.Default().Get(key)
 }
 
 // Set value by key
 func Set(key string, val interface{}, ttl time.Duration) error {
-	return manager.Default().Set(key, val, ttl)
+	return defMgr.Default().Set(key, val, ttl)
 }
 
 // Del value by key
 func Del(key string) error {
-	return manager.Default().Del(key)
+	return defMgr.Default().Del(key)
 }
 
 // GetMulti values by keys
-func GetMulti(keys []string) []interface{} {
-	return manager.Default().GetMulti(keys)
+func GetMulti(keys []string) map[string]interface{} {
+	return defMgr.Default().GetMulti(keys)
 }
 
 // SetMulti values
 func SetMulti(mv map[string]interface{}, ttl time.Duration) error {
-	return manager.Default().SetMulti(mv, ttl)
+	return defMgr.Default().SetMulti(mv, ttl)
 }
 
 // DelMulti values by keys
 func DelMulti(keys []string) error {
-	return manager.Default().DelMulti(keys)
+	return defMgr.Default().DelMulti(keys)
 }
 
 // Clear all caches
 func Clear() error {
-	return manager.Default().Clear()
+	return defMgr.Default().Clear()
 }

file_cache.go

@@ -31,7 +31,7 @@ func NewFileCache(dir string, pfxAndKey ...string) *FileCache {
 	c := &FileCache{
 		cacheDir: dir,
 		// init a memory cache.
-		MemoryCache: MemoryCache{caches: make(map[string]*CacheItem)},
+		MemoryCache: MemoryCache{caches: make(map[string]*Item)},
 	}
 
 	if ln := len(pfxAndKey); ln > 0 {
@@ -73,7 +73,7 @@ func (c *FileCache) Get(key string) interface{} {
 		return nil
 	}
 
-	item := &CacheItem{}
+	item := &Item{}
 	if err = Unmarshal(bs, item); err != nil {
 		c.lastErr = err
 		return nil

manager.go

@@ -9,58 +9,58 @@ const (
 )
 
 /*************************************************************
- * CacheManager
+ * Manager
  *************************************************************/
 
-// CacheManager definition
-type CacheManager struct {
+// Manager definition
+type Manager struct {
 	// Debug bool
 	// default driver name
 	defName string
 	// drivers map
-	drivers map[string]CacheFace
+	drivers map[string]Cache
 }
 
 // NewManager create a cache manager instance
-func NewManager() *CacheManager {
-	return &CacheManager{
+func NewManager() *Manager {
+	return &Manager{
 		// defName: driverName,
-		drivers: make(map[string]CacheFace),
+		drivers: make(map[string]Cache),
 	}
 }
 
 // SetDefName set default driver name
-func (m *CacheManager) SetDefName(driverName string) {
+func (m *Manager) SetDefName(driverName string) {
 	m.defName = driverName
 }
 
 // Register new driver object
-func (m *CacheManager) Register(name string, driver CacheFace) *CacheManager {
+func (m *Manager) Register(name string, driver Cache) *Manager {
 	m.drivers[name] = driver
 	return m
 }
 
 // Default returns the default driver instance
-func (m *CacheManager) Default() CacheFace {
+func (m *Manager) Default() Cache {
 	return m.drivers[m.defName]
 }
 
 // Use returns a driver instance
-func (m *CacheManager) Use(driverName string) CacheFace {
+func (m *Manager) Use(driverName string) Cache {
 	return m.drivers[driverName]
 }
 
 // Get driver object by name
-func (m *CacheManager) Get(name string) CacheFace {
+func (m *Manager) Get(name string) Cache {
 	return m.Use(name)
 }
 
 // Driver object get
-func (m *CacheManager) Driver(name string) CacheFace {
+func (m *Manager) Driver(name string) Cache {
 	return m.Use(name)
 }
 
 // DefName get default driver name
-func (m *CacheManager) DefName() string {
+func (m *Manager) DefName() string {
 	return m.defName
 }

memcached/memcached_test.go

@@ -1,5 +1,17 @@
 package memcached
 
+import "fmt"
+
 func Example() {
 	c := New("10.0.0.1:11211", "10.0.0.2:11211")
+
+	// set
+	c.Set("name", "cache value", 60)
+	// get
+	val := c.Get("name")
+	// del
+	c.Del("name")
+
+	// get: "cache value"
+	fmt.Print(val)
 }

memory_cache.go

@@ -10,13 +10,13 @@ type MemoryCache struct {
 	// locker
 	lock sync.RWMutex
 	// cache data in memory
-	caches map[string]*CacheItem
+	caches map[string]*Item
 	// last error
 	lastErr error
 }
 
-// CacheItem for memory cache
-type CacheItem struct {
+// Item for memory cache
+type Item struct {
 	// Exp expire time
 	Exp int64
 	// Val cache value storage
@@ -26,7 +26,7 @@ type CacheItem struct {
 // NewMemoryCache create a memory cache instance
 func NewMemoryCache() *MemoryCache {
 	return &MemoryCache{
-		caches: make(map[string]*CacheItem),
+		caches: make(map[string]*Item),
 	}
 }
 
@@ -62,7 +62,7 @@ func (c *MemoryCache) Set(key string, val interface{}, ttl time.Duration) (err e
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
-	item := &CacheItem{Val: val}
+	item := &Item{Val: val}
 	if ttl > 0 {
 		item.Exp = time.Now().Unix() + int64(ttl/time.Second)
 	}

redis/redis.go

@@ -171,7 +171,7 @@ func (c *RedisCache) String() string {
  * helper methods
  *************************************************************/
 
-// Driver object get
+// Pool get
 func (c *RedisCache) Pool() *redis.Pool {
 	return c.pool
 }

redis/redis_test.go

@@ -6,8 +6,6 @@ func Example() {
 	// init  driver
 	c := Connect("127.0.0.1:6379", "", 0)
 
-	// usage
-	//
 	// set
 	c.Set("name", "cache value", 60)
 	// get