bingyi/gf
1
0
Fork 0
mirror of https://gitee.com/johng/gf synced 2026-07-08 22:40:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

add Clone for garray; comments of garray update

Browse Source
This commit is contained in:
John
2019-02-01 22:00:58 +08:00
parent 87d553fca2
commit 7b85c44444
32 changed files with 307 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
g/container/garray/garray_normal_int.go
View File

@ -17,27 +17,23 @@ import (
type IntArray struct {
mu *rwmutex.RWMutex // 互斥锁
cap int // 初始化设置的数组容量
size int // 初始化设置的数组大小
array []int // 底层数组
}
func NewIntArray(size int, cap int, unsafe...bool) *IntArray {
a := &IntArray{
mu : rwmutex.New(unsafe...),
}
a.size = size
if cap > 0 {
a.cap = cap
a.array = make([]int, size, cap)
} else {
a.array = make([]int, size)
}
return a
// Create an empty array.
// The param <unsafe> used to specify whether using array with un-concurrent-safety,
// which is false in default, means concurrent-safe in default.
//
// 创建一个空的数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
func NewIntArray(unsafe...bool) *IntArray {
return NewIntArraySize(0, 0, unsafe...)
}
func NewIntArrayEmpty(unsafe...bool) *IntArray {
return NewIntArray(0, 0, unsafe...)
func NewIntArraySize(size int, cap int, unsafe...bool) *IntArray {
return &IntArray{
mu : rwmutex.New(unsafe...),
array : make([]int, size, cap),
}
}
func NewIntArrayFrom(array []int, unsafe...bool) *IntArray {
@ -234,16 +230,23 @@ func (a *IntArray) Slice() []int {
return array
}
// Return a new array, which is a copy of current array.
//
// 克隆当前数组，返回当前数组的一个拷贝。
func (a *IntArray) Clone() (newArray *IntArray) {
a.mu.RLock()
array := make([]int, len(a.array))
copy(array, a.array)
a.mu.RUnlock()
return NewIntArrayFrom(array, !a.mu.IsSafe())
}
// 清空数据数组
func (a *IntArray) Clear() *IntArray {
a.mu.Lock()
if len(a.array) > 0 {
if a.cap > 0 {
a.array = make([]int, a.size, a.cap)
} else {
a.array = make([]int, a.size)
}
}
a.array = make([]int, 0)
}
a.mu.Unlock()
return a
}
@ -314,6 +317,8 @@ func (a *IntArray) Merge(array *IntArray) *IntArray {
}
// Fills an array with num entries of the value of the value parameter, keys starting at the startIndex parameter.
//
// 用value参数的值将数组填充num个条目，位置由startIndex参数指定的开始。
func (a *IntArray) Fill(startIndex int, num int, value int) *IntArray {
a.mu.Lock()
defer a.mu.Unlock()
@ -331,6 +336,8 @@ func (a *IntArray) Fill(startIndex int, num int, value int) *IntArray {
}
// Chunks an array into arrays with size elements. The last chunk may contain less than size elements.
//
// 将一个数组分割成多个数组，其中每个数组的单元数目由size决定。最后一个数组的单元数目可能会少于size个。
func (a *IntArray) Chunk(size int) [][]int {
if size < 1 {
panic("size: cannot be less than 1")
@ -355,6 +362,10 @@ func (a *IntArray) Chunk(size int) [][]int {
// If size is positive then the array is padded on the right, or negative on the left.
// If the absolute value of size is less than or equal to the length of the array
// then no padding takes place.
//
// 返回数组的一个拷贝，并用value将其填补到size指定的长度。
// 如果size为正数，则填补到数组的右侧，如果为负数则从左侧开始填补。
// 如果size的绝对值小于或等于数组的长度则没有任何填补。
func (a *IntArray) Pad(size int, value int) *IntArray {
a.mu.Lock()
defer a.mu.Unlock()
@ -380,6 +391,8 @@ func (a *IntArray) Pad(size int, value int) *IntArray {
// Extract a slice of the array(If in concurrent safe usage, it returns a copy of the slice; else a pointer).
// It returns the sequence of elements from the array array as specified by the offset and length parameters.
//
// 返回根据offset和size参数所指定的数组中的一段序列。
func (a *IntArray) SubSlice(offset, size int) []int {
a.mu.RLock()
defer a.mu.RUnlock()
@ -399,6 +412,8 @@ func (a *IntArray) SubSlice(offset, size int) []int {
}
// Picks one or more random entries out of an array(a copy), and returns the key (or keys) of the random entries.
//
// 从数组中随机取出size个元素项，构成slice返回。
func (a *IntArray) Rand(size int) []int {
a.mu.RLock()
defer a.mu.RUnlock()
@ -416,6 +431,8 @@ func (a *IntArray) Rand(size int) []int {
}
// Randomly shuffles the array.
//
// 随机打乱当前数组。
func (a *IntArray) Shuffle() *IntArray {
a.mu.Lock()
defer a.mu.Unlock()
@ -426,6 +443,8 @@ func (a *IntArray) Shuffle() *IntArray {
}
// Make array with elements in reverse order.
//
// 将当前数组反转。
func (a *IntArray) Reverse() *IntArray {
a.mu.Lock()
defer a.mu.Unlock()
@ -436,6 +455,8 @@ func (a *IntArray) Reverse() *IntArray {
}
// Join array elements with a string.
//
// 使用glue字符串串连当前数组的元素项，构造成新的字符串返回。
func (a *IntArray) Join(glue string) string {
a.mu.RLock()
defer a.mu.RUnlock()

73
g/container/garray/garray_normal_interface.go
View File

@ -16,32 +16,28 @@ import (
)
type Array struct {
mu *rwmutex.RWMutex // 互斥锁
cap int // 初始化设置的数组容量
size int // 初始化设置的数组大小
array []interface{} // 底层数组
mu *rwmutex.RWMutex // 互斥锁
array []interface{} // 底层数组
}
func New(size int, cap int, unsafe...bool) *Array {
return NewArray(size, cap, unsafe...)
// Create an empty array.
// The param <unsafe> used to specify whether using array with un-concurrent-safety,
// which is false in default, means concurrent-safe in default.
//
// 创建一个空的数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
func New(unsafe...bool) *Array {
return NewArraySize(0, 0, unsafe...)
}
func NewArray(size int, cap int, unsafe...bool) *Array {
a := &Array{
mu : rwmutex.New(unsafe...),
func NewArray(unsafe...bool) *Array {
return NewArraySize(0, 0, unsafe...)
}
func NewArraySize(size int, cap int, unsafe...bool) *Array {
return &Array{
mu : rwmutex.New(unsafe...),
array : make([]interface{}, size, cap),
}
a.size = size
if cap > 0 {
a.cap = cap
a.array = make([]interface{}, size, cap)
} else {
a.array = make([]interface{}, size)
}
return a
}
func NewArrayEmpty(unsafe...bool) *Array {
return NewArray(0, 0, unsafe...)
}
func NewArrayFrom(array []interface{}, unsafe...bool) *Array {
@ -219,15 +215,22 @@ func (a *Array) Slice() []interface{} {
return array
}
// Return a new array, which is a copy of current array.
//
// 克隆当前数组，返回当前数组的一个拷贝。
func (a *Array) Clone() (newArray *Array) {
a.mu.RLock()
array := make([]interface{}, len(a.array))
copy(array, a.array)
a.mu.RUnlock()
return NewArrayFrom(array, !a.mu.IsSafe())
}
// 清空数据数组
func (a *Array) Clear() *Array {
a.mu.Lock()
if len(a.array) > 0 {
if a.cap > 0 {
a.array = make([]interface{}, a.size, a.cap)
} else {
a.array = make([]interface{}, a.size)
}
a.array = make([]interface{}, 0)
}
a.mu.Unlock()
return a
@ -299,6 +302,8 @@ func (a *Array) Merge(array *Array) *Array {
}
// Fills an array with num entries of the value of the value parameter, keys starting at the start_index parameter.
//
// 用value参数的值将数组填充num个条目，位置由startIndex参数指定的开始。
func (a *Array) Fill(startIndex int, num int, value interface{}) *Array {
a.mu.Lock()
defer a.mu.Unlock()
@ -316,6 +321,8 @@ func (a *Array) Fill(startIndex int, num int, value interface{}) *Array {
}
// Chunks an array into arrays with size elements. The last chunk may contain less than size elements.
//
// 将一个数组分割成多个数组，其中每个数组的单元数目由size决定。最后一个数组的单元数目可能会少于size个。
func (a *Array) Chunk(size int) [][]interface{} {
if size < 1 {
panic("size: cannot be less than 1")
@ -341,6 +348,10 @@ func (a *Array) Chunk(size int) [][]interface{} {
// if it's negative then on the left.
// If the absolute value of size is less than or equal to the length of the array
// then no padding takes place.
//
// 返回数组的一个拷贝，并用value将其填补到size指定的长度。
// 如果size为正数，则填补到数组的右侧，如果为负数则从左侧开始填补。
// 如果size的绝对值小于或等于数组的长度则没有任何填补。
func (a *Array) Pad(size int, val interface{}) *Array {
a.mu.Lock()
defer a.mu.Unlock()
@ -366,6 +377,8 @@ func (a *Array) Pad(size int, val interface{}) *Array {
// Extract a slice of the array(If in concurrent safe usage, it returns a copy of the slice; else a pointer).
// It returns the sequence of elements from the array array as specified by the offset and length parameters.
//
// 返回根据offset和size参数所指定的数组中的一段序列。
func (a *Array) SubSlice(offset, size int) []interface{} {
a.mu.RLock()
defer a.mu.RUnlock()
@ -385,6 +398,8 @@ func (a *Array) SubSlice(offset, size int) []interface{} {
}
// Picks one or more random entries out of an array(a copy), and returns the key (or keys) of the random entries.
//
// 从数组中随机取出size个元素项，构成slice返回。
func (a *Array) Rand(size int) []interface{} {
a.mu.RLock()
defer a.mu.RUnlock()
@ -402,6 +417,8 @@ func (a *Array) Rand(size int) []interface{} {
}
// Randomly shuffles the array.
//
// 随机打乱当前数组。
func (a *Array) Shuffle() *Array {
a.mu.Lock()
defer a.mu.Unlock()
@ -412,6 +429,8 @@ func (a *Array) Shuffle() *Array {
}
// Make array with elements in reverse order.
//
// 将当前数组反转。
func (a *Array) Reverse() *Array {
a.mu.Lock()
defer a.mu.Unlock()
@ -422,6 +441,8 @@ func (a *Array) Reverse() *Array {
}
// Join array elements with a string.
//
// 使用glue字符串串连当前数组的元素项，构造成新的字符串返回。
func (a *Array) Join(glue string) string {
a.mu.RLock()
defer a.mu.RUnlock()

71
g/container/garray/garray_normal_string.go
View File

@ -17,27 +17,23 @@ import (
type StringArray struct {
mu *rwmutex.RWMutex // 互斥锁
cap int // 初始化设置的数组容量
size int // 初始化设置的数组大小
array []string // 底层数组
}
func NewStringArray(size int, cap int, unsafe...bool) *StringArray {
a := &StringArray{
mu : rwmutex.New(unsafe...),
}
a.size = size
if cap > 0 {
a.cap = cap
a.array = make([]string, size, cap)
} else {
a.array = make([]string, size)
}
return a
// Create an empty array.
// The param <unsafe> used to specify whether using array with un-concurrent-safety,
// which is false in default, means concurrent-safe in default.
//
// 创建一个空的数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
func NewStringArray(unsafe...bool) *StringArray {
return NewStringArraySize(0, 0, unsafe...)
}
func NewStringArrayEmpty(unsafe...bool) *StringArray {
return NewStringArray(0, 0, unsafe...)
func NewStringArraySize(size int, cap int, unsafe...bool) *StringArray {
return &StringArray{
mu : rwmutex.New(unsafe...),
array : make([]string, size, cap),
}
}
func NewStringArrayFrom(array []string, unsafe...bool) *StringArray {
@ -234,17 +230,24 @@ func (a *StringArray) Slice() []string {
return array
}
// Return a new array, which is a copy of current array.
//
// 克隆当前数组，返回当前数组的一个拷贝。
func (a *StringArray) Clone() (newArray *StringArray) {
a.mu.RLock()
array := make([]string, len(a.array))
copy(array, a.array)
a.mu.RUnlock()
return NewStringArrayFrom(array, !a.mu.IsSafe())
}
// 清空数据数组
func (a *StringArray) Clear() *StringArray {
a.mu.Lock()
if len(a.array) > 0 {
if a.cap > 0 {
a.array = make([]string, a.size, a.cap)
} else {
a.array = make([]string, a.size)
}
}
a.mu.Unlock()
a.mu.Lock()
if len(a.array) > 0 {
a.array = make([]string, 0)
}
a.mu.Unlock()
return a
}
@ -313,6 +316,8 @@ func (a *StringArray) Merge(array *StringArray) *StringArray {
}
// Fills an array with num entries of the value of the value parameter, keys starting at the start_index parameter.
//
// 用value参数的值将数组填充num个条目，位置由startIndex参数指定的开始。
func (a *StringArray) Fill(startIndex int, num int, value string) *StringArray {
a.mu.Lock()
defer a.mu.Unlock()
@ -330,6 +335,8 @@ func (a *StringArray) Fill(startIndex int, num int, value string) *StringArray {
}
// Chunks an array into arrays with size elements. The last chunk may contain less than size elements.
//
// 将一个数组分割成多个数组，其中每个数组的单元数目由size决定。最后一个数组的单元数目可能会少于size个。
func (a *StringArray) Chunk(size int) [][]string {
if size < 1 {
panic("size: cannot be less than 1")
@ -355,6 +362,10 @@ func (a *StringArray) Chunk(size int) [][]string {
// if it's negative then on the left.
// If the absolute value of size is less than or equal to the length of the array
// then no padding takes place.
//
// 返回数组的一个拷贝，并用value将其填补到size指定的长度。
// 如果size为正数，则填补到数组的右侧，如果为负数则从左侧开始填补。
// 如果size的绝对值小于或等于数组的长度则没有任何填补。
func (a *StringArray) Pad(size int, value string) *StringArray {
a.mu.Lock()
defer a.mu.Unlock()
@ -380,6 +391,8 @@ func (a *StringArray) Pad(size int, value string) *StringArray {
// Extract a slice of the array(If in concurrent safe usage, it returns a copy of the slice; else a pointer).
// It returns the sequence of elements from the array array as specified by the offset and length parameters.
//
// 返回根据offset和size参数所指定的数组中的一段序列。
func (a *StringArray) SubSlice(offset, size int) []string {
a.mu.RLock()
defer a.mu.RUnlock()
@ -399,6 +412,8 @@ func (a *StringArray) SubSlice(offset, size int) []string {
}
// Picks one or more random entries out of an array(a copy), and returns the key (or keys) of the random entries.
//
// 从数组中随机取出size个元素项，构成slice返回。
func (a *StringArray) Rand(size int) []string {
a.mu.RLock()
defer a.mu.RUnlock()
@ -416,6 +431,8 @@ func (a *StringArray) Rand(size int) []string {
}
// Randomly shuffles the array.
//
// 随机打乱当前数组。
func (a *StringArray) Shuffle() *StringArray {
a.mu.Lock()
defer a.mu.Unlock()
@ -426,6 +443,8 @@ func (a *StringArray) Shuffle() *StringArray {
}
// Make array with elements in reverse order.
//
// 将当前数组反转。
func (a *StringArray) Reverse() *StringArray {
a.mu.Lock()
defer a.mu.Unlock()
@ -436,6 +455,8 @@ func (a *StringArray) Reverse() *StringArray {
}
// Join array elements with a string.
//
// 使用glue字符串串连当前数组的元素项，构造成新的字符串返回。
func (a *StringArray) Join(glue string) string {
a.mu.RLock()
defer a.mu.RUnlock()

40
g/container/garray/garray_sorted_int.go
View File

@ -19,14 +19,21 @@ import (
// 默认按照从小到大进行排序
type SortedIntArray struct {
mu *rwmutex.RWMutex // 互斥锁
cap int // 初始化设置的数组容量
array []int // 底层数组
unique *gtype.Bool // 是否要求不能重复(默认false)
compareFunc func(v1, v2 int) int // 比较函数，返回值 -1: v1 < v2；0: v1 == v2；1: v1 > v2
}
// 创建一个排序的int数组
func NewSortedIntArray(cap int, unsafe...bool) *SortedIntArray {
// Create an empty sorted array.
// The param <unsafe> used to specify whether using array with un-concurrent-safety,
// which is false in default, means concurrent-safe in default.
//
// 创建一个空的排序数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
func NewSortedIntArray(unsafe...bool) *SortedIntArray {
return NewSortedIntArraySize(0, unsafe...)
}
func NewSortedIntArraySize(cap int, unsafe...bool) *SortedIntArray {
return &SortedIntArray {
mu : rwmutex.New(unsafe...),
array : make([]int, 0, cap),
@ -43,12 +50,8 @@ func NewSortedIntArray(cap int, unsafe...bool) *SortedIntArray {
}
}
func NewSortedIntArrayEmpty(unsafe...bool) *SortedIntArray {
return NewSortedIntArray(0, unsafe...)
}
func NewSortedIntArrayFrom(array []int, unsafe...bool) *SortedIntArray {
a := NewSortedIntArray(0, unsafe...)
a := NewSortedIntArraySize(0, unsafe...)
a.array = array
sort.Ints(a.array)
return a
@ -244,11 +247,22 @@ func (a *SortedIntArray) Unique() *SortedIntArray {
return a
}
// Return a new array, which is a copy of current array.
//
// 克隆当前数组，返回当前数组的一个拷贝。
func (a *SortedIntArray) Clone() (newArray *SortedIntArray) {
a.mu.RLock()
array := make([]int, len(a.array))
copy(array, a.array)
a.mu.RUnlock()
return NewSortedIntArrayFrom(array, !a.mu.IsSafe())
}
// 清空数据数组
func (a *SortedIntArray) Clear() *SortedIntArray {
a.mu.Lock()
if len(a.array) > 0 {
a.array = make([]int, 0, a.cap)
a.array = make([]int, 0)
}
a.mu.Unlock()
return a
@ -284,6 +298,8 @@ func (a *SortedIntArray) Merge(array *SortedIntArray) *SortedIntArray {
}
// Chunks an array into arrays with size elements. The last chunk may contain less than size elements.
//
// 将一个数组分割成多个数组，其中每个数组的单元数目由size决定。最后一个数组的单元数目可能会少于size个。
func (a *SortedIntArray) Chunk(size int) [][]int {
if size < 1 {
panic("size: cannot be less than 1")
@ -306,6 +322,8 @@ func (a *SortedIntArray) Chunk(size int) [][]int {
// Extract a slice of the array(If in concurrent safe usage, it returns a copy of the slice; else a pointer).
// It returns the sequence of elements from the array array as specified by the offset and length parameters.
//
// 返回根据offset和size参数所指定的数组中的一段序列。
func (a *SortedIntArray) SubSlice(offset, size int) []int {
a.mu.RLock()
defer a.mu.RUnlock()
@ -325,6 +343,8 @@ func (a *SortedIntArray) SubSlice(offset, size int) []int {
}
// Picks one or more random entries out of an array(a copy), and returns the key (or keys) of the random entries.
//
// 从数组中随机取出size个元素项，构成slice返回。
func (a *SortedIntArray) Rand(size int) []int {
a.mu.RLock()
defer a.mu.RUnlock()
@ -342,6 +362,8 @@ func (a *SortedIntArray) Rand(size int) []int {
}
// Join array elements with a string.
//
// 使用glue字符串串连当前数组的元素项，构造成新的字符串返回。
func (a *SortedIntArray) Join(glue string) string {
a.mu.RLock()
defer a.mu.RUnlock()

47
g/container/garray/garray_sorted_interface.go
View File

@ -19,13 +19,29 @@ import (
// 默认按照从小到大进行排序
type SortedArray struct {
mu *rwmutex.RWMutex // 互斥锁
cap int // 初始化设置的数组容量
array []interface{} // 底层数组
unique *gtype.Bool // 是否要求不能重复
compareFunc func(v1, v2 interface{}) int // 比较函数，返回值 -1: v1 < v2；0: v1 == v2；1: v1 > v2
}
func NewSortedArray(cap int, compareFunc func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
// Create an empty sorted array.
// The param <unsafe> used to specify whether using array with un-concurrent-safety,
// which is false in default, means concurrent-safe in default.
// The param <compareFunc> used to compare values to sort in array,
// if it returns value < 0, means v1 < v2;
// if it returns value = 0, means v1 = v2;
// if it returns value > 0, means v1 > v2;
//
// 创建一个空的排序数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
// 参数compareFunc用于指定排序方法：
// 如果返回值 < 0, 表示 v1 < v2;
// 如果返回值 = 0, 表示 v1 = v2;
// 如果返回值 > 0, 表示 v1 > v2;
func NewSortedArray(compareFunc func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
return NewSortedArraySize(0, compareFunc, unsafe...)
}
func NewSortedArraySize(cap int, compareFunc func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
return &SortedArray{
mu : rwmutex.New(unsafe...),
unique : gtype.NewBool(),
@ -34,12 +50,8 @@ func NewSortedArray(cap int, compareFunc func(v1, v2 interface{}) int, unsafe...
}
}
func NewSortedArrayEmpty(compareFunc func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
return NewSortedArray(0, compareFunc, unsafe...)
}
func NewSortedArrayFrom(array []interface{}, compareFunc func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
a := NewSortedArray(0, compareFunc, unsafe...)
a := NewSortedArraySize(0, compareFunc, unsafe...)
a.array = array
sort.Slice(a.array, func(i, j int) bool {
return a.compareFunc(a.array[i], a.array[j]) < 0
@ -243,11 +255,22 @@ func (a *SortedArray) Unique() *SortedArray {
return a
}
// Return a new array, which is a copy of current array.
//
// 克隆当前数组，返回当前数组的一个拷贝。
func (a *SortedArray) Clone() (newArray *SortedArray) {
a.mu.RLock()
array := make([]interface{}, len(a.array))
copy(array, a.array)
a.mu.RUnlock()
return NewSortedArrayFrom(array, a.compareFunc, !a.mu.IsSafe())
}
// 清空数据数组
func (a *SortedArray) Clear() *SortedArray {
a.mu.Lock()
if len(a.array) > 0 {
a.array = make([]interface{}, 0, a.cap)
a.array = make([]interface{}, 0)
}
a.mu.Unlock()
return a
@ -285,6 +308,8 @@ func (a *SortedArray) Merge(array *SortedArray) *SortedArray {
}
// Chunks an array into arrays with size elements. The last chunk may contain less than size elements.
//
// 将一个数组分割成多个数组，其中每个数组的单元数目由size决定。最后一个数组的单元数目可能会少于size个。
func (a *SortedArray) Chunk(size int) [][]interface{} {
if size < 1 {
panic("size: cannot be less than 1")
@ -307,6 +332,8 @@ func (a *SortedArray) Chunk(size int) [][]interface{} {
// Extract a slice of the array(If in concurrent safe usage, it returns a copy of the slice; else a pointer).
// It returns the sequence of elements from the array array as specified by the offset and length parameters.
//
// 返回根据offset和size参数所指定的数组中的一段序列。
func (a *SortedArray) SubSlice(offset, size int) []interface{} {
a.mu.RLock()
defer a.mu.RUnlock()
@ -326,6 +353,8 @@ func (a *SortedArray) SubSlice(offset, size int) []interface{} {
}
// Picks one or more random entries out of an array(a copy), and returns the key (or keys) of the random entries.
//
// 从数组中随机取出size个元素项，构成slice返回。
func (a *SortedArray) Rand(size int) []interface{} {
a.mu.RLock()
defer a.mu.RUnlock()
@ -343,6 +372,8 @@ func (a *SortedArray) Rand(size int) []interface{} {
}
// Join array elements with a string.
//
// 使用glue字符串串连当前数组的元素项，构造成新的字符串返回。
func (a *SortedArray) Join(glue string) string {
a.mu.RLock()
defer a.mu.RUnlock()

39
g/container/garray/garray_sorted_string.go
View File

@ -19,13 +19,21 @@ import (
// 默认按照从小到大进行排序
type SortedStringArray struct {
mu *rwmutex.RWMutex // 互斥锁
cap int // 初始化设置的数组容量
array []string // 底层数组
unique *gtype.Bool // 是否要求不能重复
compareFunc func(v1, v2 string) int // 比较函数，返回值 -1: v1 < v2；0: v1 == v2；1: v1 > v2
}
func NewSortedStringArray(cap int, unsafe...bool) *SortedStringArray {
// Create an empty sorted array.
// The param <unsafe> used to specify whether using array with un-concurrent-safety,
// which is false in default, means concurrent-safe in default.
//
// 创建一个空的排序数组对象，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
func NewSortedStringArray(unsafe...bool) *SortedStringArray {
return NewSortedStringArraySize(0, unsafe...)
}
func NewSortedStringArraySize(cap int, unsafe...bool) *SortedStringArray {
return &SortedStringArray {
mu : rwmutex.New(unsafe...),
array : make([]string, 0, cap),
@ -36,12 +44,8 @@ func NewSortedStringArray(cap int, unsafe...bool) *SortedStringArray {
}
}
func NewSortedStringArrayEmpty(unsafe...bool) *SortedStringArray {
return NewSortedStringArray(0, unsafe...)
}
func NewSortedStringArrayFrom(array []string, unsafe...bool) *SortedStringArray {
a := NewSortedStringArray(0, unsafe...)
a := NewSortedStringArraySize(0, unsafe...)
a.array = array
sort.Strings(a.array)
return a
@ -237,11 +241,22 @@ func (a *SortedStringArray) Unique() *SortedStringArray {
return a
}
// Return a new array, which is a copy of current array.
//
// 克隆当前数组，返回当前数组的一个拷贝。
func (a *SortedStringArray) Clone() (newArray *SortedStringArray) {
a.mu.RLock()
array := make([]string, len(a.array))
copy(array, a.array)
a.mu.RUnlock()
return NewSortedStringArrayFrom(array, !a.mu.IsSafe())
}
// 清空数据数组
func (a *SortedStringArray) Clear() *SortedStringArray {
a.mu.Lock()
if len(a.array) > 0 {
a.array = make([]string, 0, a.cap)
a.array = make([]string, 0)
}
a.mu.Unlock()
return a
@ -277,6 +292,8 @@ func (a *SortedStringArray) Merge(array *SortedStringArray) *SortedStringArray {
}
// Chunks an array into arrays with size elements. The last chunk may contain less than size elements.
//
// 将一个数组分割成多个数组，其中每个数组的单元数目由size决定。最后一个数组的单元数目可能会少于size个。
func (a *SortedStringArray) Chunk(size int) [][]string {
if size < 1 {
panic("size: cannot be less than 1")
@ -299,6 +316,8 @@ func (a *SortedStringArray) Chunk(size int) [][]string {
// Extract a slice of the array(If in concurrent safe usage, it returns a copy of the slice; else a pointer).
// It returns the sequence of elements from the array array as specified by the offset and length parameters.
//
// 返回根据offset和size参数所指定的数组中的一段序列。
func (a *SortedStringArray) SubSlice(offset, size int) []string {
a.mu.RLock()
defer a.mu.RUnlock()
@ -318,6 +337,8 @@ func (a *SortedStringArray) SubSlice(offset, size int) []string {
}
// Picks one or more random entries out of an array(a copy), and returns the key (or keys) of the random entries.
//
// 从数组中随机取出size个元素项，构成slice返回。
func (a *SortedStringArray) Rand(size int) []string {
a.mu.RLock()
defer a.mu.RUnlock()
@ -335,6 +356,8 @@ func (a *SortedStringArray) Rand(size int) []string {
}
// Join array elements with a string.
//
// 使用glue字符串串连当前数组的元素项，构造成新的字符串返回。
func (a *SortedStringArray) Join(glue string) string {
a.mu.RLock()
defer a.mu.RUnlock()

2
g/container/garray/garray_z_bench_test.go
View File

@ -14,7 +14,7 @@ import (
)
var (
sortedIntArray = garray.NewSortedIntArray(0)
sortedIntArray = garray.NewSortedIntArray()
)
func BenchmarkSortedIntArray_Add(b *testing.B) {

14
g/container/garray/garray_z_unit_basic_test.go
View File

@ -18,7 +18,7 @@ import (
func Test_IntArray_Unique(t *testing.T) {
expect := []int{1, 2, 3, 4, 5, 6}
array := garray.NewIntArray(0, 0)
array := garray.NewIntArray()
array.Append(1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6)
array.Unique()
gtest.Assert(array.Slice(), expect)
@ -26,7 +26,7 @@ func Test_IntArray_Unique(t *testing.T) {
func Test_SortedIntArray1(t *testing.T) {
expect := []int{0,1,2,3,4,5,6,7,8,9,10}
array := garray.NewSortedIntArray(0)
array := garray.NewSortedIntArray()
for i := 10; i > -1; i-- {
array.Add(i)
}
@ -35,7 +35,7 @@ func Test_SortedIntArray1(t *testing.T) {
func Test_SortedIntArray2(t *testing.T) {
expect := []int{0,1,2,3,4,5,6,7,8,9,10}
array := garray.NewSortedIntArray(0)
array := garray.NewSortedIntArray()
for i := 0; i <= 10; i++ {
array.Add(i)
}
@ -44,7 +44,7 @@ func Test_SortedIntArray2(t *testing.T) {
func Test_SortedStringArray1(t *testing.T) {
expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
array := garray.NewSortedStringArray(0)
array := garray.NewSortedStringArray()
for i := 10; i > -1; i-- {
array.Add(gconv.String(i))
}
@ -53,7 +53,7 @@ func Test_SortedStringArray1(t *testing.T) {
func Test_SortedStringArray2(t *testing.T) {
expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
array := garray.NewSortedStringArray(0)
array := garray.NewSortedStringArray()
for i := 0; i <= 10; i++ {
array.Add(gconv.String(i))
}
@ -62,7 +62,7 @@ func Test_SortedStringArray2(t *testing.T) {
func Test_SortedArray1(t *testing.T) {
expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
array := garray.NewSortedArray(0, func(v1, v2 interface{}) int {
array := garray.NewSortedArray(func(v1, v2 interface{}) int {
return strings.Compare(gconv.String(v1), gconv.String(v2))
})
for i := 10; i > -1; i-- {
@ -73,7 +73,7 @@ func Test_SortedArray1(t *testing.T) {
func Test_SortedArray2(t *testing.T) {
expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
array := garray.NewSortedArray(0, func(v1, v2 interface{}) int {
array := garray.NewSortedArray(func(v1, v2 interface{}) int {
return strings.Compare(gconv.String(v1), gconv.String(v2))
})
for i := 0; i <= 10; i++ {

2
g/container/garray/garray_z_unit_int_test.go
View File

@ -42,7 +42,7 @@ func TestIntArray_Sort(t *testing.T) {
gtest.Case(t, func() {
expect1 := []int{0, 1, 2, 3}
expect2 := []int{3, 2, 1, 0}
array := garray.NewIntArray(0, 0)
array := garray.NewIntArray()
for i := 3; i >= 0; i-- {
array.Append(i)
}

2
g/container/garray/garray_z_unit_interface_test.go
View File

@ -42,7 +42,7 @@ func TestArray_Sort(t *testing.T) {
gtest.Case(t, func() {
expect1 := []interface{}{0, 1, 2, 3}
expect2 := []interface{}{3, 2, 1, 0}
array := garray.NewArray(0, 0)
array := garray.NewArray()
for i := 3; i >= 0; i-- {
array.Append(i)
}

2
g/container/garray/garray_z_unit_string_test.go
View File

@ -43,7 +43,7 @@ func TestStringArray_Sort(t *testing.T) {
gtest.Case(t, func() {
expect1 := []string{"0", "1", "2", "3"}
expect2 := []string{"3", "2", "1", "0"}
array := garray.NewStringArray(0, 0)
array := garray.NewStringArray()
for i := 3; i >= 0; i-- {
array.Append(gconv.String(i))
}

4
g/container/gset/gset_z_unit_int_test.go
View File

@ -41,8 +41,8 @@ func TestIntSet_Iterator(t *testing.T) {
s.Add(1).Add(2).Add(3)
gtest.Assert(s.Size(), 3)
a1 := garray.New(0, 0)
a2 := garray.New(0, 0)
a1 := garray.New()
a2 := garray.New()
s.Iterator(func(v int) bool {
a1.Append(1)
return false

4
g/container/gset/gset_z_unit_string_test.go
View File

@ -41,8 +41,8 @@ func TestStringSet_Iterator(t *testing.T) {
s.Add("1").Add("2").Add("3")
gtest.Assert(s.Size(), 3)
a1 := garray.New(0, 0)
a2 := garray.New(0, 0)
a1 := garray.New()
a2 := garray.New()
s.Iterator(func(v string) bool {
a1.Append("1")
return false

4
g/container/gset/gset_z_unit_test.go
View File

@ -41,8 +41,8 @@ func TestSet_Iterator(t *testing.T) {
s.Add(1).Add(2).Add(3)
gtest.Assert(s.Size(), 3)
a1 := garray.New(0, 0)
a2 := garray.New(0, 0)
a1 := garray.New()
a2 := garray.New()
s.Iterator(func(v interface{}) bool {
a1.Append(1)
return false

2
g/net/ghttp/ghttp_server.go
View File

@ -309,7 +309,7 @@ func (s *Server) GetRouteMap() string {
}
if _, ok := m[item.domain]; !ok {
// 注意排序函数的逻辑
m[item.domain] = garray.NewSortedArray(100, func(v1, v2 interface{}) int {
m[item.domain] = garray.NewSortedArraySize(100, func(v1, v2 interface{}) int {
item1 := v1.(*tableItem)
item2 := v2.(*tableItem)
r := 0

2
g/net/ghttp/ghttp_server_config_static.go
View File

@ -108,7 +108,7 @@ func (s *Server) AddStaticPath(prefix string, path string) {
// 先添加item
s.config.StaticPaths = append(s.config.StaticPaths, addItem)
// 按照prefix从长到短进行排序
array := garray.NewSortedArray(0, func(v1, v2 interface{}) int {
array := garray.NewSortedArray(func(v1, v2 interface{}) int {
s1 := gconv.String(v1)
s2 := gconv.String(v2)
r := len(s2) - len(s1)

2
g/os/gcfg/gcfg.go
View File

@ -45,7 +45,7 @@ func New(path string, file...string) *Config {
}
c := &Config {
name : gtype.NewString(name),
paths : garray.NewStringArray(0, 1),
paths : garray.NewStringArray(),
jsons : gmap.NewStringInterfaceMap(),
vc : gtype.NewBool(),
}

2
g/os/gcron/gcron_cron.go
View File

@ -159,7 +159,7 @@ func (c *Cron) Size() int {
// 获取所有已注册的定时任务项(按照注册时间从小到大进行排序)
func (c *Cron) Entries() []*Entry {
array := garray.NewSortedArray(c.entries.Size(), func(v1, v2 interface{}) int {
array := garray.NewSortedArraySize(c.entries.Size(), func(v1, v2 interface{}) int {
entry1 := v1.(*Entry)
entry2 := v2.(*Entry)
if entry1.Time.Nanosecond() > entry2.Time.Nanosecond() {

16
g/os/gcron/gcron_unit_1_test.go
View File

@ -18,7 +18,7 @@ import (
func TestCron_Add_Close(t *testing.T) {
gtest.Case(t, func() {
cron := gcron.New()
array := garray.New(0, 0)
array := garray.New()
_, err1 := cron.Add("* * * * * *", func() {
//glog.Println("cron1")
array.Append(1)
@ -92,7 +92,7 @@ func TestCron_AddSingleton(t *testing.T) {
// keep this
gtest.Case(t, func() {
cron := gcron.New()
array := garray.New(0, 0)
array := garray.New()
cron.AddSingleton("* * * * * *", func() {
array.Append(1)
time.Sleep(50*time.Second)
@ -107,7 +107,7 @@ func TestCron_AddSingleton(t *testing.T) {
func TestCron_AddOnce(t *testing.T) {
gtest.Case(t, func() {
cron := gcron.New()
array := garray.New(0, 0)
array := garray.New()
cron.AddOnce("* * * * * *", func() {
array.Append(1)
})
@ -124,7 +124,7 @@ func TestCron_AddOnce(t *testing.T) {
func TestCron_AddTimes(t *testing.T) {
gtest.Case(t, func() {
cron := gcron.New()
array := garray.New(0, 0)
array := garray.New()
cron.AddTimes("* * * * * *", 2, func() {
array.Append(1)
})
@ -137,7 +137,7 @@ func TestCron_AddTimes(t *testing.T) {
func TestCron_DelayAdd(t *testing.T) {
gtest.Case(t, func() {
cron := gcron.New()
array := garray.New(0, 0)
array := garray.New()
cron.DelayAdd(500*time.Millisecond, "* * * * * *", func() {
array.Append(1)
})
@ -154,7 +154,7 @@ func TestCron_DelayAdd(t *testing.T) {
func TestCron_DelayAddSingleton(t *testing.T) {
gtest.Case(t, func() {
cron := gcron.New()
array := garray.New(0, 0)
array := garray.New()
cron.DelayAddSingleton(500*time.Millisecond, "* * * * * *", func() {
array.Append(1)
time.Sleep(10*time.Second)
@ -169,7 +169,7 @@ func TestCron_DelayAddSingleton(t *testing.T) {
func TestCron_DelayAddOnce(t *testing.T) {
gtest.Case(t, func() {
cron := gcron.New()
array := garray.New(0, 0)
array := garray.New()
cron.DelayAddOnce(500*time.Millisecond, "* * * * * *", func() {
array.Append(1)
})
@ -186,7 +186,7 @@ func TestCron_DelayAddOnce(t *testing.T) {
func TestCron_DelayAddTimes(t *testing.T) {
gtest.Case(t, func() {
cron := gcron.New()
array := garray.New(0, 0)
array := garray.New()
cron.DelayAddTimes(500*time.Millisecond, "* * * * * *", 2, func() {
array.Append(1)
})

4
g/os/gcron/gcron_unit_2_test.go
View File

@ -21,7 +21,7 @@ func TestCron_Entry_Operations(t *testing.T) {
gtest.Case(t, func() {
cron := gcron.New()
array := garray.New(0, 0)
array := garray.New()
cron.DelayAddTimes(500*time.Millisecond, "* * * * * *", 2, func() {
glog.Println("add times")
array.Append(1)
@ -36,7 +36,7 @@ func TestCron_Entry_Operations(t *testing.T) {
})
cron := gcron.New()
array := garray.New(0, 0)
array := garray.New()
entry, err1 := cron.Add("* * * * * *", func() {
glog.Println("add")
array.Append(1)

6
g/os/gmlock/gmlock_unit_lock_test.go
View File

@ -17,7 +17,7 @@ import (
func TestLocker_Lock_Unlock(t *testing.T) {
gtest.Case(t, func() {
key := "test1"
array := garray.New(0, 0)
array := garray.New()
go func() {
gmlock.Lock(key)
array.Append(1)
@ -47,7 +47,7 @@ func TestLocker_Lock_Unlock(t *testing.T) {
func TestLocker_Lock_Expire(t *testing.T) {
gtest.Case(t, func() {
key := "test2"
array := garray.New(0, 0)
array := garray.New()
go func() {
gmlock.Lock(key, 100*time.Millisecond)
array.Append(1)
@ -69,7 +69,7 @@ func TestLocker_Lock_Expire(t *testing.T) {
func TestLocker_TryLock_Expire(t *testing.T) {
gtest.Case(t, func() {
key := "test3"
array := garray.New(0, 0)
array := garray.New()
go func() {
gmlock.Lock(key, 200*time.Millisecond)
array.Append(1)

4
g/os/gmlock/gmlock_unit_rlock_test.go
View File

@ -17,7 +17,7 @@ import (
func TestLocker_RLock1(t *testing.T) {
gtest.Case(t, func() {
key := "test100"
array := garray.New(0, 0)
array := garray.New()
go func() {
gmlock.RLock(key)
array.Append(1)
@ -41,7 +41,7 @@ func TestLocker_RLock1(t *testing.T) {
func TestLocker_RLock2(t *testing.T) {
gtest.Case(t, func() {
key := "test200"
array := garray.New(0, 0)
array := garray.New()
go func() {
gmlock.Lock(key)
array.Append(1)

2
g/os/gspath/gspath.go
View File

@ -43,7 +43,7 @@ var (
// 创建一个搜索对象
func New(path...string) *SPath {
sp := &SPath {
paths : garray.NewStringArray(0, 1),
paths : garray.NewStringArray(),
cache : gmap.NewStringStringMap(),
}
if len(path) > 0 {

20
g/os/gtimer/gtimer_z_unit_0_test.go
View File

@ -19,7 +19,7 @@ import (
func TestSetTimeout(t *testing.T) {
gtest.Case(t, func() {
array := garray.New(0, 0)
array := garray.New()
gtimer.SetTimeout(200*time.Millisecond, func() {
array.Append(1)
})
@ -30,7 +30,7 @@ func TestSetTimeout(t *testing.T) {
func TestSetInterval(t *testing.T) {
gtest.Case(t, func() {
array := garray.New(0, 0)
array := garray.New()
gtimer.SetInterval(200*time.Millisecond, func() {
array.Append(1)
})
@ -41,7 +41,7 @@ func TestSetInterval(t *testing.T) {
func TestAddEntry(t *testing.T) {
gtest.Case(t, func() {
array := garray.New(0, 0)
array := garray.New()
gtimer.AddEntry(200*time.Millisecond, func() {
array.Append(1)
}, false, 2, gtimer.STATUS_READY)
@ -52,7 +52,7 @@ func TestAddEntry(t *testing.T) {
func TestAddSingleton(t *testing.T) {
gtest.Case(t, func() {
array := garray.New(0, 0)
array := garray.New()
gtimer.AddSingleton(200*time.Millisecond, func() {
array.Append(1)
time.Sleep(10000*time.Millisecond)
@ -64,7 +64,7 @@ func TestAddSingleton(t *testing.T) {
func TestAddTimes(t *testing.T) {
gtest.Case(t, func() {
array := garray.New(0, 0)
array := garray.New()
gtimer.AddTimes(200*time.Millisecond, 2, func() {
array.Append(1)
})
@ -75,7 +75,7 @@ func TestAddTimes(t *testing.T) {
func TestDelayAdd(t *testing.T) {
gtest.Case(t, func() {
array := garray.New(0, 0)
array := garray.New()
gtimer.DelayAdd(200*time.Millisecond, 200*time.Millisecond, func() {
array.Append(1)
})
@ -88,7 +88,7 @@ func TestDelayAdd(t *testing.T) {
func TestDelayAddEntry(t *testing.T) {
gtest.Case(t, func() {
array := garray.New(0, 0)
array := garray.New()
gtimer.DelayAddEntry(200*time.Millisecond, 200*time.Millisecond, func() {
array.Append(1)
}, false, 2, gtimer.STATUS_READY)
@ -101,7 +101,7 @@ func TestDelayAddEntry(t *testing.T) {
func TestDelayAddSingleton(t *testing.T) {
gtest.Case(t, func() {
array := garray.New(0, 0)
array := garray.New()
gtimer.DelayAddSingleton(200*time.Millisecond, 200*time.Millisecond, func() {
array.Append(1)
time.Sleep(10000*time.Millisecond)
@ -115,7 +115,7 @@ func TestDelayAddSingleton(t *testing.T) {
func TestDelayAddOnce(t *testing.T) {
gtest.Case(t, func() {
array := garray.New(0, 0)
array := garray.New()
gtimer.DelayAddOnce(200*time.Millisecond, 200*time.Millisecond, func() {
array.Append(1)
})
@ -128,7 +128,7 @@ func TestDelayAddOnce(t *testing.T) {
func TestDelayAddTimes(t *testing.T) {
gtest.Case(t, func() {
array := garray.New(0, 0)
array := garray.New()
gtimer.DelayAddTimes(200*time.Millisecond, 200*time.Millisecond, 2, func() {
array.Append(1)
})

26
g/os/gtimer/gtimer_z_unit_1_test.go
View File

@ -24,7 +24,7 @@ func New() *gtimer.Timer {
func TestTimer_Add_Close(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
//fmt.Println("start", time.Now())
timer.Add(200*time.Millisecond, func() {
//fmt.Println("entry1", time.Now())
@ -53,7 +53,7 @@ func TestTimer_Add_Close(t *testing.T) {
func TestTimer_Start_Stop_Close(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
timer.Add(200*time.Millisecond, func() {
//glog.Println("add...")
array.Append(1)
@ -76,7 +76,7 @@ func TestTimer_Start_Stop_Close(t *testing.T) {
func TestTimer_AddSingleton(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
timer.AddSingleton(200*time.Millisecond, func() {
array.Append(1)
time.Sleep(10*time.Second)
@ -92,7 +92,7 @@ func TestTimer_AddSingleton(t *testing.T) {
func TestTimer_AddOnce(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
timer.AddOnce(200*time.Millisecond, func() {
array.Append(1)
})
@ -114,7 +114,7 @@ func TestTimer_AddOnce(t *testing.T) {
func TestTimer_AddTimes(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
timer.AddTimes(200*time.Millisecond, 2, func() {
array.Append(1)
})
@ -126,7 +126,7 @@ func TestTimer_AddTimes(t *testing.T) {
func TestTimer_DelayAdd(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
timer.DelayAdd(200*time.Millisecond, 200*time.Millisecond, func() {
array.Append(1)
})
@ -140,7 +140,7 @@ func TestTimer_DelayAdd(t *testing.T) {
func TestTimer_DelayAddEntry(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
timer.DelayAddEntry(200*time.Millisecond, 200*time.Millisecond, func() {
array.Append(1)
}, false, 100, gtimer.STATUS_READY)
@ -154,7 +154,7 @@ func TestTimer_DelayAddEntry(t *testing.T) {
func TestTimer_DelayAddSingleton(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
timer.DelayAddSingleton(200*time.Millisecond, 200*time.Millisecond, func() {
array.Append(1)
time.Sleep(10*time.Second)
@ -170,7 +170,7 @@ func TestTimer_DelayAddSingleton(t *testing.T) {
func TestTimer_DelayAddOnce(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
timer.DelayAddOnce(200*time.Millisecond, 200*time.Millisecond, func() {
array.Append(1)
})
@ -188,7 +188,7 @@ func TestTimer_DelayAddOnce(t *testing.T) {
func TestTimer_DelayAddTimes(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
timer.DelayAddTimes(200*time.Millisecond, 500*time.Millisecond, 2, func() {
array.Append(1)
})
@ -209,7 +209,7 @@ func TestTimer_DelayAddTimes(t *testing.T) {
func TestTimer_AddLessThanInterval(t *testing.T) {
gtest.Case(t, func() {
timer := gtimer.New(10, 100*time.Millisecond)
array := garray.New(0, 0)
array := garray.New()
timer.Add(20*time.Millisecond, func() {
array.Append(1)
})
@ -227,7 +227,7 @@ func TestTimer_AddLessThanInterval(t *testing.T) {
func TestTimer_AddLeveledEntry1(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
//glog.Println("start")
timer.DelayAdd(1000*time.Millisecond, 1001*time.Millisecond, func() {
//glog.Println("add")
@ -244,7 +244,7 @@ func TestTimer_AddLeveledEntry1(t *testing.T) {
func TestTimer_Exit(t *testing.T) {
gtest.Case(t, func() {
timer := New()
array := garray.New(0, 0)
array := garray.New()
timer.Add(200*time.Millisecond, func() {
array.Append(1)
gtimer.Exit()

8
g/os/gtimer/gtimer_z_unit_2_test.go
View File

@ -18,7 +18,7 @@ import (
func TestEntry_Start_Stop_Close(t *testing.T) {
timer := New()
array := garray.New(0, 0)
array := garray.New()
entry := timer.Add(200*time.Millisecond, func() {
array.Append(1)
})
@ -39,7 +39,7 @@ func TestEntry_Start_Stop_Close(t *testing.T) {
func TestEntry_Singleton(t *testing.T) {
timer := New()
array := garray.New(0, 0)
array := garray.New()
entry := timer.Add(200*time.Millisecond, func() {
array.Append(1)
time.Sleep(10*time.Second)
@ -56,7 +56,7 @@ func TestEntry_Singleton(t *testing.T) {
func TestEntry_SetTimes(t *testing.T) {
timer := New()
array := garray.New(0, 0)
array := garray.New()
entry := timer.Add(200*time.Millisecond, func() {
array.Append(1)
})
@ -67,7 +67,7 @@ func TestEntry_SetTimes(t *testing.T) {
func TestEntry_Run(t *testing.T) {
timer := New()
array := garray.New(0, 0)
array := garray.New()
entry := timer.Add(1000*time.Millisecond, func() {
array.Append(1)
})

2
g/os/gview/gview.go
View File

@ -70,7 +70,7 @@ func ParseContent(content string, params Params) ([]byte, error) {
// 生成一个视图对象
func New(path...string) *View {
view := &View {
paths : garray.NewStringArray(0, 1),
paths : garray.NewStringArray(),
data : make(map[string]interface{}),
funcmap : make(map[string]interface{}),
delimiters : make([]string, 2),

2
geg/container/garray/garray1.go
View File

@ -8,7 +8,7 @@ import (
func main () {
// 创建普通的int类型数组，并关闭默认的并发安全特性
a := garray.NewIntArray(0, 0, false)
a := garray.NewIntArray(true)
// 添加数据项
for i := 0; i < 10; i++ {

2
geg/container/garray/garray2.go
View File

@ -8,7 +8,7 @@ import (
func main () {
// 自定义排序数组，降序排序(SortedIntArray管理的数据是升序)
a := garray.NewSortedArray(0, 0, func(v1, v2 interface{}) int {
a := garray.NewSortedArray(func(v1, v2 interface{}) int {
if v1.(int) < v2.(int) {
return 1
}

2
geg/container/garray/garray_slice_safe.go
View File

@ -7,7 +7,7 @@ import (
func main () {
a := garray.NewIntArray(0, 0)
a := garray.NewIntArray()
a.Append(1, 2, 3)
v := a.Slice()

2
geg/container/garray/sorted_string_array1.go
View File

@ -6,7 +6,7 @@ import (
)
func main() {
array := garray.NewSortedStringArray(0, false)
array := garray.NewSortedStringArray()
array.Add("1")
array.Add("2")
array.Add("3")

2
geg/container/garray/sorted_string_array2.go
View File

@ -8,7 +8,7 @@ import (
)
func main() {
array := garray.NewSortedStringArray(0, false)
array := garray.NewSortedStringArray()
array.Add("/api/ctl/show")
array.Add("/api/ctl/post")
array.Add("/api/obj/rest")