status-go/vendor/github.com/wk8/go-ordered-map/v2
Stefan c61a4000d8 feat(wallet) make remaining filter apis async
Implement activity.Scheduler to serialize and limit the number of
calls on the activity service. This way we protect form inefficient
parallel queries and easy support async and rate limiting based on the
API requirements.

Refactor the activity APIs async and use the Scheduler for managing
the activity service calls configured with one of the two rules: cancel
ignore.

Updates status-desktop #11170
2023-07-03 16:50:48 +02:00
..
.gitignore feat(wallet) make remaining filter apis async 2023-07-03 16:50:48 +02:00
.golangci.yml feat(wallet) make remaining filter apis async 2023-07-03 16:50:48 +02:00
CHANGELOG.md feat(wallet) make remaining filter apis async 2023-07-03 16:50:48 +02:00
LICENSE feat(wallet) make remaining filter apis async 2023-07-03 16:50:48 +02:00
Makefile feat(wallet) make remaining filter apis async 2023-07-03 16:50:48 +02:00
README.md feat(wallet) make remaining filter apis async 2023-07-03 16:50:48 +02:00
json.go feat(wallet) make remaining filter apis async 2023-07-03 16:50:48 +02:00
orderedmap.go feat(wallet) make remaining filter apis async 2023-07-03 16:50:48 +02:00

README.md

Go Reference Build Status

Golang Ordered Maps

Same as regular maps, but also remembers the order in which keys were inserted, akin to Python's collections.OrderedDicts.

It offers the following features:

  • optimal runtime performance (all operations are constant time)
  • optimal memory usage (only one copy of values, no unnecessary memory allocation)
  • allows iterating from newest or oldest keys indifferently, without memory copy, allowing to break the iteration, and in time linear to the number of keys iterated over rather than the total length of the ordered map
  • supports any generic types for both keys and values. If you're running go < 1.18, you can use version 1 that takes and returns generic interface{}s instead of using generics
  • idiomatic API, akin to that of container/list

Documentation

The full documentation is available on pkg.go.dev.

Installation

go get -u github.com/wk8/go-ordered-map/v2

Or use your favorite golang vendoring tool!

Supported go versions

Go >= 1.18 is required to use version >= 2 of this library, as it uses generics.

If you're running go < 1.18, you can use version 1 instead.

Example / usage

package main

import (
	"fmt"

	"github.com/wk8/go-ordered-map/v2"
)

func main() {
	om := orderedmap.New[string, string]()

	om.Set("foo", "bar")
	om.Set("bar", "baz")
	om.Set("coucou", "toi")

	fmt.Println(om.Get("foo"))          // => "bar", true
	fmt.Println(om.Get("i dont exist")) // => "", false

	// iterating pairs from oldest to newest:
	for pair := om.Oldest(); pair != nil; pair = pair.Next() {
		fmt.Printf("%s => %s\n", pair.Key, pair.Value)
	} // prints:
	// foo => bar
	// bar => baz
	// coucou => toi

	// iterating over the 2 newest pairs:
	i := 0
	for pair := om.Newest(); pair != nil; pair = pair.Prev() {
		fmt.Printf("%s => %s\n", pair.Key, pair.Value)
		i++
		if i >= 2 {
			break
		}
	} // prints:
	// coucou => toi
	// bar => baz
}

An OrderedMap's keys must implement comparable, and its values can be anything, for example:

type myStruct struct {
	payload string
}

func main() {
	om := orderedmap.New[int, *myStruct]()

	om.Set(12, &myStruct{"foo"})
	om.Set(1, &myStruct{"bar"})

	value, present := om.Get(12)
	if !present {
		panic("should be there!")
	}
	fmt.Println(value.payload) // => foo

	for pair := om.Oldest(); pair != nil; pair = pair.Next() {
		fmt.Printf("%d => %s\n", pair.Key, pair.Value.payload)
	} // prints:
	// 12 => foo
	// 1 => bar
}

Also worth noting that you can provision ordered maps with a capacity hint, as you would do by passing an optional hint to make(map[K]V, capacity):

om := orderedmap.New[int, *myStruct](28)

You can also pass in some initial data to store in the map:

om := orderedmap.New[int, string](orderedmap.WithInitialData[int, string](
	orderedmap.Pair[int, string]{
		Key:   12,
		Value: "foo",
	},
	orderedmap.Pair[int, string]{
		Key:   28,
		Value: "bar",
	},
))

OrderedMaps also support JSON serialization/deserialization, and preserves order:

// serialization
data, err := json.Marshal(om)
...

// deserialization
om := orderedmap.New[string, string]() // or orderedmap.New[int, any](), or any type you expect
err := json.Unmarshal(data, &om)
...

Alternatives

There are several other ordered map golang implementations out there, but I believe that at the time of writing none of them offer the same functionality as this library; more specifically:

  • iancoleman/orderedmap only accepts string keys, its Delete operations are linear
  • cevaris/ordered_map uses a channel for iterations, and leaks goroutines if the iteration is interrupted before fully traversing the map
  • mantyr/iterator also uses a channel for iterations, and its Delete operations are linear
  • samdolan/go-ordered-map adds unnecessary locking (users should add their own locking instead if they need it), its Delete and Get operations are linear, iterations trigger a linear memory allocation