wtype

ExampleCache_Get demonstrates getting data from the cache

package main

import (
	"fmt"
	"time"

	"github.com/wuchieh/wtype"
)

func main() {
	cache := wtype.NewCache[int](1 * time.Second)

	// Get from empty cache (zero value)
	fmt.Printf("Empty cache: %d\n", cache.Get())

	// Set and get data
	cache.Set(100)
	fmt.Printf("With data: %d\n", cache.Get())

}

Output:

Empty cache: 0
With data: 100

ExampleCache_ResetTimer demonstrates resetting the cache timer

package main

import (
	"fmt"
	"time"

	"github.com/wuchieh/wtype"
)

func main() {
	cache := wtype.NewCache[string](100 * time.Millisecond)
	cache.Set("data")

	// Wait a bit, then reset timer
	time.Sleep(50 * time.Millisecond)
	cache.ResetTimer()
	fmt.Printf("Timer reset, data: %q\n", cache.Get())

	// Data should still be available after original time would have expired
	time.Sleep(75 * time.Millisecond)
	fmt.Printf("After partial wait, data: %q\n", cache.Get())

}

Output:

Timer reset, data: "data"
After partial wait, data: "data"

ExampleCache_Set demonstrates setting data in the cache

package main

import (
	"fmt"
	"time"

	"github.com/wuchieh/wtype"
)

func main() {
	cache := wtype.NewCache[string](2 * time.Second)

	cache.Set("Hello, World!")
	fmt.Printf("After set: %q\n", cache.Get())

	// Setting new data resets the timer
	cache.Set("Updated data")
	fmt.Printf("After update: %q\n", cache.Get())

}

Output:

After set: "Hello, World!"
After update: "Updated data"

ExampleCache_SetDuration demonstrates changing cache duration

package main

import (
	"fmt"
	"time"

	"github.com/wuchieh/wtype"
)

func main() {
	cache := wtype.NewCache[string](1 * time.Second)
	cache.Set("test data")

	// Change duration to 5 seconds
	cache.SetDuration(5 * time.Second)
	fmt.Printf("Duration changed, data: %q\n", cache.Get())

	// Change to permanent (0 duration)
	cache.SetDuration(0)
	fmt.Printf("Permanent cache, data: %q\n", cache.Get())

}

Output:

Duration changed, data: "test data"
Permanent cache, data: "test data"

ExampleCache_StopTimer demonstrates stopping the cache timer

package main

import (
	"fmt"
	"time"

	"github.com/wuchieh/wtype"
)

func main() {
	cache := wtype.NewCache[string](100 * time.Millisecond)
	cache.Set("important data")

	// Stop the timer to prevent expiration
	cache.StopTimer()
	fmt.Printf("Timer stopped, data: %q\n", cache.Get())

	// Wait beyond the original expiration time
	time.Sleep(200 * time.Millisecond)
	fmt.Printf("After wait, data still: %q\n", cache.Get())

}

Output:

Timer stopped, data: "important data"
After wait, data still: "important data"

package main

import (
	"fmt"

	"github.com/wuchieh/wtype"
)

func main() {
	ec := wtype.NewEventCenter()
	ec.Once("once", func(data ...any) {
		fmt.Println(data...)
	})

	ec.Emit("once", "first")
	ec.Emit("once", "second")

}

Output:

first

ExampleSafeCache_Get demonstrates getting data from the thread-safe cache

package main

import (
	"fmt"
	"time"

	"github.com/wuchieh/wtype"
)

func main() {
	safeCache := wtype.NewSafeCache[int](1 * time.Second)

	// Get from empty cache (zero value)
	fmt.Printf("Empty safe cache: %d\n", safeCache.Get())

	// Set and get data
	safeCache.Set(100)
	fmt.Printf("With data: %d\n", safeCache.Get())

}

Output:

Empty safe cache: 0
With data: 100

ExampleSafeCache_Set demonstrates setting data in the thread-safe cache

package main

import (
	"fmt"
	"time"

	"github.com/wuchieh/wtype"
)

func main() {
	safeCache := wtype.NewSafeCache[string](2 * time.Second)

	safeCache.Set("Hello, Safe World!")
	fmt.Printf("After set: %q\n", safeCache.Get())

	// Setting new data resets the timer
	safeCache.Set("Updated safe data")
	fmt.Printf("After update: %q\n", safeCache.Get())

}

Output:

After set: "Hello, Safe World!"
After update: "Updated safe data"

ExampleSafeCache_Use demonstrates using the Use method to update cache data

package main

import (
	"fmt"
	"time"

	"github.com/wuchieh/wtype"
)

func main() {
	safeCache := wtype.NewSafeCache[int](5 * time.Second)
	safeCache.Set(10)

	fmt.Printf("Before Use: %d\n", safeCache.Get())

	// Use function to double the value
	safeCache.Use(func(current int) int {
		return current * 2
	})

	fmt.Printf("After Use (doubled): %d\n", safeCache.Get())

	// Use function to add 5
	safeCache.Use(func(current int) int {
		return current + 5
	})

	fmt.Printf("After Use (added 5): %d\n", safeCache.Get())

}

Output:

Before Use: 10
After Use (doubled): 20
After Use (added 5): 25

ExampleSafeCache_Use2 demonstrates using the Use2 method with error handling

package main

import (
	"fmt"
	"time"

	"github.com/wuchieh/wtype"
)

func main() {
	safeCache := wtype.NewSafeCache[string](5 * time.Second)
	safeCache.Set("hello")

	fmt.Printf("Before Use2: %q\n", safeCache.Get())

	// Use2 function to convert to uppercase
	err := safeCache.Use2(func(current string) (string, error) {
		if current == "" {
			return "", fmt.Errorf("empty string")
		}
		return fmt.Sprintf("%s WORLD", current), nil
	})

	if err != nil {
		fmt.Printf("Error: %v\n", err)
	} else {
		fmt.Printf("After Use2 (success): %q\n", safeCache.Get())
	}

	// Use2 function that returns an error
	safeCache.Set("")
	err = safeCache.Use2(func(current string) (string, error) {
		if current == "" {
			return "", fmt.Errorf("cannot process empty string")
		}
		return current + " processed", nil
	})
	if err != nil {
		fmt.Printf("Error occurred: %v\n", err)
		fmt.Printf("Data unchanged: %q\n", safeCache.Get())
	}

}

Output:

Before Use2: "hello"
After Use2 (success): "hello WORLD"
Error occurred: cannot process empty string
Data unchanged: ""

ExampleSet_Add demonstrates adding elements to a set

package main

import (
	"fmt"

	"github.com/wuchieh/wtype"
)

func main() {
	set := wtype.NewSet[string]()

	// Add elements
	set.Add("apple")
	set.Add("banana")
	set.Add("cherry")

	fmt.Printf("Set length after adding 3 elements: %d\n", set.Len())

	// Adding duplicate element (no effect)
	set.Add("apple")
	fmt.Printf("Set length after adding duplicate: %d\n", set.Len())

}

Output:

Set length after adding 3 elements: 3
Set length after adding duplicate: 3

ExampleSet_Clear demonstrates clearing all elements from a set

package main

import (
	"fmt"

	"github.com/wuchieh/wtype"
)

func main() {
	set := wtype.NewSet[int]()
	set.Add(10)
	set.Add(20)
	set.Add(30)

	fmt.Printf("Before clear - Length: %d\n", set.Len())

	set.Clear()
	fmt.Printf("After clear - Length: %d\n", set.Len())
	fmt.Printf("Contains 10 after clear: %t\n", set.Contains(10))

}

Output:

Before clear - Length: 3
After clear - Length: 0
Contains 10 after clear: false

ExampleSet_Contains demonstrates checking if elements exist in the set

package main

import (
	"fmt"

	"github.com/wuchieh/wtype"
)

func main() {
	set := wtype.NewSet[int]()
	set.Add(1)
	set.Add(2)
	set.Add(3)

	fmt.Printf("Contains 2: %t\n", set.Contains(2))
	fmt.Printf("Contains 5: %t\n", set.Contains(5))
	fmt.Printf("Contains 1: %t\n", set.Contains(1))

}

Output:

Contains 2: true
Contains 5: false
Contains 1: true

ExampleSet_Get demonstrates getting all elements from a set

package main

import (
	"fmt"
	"sort"

	"github.com/wuchieh/wtype"
)

func main() {
	set := wtype.NewSet[int]()
	set.Add(3)
	set.Add(1)
	set.Add(4)
	set.Add(2)

	elements := set.Get()
	// Sort for consistent output since set order is not guaranteed
	sort.Ints(elements)
	fmt.Printf("Set elements: %v\n", elements)
	fmt.Printf("Number of elements: %d\n", len(elements))

}

Output:

Set elements: [1 2 3 4]
Number of elements: 4

ExampleSet_Len demonstrates getting the length of a set

package main

import (
	"fmt"

	"github.com/wuchieh/wtype"
)

func main() {
	set := wtype.NewSet[string]()

	fmt.Printf("Empty set length: %d\n", set.Len())

	set.Add("first")
	fmt.Printf("After adding 1 element: %d\n", set.Len())

	set.Add("second")
	set.Add("third")
	fmt.Printf("After adding 3 elements total: %d\n", set.Len())

}

Output:

Empty set length: 0
After adding 1 element: 1
After adding 3 elements total: 3

ExampleSet_Range demonstrates iterating over set elements

package main

import (
	"fmt"

	"github.com/wuchieh/wtype"
)

func main() {
	set := wtype.NewSet[string]()
	set.Add("apple")
	set.Add("banana")
	set.Add("cherry")

	fmt.Println("All elements:")
	set.Range(func(element string) bool {
		fmt.Printf("- %s\n", element)
		return true // Continue iteration
	})

	fmt.Println("\nFirst 2 elements:")
	count := 0
	set.Range(func(element string) bool {
		fmt.Printf("- %s\n", element)
		count++
		return count < 2 // Stop after 2 elements
	})

	// Output will vary due to map iteration order, but structure will be:
	// All elements:
	// - apple
	// - banana
	// - cherry
	//
	// First 2 elements:
	// - apple
	// - banana
}

ExampleSet_Range_conditionalStop demonstrates stopping iteration early

package main

import (
	"fmt"

	"github.com/wuchieh/wtype"
)

func main() {
	set := wtype.NewSet[int]()
	for i := 1; i <= 10; i++ {
		set.Add(i)
	}

	fmt.Println("Numbers until we find one > 5:")
	set.Range(func(num int) bool {
		fmt.Printf("%d ", num)
		return num <= 5 // Stop when we find a number > 5
	})
	fmt.Println()

	// Output will vary due to map iteration order, but will stop early
}

ExampleSet_Remove demonstrates removing elements from a set

package main

import (
	"fmt"

	"github.com/wuchieh/wtype"
)

func main() {
	set := wtype.NewSet[string]()
	set.Add("red")
	set.Add("green")
	set.Add("blue")

	fmt.Printf("Before removal - Length: %d, Contains 'green': %t\n",
		set.Len(), set.Contains("green"))

	// Remove an existing element
	set.Remove("green")
	fmt.Printf("After removing 'green' - Length: %d, Contains 'green': %t\n",
		set.Len(), set.Contains("green"))

	// Remove a non-existing element (no effect)
	set.Remove("yellow")
	fmt.Printf("After removing non-existing 'yellow' - Length: %d\n", set.Len())

}

Output:

Before removal - Length: 3, Contains 'green': true
After removing 'green' - Length: 2, Contains 'green': false
After removing non-existing 'yellow' - Length: 2