go标准库encoding/gob使用

func (c *cache) Save(w io.Writer) (err error) {
    enc := gob.NewEncoder(w)
    defer func() {
       if x := recover(); x != nil {
          err = fmt.Errorf("Error registering item types with Gob library")
       }
    }()
    c.mu.RLock()
    defer c.mu.RUnlock()
    for _, v := range c.items {
       gob.Register(v.Object)
    }
    err = enc.Encode(&c.items)
    return
}

// Save the cache's items to the given filename, creating the file if it
// doesn't exist, and overwriting it if it does.
//
// NOTE: This method is deprecated in favor of c.Items() and NewFrom() (see the
// documentation for NewFrom().)
func (c *cache) SaveFile(fname string) error {
    fp, err := os.Create(fname)
    if err != nil {
       return err
    }
    err = c.Save(fp)
    if err != nil {
       fp.Close()
       return err
    }
    return fp.Close()
}

// Add (Gob-serialized) cache items from an io.Reader, excluding any items with
// keys that already exist (and haven't expired) in the current cache.
//
// NOTE: This method is deprecated in favor of c.Items() and NewFrom() (see the
// documentation for NewFrom().)
func (c *cache) Load(r io.Reader) error {
    dec := gob.NewDecoder(r)
    items := map[string]Item{}
    err := dec.Decode(&items)
    if err == nil {
       c.mu.Lock()
       defer c.mu.Unlock()
       for k, v := range items {
          ov, found := c.items[k]
          if !found || ov.Expired() {
             c.items[k] = v
          }
       }
    }
    return err
}

// Load and add cache items from the given filename, excluding any items with
// keys that already exist in the current cache.
//
// NOTE: This method is deprecated in favor of c.Items() and NewFrom() (see the
// documentation for NewFrom().)
func (c *cache) LoadFile(fname string) error {
    fp, err := os.Open(fname)
    if err != nil {
       return err
    }
    err = c.Load(fp)
    if err != nil {
       fp.Close()
       return err
    }
    return fp.Close()
}

// Copies all unexpired items in the cache into a new map and returns it.
func (c *cache) Items() map[string]Item {
    c.mu.RLock()
    defer c.mu.RUnlock()
    m := make(map[string]Item, len(c.items))
    now := time.Now().UnixNano()
    for k, v := range c.items {
       // "Inlining" of Expired
       if v.Expiration > 0 {
          if now > v.Expiration {
             continue
          }
       }
       m[k] = v
    }
    return m
}

// Returns the number of items in the cache. This may include items that have
// expired, but have not yet been cleaned up.
func (c *cache) ItemCount() int {
    c.mu.RLock()
    n := len(c.items)
    c.mu.RUnlock()
    return n
}