mirror of
https://gitee.com/johng/gf.git
synced 2024-12-02 12:17:53 +08:00
409 lines
9.1 KiB
Go
409 lines
9.1 KiB
Go
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
|
|
//
|
|
// This Source Code Form is subject to the terms of the MIT License.
|
|
// If a copy of the MIT was not distributed with gm file,
|
|
// You can obtain one at https://github.com/gogf/gf.
|
|
|
|
package gset_test
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
|
|
"github.com/gogf/gf/v2/container/gset"
|
|
"github.com/gogf/gf/v2/frame/g"
|
|
)
|
|
|
|
// New create and returns a new set, which contains un-repeated items.
|
|
// The parameter `safe` is used to specify whether using set in concurrent-safety,
|
|
// which is false in default.
|
|
func ExampleNewIntSet() {
|
|
intSet := gset.NewIntSet()
|
|
intSet.Add([]int{1, 2, 3}...)
|
|
fmt.Println(intSet.Slice())
|
|
|
|
// May Output:
|
|
// [2 1 3]
|
|
}
|
|
|
|
// NewIntSetFrom returns a new set from `items`.
|
|
func ExampleNewFrom() {
|
|
intSet := gset.NewIntSetFrom([]int{1, 2, 3})
|
|
fmt.Println(intSet.Slice())
|
|
|
|
// May Output:
|
|
// [2 1 3]
|
|
}
|
|
|
|
// Add adds one or multiple items to the set.
|
|
func ExampleIntSet_Add() {
|
|
intSet := gset.NewIntSetFrom([]int{1, 2, 3})
|
|
intSet.Add(1)
|
|
fmt.Println(intSet.Slice())
|
|
fmt.Println(intSet.AddIfNotExist(1))
|
|
|
|
// Mya Output:
|
|
// [1 2 3]
|
|
// false
|
|
}
|
|
|
|
// AddIfNotExist checks whether item exists in the set,
|
|
// it adds the item to set and returns true if it does not exists in the set,
|
|
// or else it does nothing and returns false.
|
|
func ExampleIntSet_AddIfNotExist() {
|
|
intSet := gset.NewIntSetFrom([]int{1, 2, 3})
|
|
intSet.Add(1)
|
|
fmt.Println(intSet.Slice())
|
|
fmt.Println(intSet.AddIfNotExist(1))
|
|
|
|
// Mya Output:
|
|
// [1 2 3]
|
|
// false
|
|
}
|
|
|
|
// AddIfNotExistFunc checks whether item exists in the set,
|
|
// it adds the item to set and returns true if it does not exists in the set and function `f` returns true,
|
|
// or else it does nothing and returns false.
|
|
// Note that, the function `f` is executed without writing lock.
|
|
func ExampleIntSet_AddIfNotExistFunc() {
|
|
intSet := gset.NewIntSetFrom([]int{1, 2, 3})
|
|
intSet.Add(1)
|
|
fmt.Println(intSet.Slice())
|
|
fmt.Println(intSet.AddIfNotExistFunc(5, func() bool {
|
|
return true
|
|
}))
|
|
|
|
// May Output:
|
|
// [1 2 3]
|
|
// true
|
|
}
|
|
|
|
// AddIfNotExistFunc checks whether item exists in the set,
|
|
// it adds the item to set and returns true if it does not exists in the set and function `f` returns true,
|
|
// or else it does nothing and returns false.
|
|
// Note that, the function `f` is executed without writing lock.
|
|
func ExampleIntSet_AddIfNotExistFuncLock() {
|
|
intSet := gset.NewIntSetFrom([]int{1, 2, 3})
|
|
intSet.Add(1)
|
|
fmt.Println(intSet.Slice())
|
|
fmt.Println(intSet.AddIfNotExistFuncLock(4, func() bool {
|
|
return true
|
|
}))
|
|
|
|
// May Output:
|
|
// [1 2 3]
|
|
// true
|
|
}
|
|
|
|
// Clear deletes all items of the set.
|
|
func ExampleIntSet_Clear() {
|
|
intSet := gset.NewIntSetFrom([]int{1, 2, 3})
|
|
fmt.Println(intSet.Size())
|
|
intSet.Clear()
|
|
fmt.Println(intSet.Size())
|
|
|
|
// Output:
|
|
// 3
|
|
// 0
|
|
}
|
|
|
|
// Complement returns a new set which is the complement from `set` to `full`.
|
|
// Which means, all the items in `newSet` are in `full` and not in `set`.
|
|
// It returns the difference between `full` and `set` if the given set `full` is not the full set of `set`.
|
|
func ExampleIntSet_Complement() {
|
|
intSet := gset.NewIntSetFrom([]int{1, 2, 3, 4, 5})
|
|
s := gset.NewIntSetFrom([]int{1, 2, 3})
|
|
fmt.Println(s.Complement(intSet).Slice())
|
|
|
|
// May Output:
|
|
// [4 5]
|
|
}
|
|
|
|
// Contains checks whether the set contains `item`.
|
|
func ExampleIntSet_Contains() {
|
|
var set1 gset.IntSet
|
|
set1.Add(1, 4, 5, 6, 7)
|
|
fmt.Println(set1.Contains(1))
|
|
|
|
var set2 gset.IntSet
|
|
set2.Add(1, 4, 5, 6, 7)
|
|
fmt.Println(set2.Contains(8))
|
|
|
|
// Output:
|
|
// true
|
|
// false
|
|
}
|
|
|
|
// Diff returns a new set which is the difference set from `set` to `other`.
|
|
// Which means, all the items in `newSet` are in `set` but not in `other`.
|
|
func ExampleIntSet_Diff() {
|
|
s1 := gset.NewIntSetFrom([]int{1, 2, 3})
|
|
s2 := gset.NewIntSetFrom([]int{1, 2, 3, 4})
|
|
fmt.Println(s2.Diff(s1).Slice())
|
|
|
|
// Output:
|
|
// [4]
|
|
}
|
|
|
|
// Equal checks whether the two sets equal.
|
|
func ExampleIntSet_Equal() {
|
|
s1 := gset.NewIntSetFrom([]int{1, 2, 3})
|
|
s2 := gset.NewIntSetFrom([]int{1, 2, 3, 4})
|
|
fmt.Println(s2.Equal(s1))
|
|
|
|
s3 := gset.NewIntSetFrom([]int{1, 2, 3})
|
|
s4 := gset.NewIntSetFrom([]int{1, 2, 3})
|
|
fmt.Println(s3.Equal(s4))
|
|
|
|
// Output:
|
|
// false
|
|
// true
|
|
}
|
|
|
|
// Intersect returns a new set which is the intersection from `set` to `other`.
|
|
// Which means, all the items in `newSet` are in `set` and also in `other`.
|
|
func ExampleIntSet_Intersect() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3}...)
|
|
var s2 gset.IntSet
|
|
s2.Add([]int{1, 2, 3, 4}...)
|
|
fmt.Println(s2.Intersect(s1).Slice())
|
|
|
|
// May Output:
|
|
// [1 2 3]
|
|
}
|
|
|
|
// IsSubsetOf checks whether the current set is a sub-set of `other`
|
|
func ExampleIntSet_IsSubsetOf() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
var s2 gset.IntSet
|
|
s2.Add([]int{1, 2, 4}...)
|
|
fmt.Println(s2.IsSubsetOf(s1))
|
|
|
|
// Output:
|
|
// true
|
|
}
|
|
|
|
// Iterator iterates the set readonly with given callback function `f`,
|
|
// if `f` returns true then continue iterating; or false to stop.
|
|
func ExampleIntSet_Iterator() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
s1.Iterator(func(v int) bool {
|
|
fmt.Println("Iterator", v)
|
|
return true
|
|
})
|
|
// May Output:
|
|
// Iterator 2
|
|
// Iterator 3
|
|
// Iterator 1
|
|
// Iterator 4
|
|
}
|
|
|
|
// Join joins items with a string `glue`.
|
|
func ExampleIntSet_Join() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
fmt.Println(s1.Join(","))
|
|
|
|
// May Output:
|
|
// 3,4,1,2
|
|
}
|
|
|
|
// LockFunc locks writing with callback function `f`.
|
|
func ExampleIntSet_LockFunc() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2}...)
|
|
s1.LockFunc(func(m map[int]struct{}) {
|
|
m[3] = struct{}{}
|
|
})
|
|
fmt.Println(s1.Slice())
|
|
|
|
// May Output
|
|
// [2 3 1]
|
|
}
|
|
|
|
// MarshalJSON implements the interface MarshalJSON for json.Marshal.
|
|
func ExampleIntSet_MarshalJSON() {
|
|
type Student struct {
|
|
Id int
|
|
Name string
|
|
Scores *gset.IntSet
|
|
}
|
|
s := Student{
|
|
Id: 1,
|
|
Name: "john",
|
|
Scores: gset.NewIntSetFrom([]int{100, 99, 98}),
|
|
}
|
|
b, _ := json.Marshal(s)
|
|
fmt.Println(string(b))
|
|
|
|
// May Output:
|
|
// {"Id":1,"Name":"john","Scores":[100,99,98]}
|
|
}
|
|
|
|
// Merge adds items from `others` sets into `set`.
|
|
func ExampleIntSet_Merge() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
|
|
s2 := gset.NewIntSet()
|
|
fmt.Println(s1.Merge(s2).Slice())
|
|
|
|
// May Output:
|
|
// [1 2 3 4]
|
|
}
|
|
|
|
// Pops randomly pops an item from set.
|
|
func ExampleIntSet_Pop() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
|
|
fmt.Println(s1.Pop())
|
|
|
|
// May Output:
|
|
// 1
|
|
}
|
|
|
|
// Pops randomly pops `size` items from set.
|
|
// It returns all items if size == -1.
|
|
func ExampleIntSet_Pops() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
for _, v := range s1.Pops(2) {
|
|
fmt.Println(v)
|
|
}
|
|
|
|
// May Output:
|
|
// 1
|
|
// 2
|
|
}
|
|
|
|
// RLockFunc locks reading with callback function `f`.
|
|
func ExampleIntSet_RLockFunc() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
s1.RLockFunc(func(m map[int]struct{}) {
|
|
fmt.Println(m)
|
|
})
|
|
|
|
// Output:
|
|
// map[1:{} 2:{} 3:{} 4:{}]
|
|
}
|
|
|
|
// Remove deletes `item` from set.
|
|
func ExampleIntSet_Remove() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
s1.Remove(1)
|
|
fmt.Println(s1.Slice())
|
|
|
|
// May Output:
|
|
// [3 4 2]
|
|
}
|
|
|
|
// Size returns the size of the set.
|
|
func ExampleIntSet_Size() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
fmt.Println(s1.Size())
|
|
|
|
// Output:
|
|
// 4
|
|
}
|
|
|
|
// Slice returns the an of items of the set as slice.
|
|
func ExampleIntSet_Slice() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
fmt.Println(s1.Slice())
|
|
|
|
// May Output:
|
|
// [1, 2, 3, 4]
|
|
}
|
|
|
|
// String returns items as a string, which implements like json.Marshal does.
|
|
func ExampleIntSet_String() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
fmt.Println(s1.String())
|
|
|
|
// May Output:
|
|
// [1,2,3,4]
|
|
}
|
|
|
|
// Sum sums items. Note: The items should be converted to int type,
|
|
// or you'd get a result that you unexpected.
|
|
func ExampleIntSet_Sum() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
fmt.Println(s1.Sum())
|
|
|
|
// Output:
|
|
// 10
|
|
}
|
|
|
|
// Union returns a new set which is the union of `set` and `other`.
|
|
// Which means, all the items in `newSet` are in `set` or in `other`.
|
|
func ExampleIntSet_Union() {
|
|
s1 := gset.NewIntSet()
|
|
s1.Add([]int{1, 2, 3, 4}...)
|
|
s2 := gset.NewIntSet()
|
|
s2.Add([]int{1, 2, 4}...)
|
|
fmt.Println(s1.Union(s2).Slice())
|
|
|
|
// May Output:
|
|
// [3 4 1 2]
|
|
}
|
|
|
|
// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
|
|
func ExampleIntSet_UnmarshalJSON() {
|
|
b := []byte(`{"Id":1,"Name":"john","Scores":[100,99,98]}`)
|
|
type Student struct {
|
|
Id int
|
|
Name string
|
|
Scores *gset.IntSet
|
|
}
|
|
s := Student{}
|
|
json.Unmarshal(b, &s)
|
|
fmt.Println(s)
|
|
|
|
// May Output:
|
|
// {1 john [100,99,98]}
|
|
}
|
|
|
|
// UnmarshalValue is an interface implement which sets any type of value for set.
|
|
func ExampleIntSet_UnmarshalValue() {
|
|
b := []byte(`{"Id":1,"Name":"john","Scores":100,99,98}`)
|
|
type Student struct {
|
|
Id int
|
|
Name string
|
|
Scores *gset.IntSet
|
|
}
|
|
s := Student{}
|
|
json.Unmarshal(b, &s)
|
|
fmt.Println(s)
|
|
|
|
// May Output:
|
|
// {1 john [100,99,98]}
|
|
}
|
|
|
|
// Walk applies a user supplied function `f` to every item of set.
|
|
func ExampleIntSet_Walk() {
|
|
var (
|
|
set gset.IntSet
|
|
names = g.SliceInt{1, 0}
|
|
delta = 10
|
|
)
|
|
set.Add(names...)
|
|
// Add prefix for given table names.
|
|
set.Walk(func(item int) int {
|
|
return delta + item
|
|
})
|
|
fmt.Println(set.Slice())
|
|
|
|
// May Output:
|
|
// [12 60]
|
|
}
|