cache-memcached

package main

import (
	"context"
	"errors"
	"log"
	"time"

	"github.com/bradfitz/gomemcache/memcache"
	"github.com/ubgo/cache"
	memcachedcache "github.com/ubgo/cache-memcached"
)

func main() {
	mc := memcache.New("localhost:11211")
	c := memcachedcache.New(mc)
	defer c.Close()

	ctx := context.Background()
	_ = c.Set(ctx, "k", []byte("v"), time.Minute)

	b, err := c.Get(ctx, "k")
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("%s", b)

	// Unsupported ops are explicit, never silent:
	if _, err := c.TTL(ctx, "k"); errors.Is(err, cache.ErrUnsupported) {
		log.Println("Memcached cannot report remaining TTL")
	}
}

ctx := context.Background()

// --- Works ---
b, err := c.Get(ctx, "k")                        // ErrNotFound on miss
m, err := c.GetMulti(ctx, []string{"a", "b"})    // missing keys absent from map
ok, err := c.Has(ctx, "k")
err = c.Set(ctx, "k", []byte("v"), time.Minute)  // ttl<=0 => no expiry (Expiration 0)
err = c.SetMulti(ctx, map[string]cache.Item{"a": {Value: []byte("1")}})
created, err := c.SetNX(ctx, "k", []byte("v"), time.Minute) // ADD; false if exists
err = c.Expire(ctx, "k", time.Hour)              // TOUCH; ErrNotFound if absent
err = c.Touch(ctx, "k")                          // Expire(key, 1h)
n, err := c.Incr(ctx, "hits", 1)                 // missing key initialised to delta
n, err = c.Decr(ctx, "hits", 2)                  // floors at 0 (unsigned counter)
err = c.Del(ctx, "a", "b")                       // DELETE; miss tolerated
err = c.Flush(ctx)                               // flush_all
err = c.Ping(ctx)
err = c.Close()                                  // idempotent; does not close mc

// --- ErrUnsupported by protocol design ---
_, err = c.TTL(ctx, "k")                         // cache.ErrUnsupported
err = c.DeleteByPrefix(ctx, "user:")             // cache.ErrUnsupported
it := c.Iterate(ctx, cache.IterateOpts{})
_ = it.Next()                                    // false
_ = it.Err()                                     // cache.ErrUnsupported