README ¶
gonerix
Generic collections for golang
Documentation still in development
For still not documented collections check out code and test/example, to understand more.
Usage
We'll assume that in each file you'll have import of collection package with qx prefix, to make examples more readable:
import (
gx "github.com/jtomasevic/gonerix/collections"
)
API
- List[T]
- SimpleSortedList[T]
- SortedList[K, V]
- SortedsSructList[T]
- LinkedList[T] check unit tests until documentation is done
- Stack[T] check unit tests until documentation is done
- Queue[T] check unit tests until documentation is done
- PriorityQueue[T] check unit tests until documentation is done
- Dictionary[K,V] check unit tests until documentation is done
- LRUCache[K, V] [check unit tests until documentation is done] (https://github.com/jtomasevic/gonerix/blob/main/collections/lru_cache.go)
List[T]
Add
list := gx.List[int]{}
list.Add(1)
list.Add(2)
list.Add(4)
list.Add(8)
fmt.Println(list)
// [1 2 4 8]
Insert
First parameter is index where to insert an element of more of them. Second parameter is one or vmore alues to be added to list.
Insert one value
list.Insert(2, 3)
fmt.Println(list)
// [1 2 3 4 8]
Insert multiple value
list.Insert(4, 5, 6, 7)
fmt.Println(list)
// [1 2 3 4 5 6 7 8]
Reverse
list.Reverse()
fmt.Println(list)
// [8 7 6 5 4 3 2 1]
Remove element from list
list.Remove(7)
fmt.Println(list)
// [8 6 5 4 3 2 1]
Remove element with particular index
list.RemoveAt(2)
fmt.Println(list)
// [8 6 4 3 2 1]
list.RemoveAt(len(list) - 1)
fmt.Println(list)
// [8 6 4 3 2]
Exist
res, index := list.Exist(4)
fmt.Printf("element: %v, index: %v\n", res, index)
// element: true, index: 2
res, index = list.Exist(14)
fmt.Printf("element: %v, index: %v\n", res, index)
// element: false, index: -1
AddOrReplace
This operation applies only to first element found under certain condition.
- Try to find element that satisfied condition in isEqual function (second parameter)
- If found replace with new provided element (first parameter).
- If not found, add it to list.
// Create some structs to be part of List
type CupSize string
const (
Small CupSize = "small"
Medium CupSize = "medium"
Large CupSize = "large"
ExtraLarge CupSize = "extraLarge"
)
type BlackCoffeeOffer struct {
Price int
Size CupSize
}
// Initialise list
products := gx.List[BlackCoffeeOffer]{
{
Price: 100,
Size: Small,
},
{
Price: 150,
Size: Medium,
},
{
Price: 200,
Size: Large,
},
}
products.AddOrReplace(BlackCoffeeOffer{
Price: 250,
Size: ExtraLarge,
}, func(left BlackCoffeeOffer, right BlackCoffeeOffer) bool {
return left.Size == right.Size
})
fmt.Println(products)
// [{100 small} {150 medium} {200 large} {250 extraLarge}]
// define isEqual function as variable
var isEqual gx.IsEqual[BlackCoffeeOffer] = func(left BlackCoffeeOffer, right BlackCoffeeOffer) bool {
return left.Size == right.Size
}
products.AddOrReplace(BlackCoffeeOffer{
Price: 95,
Size: Small,
}, isEqual)
fmt.Println(products)
// [{95 small} {150 medium} {200 large} {250 extraLarge}]
Find
Return list of elements that satisfy function check, provided by expression parameter
cheaperThan200 := products.Find(func(left BlackCoffeeOffer) bool {
return left.Price < 200
})
fmt.Println(cheaperThan200)
// [{95 small} {150 medium}]
SimpleSortedList
Represents a collection of simple values like int, float or string, anything where oprerator '<' is applicable.
Add
list := gx.SimpleSortedList[int](gx.ASC)
list.Add(30)
list.Add(50)
list.Add(20)
list.Add(10)
list.Add(40)
fmt.Println(list)
// {[10 20 30 40 50] asc}
fmt.Println(list.ToList())
// NOTE: ToList is O(1), no transformation just pass internal reference.
// [10 20 30 40 50]
Remove
list.Remove(10)
fmt.Println(list.ToList())
// [20 30 40 50]
First
first := list.First()
fmt.Println(*first)
// 20
Last
last := list.Last()
fmt.Println(*last)
// 50
RemoveAt
list.RemoveAt(2)
// before [20 30 40 50]
fmt.Println(list.ToList())
// [20 30 50]
IsEmpty
res:= list.IsEmpty()
fmt.Println(list.res)
// false
Count
count := list.Count()
// currently [20 30 50]
fmt.Println(count)
// 3
SortedList[T]
Represents a collection of key/value pairs that are sorted by the keys and are accessible by key and by index.
Add
list := gx.SortedList[int, Order](gx.ASC)
list.Add(3, Order{
Customer: "C",
OrderNo: 52,
})
list.Add(1, Order{
Customer: "A",
OrderNo: 50,
})
list.Add(4, Order{
Customer: "D",
OrderNo: 53,
})
list.Add(2, Order{
Customer: "B",
OrderNo: 51,
})
fmt.Println(list.ToList())
// [{A 50} {B 51} {C 52} {D 53}]
Remove
...
RemoveAt
...
SortedStructList[T]
Mandatory parameter for creating sorted struct list is comapare function.
- If left parameter is lower than right parameter, this is ASC ordered list.
- If left parameter is higher than right parameter, this is DESC ordered list.
Add
type Brand struct {
Name string
}
brands := []Brand{
{
Name: "Diadora",
},
{
Name: "Nike",
},
{
Name: "Addidas",
},
{
Name: "Puma",
},
{
Name: "Nokka",
},
}
sorted := gx.SortedStructList(func(left Brand, right Brand) bool {
return left.Name > right.Name
})
for _, brand := range brands {
sorted.Add(brand)
}
// this is O(1) operation.
fmt.Println(sorted.Values())
// [{Puma} {Nokka} {Nike} {Diadora} {Addidas}]
Remove
sorted.Remove(Brand{
Name: "Puma",
})
fmt.Println(sorted.Values())
// [{Nokka} {Nike} {Diadora} {Addidas}]
// non existing
result := sorted.Remove(Brand{
Name: "BOSS",
})
fmt.Println(result)
// false
Remove At
sorted.RemoveAt(0)
fmt.Println(sorted.Values())
// [{Nike} {Diadora} {Addidas}]
sorted.Size()
// return size of element.