gset

package
v2.8.8 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Oct 23, 2024 License: MIT Imports: 6 Imported by: 4

Documentation

Overview

Package gset provides kinds of concurrent-safe/unsafe sets.

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type IntSet

type IntSet struct {
	// contains filtered or unexported fields
}

IntSet is consisted of int items.

func NewIntSet

func NewIntSet(safe ...bool) *IntSet

NewIntSet 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.

Example

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.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	intSet := gset.NewIntSet()
	intSet.Add([]int{1, 2, 3}...)
	fmt.Println(intSet.Slice())

	// May Output:
	// [2 1 3]
}
Output:

func NewIntSetFrom

func NewIntSetFrom(items []int, safe ...bool) *IntSet

NewIntSetFrom returns a new set from `items`.

func (*IntSet) Add

func (set *IntSet) Add(item ...int)

Add adds one or multiple items to the set.

Example

Add adds one or multiple items to the set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	intSet := gset.NewIntSetFrom([]int{1, 2, 3})
	intSet.Add(1)
	fmt.Println(intSet.Slice())
	fmt.Println(intSet.AddIfNotExist(1))

	// May Output:
	// [1 2 3]
	// false
}
Output:

func (*IntSet) AddIfNotExist

func (set *IntSet) AddIfNotExist(item int) bool

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.

Note that, if `item` is nil, it does nothing and returns false.

Example

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.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	intSet := gset.NewIntSetFrom([]int{1, 2, 3})
	intSet.Add(1)
	fmt.Println(intSet.Slice())
	fmt.Println(intSet.AddIfNotExist(1))

	// May Output:
	// [1 2 3]
	// false
}
Output:

func (*IntSet) AddIfNotExistFunc

func (set *IntSet) AddIfNotExistFunc(item int, f func() bool) bool

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.

Example

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.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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
}
Output:

func (*IntSet) AddIfNotExistFuncLock

func (set *IntSet) AddIfNotExistFuncLock(item int, f func() bool) bool

AddIfNotExistFuncLock 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.

Example

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.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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
}
Output:

func (*IntSet) Clear

func (set *IntSet) Clear()

Clear deletes all items of the set.

Example

Clear deletes all items of the set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	intSet := gset.NewIntSetFrom([]int{1, 2, 3})
	fmt.Println(intSet.Size())
	intSet.Clear()
	fmt.Println(intSet.Size())

}
Output:

3
0

func (*IntSet) Complement

func (set *IntSet) Complement(full *IntSet) (newSet *IntSet)

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`.

Example

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`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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]
}
Output:

func (*IntSet) Contains

func (set *IntSet) Contains(item int) bool

Contains checks whether the set contains `item`.

Example

Contains checks whether the set contains `item`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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

func (*IntSet) DeepCopy

func (set *IntSet) DeepCopy() interface{}

DeepCopy implements interface for deep copy of current type.

func (*IntSet) Diff

func (set *IntSet) Diff(others ...*IntSet) (newSet *IntSet)

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`.

Example

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`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSetFrom([]int{1, 2, 3})
	s2 := gset.NewIntSetFrom([]int{1, 2, 3, 4})
	fmt.Println(s2.Diff(s1).Slice())

}
Output:

[4]

func (*IntSet) Equal

func (set *IntSet) Equal(other *IntSet) bool

Equal checks whether the two sets equal.

Example

Equal checks whether the two sets equal.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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

func (*IntSet) Intersect

func (set *IntSet) Intersect(others ...*IntSet) (newSet *IntSet)

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`.

Example

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`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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]
}
Output:

func (*IntSet) IsSubsetOf

func (set *IntSet) IsSubsetOf(other *IntSet) bool

IsSubsetOf checks whether the current set is a sub-set of `other`.

Example

IsSubsetOf checks whether the current set is a sub-set of `other`

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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

func (*IntSet) Iterator

func (set *IntSet) Iterator(f func(v int) bool)

Iterator iterates the set readonly with given callback function `f`, if `f` returns true then continue iterating; or false to stop.

Example

Iterator iterates the set readonly with given callback function `f`, if `f` returns true then continue iterating; or false to stop.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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
}
Output:

func (*IntSet) Join

func (set *IntSet) Join(glue string) string

Join joins items with a string `glue`.

Example

Join joins items with a string `glue`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	fmt.Println(s1.Join(","))

	// May Output:
	// 3,4,1,2
}
Output:

func (*IntSet) LockFunc

func (set *IntSet) LockFunc(f func(m map[int]struct{}))

LockFunc locks writing with callback function `f`.

Example

LockFunc locks writing with callback function `f`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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]
}
Output:

func (IntSet) MarshalJSON

func (set IntSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the interface MarshalJSON for json.Marshal.

Example

MarshalJSON implements the interface MarshalJSON for json.Marshal.

package main

import (
	"encoding/json"
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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]}
}
Output:

func (*IntSet) Merge

func (set *IntSet) Merge(others ...*IntSet) *IntSet

Merge adds items from `others` sets into `set`.

Example

Merge adds items from `others` sets into `set`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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]
}
Output:

func (*IntSet) Pop

func (set *IntSet) Pop() int

Pop randomly pops an item from set.

Example

Pops randomly pops an item from set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)

	fmt.Println(s1.Pop())

	// May Output:
	// 1
}
Output:

func (*IntSet) Pops

func (set *IntSet) Pops(size int) []int

Pops randomly pops `size` items from set. It returns all items if size == -1.

Example

Pops randomly pops `size` items from set. It returns all items if size == -1.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	for _, v := range s1.Pops(2) {
		fmt.Println(v)
	}

	// May Output:
	// 1
	// 2
}
Output:

func (*IntSet) RLockFunc

func (set *IntSet) RLockFunc(f func(m map[int]struct{}))

RLockFunc locks reading with callback function `f`.

Example

RLockFunc locks reading with callback function `f`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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:{}]

func (*IntSet) Remove

func (set *IntSet) Remove(item int)

Remove deletes `item` from set.

Example

Remove deletes `item` from set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	s1.Remove(1)
	fmt.Println(s1.Slice())

	// May Output:
	// [3 4 2]
}
Output:

func (*IntSet) Size

func (set *IntSet) Size() int

Size returns the size of the set.

Example

Size returns the size of the set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	fmt.Println(s1.Size())

}
Output:

4

func (*IntSet) Slice

func (set *IntSet) Slice() []int

Slice returns the an of items of the set as slice.

Example

Slice returns the an of items of the set as slice.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	fmt.Println(s1.Slice())

	// May Output:
	// [1, 2, 3, 4]
}
Output:

func (*IntSet) String

func (set *IntSet) String() string

String returns items as a string, which implements like json.Marshal does.

Example

String returns items as a string, which implements like json.Marshal does.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	fmt.Println(s1.String())

	// May Output:
	// [1,2,3,4]
}
Output:

func (*IntSet) Sum

func (set *IntSet) Sum() (sum int)

Sum sums items. Note: The items should be converted to int type, or you'd get a result that you unexpected.

Example

Sum sums items. Note: The items should be converted to int type, or you'd get a result that you unexpected.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewIntSet()
	s1.Add([]int{1, 2, 3, 4}...)
	fmt.Println(s1.Sum())

}
Output:

10

func (*IntSet) Union

func (set *IntSet) Union(others ...*IntSet) (newSet *IntSet)

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`.

Example

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`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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]
}
Output:

func (*IntSet) UnmarshalJSON

func (set *IntSet) UnmarshalJSON(b []byte) error

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

Example

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

package main

import (
	"encoding/json"
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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]}
}
Output:

func (*IntSet) UnmarshalValue

func (set *IntSet) UnmarshalValue(value interface{}) (err error)

UnmarshalValue is an interface implement which sets any type of value for set.

Example

UnmarshalValue is an interface implement which sets any type of value for set.

package main

import (
	"encoding/json"
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	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]}
}
Output:

func (*IntSet) Walk

func (set *IntSet) Walk(f func(item int) int) *IntSet

Walk applies a user supplied function `f` to every item of set.

Example

Walk applies a user supplied function `f` to every item of set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
	"gitee.com/clannad_sk/webkit/v2/frame/g"
)

func main() {
	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]
}
Output:

type Set

type Set struct {
	// contains filtered or unexported fields
}

Set is consisted of interface{} items.

func New

func New(safe ...bool) *Set

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 NewFrom

func NewFrom(items interface{}, safe ...bool) *Set

NewFrom returns a new set from `items`. Parameter `items` can be either a variable of any type, or a slice.

Example

NewIntSetFrom returns a new set from `items`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	intSet := gset.NewIntSetFrom([]int{1, 2, 3})
	fmt.Println(intSet.Slice())

	// May Output:
	// [2 1 3]
}
Output:

func NewSet

func NewSet(safe ...bool) *Set

NewSet create and returns a new set, which contains un-repeated items. Also see New.

func (*Set) Add

func (set *Set) Add(items ...interface{})

Add adds one or multiple items to the set.

func (*Set) AddIfNotExist

func (set *Set) AddIfNotExist(item interface{}) bool

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.

Note that, if `item` is nil, it does nothing and returns false.

Example
package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	var set gset.Set
	fmt.Println(set.AddIfNotExist(1))
	fmt.Println(set.AddIfNotExist(1))
	fmt.Println(set.Slice())

}
Output:

true
false
[1]

func (*Set) AddIfNotExistFunc

func (set *Set) AddIfNotExistFunc(item interface{}, f func() bool) bool

AddIfNotExistFunc checks whether item exists in the set, it adds the item to set and returns true if it does not exist in the set and function `f` returns true, or else it does nothing and returns false.

Note that, if `item` is nil, it does nothing and returns false. The function `f` is executed without writing lock.

func (*Set) AddIfNotExistFuncLock

func (set *Set) AddIfNotExistFuncLock(item interface{}, f func() bool) bool

AddIfNotExistFuncLock 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, if `item` is nil, it does nothing and returns false. The function `f` is executed within writing lock.

func (*Set) Clear

func (set *Set) Clear()

Clear deletes all items of the set.

func (*Set) Complement

func (set *Set) Complement(full *Set) (newSet *Set)

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`.

Example
package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
	"gitee.com/clannad_sk/webkit/v2/frame/g"
)

func main() {
	s1 := gset.NewFrom(g.Slice{1, 2, 3})
	s2 := gset.NewFrom(g.Slice{4, 5, 6})
	s3 := gset.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7})

	fmt.Println(s3.Intersect(s1).Slice())
	fmt.Println(s3.Diff(s1).Slice())
	fmt.Println(s1.Union(s2).Slice())
	fmt.Println(s1.Complement(s3).Slice())

	// May Output:
	// [2 3 1]
	// [5 6 7 4]
	// [6 1 2 3 4 5]
	// [4 5 6 7]
}
Output:

func (*Set) Contains

func (set *Set) Contains(item interface{}) bool

Contains checks whether the set contains `item`.

Example
package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	var set gset.StrSet
	set.Add("a")
	fmt.Println(set.Contains("a"))
	fmt.Println(set.Contains("A"))
	fmt.Println(set.ContainsI("A"))

}
Output:

true
false
true

func (*Set) DeepCopy

func (set *Set) DeepCopy() interface{}

DeepCopy implements interface for deep copy of current type.

func (*Set) Diff

func (set *Set) Diff(others ...*Set) (newSet *Set)

Diff returns a new set which is the difference set from `set` to `others`. Which means, all the items in `newSet` are in `set` but not in `others`.

Example
package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
	"gitee.com/clannad_sk/webkit/v2/frame/g"
)

func main() {
	s1 := gset.NewFrom(g.Slice{1, 2, 3})
	s2 := gset.NewFrom(g.Slice{4, 5, 6})
	s3 := gset.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7})

	fmt.Println(s3.Intersect(s1).Slice())
	fmt.Println(s3.Diff(s1).Slice())
	fmt.Println(s1.Union(s2).Slice())
	fmt.Println(s1.Complement(s3).Slice())

	// May Output:
	// [2 3 1]
	// [5 6 7 4]
	// [6 1 2 3 4 5]
	// [4 5 6 7]
}
Output:

func (*Set) Equal

func (set *Set) Equal(other *Set) bool

Equal checks whether the two sets equal.

func (*Set) Intersect

func (set *Set) Intersect(others ...*Set) (newSet *Set)

Intersect returns a new set which is the intersection from `set` to `others`. Which means, all the items in `newSet` are in `set` and also in `others`.

Example
package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
	"gitee.com/clannad_sk/webkit/v2/frame/g"
)

func main() {
	s1 := gset.NewFrom(g.Slice{1, 2, 3})
	s2 := gset.NewFrom(g.Slice{4, 5, 6})
	s3 := gset.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7})

	fmt.Println(s3.Intersect(s1).Slice())
	fmt.Println(s3.Diff(s1).Slice())
	fmt.Println(s1.Union(s2).Slice())
	fmt.Println(s1.Complement(s3).Slice())

	// May Output:
	// [2 3 1]
	// [5 6 7 4]
	// [6 1 2 3 4 5]
	// [4 5 6 7]
}
Output:

func (*Set) IsSubsetOf

func (set *Set) IsSubsetOf(other *Set) bool

IsSubsetOf checks whether the current set is a sub-set of `other`.

Example
package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
	"gitee.com/clannad_sk/webkit/v2/frame/g"
)

func main() {
	var s1, s2 gset.Set
	s1.Add(g.Slice{1, 2, 3}...)
	s2.Add(g.Slice{2, 3}...)
	fmt.Println(s1.IsSubsetOf(&s2))
	fmt.Println(s2.IsSubsetOf(&s1))

}
Output:

false
true

func (*Set) Iterator

func (set *Set) Iterator(f func(v interface{}) bool)

Iterator iterates the set readonly with given callback function `f`, if `f` returns true then continue iterating; or false to stop.

func (*Set) Join

func (set *Set) Join(glue string) string

Join joins items with a string `glue`.

Example
package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	var set gset.Set
	set.Add("a", "b", "c", "d")
	fmt.Println(set.Join(","))

	// May Output:
	// a,b,c,d
}
Output:

func (*Set) LockFunc

func (set *Set) LockFunc(f func(m map[interface{}]struct{}))

LockFunc locks writing with callback function `f`.

func (Set) MarshalJSON

func (set Set) MarshalJSON() ([]byte, error)

MarshalJSON implements the interface MarshalJSON for json.Marshal.

func (*Set) Merge

func (set *Set) Merge(others ...*Set) *Set

Merge adds items from `others` sets into `set`.

func (*Set) Pop

func (set *Set) Pop() interface{}

Pop randomly pops an item from set.

Example
package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	var set gset.Set
	set.Add(1, 2, 3, 4)
	fmt.Println(set.Pop())
	fmt.Println(set.Pops(2))
	fmt.Println(set.Size())

	// May Output:
	// 1
	// [2 3]
	// 1
}
Output:

func (*Set) Pops

func (set *Set) Pops(size int) []interface{}

Pops randomly pops `size` items from set. It returns all items if size == -1.

Example
package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	var set gset.Set
	set.Add(1, 2, 3, 4)
	fmt.Println(set.Pop())
	fmt.Println(set.Pops(2))
	fmt.Println(set.Size())

	// May Output:
	// 1
	// [2 3]
	// 1
}
Output:

func (*Set) RLockFunc

func (set *Set) RLockFunc(f func(m map[interface{}]struct{}))

RLockFunc locks reading with callback function `f`.

func (*Set) Remove

func (set *Set) Remove(item interface{})

Remove deletes `item` from set.

func (*Set) Size

func (set *Set) Size() int

Size returns the size of the set.

func (*Set) Slice

func (set *Set) Slice() []interface{}

Slice returns all items of the set as slice.

func (*Set) String

func (set *Set) String() string

String returns items as a string, which implements like json.Marshal does.

func (*Set) Sum

func (set *Set) Sum() (sum int)

Sum sums items. Note: The items should be converted to int type, or you'd get a result that you unexpected.

func (*Set) Union

func (set *Set) Union(others ...*Set) (newSet *Set)

Union returns a new set which is the union of `set` and `others`. Which means, all the items in `newSet` are in `set` or in `others`.

Example
package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
	"gitee.com/clannad_sk/webkit/v2/frame/g"
)

func main() {
	s1 := gset.NewFrom(g.Slice{1, 2, 3})
	s2 := gset.NewFrom(g.Slice{4, 5, 6})
	s3 := gset.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7})

	fmt.Println(s3.Intersect(s1).Slice())
	fmt.Println(s3.Diff(s1).Slice())
	fmt.Println(s1.Union(s2).Slice())
	fmt.Println(s1.Complement(s3).Slice())

	// May Output:
	// [2 3 1]
	// [5 6 7 4]
	// [6 1 2 3 4 5]
	// [4 5 6 7]
}
Output:

func (*Set) UnmarshalJSON

func (set *Set) UnmarshalJSON(b []byte) error

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

func (*Set) UnmarshalValue

func (set *Set) UnmarshalValue(value interface{}) (err error)

UnmarshalValue is an interface implement which sets any type of value for set.

func (*Set) Walk

func (set *Set) Walk(f func(item interface{}) interface{}) *Set

Walk applies a user supplied function `f` to every item of set.

type StrSet

type StrSet struct {
	// contains filtered or unexported fields
}

StrSet is consisted of string items.

func NewStrSet

func NewStrSet(safe ...bool) *StrSet

NewStrSet 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.

Example

NewStrSet 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.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSet(true)
	strSet.Add([]string{"str1", "str2", "str3"}...)
	fmt.Println(strSet.Slice())

	// May Output:
	// [str3 str1 str2]
}
Output:

func NewStrSetFrom

func NewStrSetFrom(items []string, safe ...bool) *StrSet

NewStrSetFrom returns a new set from `items`.

Example

NewStrSetFrom returns a new set from `items`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	fmt.Println(strSet.Slice())

	// May Output:
	// [str1 str2 str3]
}
Output:

func (*StrSet) Add

func (set *StrSet) Add(item ...string)

Add adds one or multiple items to the set.

Example

Add adds one or multiple items to the set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	strSet.Add("str")
	fmt.Println(strSet.Slice())
	fmt.Println(strSet.AddIfNotExist("str"))

	// May Output:
	// [str str1 str2 str3]
	// false
}
Output:

func (*StrSet) AddIfNotExist

func (set *StrSet) AddIfNotExist(item string) bool

AddIfNotExist checks whether item exists in the set, it adds the item to set and returns true if it does not exist in the set, or else it does nothing and returns false.

Example

AddIfNotExist checks whether item exists in the set, it adds the item to set and returns true if it does not exist in the set, or else it does nothing and returns false.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	strSet.Add("str")
	fmt.Println(strSet.Slice())
	fmt.Println(strSet.AddIfNotExist("str"))

	// May Output:
	// [str str1 str2 str3]
	// false
}
Output:

func (*StrSet) AddIfNotExistFunc

func (set *StrSet) AddIfNotExistFunc(item string, f func() bool) bool

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.

Example

AddIfNotExistFunc checks whether item exists in the set, it adds the item to set and returns true if it does not exist 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.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	strSet.Add("str")
	fmt.Println(strSet.Slice())
	fmt.Println(strSet.AddIfNotExistFunc("str5", func() bool {
		return true
	}))

	// May Output:
	// [str1 str2 str3 str]
	// true
}
Output:

func (*StrSet) AddIfNotExistFuncLock

func (set *StrSet) AddIfNotExistFuncLock(item string, f func() bool) bool

AddIfNotExistFuncLock 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.

Example

AddIfNotExistFunc checks whether item exists in the set, it adds the item to set and returns true if it does not exist 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.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	strSet.Add("str")
	fmt.Println(strSet.Slice())
	fmt.Println(strSet.AddIfNotExistFuncLock("str4", func() bool {
		return true
	}))

	// May Output:
	// [str1 str2 str3 str]
	// true
}
Output:

func (*StrSet) Clear

func (set *StrSet) Clear()

Clear deletes all items of the set.

Example

Clear deletes all items of the set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	fmt.Println(strSet.Size())
	strSet.Clear()
	fmt.Println(strSet.Size())

}
Output:

3
0

func (*StrSet) Complement

func (set *StrSet) Complement(full *StrSet) (newSet *StrSet)

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`.

Example

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`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	strSet := gset.NewStrSetFrom([]string{"str1", "str2", "str3", "str4", "str5"}, true)
	s := gset.NewStrSetFrom([]string{"str1", "str2", "str3"}, true)
	fmt.Println(s.Complement(strSet).Slice())

	// May Output:
	// [str4 str5]
}
Output:

func (*StrSet) Contains

func (set *StrSet) Contains(item string) bool

Contains checks whether the set contains `item`.

Example

Contains checks whether the set contains `item`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	var set gset.StrSet
	set.Add("a")
	fmt.Println(set.Contains("a"))
	fmt.Println(set.Contains("A"))

}
Output:

true
false

func (*StrSet) ContainsI

func (set *StrSet) ContainsI(item string) bool

ContainsI checks whether a value exists in the set with case-insensitively. Note that it internally iterates the whole set to do the comparison with case-insensitively.

Example

ContainsI checks whether a value exists in the set with case-insensitively. Note that it internally iterates the whole set to do the comparison with case-insensitively.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	var set gset.StrSet
	set.Add("a")
	fmt.Println(set.ContainsI("a"))
	fmt.Println(set.ContainsI("A"))

}
Output:

true
true

func (*StrSet) DeepCopy

func (set *StrSet) DeepCopy() interface{}

DeepCopy implements interface for deep copy of current type.

func (*StrSet) Diff

func (set *StrSet) Diff(others ...*StrSet) (newSet *StrSet)

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`.

Example

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`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSetFrom([]string{"a", "b", "c"}, true)
	s2 := gset.NewStrSetFrom([]string{"a", "b", "c", "d"}, true)
	fmt.Println(s2.Diff(s1).Slice())

}
Output:

[d]

func (*StrSet) Equal

func (set *StrSet) Equal(other *StrSet) bool

Equal checks whether the two sets equal.

Example

Equal checks whether the two sets equal.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSetFrom([]string{"a", "b", "c"}, true)
	s2 := gset.NewStrSetFrom([]string{"a", "b", "c", "d"}, true)
	fmt.Println(s2.Equal(s1))

	s3 := gset.NewStrSetFrom([]string{"a", "b", "c"}, true)
	s4 := gset.NewStrSetFrom([]string{"a", "b", "c"}, true)
	fmt.Println(s3.Equal(s4))

}
Output:

false
true

func (*StrSet) Intersect

func (set *StrSet) Intersect(others ...*StrSet) (newSet *StrSet)

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`.

Example

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`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c"}...)
	var s2 gset.StrSet
	s2.Add([]string{"a", "b", "c", "d"}...)
	fmt.Println(s2.Intersect(s1).Slice())

	// May Output:
	// [c a b]
}
Output:

func (*StrSet) IsSubsetOf

func (set *StrSet) IsSubsetOf(other *StrSet) bool

IsSubsetOf checks whether the current set is a sub-set of `other`.

Example

IsSubsetOf checks whether the current set is a sub-set of `other`

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	var s2 gset.StrSet
	s2.Add([]string{"a", "b", "d"}...)
	fmt.Println(s2.IsSubsetOf(s1))

}
Output:

true

func (*StrSet) Iterator

func (set *StrSet) Iterator(f func(v string) bool)

Iterator iterates the set readonly with given callback function `f`, if `f` returns true then continue iterating; or false to stop.

Example

Iterator iterates the set readonly with given callback function `f`, if `f` returns true then continue iterating; or false to stop.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	s1.Iterator(func(v string) bool {
		fmt.Println("Iterator", v)
		return true
	})

	// May Output:
	// Iterator a
	// Iterator b
	// Iterator c
	// Iterator d
}
Output:

func (*StrSet) Join

func (set *StrSet) Join(glue string) string

Join joins items with a string `glue`.

Example

Join joins items with a string `glue`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	fmt.Println(s1.Join(","))

	// May Output:
	// b,c,d,a
}
Output:

func (*StrSet) LockFunc

func (set *StrSet) LockFunc(f func(m map[string]struct{}))

LockFunc locks writing with callback function `f`.

Example

LockFunc locks writing with callback function `f`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"1", "2"}...)
	s1.LockFunc(func(m map[string]struct{}) {
		m["3"] = struct{}{}
	})
	fmt.Println(s1.Slice())

	// May Output
	// [2 3 1]

}
Output:

func (StrSet) MarshalJSON

func (set StrSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the interface MarshalJSON for json.Marshal.

Example

MarshalJSON implements the interface MarshalJSON for json.Marshal.

package main

import (
	"encoding/json"
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	type Student struct {
		Id     int
		Name   string
		Scores *gset.StrSet
	}
	s := Student{
		Id:     1,
		Name:   "john",
		Scores: gset.NewStrSetFrom([]string{"100", "99", "98"}, true),
	}
	b, _ := json.Marshal(s)
	fmt.Println(string(b))

	// May Output:
	// {"Id":1,"Name":"john","Scores":["100","99","98"]}
}
Output:

func (*StrSet) Merge

func (set *StrSet) Merge(others ...*StrSet) *StrSet

Merge adds items from `others` sets into `set`.

Example

Merge adds items from `others` sets into `set`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)

	s2 := gset.NewStrSet(true)
	fmt.Println(s1.Merge(s2).Slice())

	// May Output:
	// [d a b c]
}
Output:

func (*StrSet) Pop

func (set *StrSet) Pop() string

Pop randomly pops an item from set.

Example

Pops randomly pops an item from set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)

	fmt.Println(s1.Pop())

	// May Output:
	// a
}
Output:

func (*StrSet) Pops

func (set *StrSet) Pops(size int) []string

Pops randomly pops `size` items from set. It returns all items if size == -1.

Example

Pops randomly pops `size` items from set. It returns all items if size == -1.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	for _, v := range s1.Pops(2) {
		fmt.Println(v)
	}

	// May Output:
	// a
	// b
}
Output:

func (*StrSet) RLockFunc

func (set *StrSet) RLockFunc(f func(m map[string]struct{}))

RLockFunc locks reading with callback function `f`.

Example

RLockFunc locks reading with callback function `f`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	s1.RLockFunc(func(m map[string]struct{}) {
		fmt.Println(m)
	})

}
Output:

map[a:{} b:{} c:{} d:{}]

func (*StrSet) Remove

func (set *StrSet) Remove(item string)

Remove deletes `item` from set.

Example

Remove deletes `item` from set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	s1.Remove("a")
	fmt.Println(s1.Slice())

	// May Output:
	// [b c d]
}
Output:

func (*StrSet) Size

func (set *StrSet) Size() int

Size returns the size of the set.

Example

Size returns the size of the set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	fmt.Println(s1.Size())

}
Output:

4

func (*StrSet) Slice

func (set *StrSet) Slice() []string

Slice returns the an of items of the set as slice.

Example

Slice returns the an of items of the set as slice.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	fmt.Println(s1.Slice())

	// May Output:
	// [a,b,c,d]
}
Output:

func (*StrSet) String

func (set *StrSet) String() string

String returns items as a string, which implements like json.Marshal does.

Example

String returns items as a string, which implements like json.Marshal does.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	fmt.Println(s1.String())

	// May Output:
	// "a","b","c","d"
}
Output:

func (*StrSet) Sum

func (set *StrSet) Sum() (sum int)

Sum sums items. Note: The items should be converted to int type, or you'd get a result that you unexpected.

Example

Sum sums items. Note: The items should be converted to int type, or you'd get a result that you unexpected.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"1", "2", "3", "4"}...)
	fmt.Println(s1.Sum())

}
Output:

10

func (*StrSet) Union

func (set *StrSet) Union(others ...*StrSet) (newSet *StrSet)

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`.

Example

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`.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	s1 := gset.NewStrSet(true)
	s1.Add([]string{"a", "b", "c", "d"}...)
	s2 := gset.NewStrSet(true)
	s2.Add([]string{"a", "b", "d"}...)
	fmt.Println(s1.Union(s2).Slice())

	// May Output:
	// [a b c d]
}
Output:

func (*StrSet) UnmarshalJSON

func (set *StrSet) UnmarshalJSON(b []byte) error

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

Example

UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

package main

import (
	"encoding/json"
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	b := []byte(`{"Id":1,"Name":"john","Scores":["100","99","98"]}`)
	type Student struct {
		Id     int
		Name   string
		Scores *gset.StrSet
	}
	s := Student{}
	json.Unmarshal(b, &s)
	fmt.Println(s)

	// May Output:
	// {1 john "99","98","100"}
}
Output:

func (*StrSet) UnmarshalValue

func (set *StrSet) UnmarshalValue(value interface{}) (err error)

UnmarshalValue is an interface implement which sets any type of value for set.

Example

UnmarshalValue is an interface implement which sets any type of value for set.

package main

import (
	"encoding/json"
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
)

func main() {
	b := []byte(`{"Id":1,"Name":"john","Scores":["100","99","98"]}`)
	type Student struct {
		Id     int
		Name   string
		Scores *gset.StrSet
	}
	s := Student{}
	json.Unmarshal(b, &s)
	fmt.Println(s)

	// May Output:
	// {1 john "99","98","100"}
}
Output:

func (*StrSet) Walk

func (set *StrSet) Walk(f func(item string) string) *StrSet

Walk applies a user supplied function `f` to every item of set.

Example

Walk applies a user supplied function `f` to every item of set.

package main

import (
	"fmt"

	"gitee.com/clannad_sk/webkit/v2/container/gset"
	"gitee.com/clannad_sk/webkit/v2/frame/g"
)

func main() {
	var (
		set    gset.StrSet
		names  = g.SliceStr{"user", "user_detail"}
		prefix = "gf_"
	)
	set.Add(names...)
	// Add prefix for given table names.
	set.Walk(func(item string) string {
		return prefix + item
	})
	fmt.Println(set.Slice())

	// May Output:
	// [gf_user gf_user_detail]
}
Output:

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL