diff --git a/os/gcache/gcache_z_example_cache_test.go b/os/gcache/gcache_z_example_cache_test.go index 3b2a47364..8b783c153 100644 --- a/os/gcache/gcache_z_example_cache_test.go +++ b/os/gcache/gcache_z_example_cache_test.go @@ -58,27 +58,6 @@ func ExampleCache_Set() { // [1,2,3,4,5,6,7,8,9] } -func ExampleCache_SetAdapters() { - - // Create a cache object, - // Of course, you can also easily use the gcache package method directly - c := gcache.New() - - // SetAdapter changes the adapter for this cache. Be very note that, this setting function is not concurrent-safe, - // which means you should not call this setting function concurrently in multiple goroutines. - adapter := gcache.New() - c.SetAdapter(adapter) - - // Set cache - c.Set(ctx, "k1", g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9}, 0) - - // Reverse makes array with elements in reverse order. - fmt.Println(c.Get(ctx, "k1")) - - // Output: - // [1,2,3,4,5,6,7,8,9] -} - func ExampleCache_SetIfNotExist() { // Create a cache object, @@ -301,24 +280,19 @@ func ExampleCache_Data() { // Of course, you can also easily use the gcache package method directly c := gcache.New() - c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0) - c.Set(ctx, "k5", "v5", 0) + c.SetMap(ctx, g.MapAnyAny{"k1": "v1"}, 0) - // Get retrieves and returns the associated value of given `key`. - // It returns nil if it does not exist, its value is nil or it's expired. - data, _ := c.Get(ctx, "k1") + data, _ := c.Data(ctx) fmt.Println(data) - data1, _ := c.Get(ctx, "k2") + // Set Cache + c.Set(ctx, "k5", "v5", 0) + data1, _ := c.Get(ctx, "k1") fmt.Println(data1) - data2, _ := c.Get(ctx, "k5") - fmt.Println(data2) - // Output: + // map[k1:v1] // v1 - // v2 - // v5 } func ExampleCache_Get() { @@ -353,7 +327,7 @@ func ExampleCache_GetExpire() { expire, _ := c.GetExpire(ctx, "k") fmt.Println(expire) - // Output: + // May Output: // 10s } @@ -385,21 +359,21 @@ func ExampleCache_GetOrSetFunc() { // GetOrSetFunc retrieves and returns the value of `key`, or sets `key` with result of function `f` // and returns its result if `key` does not exist in the cache. - c.GetOrSetFunc(ctx, 1, func() (interface{}, error) { - return 111, nil + c.GetOrSetFunc(ctx, "k1", func() (interface{}, error) { + return "v1", nil }, 10000*time.Millisecond) - v, _ := c.Get(ctx, 1) + v, _ := c.Get(ctx, "k1") fmt.Println(v) - c.GetOrSetFunc(ctx, 2, func() (interface{}, error) { + // If func returns nil, no action is taken + c.GetOrSetFunc(ctx, "k2", func() (interface{}, error) { return nil, nil }, 10000*time.Millisecond) - v1, _ := c.Get(ctx, 2) + v1, _ := c.Get(ctx, "k2") fmt.Println(v1) // Output: - // 111 - // + // v1 } func ExampleCache_GetOrSetFuncLock() { @@ -409,40 +383,24 @@ func ExampleCache_GetOrSetFuncLock() { c := gcache.New() // Modify locking Note that the function `f` should be executed within writing mutex lock for concurrent safety purpose. - c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) { - return 11, nil + c.GetOrSetFuncLock(ctx, "k1", func() (interface{}, error) { + return "v1", nil }, 0) - v, _ := c.Get(ctx, 1) + v, _ := c.Get(ctx, "k1") fmt.Println(v) // Modification failed - c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) { - return 111, nil + c.GetOrSetFuncLock(ctx, "k1", func() (interface{}, error) { + return "update v1", nil }, 0) - v, _ = c.Get(ctx, 1) + v, _ = c.Get(ctx, "k1") fmt.Println(v) - c.Remove(ctx, g.Slice{1, 2, 3}...) - - // Modify locking - c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) { - return 111, nil - }, 0) - v, _ = c.Get(ctx, 1) - fmt.Println(v) - - // Modification failed - c.GetOrSetFuncLock(ctx, 1, func() (interface{}, error) { - return 11, nil - }, 0) - v, _ = c.Get(ctx, 1) - fmt.Println(v) + c.Remove(ctx, g.Slice{"k1"}...) // Output: - // 11 - // 11 - // 111 - // 111 + // v1 + // v1 } func ExampleCache_Keys() { @@ -462,6 +420,19 @@ func ExampleCache_Keys() { } +func ExampleCache_KeyStrings() { + c := gcache.New() + + c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0) + + // KeyStrings returns all keys in the cache as string slice. + keys, _ := c.KeyStrings(ctx) + fmt.Println(keys) + + // May Output: + // [k1 k2] +} + func ExampleCache_Remove() { // Create a cache object, @@ -472,12 +443,14 @@ func ExampleCache_Remove() { // Remove deletes one or more keys from cache, and returns its value. // If multiple keys are given, it returns the value of the last deleted item. - c.Remove(ctx, "k1") + remove, _ := c.Remove(ctx, "k1") + fmt.Println(remove) data, _ := c.Data(ctx) fmt.Println(data) // Output: + // v1 // map[k2:v2] } @@ -499,3 +472,222 @@ func ExampleCache_Removes() { // Output: // map[k4:v4] } + +func ExampleCache_MustGet() { + // Intercepting panic exception information + // err is empty, so panic is not performed + defer func() { + if r := recover(); r != nil { + fmt.Println("recover...:", r) + } + }() + + // Create a cache object, + // Of course, you can also easily use the gcache package method directly + c := gcache.New() + + // Set Cache Object + c.Set(ctx, "k1", "v1", 0) + + // MustGet acts like Get, but it panics if any error occurs. + k2 := c.MustGet(ctx, "k2") + fmt.Println(k2) + + k1 := c.MustGet(ctx, "k1") + fmt.Println(k1) + + // Output: + // v1 + +} + +func ExampleCache_MustGetOrSet() { + + // Create a cache object, + // Of course, you can also easily use the gcache package method directly + c := gcache.New() + + // MustGetOrSet acts like GetOrSet, but it panics if any error occurs. + k1 := c.MustGetOrSet(ctx, "k1", "v1", 0) + fmt.Println(k1) + + k2 := c.MustGetOrSet(ctx, "k1", "v2", 0) + fmt.Println(k2) + + // Output: + // v1 + // v1 + +} + +func ExampleCache_MustGetOrSetFunc() { + + // Create a cache object, + // Of course, you can also easily use the gcache package method directly + c := gcache.New() + + // MustGetOrSetFunc acts like GetOrSetFunc, but it panics if any error occurs. + c.MustGetOrSetFunc(ctx, "k1", func() (interface{}, error) { + return "v1", nil + }, 10000*time.Millisecond) + v := c.MustGet(ctx, "k1") + fmt.Println(v) + + c.MustGetOrSetFunc(ctx, "k2", func() (interface{}, error) { + return nil, nil + }, 10000*time.Millisecond) + v1 := c.MustGet(ctx, "k2") + fmt.Println(v1) + + // Output: + // v1 + // +} + +func ExampleCache_MustGetOrSetFuncLock() { + + // Create a cache object, + // Of course, you can also easily use the gcache package method directly + c := gcache.New() + + // MustGetOrSetFuncLock acts like GetOrSetFuncLock, but it panics if any error occurs. + c.MustGetOrSetFuncLock(ctx, "k1", func() (interface{}, error) { + return "v1", nil + }, 0) + v := c.MustGet(ctx, "k1") + fmt.Println(v) + + // Modification failed + c.MustGetOrSetFuncLock(ctx, "k1", func() (interface{}, error) { + return "update v1", nil + }, 0) + v = c.MustGet(ctx, "k1") + fmt.Println(v) + + // Output: + // v1 + // v1 +} + +func ExampleCache_MustContains() { + + // Create a cache object, + // Of course, you can also easily use the gcache package method directly + c := gcache.New() + + // Set Cache + c.Set(ctx, "k", "v", 0) + + // Contains returns true if `key` exists in the cache, or else returns false. + // return true + data := c.MustContains(ctx, "k") + fmt.Println(data) + + // return false + data1 := c.MustContains(ctx, "k1") + fmt.Println(data1) + + // Output: + // true + // false + +} + +func ExampleCache_MustGetExpire() { + + // Create a cache object, + // Of course, you can also easily use the gcache package method directly + c := gcache.New() + + // Set cache without expiration + c.Set(ctx, "k", "v", 10000*time.Millisecond) + + // MustGetExpire acts like GetExpire, but it panics if any error occurs. + expire := c.MustGetExpire(ctx, "k") + fmt.Println(expire) + + // May Output: + // 10s +} + +func ExampleCache_MustSize() { + + // Create a cache object, + // Of course, you can also easily use the gcache package method directly + c := gcache.New() + + // Add 10 elements without expiration + for i := 0; i < 10; i++ { + c.Set(ctx, i, i, 0) + } + + // Size returns the number of items in the cache. + n := c.MustSize(ctx) + fmt.Println(n) + + // Output: + // 10 +} + +func ExampleCache_MustData() { + + // Create a cache object, + // Of course, you can also easily use the gcache package method directly + c := gcache.New() + + c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0) + + data := c.MustData(ctx) + fmt.Println(data) + + // May Output: + // map[k1:v1 k2:v2] +} + +func ExampleCache_MustKeys() { + + // Create a cache object, + // Of course, you can also easily use the gcache package method directly + c := gcache.New() + + c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0) + + // MustKeys acts like Keys, but it panics if any error occurs. + keys1 := c.MustKeys(ctx) + fmt.Println(keys1) + + // May Output: + // [k1 k2] + +} + +func ExampleCache_MustKeyStrings() { + c := gcache.New() + + c.SetMap(ctx, g.MapAnyAny{"k1": "v1", "k2": "v2"}, 0) + + // MustKeyStrings returns all keys in the cache as string slice. + // MustKeyStrings acts like KeyStrings, but it panics if any error occurs. + keys := c.MustKeyStrings(ctx) + fmt.Println(keys) + + // May Output: + // [k1 k2] +} + +func ExampleCache_MustValues() { + + // Create a cache object, + // Of course, you can also easily use the gcache package method directly + c := gcache.New() + + // Write value + c.Set(ctx, "k1", "v1", 0) + + // Values returns all values in the cache as slice. + data := c.MustValues(ctx) + fmt.Println(data) + + // Output: + // [v1] +}