maps

ExampleCMapGen_Range shows how to iterate over all entries. Returning false from the callback stops iteration early.

package main

import (
	"fmt"

	"github.com/phcp-tech/common-library-golang/maps"
)

func main() {
	m := maps.NewCMapGen[string, int64]()
	m.Set("A", 1)

	m.Range(func(key string, val int64) bool {
		fmt.Println(key, val)
		return true
	})
}

Output:
A 1

ExampleCMapGen_ReplaceAlways shows unconditional overwrite regardless of value.

package main

import (
	"fmt"

	"github.com/phcp-tech/common-library-golang/maps"
)

func main() {
	m := maps.NewCMapGen[string, int64]()
	m.Set("NZDUSD", 6500)

	m.ReplaceAlways("NZDUSD", 6000) // always stored, even though 6000 < 6500
	val, _ := m.Get("NZDUSD")
	fmt.Println(val)
}

Output:
6000

ExampleCMapGen_ReplaceIfNotExists shows set-once semantics: value is stored only when the key is not already present.

package main

import (
	"fmt"

	"github.com/phcp-tech/common-library-golang/maps"
)

func main() {
	m := maps.NewCMapGen[string, int64]()

	fmt.Println(m.ReplaceIfNotExists("CADUSD", 7500)) // true  — key absent
	fmt.Println(m.ReplaceIfNotExists("CADUSD", 8000)) // false — key exists

	val, _ := m.Get("CADUSD")
	fmt.Println(val)
}

Output:
true
false
7500

ExampleCMapGen_ReplaceWithStrategy shows how to supply a strategy ad-hoc without modifying the map's default configuration.

package main

import (
	"fmt"

	"github.com/phcp-tech/common-library-golang/maps"
)

func main() {
	m := maps.NewCMapGen[string, int64]()
	m.Set("AUDUSD", 7000)

	// NumericGreaterStrategy replaces only when the new value is greater.
	replaced := m.ReplaceWithStrategy("AUDUSD", 7200, maps.NumericGreaterStrategy[int64]{})
	fmt.Println(replaced)

	val, _ := m.Get("AUDUSD")
	fmt.Println(val)
}

Output:
true
7200

ExampleCMapGen_UpsertWithCallback shows how to perform a read-modify-write using a callback. The callback receives whether the key existed, the old value, and the candidate new value, and returns the value to store.

This is NOT atomic across concurrent callers of the same key: Get and Set are two independent, separately-locked operations with the callback running in between, so two goroutines racing on the same key can both read the same old value and the last Set wins, regardless of which callback result should logically have won. It is safe under concurrent writes to different keys, and safe (no corruption/panic) even for the same key — it just doesn't guarantee the logically-correct value is the one that ends up stored. For a true atomic read-modify-write on a single key, use the underlying cmap.ConcurrentMap.Upsert directly, which holds the shard lock for the whole callback.

package main

import (
	"fmt"

	"github.com/phcp-tech/common-library-golang/maps"
)

func main() {
	m := maps.NewCMapGen[string, int64]()
	m.Set("CHFUSD", 1000)

	// Keep the larger of the two values.
	m.UpsertWithCallback("CHFUSD", 1200, func(exists bool, old, new int64) int64 {
		if !exists || new > old {
			return new
		}
		return old
	})
	val, _ := m.Get("CHFUSD")
	fmt.Println(val)
}

Output:
1200