coverage.html


<!DOCTYPE html>
<html>
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
		<title>hashmap: Go Coverage Report</title>
		<style>
			body {
				background: black;
				color: rgb(80, 80, 80);
			}
			body, pre, #legend span {
				font-family: Menlo, monospace;
				font-weight: bold;
			}
			#topbar {
				background: black;
				position: fixed;
				top: 0; left: 0; right: 0;
				height: 42px;
				border-bottom: 1px solid rgb(80, 80, 80);
			}
			#content {
				margin-top: 50px;
			}
			#nav, #legend {
				float: left;
				margin-left: 10px;
			}
			#legend {
				margin-top: 12px;
			}
			#nav {
				margin-top: 10px;
			}
			#legend span {
				margin: 0 5px;
			}
			.cov0 { color: rgb(192, 0, 0) }
.cov1 { color: rgb(128, 128, 128) }
.cov2 { color: rgb(116, 140, 131) }
.cov3 { color: rgb(104, 152, 134) }
.cov4 { color: rgb(92, 164, 137) }
.cov5 { color: rgb(80, 176, 140) }
.cov6 { color: rgb(68, 188, 143) }
.cov7 { color: rgb(56, 200, 146) }
.cov8 { color: rgb(44, 212, 149) }
.cov9 { color: rgb(32, 224, 152) }
.cov10 { color: rgb(20, 236, 155) }

		</style>
	</head>
	<body>
		<div id="topbar">
			<div id="nav">
				<select id="files">
				
				<option value="file0">github.com/billowdev/fastmap/hashmap/appendable.go (6.9%)</option>
				
				<option value="file1">github.com/billowdev/fastmap/hashmap/appendable_threadsafe.go (8.3%)</option>
				
				<option value="file2">github.com/billowdev/fastmap/hashmap/combination.go (92.4%)</option>
				
				<option value="file3">github.com/billowdev/fastmap/hashmap/config_operation_threadsafe.go (100.0%)</option>
				
				<option value="file4">github.com/billowdev/fastmap/hashmap/config_operations.go (100.0%)</option>
				
				<option value="file5">github.com/billowdev/fastmap/hashmap/conversion.go (100.0%)</option>
				
				<option value="file6">github.com/billowdev/fastmap/hashmap/core.go (100.0%)</option>
				
				<option value="file7">github.com/billowdev/fastmap/hashmap/core_threadsafe.go (100.0%)</option>
				
				<option value="file8">github.com/billowdev/fastmap/hashmap/functional.go (100.0%)</option>
				
				<option value="file9">github.com/billowdev/fastmap/hashmap/functional_threadsafe.go (100.0%)</option>
				
				<option value="file10">github.com/billowdev/fastmap/hashmap/multiple_appendable.go (86.0%)</option>
				
				<option value="file11">github.com/billowdev/fastmap/hashmap/multiple_key_threadsafe.go (89.3%)</option>
				
				<option value="file12">github.com/billowdev/fastmap/hashmap/mutiple_key.go (92.3%)</option>
				
				<option value="file13">github.com/billowdev/fastmap/hashmap/operation_threadsafe.go (100.0%)</option>
				
				<option value="file14">github.com/billowdev/fastmap/hashmap/operations.go (95.5%)</option>
				
				<option value="file15">github.com/billowdev/fastmap/robinhood/robinhood.go (90.5%)</option>
				
				<option value="file16">github.com/billowdev/fastmap/sample/main.go (0.0%)</option>
				
				</select>
			</div>
			<div id="legend">
				<span>not tracked</span>
			
				<span class="cov0">not covered</span>
				<span class="cov8">covered</span>
			
			</div>
		</div>
		<div id="content">
		
		<pre class="file" id="file0" style="display: none">package fastmap

import "sort"

// AppendableHashMap extends HashMap to provide specialized functionality for handling slice operations.
// It maintains type safety through generics while providing convenient methods for appending values
// to existing slices within the map.
//
// Example:
//
//        layoutMap := NewAppendableHashMap[string, Component]()
//        layoutMap.AppendValues("section1", component1, component2)
//        layoutMap.AppendValues("section1", component3) // Appends to existing slice
type AppendableHashMap[K comparable, V any] struct {
        *HashMap[K, []V]
}

// NewAppendableHashMap creates a new instance of AppendableHashMap that safely manages
// slices of values associated with keys. It initializes an underlying HashMap to store
// the key-value pairs where values are slices.
//
// Example:
//
//        map := NewAppendableHashMap[string, int]()
//        map.AppendValues("key1", 1, 2, 3)
func NewAppendableHashMap[K comparable, V any]() *AppendableHashMap[K, V] <span class="cov8" title="1">{
        return &amp;AppendableHashMap[K, V]{
                HashMap: NewHashMap[K, []V](),
        }
}</span>

// AppendValues appends multiple values to an existing slice for a given key.
// If the key doesn't exist, it creates a new slice with the provided values.
// This method provides a safe way to handle the spread operator equivalent in Go.
//
// Parameters:
//   - key: The key to associate the values with
//   - values: Variadic parameter of values to append
//
// Example:
//
//        map.AppendValues("components", component1, component2)
//        map.AppendValues("components", component3) // Appends to existing slice
func (h *AppendableHashMap[K, V]) AppendValues(key K, values ...V) <span class="cov8" title="1">{
        if existing, exists := h.Get(key); exists </span><span class="cov8" title="1">{
                h.Put(key, append(existing, values...))
        }</span> else<span class="cov8" title="1"> {
                h.Put(key, values)
        }</span>
}

// SortValues sorts the slice stored at the given key using a custom comparison function.
// Returns true if the key exists and sorting was performed, false otherwise.
// The less function should return true if a comes before b in the desired order.
//
// Parameters:
//   - key: The key whose values should be sorted
//   - less: Comparison function that defines the sort order
//
// Example:
//
//        map.AppendValues("scores", 75, 82, 90, 65)
//        map.SortValues("scores", func(a, b int) bool { return a &lt; b })
//        // Result: [65, 75, 82, 90]
func (h *AppendableHashMap[K, V]) SortValues(key K, less func(a, b V) bool) bool <span class="cov0" title="0">{
        if values, exists := h.Get(key); exists </span><span class="cov0" title="0">{
                sort.Slice(values, func(i, j int) bool </span><span class="cov0" title="0">{
                        return less(values[i], values[j])
                }</span>)
                <span class="cov0" title="0">h.Put(key, values)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}

// SortValuesByField sorts values using a field extractor function that retrieves
// comparable values (int, string, float64) from the slice elements.
// Returns true if sorting was performed, false if key doesn't exist.
//
// Example:
//
//        type User struct {
//            Name string
//            Age  int
//        }
//        map.AppendValues("users", User{"Bob", 30}, User{"Alice", 25})
//        map.SortValuesByField("users", func(u User) any { return u.Name })
//        // Result: [{Alice 25} {Bob 30}]
func (h *AppendableHashMap[K, V]) SortValuesByField(key K, extractor func(V) any) bool <span class="cov0" title="0">{
        if values, exists := h.Get(key); exists </span><span class="cov0" title="0">{
                sort.Slice(values, func(i, j int) bool </span><span class="cov0" title="0">{
                        a := extractor(values[i])
                        b := extractor(values[j])
                        switch v := a.(type) </span>{
                        case int:<span class="cov0" title="0">
                                return v &lt; b.(int)</span>
                        case string:<span class="cov0" title="0">
                                return v &lt; b.(string)</span>
                        case float64:<span class="cov0" title="0">
                                return v &lt; b.(float64)</span>
                        default:<span class="cov0" title="0">
                                return false</span>
                        }
                })
                <span class="cov0" title="0">h.Put(key, values)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}

// ReverseValues reverses the order of values stored at the given key.
// Returns true if reversal was performed, false if key doesn't exist.
//
// Example:
//
//        map.AppendValues("items", "a", "b", "c")
//        map.ReverseValues("items")
//        // Result: ["c", "b", "a"]
func (h *AppendableHashMap[K, V]) ReverseValues(key K) bool <span class="cov0" title="0">{
        if values, exists := h.Get(key); exists </span><span class="cov0" title="0">{
                for i, j := 0, len(values)-1; i &lt; j; i, j = i+1, j-1 </span><span class="cov0" title="0">{
                        values[i], values[j] = values[j], values[i]
                }</span>
                <span class="cov0" title="0">h.Put(key, values)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}

// FilterValues applies a predicate function to filter values at the given key.
// Keeps only values where predicate returns true.
// Returns true if filtering was performed, false if key doesn't exist.
//
// Example:
//
//        map.AppendValues("numbers", 1, 2, 3, 4, 5)
//        map.FilterValues("numbers", func(n int) bool { return n%2 == 0 })
//        // Result: [2, 4]
func (h *AppendableHashMap[K, V]) FilterValues(key K, predicate func(V) bool) bool <span class="cov0" title="0">{
        if values, exists := h.Get(key); exists </span><span class="cov0" title="0">{
                filtered := make([]V, 0, len(values))
                for _, v := range values </span><span class="cov0" title="0">{
                        if predicate(v) </span><span class="cov0" title="0">{
                                filtered = append(filtered, v)
                        }</span>
                }
                <span class="cov0" title="0">h.Put(key, filtered)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}

// TransformValues applies a transformation function to all values at the given key.
// The transform function maps each value to a new value of the same type.
// Returns true if transformation was performed, false if key doesn't exist.
//
// Example:
//
//        map.AppendValues("numbers", 1, 2, 3)
//        map.TransformValues("numbers", func(n int) int { return n * 2 })
//        // Result: [2, 4, 6]
func (h *AppendableHashMap[K, V]) TransformValues(key K, transform func(V) V) bool <span class="cov0" title="0">{
        if values, exists := h.Get(key); exists </span><span class="cov0" title="0">{
                for i, v := range values </span><span class="cov0" title="0">{
                        values[i] = transform(v)
                }</span>
                <span class="cov0" title="0">h.Put(key, values)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}

// RemoveDuplicates removes duplicate values at the given key while maintaining order.
// Uses the provided equals function to determine value equality.
// Returns true if deduplication was performed, false if key doesn't exist.
//
// Example:
//
//        map.AppendValues("tags", "go", "java", "go", "python", "java")
//        map.RemoveDuplicates("tags", func(a, b string) bool { return a == b })
//        // Result: ["go", "java", "python"]
func (h *AppendableHashMap[K, V]) RemoveDuplicates(key K, equals func(a, b V) bool) bool <span class="cov0" title="0">{
        if values, exists := h.Get(key); exists </span><span class="cov0" title="0">{
                if len(values) &lt;= 1 </span><span class="cov0" title="0">{
                        return true
                }</span>

                <span class="cov0" title="0">unique := make([]V, 0, len(values))
                unique = append(unique, values[0])

                for i := 1; i &lt; len(values); i++ </span><span class="cov0" title="0">{
                        isDuplicate := false
                        for j := 0; j &lt; len(unique); j++ </span><span class="cov0" title="0">{
                                if equals(values[i], unique[j]) </span><span class="cov0" title="0">{
                                        isDuplicate = true
                                        break</span>
                                }
                        }
                        <span class="cov0" title="0">if !isDuplicate </span><span class="cov0" title="0">{
                                unique = append(unique, values[i])
                        }</span>
                }

                <span class="cov0" title="0">h.Put(key, unique)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}
</pre>
		
		<pre class="file" id="file1" style="display: none">package fastmap

import "sort"

// ThreadSafeAppendableHashMap provides thread-safe operations for handling slice values
// in a concurrent environment. It uses mutex locks to ensure safe access and modification
// of the underlying data structure.
//
// Example:
//
//        safeMap := NewThreadSafeAppendableHashMap[string, Component]()
//        // Safe for concurrent access
//        go func() { safeMap.AppendValues("section1", component1) }()
//        go func() { safeMap.AppendValues("section1", component2) }()
type ThreadSafeAppendableHashMap[K comparable, V any] struct {
        *ThreadSafeHashMap[K, []V]
}

// NewThreadSafeAppendableHashMap creates a new instance of ThreadSafeAppendableHashMap
// that provides synchronized access to slice operations. It's suitable for concurrent
// environments where multiple goroutines might append values simultaneously.
//
// Example:
//
//        safeMap := NewThreadSafeAppendableHashMap[string, int]()
//        // Safe for concurrent operations
//        go func() { safeMap.AppendValues("key1", 1, 2) }()
func NewThreadSafeAppendableHashMap[K comparable, V any]() *ThreadSafeAppendableHashMap[K, V] <span class="cov8" title="1">{
        return &amp;ThreadSafeAppendableHashMap[K, V]{
                ThreadSafeHashMap: NewThreadSafeHashMap[K, []V](),
        }
}</span>

// AppendValues safely appends multiple values to an existing slice for a given key
// in a thread-safe manner. It uses mutex locks to ensure concurrent safety during
// the append operation.
//
// Parameters:
//   - key: The key to associate the values with
//   - values: Variadic parameter of values to append
//
// Example:
//
//        safeMap.AppendValues("users", user1, user2)
//        // Concurrent access is safe
//        go safeMap.AppendValues("users", user3)
func (t *ThreadSafeAppendableHashMap[K, V]) AppendValues(key K, values ...V) <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()

        if existing, exists := t.data.Get(key); exists </span><span class="cov8" title="1">{
                t.data.Put(key, append(existing, values...))
        }</span> else<span class="cov8" title="1"> {
                t.data.Put(key, values)
        }</span>
}

// SortValues sorts the slice in a thread-safe manner using the custom comparison function.
// Returns true if sorting was performed, false if key doesn't exist.
//
// Example:
//
//        safeMap.AppendValues("scores", 75, 82, 90, 65)
//        safeMap.SortValues("scores", func(a, b int) bool { return a &lt; b })
//        // Result: [65, 75, 82, 90]
func (t *ThreadSafeAppendableHashMap[K, V]) SortValues(key K, less func(a, b V) bool) bool <span class="cov0" title="0">{
        t.mutex.Lock()
        defer t.mutex.Unlock()

        if values, exists := t.Get(key); exists </span><span class="cov0" title="0">{
                sort.Slice(values, func(i, j int) bool </span><span class="cov0" title="0">{
                        return less(values[i], values[j])
                }</span>)
                <span class="cov0" title="0">t.Put(key, values)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}

// SortValuesByField sorts values in a thread-safe manner using a field extractor.
// Returns true if sorting was performed, false if key doesn't exist.
//
// Example:
//
//        type User struct {
//            Name string
//            Age  int
//        }
//        safeMap.AppendValues("users", User{"Bob", 30}, User{"Alice", 25})
//        safeMap.SortValuesByField("users", func(u User) any { return u.Name })
//        // Result: [{Alice 25} {Bob 30}]
func (t *ThreadSafeAppendableHashMap[K, V]) SortValuesByField(key K, extractor func(V) any) bool <span class="cov0" title="0">{
        t.mutex.Lock()
        defer t.mutex.Unlock()

        if values, exists := t.Get(key); exists </span><span class="cov0" title="0">{
                sort.Slice(values, func(i, j int) bool </span><span class="cov0" title="0">{
                        a := extractor(values[i])
                        b := extractor(values[j])
                        switch v := a.(type) </span>{
                        case int:<span class="cov0" title="0">
                                return v &lt; b.(int)</span>
                        case string:<span class="cov0" title="0">
                                return v &lt; b.(string)</span>
                        case float64:<span class="cov0" title="0">
                                return v &lt; b.(float64)</span>
                        default:<span class="cov0" title="0">
                                return false</span>
                        }
                })
                <span class="cov0" title="0">t.Put(key, values)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}

// ReverseValues reverses values order in a thread-safe manner.
// Returns true if reversal was performed, false if key doesn't exist.
//
// Example:
//
//        safeMap.AppendValues("items", "a", "b", "c")
//        safeMap.ReverseValues("items")
//        // Result: ["c", "b", "a"]
func (t *ThreadSafeAppendableHashMap[K, V]) ReverseValues(key K) bool <span class="cov0" title="0">{
        t.mutex.Lock()
        defer t.mutex.Unlock()

        if values, exists := t.Get(key); exists </span><span class="cov0" title="0">{
                for i, j := 0, len(values)-1; i &lt; j; i, j = i+1, j-1 </span><span class="cov0" title="0">{
                        values[i], values[j] = values[j], values[i]
                }</span>
                <span class="cov0" title="0">t.Put(key, values)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}

// FilterValues filters values in a thread-safe manner using a predicate.
// Returns true if filtering was performed, false if key doesn't exist.
//
// Example:
//
//        safeMap.AppendValues("numbers", 1, 2, 3, 4, 5)
//        safeMap.FilterValues("numbers", func(n int) bool { return n%2 == 0 })
//        // Result: [2, 4]
func (t *ThreadSafeAppendableHashMap[K, V]) FilterValues(key K, predicate func(V) bool) bool <span class="cov0" title="0">{
        t.mutex.Lock()
        defer t.mutex.Unlock()

        if values, exists := t.Get(key); exists </span><span class="cov0" title="0">{
                filtered := make([]V, 0, len(values))
                for _, v := range values </span><span class="cov0" title="0">{
                        if predicate(v) </span><span class="cov0" title="0">{
                                filtered = append(filtered, v)
                        }</span>
                }
                <span class="cov0" title="0">t.Put(key, filtered)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}

// TransformValues transforms values in a thread-safe manner.
// Returns true if transformation was performed, false if key doesn't exist.
//
// Example:
//
//        safeMap.AppendValues("numbers", 1, 2, 3)
//        safeMap.TransformValues("numbers", func(n int) int { return n * 2 })
//        // Result: [2, 4, 6]
func (t *ThreadSafeAppendableHashMap[K, V]) TransformValues(key K, transform func(V) V) bool <span class="cov0" title="0">{
        t.mutex.Lock()
        defer t.mutex.Unlock()

        if values, exists := t.Get(key); exists </span><span class="cov0" title="0">{
                for i, v := range values </span><span class="cov0" title="0">{
                        values[i] = transform(v)
                }</span>
                <span class="cov0" title="0">t.Put(key, values)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}

// RemoveDuplicates removes duplicates in a thread-safe manner.
// Returns true if deduplication was performed, false if key doesn't exist.
//
// Example:
//
//        safeMap.AppendValues("tags", "go", "java", "go", "python", "java")
//        safeMap.RemoveDuplicates("tags", func(a, b string) bool { return a == b })
//        // Result: ["go", "java", "python"]
func (t *ThreadSafeAppendableHashMap[K, V]) RemoveDuplicates(key K, equals func(a, b V) bool) bool <span class="cov0" title="0">{
        t.mutex.Lock()
        defer t.mutex.Unlock()

        if values, exists := t.Get(key); exists </span><span class="cov0" title="0">{
                if len(values) &lt;= 1 </span><span class="cov0" title="0">{
                        return true
                }</span>

                <span class="cov0" title="0">unique := make([]V, 0, len(values))
                unique = append(unique, values[0])

                for i := 1; i &lt; len(values); i++ </span><span class="cov0" title="0">{
                        isDuplicate := false
                        for j := 0; j &lt; len(unique); j++ </span><span class="cov0" title="0">{
                                if equals(values[i], unique[j]) </span><span class="cov0" title="0">{
                                        isDuplicate = true
                                        break</span>
                                }
                        }
                        <span class="cov0" title="0">if !isDuplicate </span><span class="cov0" title="0">{
                                unique = append(unique, values[i])
                        }</span>
                }

                <span class="cov0" title="0">t.Put(key, unique)
                return true</span>
        }
        <span class="cov0" title="0">return false</span>
}
</pre>
		
		<pre class="file" id="file2" style="display: none">package fastmap

import (
        "fmt"
)

// ComboKeyHashMap maps combinations of keys to a single value
type ComboKeyHashMap[K comparable, V any] struct {
        data      map[string]V        // stores values
        keyGroups map[K][]KeyGroup[K] // maps individual keys to their key groups
}

// NewComboKeyHashMap creates a new ComboKeyHashMap
func NewComboKeyHashMap[K comparable, V any]() *ComboKeyHashMap[K, V] <span class="cov8" title="1">{
        return &amp;ComboKeyHashMap[K, V]{
                data:      make(map[string]V),
                keyGroups: make(map[K][]KeyGroup[K]),
        }
}</span>

// generateKeyString creates a unique string for a key group
func (m *ComboKeyHashMap[K, V]) generateKeyString(keys []K) string <span class="cov8" title="1">{
        sorted := make([]K, len(keys))
        copy(sorted, keys)
        sortSlice(sorted)
        result := ""
        for i, key := range sorted </span><span class="cov8" title="1">{
                if i &gt; 0 </span><span class="cov8" title="1">{
                        result += ","
                }</span>
                <span class="cov8" title="1">result += fmt.Sprintf("%v", key)</span>
        }
        <span class="cov8" title="1">return result</span>
}

// Put associates a value with a combination of keys
func (m *ComboKeyHashMap[K, V]) Put(keys []K, value V) <span class="cov8" title="1">{
        if len(keys) == 0 </span><span class="cov8" title="1">{
                return
        }</span>

        <span class="cov8" title="1">keyString := m.generateKeyString(keys)
        m.data[keyString] = value

        // Store key group reference for each key
        keyGroup := make(KeyGroup[K], len(keys))
        copy(keyGroup, keys)

        for _, key := range keys </span><span class="cov8" title="1">{
                m.keyGroups[key] = append(m.keyGroups[key], keyGroup)
        }</span>
}

// Get retrieves a value by its exact key combination
func (m *ComboKeyHashMap[K, V]) Get(keys []K) (V, bool) <span class="cov8" title="1">{
        keyString := m.generateKeyString(keys)
        val, exists := m.data[keyString]
        return val, exists
}</span>

// GetByKeys retrieves a value where provided keys are part of the key group
func (m *ComboKeyHashMap[K, V]) GetByKeys(keys []K) (V, bool) <span class="cov8" title="1">{
        if len(keys) == 0 </span><span class="cov8" title="1">{
                var zero V
                return zero, false
        }</span>

        // Check first key's groups
        <span class="cov8" title="1">firstKey := keys[0]
        groups := m.keyGroups[firstKey]

        for _, group := range groups </span><span class="cov8" title="1">{
                // Check if all provided keys are in this group
                allKeysFound := true
                for _, searchKey := range keys </span><span class="cov8" title="1">{
                        if !contains(group, searchKey) </span><span class="cov0" title="0">{
                                allKeysFound = false
                                break</span>
                        }
                }

                <span class="cov8" title="1">if allKeysFound </span><span class="cov8" title="1">{
                        keyString := m.generateKeyString(group)
                        if val, exists := m.data[keyString]; exists </span><span class="cov8" title="1">{
                                return val, true
                        }</span>
                }
        }

        <span class="cov8" title="1">var zero V
        return zero, false</span>
}

// Helper functions

func contains[K comparable](slice []K, item K) bool <span class="cov8" title="1">{
        for _, v := range slice </span><span class="cov8" title="1">{
                if v == item </span><span class="cov8" title="1">{
                        return true
                }</span>
        }
        <span class="cov0" title="0">return false</span>
}

func sortSlice[K comparable](slice []K) <span class="cov8" title="1">{
        n := len(slice)
        for i := 0; i &lt; n-1; i++ </span><span class="cov8" title="1">{
                for j := 0; j &lt; n-i-1; j++ </span><span class="cov8" title="1">{
                        if fmt.Sprintf("%v", slice[j]) &gt; fmt.Sprintf("%v", slice[j+1]) </span><span class="cov8" title="1">{
                                slice[j], slice[j+1] = slice[j+1], slice[j]
                        }</span>
                }
        }
}

type KeyGroup[K comparable] []K

// GetByExactKeys retrieves a value where provided keys exactly match a key group
func (m *ComboKeyHashMap[K, V]) GetByExactKeys(keys []K) (V, bool) <span class="cov8" title="1">{
        if len(keys) == 0 </span><span class="cov8" title="1">{
                var zero V
                return zero, false
        }</span>

        // Check first key's groups
        <span class="cov8" title="1">firstKey := keys[0]
        groups := m.keyGroups[firstKey]

        for _, group := range groups </span><span class="cov8" title="1">{
                // First check if lengths match - all keys must be present
                if len(group) != len(keys) </span><span class="cov8" title="1">{
                        continue</span>
                }

                // Check if all provided keys are in this group
                <span class="cov8" title="1">allKeysFound := true
                for _, searchKey := range keys </span><span class="cov8" title="1">{
                        if !contains(group, searchKey) </span><span class="cov0" title="0">{
                                allKeysFound = false
                                break</span>
                        }
                }

                <span class="cov8" title="1">if allKeysFound </span><span class="cov8" title="1">{
                        keyString := m.generateKeyString(group)
                        if val, exists := m.data[keyString]; exists </span><span class="cov8" title="1">{
                                return val, true
                        }</span>
                }
        }

        <span class="cov8" title="1">var zero V
        return zero, false</span>
}
</pre>
		
		<pre class="file" id="file3" style="display: none">package fastmap

// HandleFieldConfigs processes data using field configurations and returns results
// Example:
//
//        configs := map[string]FieldConfig[int]{
//            "field1": {
//                Handler: func(data map[string]interface{}) *int {
//                    if val, ok := data["value"].(int); ok {
//                        return &amp;val
//                    }
//                    return nil
//                },
//            },
//        }
//        results := safeMap.HandleFieldConfigs(data, configs, "field1")
func (t *ThreadSafeHashMap[K, V]) HandleFieldConfigs(
        data []map[string]interface{},
        configs map[K]FieldConfig[V],
        fieldKey K,
) []V <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.HandleFieldConfigs(data, configs, fieldKey)
}</span>

// ApplyFieldConfig applies a single field configuration to data
// Example:
//
//        config := FieldConfig[int]{
//            Handler: func(data map[string]interface{}) *int {
//                if val, ok := data["value"].(int); ok {
//                    return &amp;val
//                }
//                return nil
//            },
//        }
//        success := safeMap.ApplyFieldConfig("field1", config, data)
func (t *ThreadSafeHashMap[K, V]) ApplyFieldConfig(
        key K,
        config FieldConfig[V],
        data map[string]interface{},
) bool <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()
        return t.data.ApplyFieldConfig(key, config, data)
}</span>

// ProcessFieldConfigs processes data using field configurations with a callback
// Example:
//
//        configs := map[string]FieldConfig[int]{
//            "field1": {
//                Handler: func(data map[string]interface{}) *int {
//                    if val, ok := data["value"].(int); ok {
//                        return &amp;val
//                    }
//                    return nil
//                },
//            },
//        }
//        safeMap.ProcessFieldConfigs(configs, data, func(key string, value int, index int) {
//            fmt.Printf("Processed: %s = %d at index %d\n", key, value, index)
//        })
func (t *ThreadSafeHashMap[K, V]) ProcessFieldConfigs(
        configs map[K]FieldConfig[V],
        data []map[string]interface{},
        processor func(key K, value V, index int),
) <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()
        t.data.ProcessFieldConfigs(configs, data, processor)
}</span>
</pre>
		
		<pre class="file" id="file4" style="display: none">package fastmap

type FieldConfig[T any] struct {
        RowIndex *int
        Handler  func(data map[string]interface{}) *T
}

func (h *HashMap[K, V]) HandleFieldConfigs(
        data []map[string]interface{},
        configs map[K]FieldConfig[V],
        fieldKey K,
) []V <span class="cov8" title="1">{
        result := make([]V, 0, len(data)*len(configs))

        for index, temp := range data </span><span class="cov8" title="1">{
                if _, exists := h.Get(fieldKey); exists </span><span class="cov8" title="1">{
                        if handler := configs[fieldKey].Handler; handler != nil </span><span class="cov8" title="1">{
                                if configs[fieldKey].RowIndex != nil </span><span class="cov8" title="1">{
                                        *configs[fieldKey].RowIndex = index
                                }</span>
                                <span class="cov8" title="1">if value := handler(temp); value != nil </span><span class="cov8" title="1">{
                                        result = append(result, *value)
                                }</span>
                        }
                }
        }
        <span class="cov8" title="1">return result</span>
}

func (h *HashMap[K, V]) ApplyFieldConfig(
        key K,
        config FieldConfig[V],
        data map[string]interface{},
) bool <span class="cov8" title="1">{
        if value := config.Handler(data); value != nil </span><span class="cov8" title="1">{
                return h.UpdateValue(key, *value)
        }</span>
        <span class="cov8" title="1">return false</span>
}

func (h *HashMap[K, V]) ProcessFieldConfigs(
        configs map[K]FieldConfig[V],
        data []map[string]interface{},
        processor func(key K, value V, index int),
) <span class="cov8" title="1">{
        for index, temp := range data </span><span class="cov8" title="1">{
                for key, config := range configs </span><span class="cov8" title="1">{
                        if h.Contains(key) </span><span class="cov8" title="1">{
                                if config.RowIndex != nil </span><span class="cov8" title="1">{
                                        *config.RowIndex = index
                                }</span>
                                <span class="cov8" title="1">if value := config.Handler(temp); value != nil </span><span class="cov8" title="1">{
                                        if h.UpdateValue(key, *value) </span><span class="cov8" title="1">{
                                                if processor != nil </span><span class="cov8" title="1">{
                                                        if val, exists := h.Get(key); exists </span><span class="cov8" title="1">{
                                                                processor(key, val, index)
                                                        }</span>
                                                }
                                        }
                                }
                        }
                }
        }
}
</pre>
		
		<pre class="file" id="file5" style="display: none">package fastmap

// ToMap returns the underlying map
// Example:
//
//        standardMap := hashMap.ToMap()
//        for k, v := range standardMap {
//            fmt.Printf("%v: %v\n", k, v)
//        }
func (h *HashMap[K, V]) ToMap() map[K]V <span class="cov8" title="1">{
        result := make(map[K]V, len(h.data))
        for k, v := range h.data </span><span class="cov8" title="1">{
                result[k] = v
        }</span>
        <span class="cov8" title="1">return result</span>
}

// FromMap creates a new HashMap from a regular map
// Example:
//
//        regularMap := map[string]int{"one": 1, "two": 2}
//        hashMap := FromMap(regularMap)
func FromMap[K comparable, V any](m map[K]V) *HashMap[K, V] <span class="cov8" title="1">{
        h := NewHashMap[K, V]()
        for k, v := range m </span><span class="cov8" title="1">{
                h.Put(k, v)
        }</span>
        <span class="cov8" title="1">return h</span>
}
</pre>
		
		<pre class="file" id="file6" style="display: none">package fastmap

type ValueCallback[K comparable, V any] func(key K, value V)

// HashMap is a generic key-value store supporting comparable keys and any value type
// Example:
//
//        hashMap := NewHashMap[string, int]()
type HashMap[K comparable, V any] struct {
        data map[K]V
}

// NewHashMap creates a new empty HashMap
// Example:
//
//        hashMap := NewHashMap[string, User]()
func NewHashMap[K comparable, V any]() *HashMap[K, V] <span class="cov8" title="1">{
        return &amp;HashMap[K, V]{
                data: make(map[K]V),
        }
}</span>

// Put adds or updates a key-value pair in the HashMap
// Example:
//
//        hashMap.Put("user123", User{Name: "John"})
func (h *HashMap[K, V]) Put(key K, value V) <span class="cov8" title="1">{
        h.data[key] = value
}</span>

// Get retrieves a value by key and returns whether it exists
// Example:
//
//        if user, exists := hashMap.Get("user123"); exists {
//            fmt.Printf("Found user: %v\n", user)
//        }
func (h *HashMap[K, V]) Get(key K) (V, bool) <span class="cov8" title="1">{
        value, exists := h.data[key]
        return value, exists
}</span>

// Remove deletes a key-value pair from the HashMap
// Example:
//
//        hashMap.Remove("user123")
func (h *HashMap[K, V]) Remove(key K) <span class="cov8" title="1">{
        delete(h.data, key)
}</span>

// Size returns the number of elements in the HashMap
// Example:
//
//        count := hashMap.Size()
//        fmt.Printf("HashMap contains %d elements\n", count)
func (h *HashMap[K, V]) Size() int <span class="cov8" title="1">{
        return len(h.data)
}</span>
</pre>
		
		<pre class="file" id="file7" style="display: none">package fastmap

import (
        "sync"
)

// ThreadSafeHashMap provides thread-safe operations for HashMap through mutex synchronization
// Example:
//
//        safeMap := NewThreadSafeHashMap[string, User]()
//        safeMap.Put("user1", User{Name: "John"})
type ThreadSafeHashMap[K comparable, V any] struct {
        mutex sync.RWMutex
        data  *HashMap[K, V]
}

// NewThreadSafeHashMap creates a new thread-safe HashMap
// Example:
//
//        safeMap := NewThreadSafeHashMap[string, User]()
func NewThreadSafeHashMap[K comparable, V any]() *ThreadSafeHashMap[K, V] <span class="cov8" title="1">{
        return &amp;ThreadSafeHashMap[K, V]{
                data: NewHashMap[K, V](),
        }
}</span>

// Put adds or updates a key-value pair in the ThreadSafeHashMap with write lock
// Example:
//
//        safeMap.Put("user123", User{Name: "John"})
func (t *ThreadSafeHashMap[K, V]) Put(key K, value V) <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()
        t.data.Put(key, value)
}</span>

// Get retrieves a value by key and returns whether it exists with read lock
// Example:
//
//        if user, exists := safeMap.Get("user123"); exists {
//            fmt.Printf("Found user: %v\n", user)
//        }
func (t *ThreadSafeHashMap[K, V]) Get(key K) (V, bool) <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.Get(key)
}</span>

// Remove deletes a key-value pair from the ThreadSafeHashMap with write lock
// Example:
//
//        safeMap.Remove("user123")
func (t *ThreadSafeHashMap[K, V]) Remove(key K) <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()
        t.data.Remove(key)
}</span>

// Clear removes all elements from the ThreadSafeHashMap with write lock
// Example:
//
//        safeMap.Clear()
//        fmt.Printf("Size after clear: %d\n", safeMap.Size())
func (t *ThreadSafeHashMap[K, V]) Clear() <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()
        t.data.Clear()
}</span>

// Size returns the number of elements in the ThreadSafeHashMap with read lock
// Example:
//
//        count := safeMap.Size()
//        fmt.Printf("HashMap contains %d elements\n", count)
func (t *ThreadSafeHashMap[K, V]) Size() int <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.Size()
}</span>
</pre>
		
		<pre class="file" id="file8" style="display: none">package fastmap

// Filter returns a new HashMap containing only the elements that satisfy the predicate
// Example:
//
//        activeUsers := hashMap.Filter(func(key string, user User) bool {
//            return user.Active
//        })
func (h *HashMap[K, V]) Filter(predicate func(K, V) bool) *HashMap[K, V] <span class="cov8" title="1">{
        result := NewHashMap[K, V]()
        for k, v := range h.data </span><span class="cov8" title="1">{
                if predicate(k, v) </span><span class="cov8" title="1">{
                        result.Put(k, v)
                }</span>
        }
        <span class="cov8" title="1">return result</span>
}

// Map transforms values using the provided function and returns a new HashMap
// Example:
//
//        upperNames := hashMap.Map(func(key string, user User) User {
//            user.Name = strings.ToUpper(user.Name)
//            return user
//        })
func (h *HashMap[K, V]) Map(transform func(K, V) V) *HashMap[K, V] <span class="cov8" title="1">{
        result := NewHashMap[K, V]()
        for k, v := range h.data </span><span class="cov8" title="1">{
                result.Put(k, transform(k, v))
        }</span>
        <span class="cov8" title="1">return result</span>
}

</pre>
		
		<pre class="file" id="file9" style="display: none">package fastmap

// Filter returns a new ThreadSafeHashMap containing only the elements that satisfy the predicate with read lock
// Example:
//
//        activeUsers := safeMap.Filter(func(key string, user User) bool {
//            return user.Active
//        })
func (t *ThreadSafeHashMap[K, V]) Filter(predicate func(K, V) bool) *ThreadSafeHashMap[K, V] <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        result := NewThreadSafeHashMap[K, V]()
        result.data = t.data.Filter(predicate)
        return result
}</span>

// Map transforms values using the provided function and returns a new ThreadSafeHashMap with read lock
// Example:
//
//        upperNames := safeMap.Map(func(key string, user User) User {
//            user.Name = strings.ToUpper(user.Name)
//            return user
//        })
func (t *ThreadSafeHashMap[K, V]) Map(transform func(K, V) V) *ThreadSafeHashMap[K, V] <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        result := NewThreadSafeHashMap[K, V]()
        result.data = t.data.Map(transform)
        return result
}</span>

// ToMap returns the underlying map with read lock
// Example:
//
//        standardMap := safeMap.ToMap()
//        for k, v := range standardMap {
//            fmt.Printf("%v: %v\n", k, v)
//        }
func (t *ThreadSafeHashMap[K, V]) ToMap() map[K]V <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.ToMap()
}</span>

// FromThreadSafeMap creates a new ThreadSafeHashMap from a regular map
// Example:
//
//        regularMap := map[string]int{"one": 1, "two": 2}
//        safeMap := FromThreadSafeMap(regularMap)
func FromThreadSafeMap[K comparable, V any](m map[K]V) *ThreadSafeHashMap[K, V] <span class="cov8" title="1">{
        result := NewThreadSafeHashMap[K, V]()
        result.data = FromMap(m)
        return result
}</span>
</pre>
		
		<pre class="file" id="file10" style="display: none">package fastmap

// AppendableMultiKeyHashMap extends MultiKeyHashMap to support slice operations
type AppendableMultiKeyHashMap[K comparable, V any] struct {
        *MultiKeyHashMap[K, []V]
}

// NewAppendableMultiKeyHashMap creates a new AppendableMultiKeyHashMap instance
func NewAppendableMultiKeyHashMap[K comparable, V any]() *AppendableMultiKeyHashMap[K, V] <span class="cov8" title="1">{
        return &amp;AppendableMultiKeyHashMap[K, V]{
                MultiKeyHashMap: NewMultiKeyHashMap[K, []V](),
        }
}</span>

// AppendValues appends values to the slice associated with the primary key or any of its aliases
func (m *AppendableMultiKeyHashMap[K, V]) AppendValues(key K, values ...V) bool <span class="cov8" title="1">{
        // Get primary key if it exists
        primaryKey, exists := m.GetPrimaryKey(key)
        if !exists </span><span class="cov8" title="1">{
                return false
        }</span>

        // Get existing values or create new slice
        <span class="cov8" title="1">if currentValues, exists := m.Get(primaryKey); exists </span><span class="cov8" title="1">{
                newValues := append(currentValues, values...)
                m.Put(m.GetAllKeys(primaryKey), newValues)
        }</span> else<span class="cov0" title="0"> {
                m.Put([]K{primaryKey}, values)
        }</span>

        <span class="cov8" title="1">return true</span>
}

// AppendValuesWithKeys appends values and associates them with multiple keys
func (m *AppendableMultiKeyHashMap[K, V]) AppendValuesWithKeys(keys []K, values ...V) bool <span class="cov8" title="1">{
        if len(keys) == 0 </span><span class="cov8" title="1">{
                return false
        }</span>

        // Get existing values or create new slice
        <span class="cov8" title="1">if currentValues, exists := m.Get(keys[0]); exists </span><span class="cov8" title="1">{
                newValues := append(currentValues, values...)
                m.Put(keys, newValues)
        }</span> else<span class="cov8" title="1"> {
                m.Put(keys, values)
        }</span>

        <span class="cov8" title="1">return true</span>
}

// GetSlice returns the slice associated with any key (primary or alias)
func (m *AppendableMultiKeyHashMap[K, V]) GetSlice(key K) ([]V, bool) <span class="cov8" title="1">{
        return m.Get(key)
}</span>

// UpdateSlice updates the entire slice for a given key and its aliases
func (m *AppendableMultiKeyHashMap[K, V]) UpdateSlice(key K, newValues []V) bool <span class="cov8" title="1">{
        if primaryKey, exists := m.GetPrimaryKey(key); exists </span><span class="cov8" title="1">{
                m.Put(m.GetAllKeys(primaryKey), newValues)
                return true
        }</span>
        <span class="cov0" title="0">return false</span>
}

// GetValuesByKeys retrieves values associated with an array of keys
// If a key doesn't exist, it will be skipped in the result
func (m *AppendableMultiKeyHashMap[K, V]) GetValuesByKeys(keys []K) map[K][]V <span class="cov8" title="1">{
        result := make(map[K][]V)

        for _, key := range keys </span><span class="cov8" title="1">{
                if values, exists := m.GetSlice(key); exists </span><span class="cov8" title="1">{
                        result[key] = values
                }</span>
        }

        <span class="cov8" title="1">return result</span>
}

// GetValuesByKeysWithPrimary retrieves values associated with an array of keys
// The returned map uses primary keys instead of the provided aliases
func (m *AppendableMultiKeyHashMap[K, V]) GetValuesByKeysWithPrimary(keys []K) map[K][]V <span class="cov8" title="1">{
        result := make(map[K][]V)

        for _, key := range keys </span><span class="cov8" title="1">{
                if primaryKey, exists := m.GetPrimaryKey(key); exists </span><span class="cov8" title="1">{
                        if values, valExists := m.GetSlice(primaryKey); valExists </span><span class="cov8" title="1">{
                                result[primaryKey] = values
                        }</span>
                }
        }

        <span class="cov8" title="1">return result</span>
}

// GetByExactKeys retrieves values only if all provided keys are associated with the same value set
// Returns the values and true if an exact match is found, empty slice and false otherwise
func (m *AppendableMultiKeyHashMap[K, V]) GetByExactKeys(keys []K) ([]V, bool) <span class="cov8" title="1">{
        if len(keys) == 0 </span><span class="cov8" title="1">{
                return nil, false
        }</span>

        // First find the latest primary key among all input keys
        <span class="cov8" title="1">var latestPrimaryKey K
        var foundPrimary bool

        for _, key := range keys </span><span class="cov8" title="1">{
                if currentPrimary, exists := m.GetPrimaryKey(key); exists </span><span class="cov8" title="1">{
                        if !foundPrimary </span><span class="cov8" title="1">{
                                latestPrimaryKey = currentPrimary
                                foundPrimary = true
                        }</span> else<span class="cov8" title="1"> if currentPrimary != latestPrimaryKey </span><span class="cov8" title="1">{
                                // If we find a different primary key that has one of our keys as an alias,
                                // it means this key was reassigned more recently
                                if _, exists := m.GetSlice(currentPrimary); exists </span><span class="cov8" title="1">{
                                        latestPrimaryKey = currentPrimary
                                }</span>
                        }
                }
        }

        <span class="cov8" title="1">if !foundPrimary </span><span class="cov8" title="1">{
                return nil, false
        }</span>

        // Now verify all keys point to this latest primary key
        <span class="cov8" title="1">for _, key := range keys </span><span class="cov8" title="1">{
                if currentPrimary, exists := m.GetPrimaryKey(key); !exists || currentPrimary != latestPrimaryKey </span><span class="cov8" title="1">{
                        return nil, false
                }</span>
        }

        // Return the values associated with the latest primary key
        <span class="cov8" title="1">values, exists := m.GetSlice(latestPrimaryKey)
        return values, exists</span>
}

// GetByExactKeysAll returns a map of all entries where the provided keys match exactly
// Each entry in the result map contains the primary key and its values
func (m *AppendableMultiKeyHashMap[K, V]) GetByExactKeysAll(keyGroups [][]K) map[K][]V <span class="cov0" title="0">{
        result := make(map[K][]V)

        for _, keys := range keyGroups </span><span class="cov0" title="0">{
                if values, exists := m.GetByExactKeys(keys); exists </span><span class="cov0" title="0">{
                        // Use the primary key for storing the result
                        if primaryKey, exists := m.GetPrimaryKey(keys[0]); exists </span><span class="cov0" title="0">{
                                result[primaryKey] = values
                        }</span>
                }
        }

        <span class="cov0" title="0">return result</span>
}
</pre>
		
		<pre class="file" id="file11" style="display: none">package fastmap

import "sync"

// ThreadSafeMultiKeyHashMap provides thread-safe operations for MultiKeyHashMap through mutex synchronization
type ThreadSafeMultiKeyHashMap[K comparable, V any] struct {
        mutex sync.RWMutex
        data  *MultiKeyHashMap[K, V]
}

// NewThreadSafeMultiKeyHashMap creates a new thread-safe MultiKeyHashMap
// Example:
//
//        safeMap := NewThreadSafeMultiKeyHashMap[string, User]()
func NewThreadSafeMultiKeyHashMap[K comparable, V any]() *ThreadSafeMultiKeyHashMap[K, V] <span class="cov8" title="1">{
        return &amp;ThreadSafeMultiKeyHashMap[K, V]{
                data: NewMultiKeyHashMap[K, V](),
        }
}</span>

// Put adds a value with multiple keys with write lock
// Example:
//
//        safeMap.Put([]string{"main", "alias1", "alias2"}, user)
func (t *ThreadSafeMultiKeyHashMap[K, V]) Put(keys []K, value V) <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()
        t.data.Put(keys, value)
}</span>

// Get retrieves a value by key with read lock
// Example:
//
//        if user, exists := safeMap.Get("alias1"); exists {
//            fmt.Printf("Found user: %v\n", user)
//        }
func (t *ThreadSafeMultiKeyHashMap[K, V]) Get(key K) (V, bool) <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.Get(key)
}</span>

// GetPrimaryKey returns the primary key for any given key (alias or primary) with read lock
// Example:
//
//        if primaryKey, exists := safeMap.GetPrimaryKey("alias1"); exists {
//            fmt.Printf("Primary key: %v\n", primaryKey)
//        }
func (t *ThreadSafeMultiKeyHashMap[K, V]) GetPrimaryKey(key K) (K, bool) <span class="cov0" title="0">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.GetPrimaryKey(key)
}</span>

// GetAllKeys returns all keys (primary and aliases) associated with a given key with read lock
// Example:
//
//        keys := safeMap.GetAllKeys("alias1")
//        fmt.Printf("All associated keys: %v\n", keys)
func (t *ThreadSafeMultiKeyHashMap[K, V]) GetAllKeys(key K) []K <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.GetAllKeys(key)
}</span>

// AddAlias adds a new alias to an existing key with write lock
// Example:
//
//        if safeMap.AddAlias("main", "newAlias") {
//            fmt.Println("Alias added successfully")
//        }
func (t *ThreadSafeMultiKeyHashMap[K, V]) AddAlias(existingKey K, newAlias K) bool <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()
        return t.data.AddAlias(existingKey, newAlias)
}</span>

// Size returns the number of unique primary keys with read lock
// Example:
//
//        count := safeMap.Size()
//        fmt.Printf("Number of unique entries: %d\n", count)
func (t *ThreadSafeMultiKeyHashMap[K, V]) Size() int <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.Size()
}</span>

// Clear removes all entries from the map with write lock
// Example:
//
//        safeMap.Clear()
//        fmt.Printf("Size after clear: %d\n", safeMap.Size())
func (t *ThreadSafeMultiKeyHashMap[K, V]) Clear() <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()
        t.data.Clear()
}</span>

// Remove removes a key and its associated aliases with write lock
// Example:
//
//        safeMap.Remove("main")  // Removes main key and its aliases
//        safeMap.Remove("alias") // Removes only the alias
func (t *ThreadSafeMultiKeyHashMap[K, V]) Remove(key K) <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()
        t.data.Remove(key)
}</span>

// RemoveWithCascade removes a key and all connected keys with write lock
// Example:
//
//        safeMap.RemoveWithCascade("main") // Removes main key and all connected keys
func (t *ThreadSafeMultiKeyHashMap[K, V]) RemoveWithCascade(key K) <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()
        t.data.RemoveWithCascade(key)
}</span>
</pre>
		
		<pre class="file" id="file12" style="display: none">package fastmap

// MultiKeyHashMap extends HashMap to support multiple keys (aliases) for accessing values.
// It maintains a primary key and optional aliases for each value.
type MultiKeyHashMap[K comparable, V any] struct {
        data    map[K]V
        aliases map[K][]K // Maps primary keys to their aliases
}

// NewMultiKeyHashMap creates a new MultiKeyHashMap instance
// Example:
//
//        map := NewMultiKeyHashMap[string, User]()
func NewMultiKeyHashMap[K comparable, V any]() *MultiKeyHashMap[K, V] <span class="cov8" title="1">{
        return &amp;MultiKeyHashMap[K, V]{
                data:    make(map[K]V),
                aliases: make(map[K][]K),
        }
}</span>

// Put adds or updates a value with multiple keys where first key is primary
// Example:
//
//        map.Put([]string{"main", "alias1", "alias2"}, value)
func (m *MultiKeyHashMap[K, V]) Put(keys []K, value V) <span class="cov8" title="1">{
        if len(keys) == 0 </span><span class="cov8" title="1">{
                return
        }</span>

        // First, if the primary key exists, remove all its old aliases
        <span class="cov8" title="1">if oldAliases, exists := m.aliases[keys[0]]; exists </span><span class="cov8" title="1">{
                for _, alias := range oldAliases </span><span class="cov8" title="1">{
                        delete(m.data, alias)
                }</span>
        }

        <span class="cov8" title="1">primaryKey := keys[0]
        m.data[primaryKey] = value

        // Create a set of unique aliases
        uniqueAliases := make(map[K]bool)
        for _, alias := range keys[1:] </span><span class="cov8" title="1">{
                if alias != primaryKey </span><span class="cov8" title="1">{ // Skip if alias is same as primary key
                        uniqueAliases[alias] = true
                }</span>
        }

        // Convert unique aliases to slice
        <span class="cov8" title="1">aliases := make([]K, 0, len(uniqueAliases))
        for alias := range uniqueAliases </span><span class="cov8" title="1">{
                aliases = append(aliases, alias)
                m.data[alias] = value
        }</span>

        <span class="cov8" title="1">if len(aliases) &gt; 0 </span><span class="cov8" title="1">{
                m.aliases[primaryKey] = aliases
        }</span>
}

// Get retrieves a value using any associated key (primary or alias)
// Example:
//
//        if value, exists := map.Get("alias1"); exists {
//            fmt.Printf("Found: %v\n", value)
//        }
func (m *MultiKeyHashMap[K, V]) Get(key K) (V, bool) <span class="cov8" title="1">{
        value, exists := m.data[key]
        return value, exists
}</span>

// GetPrimaryKey returns the primary key for any given key (alias or primary)
// Example:
//
//        if primaryKey, exists := map.GetPrimaryKey("alias1"); exists {
//            fmt.Printf("Primary: %v\n", primaryKey)
//        }
func (m *MultiKeyHashMap[K, V]) GetPrimaryKey(key K) (K, bool) <span class="cov8" title="1">{
        if _, exists := m.data[key]; !exists </span><span class="cov8" title="1">{
                var zero K
                return zero, false
        }</span>

        // First check if it's a primary key
        <span class="cov8" title="1">if _, isPrimary := m.aliases[key]; isPrimary </span><span class="cov8" title="1">{
                return key, true
        }</span>

        // Check if it's an alias
        <span class="cov8" title="1">for primaryKey, aliases := range m.aliases </span><span class="cov8" title="1">{
                for _, alias := range aliases </span><span class="cov8" title="1">{
                        if alias == key </span><span class="cov8" title="1">{
                                return primaryKey, true
                        }</span>
                }
        }

        // If the key exists but isn't in aliases map as either primary or alias,
        // then it must be a standalone primary key
        <span class="cov8" title="1">return key, true</span>
}

// GetAllKeys returns all keys (primary and aliases) associated with a given key
// Example:
//
//        keys := map.GetAllKeys("alias1")
//        fmt.Printf("All keys: %v\n", keys)
func (m *MultiKeyHashMap[K, V]) GetAllKeys(key K) []K <span class="cov8" title="1">{
        // First check if the key exists
        if _, exists := m.data[key]; !exists </span><span class="cov8" title="1">{
                return nil
        }</span>

        // Get the primary key
        <span class="cov8" title="1">primaryKey, exists := m.GetPrimaryKey(key)
        if !exists </span><span class="cov0" title="0">{
                return nil
        }</span>

        // Start with the primary key
        <span class="cov8" title="1">result := make([]K, 0)
        result = append(result, primaryKey)

        // Add all current aliases
        if aliases, exists := m.aliases[primaryKey]; exists </span><span class="cov8" title="1">{
                result = append(result, aliases...)
        }</span>

        <span class="cov8" title="1">return result</span>
}

// AddAlias adds a new alias to an existing key
// Example:
//
//        success := map.AddAlias("main", "newAlias")
func (m *MultiKeyHashMap[K, V]) AddAlias(existingKey K, newAlias K) bool <span class="cov8" title="1">{
        primaryKey, exists := m.GetPrimaryKey(existingKey)
        if !exists </span><span class="cov0" title="0">{
                return false
        }</span>

        // Check if the new alias is the same as primary key
        <span class="cov8" title="1">if newAlias == primaryKey </span><span class="cov8" title="1">{
                return false
        }</span>

        // Add the value mapping for the new alias
        <span class="cov8" title="1">if value, exists := m.data[primaryKey]; exists </span><span class="cov8" title="1">{
                m.data[newAlias] = value
                // Check if the alias already exists
                for _, alias := range m.aliases[primaryKey] </span><span class="cov8" title="1">{
                        if alias == newAlias </span><span class="cov8" title="1">{
                                return true
                        }</span>
                }
                <span class="cov8" title="1">m.aliases[primaryKey] = append(m.aliases[primaryKey], newAlias)
                return true</span>
        }

        <span class="cov0" title="0">return false</span>
}

// Size returns the number of unique primary keys
// Example:
//
//        count := map.Size()
//        fmt.Printf("Unique entries: %d\n", count)
func (m *MultiKeyHashMap[K, V]) Size() int <span class="cov8" title="1">{
        // Count primary keys only
        primaryKeys := make(map[K]bool)
        for key := range m.data </span><span class="cov8" title="1">{
                primaryKey, exists := m.GetPrimaryKey(key)
                if exists </span><span class="cov8" title="1">{
                        primaryKeys[primaryKey] = true
                }</span>
        }
        <span class="cov8" title="1">return len(primaryKeys)</span>
}

// Clear removes all entries from the map
// Example:
//
//        map.Clear()
func (m *MultiKeyHashMap[K, V]) Clear() <span class="cov8" title="1">{
        m.data = make(map[K]V)
        m.aliases = make(map[K][]K)
}</span>

// Remove removes a key and potentially its connected keys
// If removing primary key, all aliases are removed
// If removing alias, only that alias is removed
// Example:
//
//        map.Remove("main")  // Removes main key and aliases
//        map.Remove("alias") // Removes only the alias
func (m *MultiKeyHashMap[K, V]) Remove(key K) <span class="cov8" title="1">{
        // First check if this key exists
        if _, exists := m.data[key]; !exists </span><span class="cov8" title="1">{
                return
        }</span>

        // Get the primary key for this key
        <span class="cov8" title="1">primaryKey, exists := m.GetPrimaryKey(key)
        if !exists </span><span class="cov0" title="0">{
                return
        }</span>

        <span class="cov8" title="1">if key == primaryKey </span><span class="cov8" title="1">{
                // If removing primary key, remove all aliases
                if aliases, exists := m.aliases[primaryKey]; exists </span><span class="cov8" title="1">{
                        for _, alias := range aliases </span><span class="cov8" title="1">{
                                delete(m.data, alias)
                        }</span>
                        <span class="cov8" title="1">delete(m.aliases, primaryKey)</span>
                }
                <span class="cov8" title="1">delete(m.data, primaryKey)</span>
        } else<span class="cov8" title="1"> {
                // If removing an alias, just remove it and update the aliases list
                delete(m.data, key)
                if aliases, exists := m.aliases[primaryKey]; exists </span><span class="cov8" title="1">{
                        newAliases := make([]K, 0, len(aliases))
                        for _, alias := range aliases </span><span class="cov8" title="1">{
                                if alias != key </span><span class="cov8" title="1">{
                                        newAliases = append(newAliases, alias)
                                }</span>
                        }

                        // Update or remove aliases list based on remaining aliases
                        <span class="cov8" title="1">if len(newAliases) &gt; 0 </span><span class="cov8" title="1">{
                                m.aliases[primaryKey] = newAliases
                        }</span> else<span class="cov8" title="1"> {
                                delete(m.aliases, primaryKey)
                        }</span>
                }
        }
}

// RemoveWithCascade removes a key and all connected keys through alias relationships
// Example:
//
//        map.RemoveWithCascade("main") // Removes main key and all connected keys
func (m *MultiKeyHashMap[K, V]) RemoveWithCascade(key K) <span class="cov8" title="1">{
        // First check if this key exists
        if _, exists := m.data[key]; !exists </span><span class="cov0" title="0">{
                return
        }</span>

        // Get all connected keys (includes the key itself and all related keys)
        <span class="cov8" title="1">allKeys := m.getAllConnectedKeys(key)

        // Remove all connected keys
        for _, k := range allKeys </span><span class="cov8" title="1">{
                delete(m.data, k)
                delete(m.aliases, k)
        }</span>
}

// getAllConnectedKeys returns all keys connected through alias relationships
func (m *MultiKeyHashMap[K, V]) getAllConnectedKeys(key K) []K <span class="cov8" title="1">{
        visited := make(map[K]bool)
        result := make([]K, 0)
        m.traverseConnectedKeys(key, visited, &amp;result)
        return result
}</span>

// traverseConnectedKeys performs DFS to find all connected keys
func (m *MultiKeyHashMap[K, V]) traverseConnectedKeys(key K, visited map[K]bool, result *[]K) <span class="cov8" title="1">{
        if visited[key] </span><span class="cov0" title="0">{
                return
        }</span>

        <span class="cov8" title="1">visited[key] = true
        *result = append(*result, key)

        // Get primary key for current key
        primaryKey, exists := m.GetPrimaryKey(key)
        if !exists </span><span class="cov0" title="0">{
                return
        }</span>

        // Add primary key and check its aliases
        <span class="cov8" title="1">if !visited[primaryKey] </span><span class="cov0" title="0">{
                m.traverseConnectedKeys(primaryKey, visited, result)
        }</span>

        // Check aliases of primary key
        <span class="cov8" title="1">if aliases, exists := m.aliases[primaryKey]; exists </span><span class="cov8" title="1">{
                for _, alias := range aliases </span><span class="cov8" title="1">{
                        if !visited[alias] </span><span class="cov8" title="1">{
                                m.traverseConnectedKeys(alias, visited, result)
                        }</span>
                }
        }
}
</pre>
		
		<pre class="file" id="file13" style="display: none">package fastmap

// Contains checks if a key exists in the ThreadSafeHashMap with read lock
// Example:
//
//        if safeMap.Contains("user123") {
//            fmt.Println("User exists")
//        }
func (t *ThreadSafeHashMap[K, V]) Contains(key K) bool <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.Contains(key)
}</span>

// IsEmpty returns true if the ThreadSafeHashMap has no elements with read lock
// Example:
//
//        if safeMap.IsEmpty() {
//            fmt.Println("HashMap is empty")
//        }
func (t *ThreadSafeHashMap[K, V]) IsEmpty() bool <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.IsEmpty()
}</span>

// Keys returns a slice of all keys in the ThreadSafeHashMap with read lock
// Example:
//
//        keys := safeMap.Keys()
//        for _, key := range keys {
//            fmt.Printf("Key: %v\n", key)
//        }
func (t *ThreadSafeHashMap[K, V]) Keys() []K <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.Keys()
}</span>

// Values returns a slice of all values in the ThreadSafeHashMap with read lock
// Example:
//
//        values := safeMap.Values()
//        for _, value := range values {
//            fmt.Printf("Value: %v\n", value)
//        }
func (t *ThreadSafeHashMap[K, V]) Values() []V <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.Values()
}</span>

// ForEach executes a callback function for each key-value pair with read lock
// Example:
//
//        err := safeMap.ForEach(func(key string, value User) error {
//            if value.IsInvalid() {
//                return fmt.Errorf("invalid user data for key %s", key)
//            }
//            fmt.Printf("User %s: %v\n", key, value)
//            return nil
//        })
func (t *ThreadSafeHashMap[K, V]) ForEach(callback func(K, V) error) error <span class="cov8" title="1">{
        t.mutex.RLock()
        defer t.mutex.RUnlock()
        return t.data.ForEach(callback)
}</span>

// UpdateValue updates an existing value by key with write lock, returns false if key doesn't exist
// Example:
//
//        if safeMap.UpdateValue("user123", updatedUser) {
//            fmt.Println("User updated successfully")
//        }
func (t *ThreadSafeHashMap[K, V]) UpdateValue(key K, newValue V) bool <span class="cov8" title="1">{
        t.mutex.Lock()
        defer t.mutex.Unlock()
        return t.data.UpdateValue(key, newValue)
}</span>

// PutAll adds all key-value pairs from another ThreadSafeHashMap with write lock
// Example:
//
//        otherMap := NewThreadSafeHashMap[string, User]()
//        otherMap.Put("user456", newUser)
//        safeMap.PutAll(otherMap)
func (t *ThreadSafeHashMap[K, V]) PutAll(other *ThreadSafeHashMap[K, V]) <span class="cov8" title="1">{
        other.mutex.RLock()
        t.mutex.Lock()
        defer other.mutex.RUnlock()
        defer t.mutex.Unlock()
        t.data.PutAll(other.data)
}</span>
</pre>
		
		<pre class="file" id="file14" style="display: none">package fastmap

import "fmt"

// Clear removes all elements from the HashMap
// Example:
//
//        hashMap.Clear()
//        fmt.Printf("Size after clear: %d\n", hashMap.Size())
func (h *HashMap[K, V]) Clear() <span class="cov8" title="1">{
        h.data = make(map[K]V)
}</span>

// Contains checks if a key exists in the HashMap
// Example:
//
//        if hashMap.Contains("user123") {
//            fmt.Println("User exists")
//        }
func (h *HashMap[K, V]) Contains(key K) bool <span class="cov8" title="1">{
        _, exists := h.data[key]
        return exists
}</span>

// IsEmpty returns true if the HashMap has no elements
// Example:
//
//        if hashMap.IsEmpty() {
//            fmt.Println("HashMap is empty")
//        }
func (h *HashMap[K, V]) IsEmpty() bool <span class="cov8" title="1">{
        return len(h.data) == 0
}</span>

// Keys returns a slice of all keys in the HashMap
// Example:
//
//        keys := hashMap.Keys()
//        for _, key := range keys {
//            fmt.Printf("Key: %v\n", key)
//        }
func (h *HashMap[K, V]) Keys() []K <span class="cov8" title="1">{
        keys := make([]K, 0, len(h.data))
        for k := range h.data </span><span class="cov8" title="1">{
                keys = append(keys, k)
        }</span>
        <span class="cov8" title="1">return keys</span>
}

// Values returns a slice of all values in the HashMap
// Example:
//
//        values := hashMap.Values()
//        for _, value := range values {
//            fmt.Printf("Value: %v\n", value)
//        }
func (h *HashMap[K, V]) Values() []V <span class="cov8" title="1">{
        values := make([]V, 0, len(h.data))
        for _, v := range h.data </span><span class="cov8" title="1">{
                values = append(values, v)
        }</span>
        <span class="cov8" title="1">return values</span>
}

// ForEach executes a callback function for each key-value pair and returns an error if the callback fails
// Example:
//
//        err := hashMap.ForEach(func(key string, value User) error {
//            if value.IsInvalid() {
//                return fmt.Errorf("invalid user data for key %s", key)
//            }
//            fmt.Printf("User %s: %v\n", key, value)
//            return nil
//        })
func (h *HashMap[K, V]) ForEach(callback func(K, V) error) error <span class="cov8" title="1">{
        for k, v := range h.data </span><span class="cov8" title="1">{
                if err := callback(k, v); err != nil </span><span class="cov0" title="0">{
                        return fmt.Errorf("ForEach operation failed at key %v: %w", k, err)
                }</span>
        }
        <span class="cov8" title="1">return nil</span>
}

// UpdateValue updates an existing value by key, returns false if key doesn't exist
// Example:
//
//        if hashMap.UpdateValue("user123", updatedUser) {
//            fmt.Println("User updated successfully")
//        }
func (h *HashMap[K, V]) UpdateValue(id K, newValue V) bool <span class="cov8" title="1">{
        if _, exists := h.data[id]; exists </span><span class="cov8" title="1">{
                h.data[id] = newValue
                return true
        }</span>
        <span class="cov8" title="1">return false</span>
}

// PutAll adds all key-value pairs from another HashMap
// Example:
//
//        otherMap := NewHashMap[string, User]()
//        otherMap.Put("user456", newUser)
//        hashMap.PutAll(otherMap)
func (h *HashMap[K, V]) PutAll(other *HashMap[K, V]) <span class="cov8" title="1">{
        for k, v := range other.data </span><span class="cov8" title="1">{
                h.data[k] = v
        }</span>
}
</pre>
		
		<pre class="file" id="file15" style="display: none">package fastmap

import (
        "fmt"
        "hash/maphash"
)

type RobinHoodMap[K comparable, V any] struct {
        entries    []entry[K, V]
        size       int
        mask       uint64
        loadFactor float64
        hasher     maphash.Hash
}

type entry[K comparable, V any] struct {
        key      K
        value    V
        distance uint8
        occupied bool
}

func NewRobinHoodMap[K comparable, V any]() *RobinHoodMap[K, V] <span class="cov8" title="1">{
        initialSize := 8
        return &amp;RobinHoodMap[K, V]{
                entries:    make([]entry[K, V], initialSize),
                mask:       uint64(initialSize - 1),
                loadFactor: 0.75,
                hasher:     maphash.Hash{},
        }
}</span>

func (m *RobinHoodMap[K, V]) hash(key K) uint64 <span class="cov8" title="1">{
        m.hasher.Write([]byte(fmt.Sprintf("%v", key)))
        defer m.hasher.Reset()
        return m.hasher.Sum64()
}</span>

func (m *RobinHoodMap[K, V]) Put(key K, value V) <span class="cov8" title="1">{
        if float64(m.size+1)/float64(len(m.entries)) &gt; m.loadFactor </span><span class="cov8" title="1">{
                m.resize()
        }</span>

        <span class="cov8" title="1">hash := m.hash(key)
        index := hash &amp; m.mask
        dist := uint8(0)

        for </span><span class="cov8" title="1">{
                entry := &amp;m.entries[index]

                if !entry.occupied </span><span class="cov8" title="1">{
                        entry.key = key
                        entry.value = value
                        entry.distance = dist
                        entry.occupied = true
                        m.size++
                        return
                }</span>

                <span class="cov8" title="1">if entry.key == key </span><span class="cov8" title="1">{
                        entry.value = value
                        return
                }</span>

                // Robin Hood: rich (current entry) vs poor (new entry)
                <span class="cov8" title="1">if dist &gt; entry.distance </span><span class="cov8" title="1">{
                        // Swap entries
                        key, entry.key = entry.key, key
                        value, entry.value = entry.value, value
                        dist, entry.distance = entry.distance, dist
                }</span>

                <span class="cov8" title="1">dist++
                index = (index + 1) &amp; m.mask</span>
        }
}

func (m *RobinHoodMap[K, V]) Get(key K) (V, bool) <span class="cov8" title="1">{
        hash := m.hash(key)
        index := hash &amp; m.mask
        dist := uint8(0)

        for </span><span class="cov8" title="1">{
                entry := &amp;m.entries[index]
                if !entry.occupied || dist &gt; entry.distance </span><span class="cov8" title="1">{
                        var zero V
                        return zero, false
                }</span>
                <span class="cov8" title="1">if entry.key == key </span><span class="cov8" title="1">{
                        return entry.value, true
                }</span>
                <span class="cov8" title="1">dist++
                index = (index + 1) &amp; m.mask</span>
        }
}

func (m *RobinHoodMap[K, V]) Remove(key K) bool <span class="cov8" title="1">{
        hash := m.hash(key)
        index := hash &amp; m.mask
        dist := uint8(0)

        for </span><span class="cov8" title="1">{
                entry := &amp;m.entries[index]
                if !entry.occupied || dist &gt; entry.distance </span><span class="cov8" title="1">{
                        return false
                }</span>
                <span class="cov8" title="1">if entry.key == key </span><span class="cov8" title="1">{
                        // Found the entry to remove
                        m.size--

                        // Backward shift deletion
                        nextIndex := (index + 1) &amp; m.mask
                        for </span><span class="cov8" title="1">{
                                nextEntry := &amp;m.entries[nextIndex]
                                if !nextEntry.occupied || nextEntry.distance == 0 </span><span class="cov8" title="1">{
                                        entry.occupied = false
                                        return true
                                }</span>
                                <span class="cov0" title="0">*entry = *nextEntry
                                entry.distance--
                                index = nextIndex
                                nextIndex = (nextIndex + 1) &amp; m.mask
                                entry = &amp;m.entries[index]</span>
                        }
                }
                <span class="cov0" title="0">dist++
                index = (index + 1) &amp; m.mask</span>
        }
}

func (m *RobinHoodMap[K, V]) resize() <span class="cov8" title="1">{
        oldEntries := m.entries
        newSize := len(m.entries) * 2
        m.entries = make([]entry[K, V], newSize)
        m.mask = uint64(newSize - 1)
        m.size = 0

        for i := range oldEntries </span><span class="cov8" title="1">{
                if oldEntries[i].occupied </span><span class="cov8" title="1">{
                        m.Put(oldEntries[i].key, oldEntries[i].value)
                }</span>
        }
}

func (m *RobinHoodMap[K, V]) Size() int <span class="cov8" title="1">{
        return m.size
}</span>

func (m *RobinHoodMap[K, V]) Clear() <span class="cov8" title="1">{
        m.entries = make([]entry[K, V], 8)
        m.mask = 7
        m.size = 0
}</span>
</pre>
		
		<pre class="file" id="file16" style="display: none">package main

import (
        fastmap "github.com/billowdev/fastmap/hashmap"
)

func main() <span class="cov0" title="0">{
        // Example usage
        hashMap := fastmap.NewHashMap[string, int]()

        // Add some values
        hashMap.Put("one", 1)
        hashMap.Put("two", 2)
        hashMap.Put("three", 3)

        // Use callback function to print all entries
        if err := hashMap.ForEach(func(key string, value int) error </span><span class="cov0" title="0">{
                println(key, ":", value)
                return nil
        }</span>); err != nil <span class="cov0" title="0">{
                println("Error during ForEach:", err)
        }</span>

        // Get a value
        <span class="cov0" title="0">if value, exists := hashMap.Get("two"); exists </span><span class="cov0" title="0">{
                println("Value for 'two':", value)
        }</span>

        // Remove a value
        <span class="cov0" title="0">hashMap.Remove("one")
        println("Size after removal:", hashMap.Size())</span>
}
</pre>
		
		</div>
	</body>
	<script>
	(function() {
		var files = document.getElementById('files');
		var visible;
		files.addEventListener('change', onChange, false);
		function select(part) {
			if (visible)
				visible.style.display = 'none';
			visible = document.getElementById(part);
			if (!visible)
				return;
			files.value = part;
			visible.style.display = 'block';
			location.hash = part;
		}
		function onChange() {
			select(files.value);
			window.scrollTo(0, 0);
		}
		if (location.hash != "") {
			select(location.hash.substr(1));
		}
		if (!visible) {
			select("file0");
		}
	})();
	</script>
</html>