README
¶
tinymap
Provides a simple to use interface that behaves like a HashMap.
Multiple Maps are exposed for use as well as structs that behave like Tuples.
This package is intended to be used with tinygo.
However it has some nice little structs, so feel free to use this as you wish.
It is very small, but helps with embedded programming.
🎉
Basic usage
Just one of the many Maps 😄
strMap := new(StrMap)
strMap.Set("foo", "bar")
val, err := strMap.Get("foo")
if err != nil {
log.Print(err)
}
fmt.Print(val)
strMap.Delete("foo")
Benchmarks
$ ./scripts/bench.sh
+ go test -bench=.
goos: windows
goarch: amd64
pkg: github.com/selfup/tinymap
Benchmark_ByteMap_Get_Lower_Bound-4 50000000 25.7 ns/op
Benchmark_ByteMap_Get_Expected_Bound-4 50000000 29.3 ns/op
Benchmark_ByteMap_Get_Upper_Bound-4 3000000 530 ns/op
Benchmark_ByteMap_Set_Upper_Bound-4 5000000 302 ns/op
Benchmark_ByteMap_Delete_Upper_Bound-4 100000000 11.7 ns/op
Benchmark_IntMap_Get_Lower_Bound-4 1000000000 2.51 ns/op
Benchmark_IntMap_Get_Expected_Bound-4 300000000 4.19 ns/op
Benchmark_IntMap_Get_Upper_Bound-4 30000000 45.3 ns/op
Benchmark_IntMap_Set_Upper_Bound-4 1000000000 2.84 ns/op
Benchmark_IntMap_Delete_Upper_Bound-4 1000000000 2.09 ns/op
Benchmark_IntStrMap_Get_Lower_Bound-4 1000000000 2.69 ns/op
Benchmark_IntStrMap_Get_Expected_Bound-4 300000000 4.84 ns/op
Benchmark_IntStrMap_Get_Upper_Bound-4 30000000 55.8 ns/op
Benchmark_IntStrMap_Set_Upper_Bound-4 100000000 20.1 ns/op
Benchmark_IntStrMap_Delete_Upper_Bound-4 1000000000 2.07 ns/op
Benchmark_StrByteMap_Get_Lower_Bound-4 200000000 6.91 ns/op
Benchmark_StrByteMap_Get_Expected_Bound-4 100000000 14.8 ns/op
Benchmark_StrByteMap_Get_Upper_Bound-4 3000000 444 ns/op
Benchmark_StrByteMap_Set_Upper_Bound-4 5000000 253 ns/op
Benchmark_StrByteMap_Delete_Upper_Bound-4 200000000 6.45 ns/op
Benchmark_StrMap_Get_Lower_Bound-4 300000000 4.86 ns/op
Benchmark_StrMap_Get_Expected_Bound-4 300000000 4.95 ns/op
Benchmark_StrMap_Get_Upper_Bound-4 5000000 325 ns/op
Benchmark_StrMap_Set_Upper_Bound-4 10000000 196 ns/op
Benchmark_StrMap_Delete_Upper_Bound-4 200000000 6.33 ns/op
PASS
ok github.com/selfup/tinymap 49.282s
Details
- Using an int as an index is fastest for lookups/comparisons.
- Using []byte as key is the slowest (makes sense)
- Lower Bound means the value being grabbed is the 1th element in a slice of 1 element.
- Expected Bound means the value is being grabbed at the 5th element in a slice of 5 elements.
- Upper Bound means the value being grabbed is the 100th element in a slice of 100 elements.
- Under the hood TinyMap uses slices to store Tuples.
- I have not yet added a catch block to prevent the slice to grow, but this should be used for small data sotrage 🙏
Documentation
¶
Overview ¶
Package tinymap provides a simple to use interface that behaves like a HashMap.
Multiple Maps are exposed for use as well as structs that behave like Tuples.
This package is intended to be used with tinygo.
However it has some nice little structs, so feel free to use this as you wish.
It is very small, but helps with embedded programming.
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type ByteMap ¶
type ByteMap struct {
// Data is public but use carefully :)
Data []ByteTuple
}
ByteMap stores ByteTuples
It behaves like a HashMap!
byteMap := new(ByteMap)
byteMap.Set([]byte("42"), []byte("9000"))
val, err := byteMap.Get([]byte("42"))
if err != nil {
log.Print(err)
}
fmt.Print(val)
byteMap.Delete([]byte("42"))
func (*ByteMap) Delete ¶
Delete removes Tuples. Returns true if deleted. Returns false if the key was not found.
type IntMap ¶
type IntMap struct {
// Data is public but use carefully :)
Data []IntTuple
}
IntMap stores IntTuples
It behaves like a HashMap!
intMap := new(IntMap)
intMap.Set(42, 9000)
val, err := intMap.Get(42)
if err != nil {
log.Print(err)
}
fmt.Print(val)
intMap.Delete(42)
func (*IntMap) Delete ¶
Delete removes Tuples. Returns true if deleted. Returns false if the key was not found.
type IntStrMap ¶
type IntStrMap struct {
// Data is public but use carefully :)
Data []IntStrTuple
}
IntStrMap stores IntStrTuples
It behaves like a HashMap!
intStrMap := new(IntStrMap)
intStrMap.Set(42, "9000")
val, err := intStrMap.Get(42)
if err != nil {
log.Print(err)
}
fmt.Print(val)
intStrMap.Delete(42)
func (*IntStrMap) Delete ¶
Delete removes Tuples. Returns true if deleted. Returns false if the key was not found.
type StrByteMap ¶
type StrByteMap struct {
// Data is public but use carefully :)
Data []StrByteTuple
}
StrByteMap stores StrByteTuples
It behaves like a HashMap!
strByteMap := new(StrByteMap)
strByteMap.Set("foo", []byte("bar"))
val, err := strByteMap.Get("foo")
if err != nil {
log.Print(err)
}
fmt.Print(val)
strByteMap.Delete("foo")
func (*StrByteMap) Delete ¶
func (t *StrByteMap) Delete(key string) bool
Delete removes Tuples. Returns true if deleted. Returns false if the key was not found.
func (StrByteMap) Get ¶
func (t StrByteMap) Get(key string) ([]byte, error)
Get fetches Tuples by Key and returns their Val
func (*StrByteMap) Set ¶
func (t *StrByteMap) Set(key string, val []byte)
Set will update or add Tuples. If StrByteTuple.Key already exists, only the StrByteTuple.Val is updated. Otherwise a new StrByteTuple is inserted into the Data slice.
type StrMap ¶
type StrMap struct {
// Data is public but use carefully :)
Data []StrTuple
}
StrMap stores StrTuples
It behaves like a HashMap!
strMap := new(StrMap)
strMap.Set("foo", "bar")
val, err := strMap.Get("foo")
if err != nil {
log.Print(err)
}
fmt.Print(val)
strMap.Delete("foo")
func (*StrMap) Delete ¶
Delete removes Tuples. Returns true if deleted. Returns false if the key was not found.
Source Files