From f7850e3ed38876e5b2bb65e7c50d7020ed6f44cb Mon Sep 17 00:00:00 2001 From: John Date: Tue, 7 Apr 2020 11:29:42 +0800 Subject: [PATCH] improve package garray --- container/garray/garray_normal_any.go | 17 ++++--- container/garray/garray_normal_int.go | 17 ++++--- container/garray/garray_normal_str.go | 17 ++++--- container/garray/garray_sorted_any.go | 45 +++++++++++-------- container/garray/garray_sorted_int.go | 43 ++++++++++-------- container/garray/garray_sorted_str.go | 39 +++++++++------- .../garray/garray_z_unit_all_basic_test.go | 29 ++++++++++++ internal/rwmutex/rwmutex.go | 10 ++++- 8 files changed, 137 insertions(+), 80 deletions(-) diff --git a/container/garray/garray_normal_any.go b/container/garray/garray_normal_any.go index 12d952585..bb1d2edb6 100644 --- a/container/garray/garray_normal_any.go +++ b/container/garray/garray_normal_any.go @@ -23,7 +23,7 @@ import ( // Array is a golang array with rich features. type Array struct { - mu *rwmutex.RWMutex + mu rwmutex.RWMutex array []interface{} } @@ -44,7 +44,7 @@ func NewArray(safe ...bool) *Array { // which is false in default. func NewArraySize(size int, cap int, safe ...bool) *Array { return &Array{ - mu: rwmutex.New(safe...), + mu: rwmutex.Create(safe...), array: make([]interface{}, size, cap), } } @@ -79,7 +79,7 @@ func NewFromCopy(array []interface{}, safe ...bool) *Array { // which is false in default. func NewArrayFrom(array []interface{}, safe ...bool) *Array { return &Array{ - mu: rwmutex.New(safe...), + mu: rwmutex.Create(safe...), array: array, } } @@ -91,7 +91,7 @@ func NewArrayFromCopy(array []interface{}, safe ...bool) *Array { newArray := make([]interface{}, len(array)) copy(newArray, array) return &Array{ - mu: rwmutex.New(safe...), + mu: rwmutex.Create(safe...), array: newArray, } } @@ -668,6 +668,9 @@ func (a *Array) Reverse() *Array { func (a *Array) Join(glue string) string { a.mu.RLock() defer a.mu.RUnlock() + if len(a.array) == 0 { + return "" + } buffer := bytes.NewBuffer(nil) for k, v := range a.array { buffer.WriteString(gconv.String(v)) @@ -749,8 +752,7 @@ func (a *Array) MarshalJSON() ([]byte, error) { // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal. func (a *Array) UnmarshalJSON(b []byte) error { - if a.mu == nil { - a.mu = rwmutex.New() + if a.array == nil { a.array = make([]interface{}, 0) } a.mu.Lock() @@ -763,9 +765,6 @@ func (a *Array) UnmarshalJSON(b []byte) error { // UnmarshalValue is an interface implement which sets any type of value for array. func (a *Array) UnmarshalValue(value interface{}) error { - if a.mu == nil { - a.mu = rwmutex.New() - } a.mu.Lock() defer a.mu.Unlock() switch value.(type) { diff --git a/container/garray/garray_normal_int.go b/container/garray/garray_normal_int.go index ecaa20c3f..8ba0cd26d 100644 --- a/container/garray/garray_normal_int.go +++ b/container/garray/garray_normal_int.go @@ -21,7 +21,7 @@ import ( // IntArray is a golang int array with rich features. type IntArray struct { - mu *rwmutex.RWMutex + mu rwmutex.RWMutex array []int } @@ -37,7 +37,7 @@ func NewIntArray(safe ...bool) *IntArray { // which is false in default. func NewIntArraySize(size int, cap int, safe ...bool) *IntArray { return &IntArray{ - mu: rwmutex.New(safe...), + mu: rwmutex.Create(safe...), array: make([]int, size, cap), } } @@ -62,7 +62,7 @@ func NewIntArrayRange(start, end, step int, safe ...bool) *IntArray { // which is false in default. func NewIntArrayFrom(array []int, safe ...bool) *IntArray { return &IntArray{ - mu: rwmutex.New(safe...), + mu: rwmutex.Create(safe...), array: array, } } @@ -74,7 +74,7 @@ func NewIntArrayFromCopy(array []int, safe ...bool) *IntArray { newArray := make([]int, len(array)) copy(newArray, array) return &IntArray{ - mu: rwmutex.New(safe...), + mu: rwmutex.Create(safe...), array: newArray, } } @@ -670,6 +670,9 @@ func (a *IntArray) Reverse() *IntArray { func (a *IntArray) Join(glue string) string { a.mu.RLock() defer a.mu.RUnlock() + if len(a.array) == 0 { + return "" + } buffer := bytes.NewBuffer(nil) for k, v := range a.array { buffer.WriteString(gconv.String(v)) @@ -734,8 +737,7 @@ func (a *IntArray) MarshalJSON() ([]byte, error) { // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal. func (a *IntArray) UnmarshalJSON(b []byte) error { - if a.mu == nil { - a.mu = rwmutex.New() + if a.array == nil { a.array = make([]int, 0) } a.mu.Lock() @@ -748,9 +750,6 @@ func (a *IntArray) UnmarshalJSON(b []byte) error { // UnmarshalValue is an interface implement which sets any type of value for array. func (a *IntArray) UnmarshalValue(value interface{}) error { - if a.mu == nil { - a.mu = rwmutex.New() - } a.mu.Lock() defer a.mu.Unlock() switch value.(type) { diff --git a/container/garray/garray_normal_str.go b/container/garray/garray_normal_str.go index 78fc98e0e..1fdde798c 100644 --- a/container/garray/garray_normal_str.go +++ b/container/garray/garray_normal_str.go @@ -23,7 +23,7 @@ import ( // StrArray is a golang string array with rich features. type StrArray struct { - mu *rwmutex.RWMutex + mu rwmutex.RWMutex array []string } @@ -39,7 +39,7 @@ func NewStrArray(safe ...bool) *StrArray { // which is false in default. func NewStrArraySize(size int, cap int, safe ...bool) *StrArray { return &StrArray{ - mu: rwmutex.New(safe...), + mu: rwmutex.Create(safe...), array: make([]string, size, cap), } } @@ -49,7 +49,7 @@ func NewStrArraySize(size int, cap int, safe ...bool) *StrArray { // which is false in default. func NewStrArrayFrom(array []string, safe ...bool) *StrArray { return &StrArray{ - mu: rwmutex.New(safe...), + mu: rwmutex.Create(safe...), array: array, } } @@ -61,7 +61,7 @@ func NewStrArrayFromCopy(array []string, safe ...bool) *StrArray { newArray := make([]string, len(array)) copy(newArray, array) return &StrArray{ - mu: rwmutex.New(safe...), + mu: rwmutex.Create(safe...), array: newArray, } } @@ -661,6 +661,9 @@ func (a *StrArray) Reverse() *StrArray { func (a *StrArray) Join(glue string) string { a.mu.RLock() defer a.mu.RUnlock() + if len(a.array) == 0 { + return "" + } buffer := bytes.NewBuffer(nil) for k, v := range a.array { buffer.WriteString(v) @@ -736,8 +739,7 @@ func (a *StrArray) MarshalJSON() ([]byte, error) { // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal. func (a *StrArray) UnmarshalJSON(b []byte) error { - if a.mu == nil { - a.mu = rwmutex.New() + if a.array == nil { a.array = make([]string, 0) } a.mu.Lock() @@ -750,9 +752,6 @@ func (a *StrArray) UnmarshalJSON(b []byte) error { // UnmarshalValue is an interface implement which sets any type of value for array. func (a *StrArray) UnmarshalValue(value interface{}) error { - if a.mu == nil { - a.mu = rwmutex.New() - } a.mu.Lock() defer a.mu.Unlock() switch value.(type) { diff --git a/container/garray/garray_sorted_any.go b/container/garray/garray_sorted_any.go index b4c3b4e63..61cda678b 100644 --- a/container/garray/garray_sorted_any.go +++ b/container/garray/garray_sorted_any.go @@ -16,7 +16,6 @@ import ( "math" "sort" - "github.com/gogf/gf/container/gtype" "github.com/gogf/gf/internal/rwmutex" "github.com/gogf/gf/util/gconv" "github.com/gogf/gf/util/grand" @@ -25,9 +24,9 @@ import ( // SortedArray is a golang sorted array with rich features. // It's using increasing order in default. type SortedArray struct { - mu *rwmutex.RWMutex + mu rwmutex.RWMutex array []interface{} - unique *gtype.Bool // Whether enable unique feature(false) + unique bool // Whether enable unique feature(false) comparator func(a, b interface{}) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b) } @@ -46,8 +45,7 @@ func NewSortedArray(comparator func(a, b interface{}) int, safe ...bool) *Sorted // which is false in default. func NewSortedArraySize(cap int, comparator func(a, b interface{}) int, safe ...bool) *SortedArray { return &SortedArray{ - mu: rwmutex.New(safe...), - unique: gtype.NewBool(), + mu: rwmutex.Create(safe...), array: make([]interface{}, 0, cap), comparator: comparator, } @@ -93,6 +91,7 @@ func NewSortedArrayFromCopy(array []interface{}, comparator func(a, b interface{ func (a *SortedArray) SetArray(array []interface{}) *SortedArray { a.mu.Lock() defer a.mu.Unlock() + a.checkComparator() a.array = array sort.Slice(a.array, func(i, j int) bool { return a.comparator(a.array[i], a.array[j]) < 0 @@ -101,11 +100,11 @@ func (a *SortedArray) SetArray(array []interface{}) *SortedArray { } // SetComparator sets/changes the comparator for sorting. +// It resorts the array as the comparator is changed. func (a *SortedArray) SetComparator(comparator func(a, b interface{}) int) { a.mu.Lock() defer a.mu.Unlock() a.comparator = comparator - // Resort the array if comparator is changed. sort.Slice(a.array, func(i, j int) bool { return a.comparator(a.array[i], a.array[j]) < 0 }) @@ -117,6 +116,7 @@ func (a *SortedArray) SetComparator(comparator func(a, b interface{}) int) { func (a *SortedArray) Sort() *SortedArray { a.mu.Lock() defer a.mu.Unlock() + a.checkComparator() sort.Slice(a.array, func(i, j int) bool { return a.comparator(a.array[i], a.array[j]) < 0 }) @@ -132,7 +132,7 @@ func (a *SortedArray) Add(values ...interface{}) *SortedArray { defer a.mu.Unlock() for _, value := range values { index, cmp := a.binSearch(value, false) - if a.unique.Val() && cmp == 0 { + if a.unique && cmp == 0 { continue } if index < 0 { @@ -427,6 +427,7 @@ func (a *SortedArray) Search(value interface{}) (index int) { // If lesser than 0, it means the value at is lesser than . // If greater than 0, it means the value at is greater than . func (a *SortedArray) binSearch(value interface{}, lock bool) (index int, result int) { + a.checkComparator() if len(a.array) == 0 { return -1, -2 } @@ -439,7 +440,7 @@ func (a *SortedArray) binSearch(value interface{}, lock bool) (index int, result mid := 0 cmp := -2 for min <= max { - mid = int((min + max) / 2) + mid = (min + max) / 2 cmp = a.comparator(value, a.array[mid]) switch { case cmp < 0: @@ -457,8 +458,8 @@ func (a *SortedArray) binSearch(value interface{}, lock bool) (index int, result // which means it does not contain any repeated items. // It also do unique check, remove all repeated items. func (a *SortedArray) SetUnique(unique bool) *SortedArray { - oldUnique := a.unique.Val() - a.unique.Set(unique) + oldUnique := a.unique + a.unique = unique if unique && oldUnique != unique { a.Unique() } @@ -469,6 +470,7 @@ func (a *SortedArray) SetUnique(unique bool) *SortedArray { func (a *SortedArray) Unique() *SortedArray { a.mu.Lock() defer a.mu.Unlock() + a.checkComparator() if len(a.array) == 0 { return a } @@ -596,6 +598,9 @@ func (a *SortedArray) Rands(size int) []interface{} { func (a *SortedArray) Join(glue string) string { a.mu.RLock() defer a.mu.RUnlock() + if len(a.array) == 0 { + return "" + } buffer := bytes.NewBuffer(nil) for k, v := range a.array { buffer.WriteString(gconv.String(v)) @@ -676,12 +681,10 @@ func (a *SortedArray) MarshalJSON() ([]byte, error) { } // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal. +// Note that the comparator is set as string comparator in default. func (a *SortedArray) UnmarshalJSON(b []byte) error { - if a.mu == nil { - a.mu = rwmutex.New() + if a.comparator == nil { a.array = make([]interface{}, 0) - a.unique = gtype.NewBool() - // Note that the comparator is string comparator in default. a.comparator = gutil.ComparatorString } a.mu.Lock() @@ -698,11 +701,9 @@ func (a *SortedArray) UnmarshalJSON(b []byte) error { } // UnmarshalValue is an interface implement which sets any type of value for array. +// Note that the comparator is set as string comparator in default. func (a *SortedArray) UnmarshalValue(value interface{}) (err error) { - if a.mu == nil { - a.mu = rwmutex.New() - a.unique = gtype.NewBool() - // Note that the comparator is string comparator in default. + if a.comparator == nil { a.comparator = gutil.ComparatorString } a.mu.Lock() @@ -768,3 +769,11 @@ func (a *SortedArray) FilterEmpty() *SortedArray { func (a *SortedArray) IsEmpty() bool { return a.Len() == 0 } + +// checkComparator checks if comparator is nil. +// Note that it panics if no comparator is set. +func (a *SortedArray) checkComparator() { + if a.comparator == nil { + panic("comparator is missing for sorted array") + } +} diff --git a/container/garray/garray_sorted_int.go b/container/garray/garray_sorted_int.go index 182f3f211..27700478c 100644 --- a/container/garray/garray_sorted_int.go +++ b/container/garray/garray_sorted_int.go @@ -13,7 +13,6 @@ import ( "math" "sort" - "github.com/gogf/gf/container/gtype" "github.com/gogf/gf/internal/rwmutex" "github.com/gogf/gf/util/gconv" "github.com/gogf/gf/util/grand" @@ -22,9 +21,9 @@ import ( // SortedIntArray is a golang sorted int array with rich features. // It's using increasing order in default. type SortedIntArray struct { - mu *rwmutex.RWMutex + mu rwmutex.RWMutex array []int - unique *gtype.Bool // Whether enable unique feature(false) + unique bool // Whether enable unique feature(false) comparator func(a, b int) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b) } @@ -48,9 +47,8 @@ func NewSortedIntArrayComparator(comparator func(a, b int) int, safe ...bool) *S // which is false in default. func NewSortedIntArraySize(cap int, safe ...bool) *SortedIntArray { return &SortedIntArray{ - mu: rwmutex.New(safe...), + mu: rwmutex.Create(safe...), array: make([]int, 0, cap), - unique: gtype.NewBool(), comparator: defaultComparatorInt, } } @@ -93,8 +91,9 @@ func NewSortedIntArrayFromCopy(array []int, safe ...bool) *SortedIntArray { func (a *SortedIntArray) SetArray(array []int) *SortedIntArray { a.mu.Lock() defer a.mu.Unlock() + a.initComparator() a.array = array - sort.Ints(a.array) + quickSortInt(a.array, a.comparator) return a } @@ -104,7 +103,8 @@ func (a *SortedIntArray) SetArray(array []int) *SortedIntArray { func (a *SortedIntArray) Sort() *SortedIntArray { a.mu.Lock() defer a.mu.Unlock() - sort.Ints(a.array) + a.initComparator() + quickSortInt(a.array, a.comparator) return a } @@ -117,7 +117,7 @@ func (a *SortedIntArray) Add(values ...int) *SortedIntArray { defer a.mu.Unlock() for _, value := range values { index, cmp := a.binSearch(value, false) - if a.unique.Val() && cmp == 0 { + if a.unique && cmp == 0 { continue } if index < 0 { @@ -424,6 +424,7 @@ func (a *SortedIntArray) Search(value int) (index int) { // If lesser than 0, it means the value at is lesser than . // If greater than 0, it means the value at is greater than . func (a *SortedIntArray) binSearch(value int, lock bool) (index int, result int) { + a.initComparator() if len(a.array) == 0 { return -1, -2 } @@ -436,7 +437,7 @@ func (a *SortedIntArray) binSearch(value int, lock bool) (index int, result int) mid := 0 cmp := -2 for min <= max { - mid = int((min + max) / 2) + mid = (min + max) / 2 cmp = a.comparator(value, a.array[mid]) switch { case cmp < 0: @@ -454,8 +455,8 @@ func (a *SortedIntArray) binSearch(value int, lock bool) (index int, result int) // which means it does not contain any repeated items. // It also do unique check, remove all repeated items. func (a *SortedIntArray) SetUnique(unique bool) *SortedIntArray { - oldUnique := a.unique.Val() - a.unique.Set(unique) + oldUnique := a.unique + a.unique = unique if unique && oldUnique != unique { a.Unique() } @@ -466,6 +467,7 @@ func (a *SortedIntArray) SetUnique(unique bool) *SortedIntArray { func (a *SortedIntArray) Unique() *SortedIntArray { a.mu.Lock() defer a.mu.Unlock() + a.initComparator() if len(a.array) == 0 { return a } @@ -593,6 +595,9 @@ func (a *SortedIntArray) Rands(size int) []int { func (a *SortedIntArray) Join(glue string) string { a.mu.RLock() defer a.mu.RUnlock() + if len(a.array) == 0 { + return "" + } buffer := bytes.NewBuffer(nil) for k, v := range a.array { buffer.WriteString(gconv.String(v)) @@ -657,10 +662,8 @@ func (a *SortedIntArray) MarshalJSON() ([]byte, error) { // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal. func (a *SortedIntArray) UnmarshalJSON(b []byte) error { - if a.mu == nil { - a.mu = rwmutex.New() + if a.comparator == nil { a.array = make([]int, 0) - a.unique = gtype.NewBool() a.comparator = defaultComparatorInt } a.mu.Lock() @@ -676,10 +679,7 @@ func (a *SortedIntArray) UnmarshalJSON(b []byte) error { // UnmarshalValue is an interface implement which sets any type of value for array. func (a *SortedIntArray) UnmarshalValue(value interface{}) (err error) { - if a.mu == nil { - a.mu = rwmutex.New() - a.unique = gtype.NewBool() - // Note that the comparator is string comparator in default. + if a.comparator == nil { a.comparator = defaultComparatorInt } a.mu.Lock() @@ -721,3 +721,10 @@ func (a *SortedIntArray) FilterEmpty() *SortedIntArray { func (a *SortedIntArray) IsEmpty() bool { return a.Len() == 0 } + +// initComparator checks and sets default integer comparator if comparator is nil. +func (a *SortedIntArray) initComparator() { + if a.comparator == nil { + a.comparator = defaultComparatorInt + } +} diff --git a/container/garray/garray_sorted_str.go b/container/garray/garray_sorted_str.go index aed2ad100..ef67df7a9 100644 --- a/container/garray/garray_sorted_str.go +++ b/container/garray/garray_sorted_str.go @@ -13,7 +13,6 @@ import ( "math" "sort" - "github.com/gogf/gf/container/gtype" "github.com/gogf/gf/internal/rwmutex" "github.com/gogf/gf/util/gconv" "github.com/gogf/gf/util/grand" @@ -22,9 +21,9 @@ import ( // SortedStrArray is a golang sorted string array with rich features. // It's using increasing order in default. type SortedStrArray struct { - mu *rwmutex.RWMutex + mu rwmutex.RWMutex array []string - unique *gtype.Bool // Whether enable unique feature(false) + unique bool // Whether enable unique feature(false) comparator func(a, b string) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b) } @@ -48,9 +47,8 @@ func NewSortedStrArrayComparator(comparator func(a, b string) int, safe ...bool) // which is false in default. func NewSortedStrArraySize(cap int, safe ...bool) *SortedStrArray { return &SortedStrArray{ - mu: rwmutex.New(safe...), + mu: rwmutex.Create(safe...), array: make([]string, 0, cap), - unique: gtype.NewBool(), comparator: defaultComparatorStr, } } @@ -78,6 +76,7 @@ func NewSortedStrArrayFromCopy(array []string, safe ...bool) *SortedStrArray { func (a *SortedStrArray) SetArray(array []string) *SortedStrArray { a.mu.Lock() defer a.mu.Unlock() + a.initComparator() a.array = array quickSortStr(a.array, a.comparator) return a @@ -89,6 +88,7 @@ func (a *SortedStrArray) SetArray(array []string) *SortedStrArray { func (a *SortedStrArray) Sort() *SortedStrArray { a.mu.Lock() defer a.mu.Unlock() + a.initComparator() quickSortStr(a.array, a.comparator) return a } @@ -102,7 +102,7 @@ func (a *SortedStrArray) Add(values ...string) *SortedStrArray { defer a.mu.Unlock() for _, value := range values { index, cmp := a.binSearch(value, false) - if a.unique.Val() && cmp == 0 { + if a.unique && cmp == 0 { continue } if index < 0 { @@ -409,6 +409,7 @@ func (a *SortedStrArray) Search(value string) (index int) { // If lesser than 0, it means the value at is lesser than . // If greater than 0, it means the value at is greater than . func (a *SortedStrArray) binSearch(value string, lock bool) (index int, result int) { + a.initComparator() if len(a.array) == 0 { return -1, -2 } @@ -421,7 +422,7 @@ func (a *SortedStrArray) binSearch(value string, lock bool) (index int, result i mid := 0 cmp := -2 for min <= max { - mid = int((min + max) / 2) + mid = (min + max) / 2 cmp = a.comparator(value, a.array[mid]) switch { case cmp < 0: @@ -439,8 +440,8 @@ func (a *SortedStrArray) binSearch(value string, lock bool) (index int, result i // which means it does not contain any repeated items. // It also do unique check, remove all repeated items. func (a *SortedStrArray) SetUnique(unique bool) *SortedStrArray { - oldUnique := a.unique.Val() - a.unique.Set(unique) + oldUnique := a.unique + a.unique = unique if unique && oldUnique != unique { a.Unique() } @@ -451,6 +452,7 @@ func (a *SortedStrArray) SetUnique(unique bool) *SortedStrArray { func (a *SortedStrArray) Unique() *SortedStrArray { a.mu.Lock() defer a.mu.Unlock() + a.initComparator() if len(a.array) == 0 { return a } @@ -578,6 +580,9 @@ func (a *SortedStrArray) Rands(size int) []string { func (a *SortedStrArray) Join(glue string) string { a.mu.RLock() defer a.mu.RUnlock() + if len(a.array) == 0 { + return "" + } buffer := bytes.NewBuffer(nil) for k, v := range a.array { buffer.WriteString(v) @@ -653,10 +658,8 @@ func (a *SortedStrArray) MarshalJSON() ([]byte, error) { // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal. func (a *SortedStrArray) UnmarshalJSON(b []byte) error { - if a.mu == nil { - a.mu = rwmutex.New() + if a.comparator == nil { a.array = make([]string, 0) - a.unique = gtype.NewBool() a.comparator = defaultComparatorStr } a.mu.Lock() @@ -672,10 +675,7 @@ func (a *SortedStrArray) UnmarshalJSON(b []byte) error { // UnmarshalValue is an interface implement which sets any type of value for array. func (a *SortedStrArray) UnmarshalValue(value interface{}) (err error) { - if a.mu == nil { - a.mu = rwmutex.New() - a.unique = gtype.NewBool() - // Note that the comparator is string comparator in default. + if a.comparator == nil { a.comparator = defaultComparatorStr } a.mu.Lock() @@ -717,3 +717,10 @@ func (a *SortedStrArray) FilterEmpty() *SortedStrArray { func (a *SortedStrArray) IsEmpty() bool { return a.Len() == 0 } + +// initComparator checks and sets default string comparator if comparator is nil. +func (a *SortedStrArray) initComparator() { + if a.comparator == nil { + a.comparator = defaultComparatorStr + } +} diff --git a/container/garray/garray_z_unit_all_basic_test.go b/container/garray/garray_z_unit_all_basic_test.go index faeaa960d..1b0b58efb 100644 --- a/container/garray/garray_z_unit_all_basic_test.go +++ b/container/garray/garray_z_unit_all_basic_test.go @@ -9,6 +9,7 @@ package garray_test import ( + "github.com/gogf/gf/util/gutil" "strings" "testing" @@ -17,6 +18,34 @@ import ( "github.com/gogf/gf/util/gconv" ) +func Test_Array_Var(t *testing.T) { + gtest.C(t, func(t *gtest.T) { + var array garray.Array + expect := []int{2, 3, 1} + array.Append(2, 3, 1) + t.Assert(array.Slice(), expect) + }) +} + +func Test_SortedArray_Var(t *testing.T) { + gtest.C(t, func(t *gtest.T) { + var array garray.SortedArray + array.SetComparator(gutil.ComparatorInt) + expect := []int{1, 2, 3} + array.Add(2, 3, 1) + t.Assert(array.Slice(), expect) + }) +} + +func Test_SortedIntArray_Var(t *testing.T) { + gtest.C(t, func(t *gtest.T) { + var array garray.SortedIntArray + expect := []int{1, 2, 3} + array.Add(2, 3, 1) + t.Assert(array.Slice(), expect) + }) +} + func Test_IntArray_Unique(t *testing.T) { gtest.C(t, func(t *gtest.T) { expect := []int{1, 2, 3, 4, 5, 6} diff --git a/internal/rwmutex/rwmutex.go b/internal/rwmutex/rwmutex.go index f92c16147..d1fed095f 100644 --- a/internal/rwmutex/rwmutex.go +++ b/internal/rwmutex/rwmutex.go @@ -20,7 +20,15 @@ type RWMutex struct { // The parameter is used to specify whether using this mutex in concurrent safety, // which is false in default. func New(safe ...bool) *RWMutex { - mu := new(RWMutex) + mu := Create(safe...) + return &mu +} + +// Create creates and returns a new RWMutex object. +// The parameter is used to specify whether using this mutex in concurrent safety, +// which is false in default. +func Create(safe ...bool) RWMutex { + mu := RWMutex{} if len(safe) > 0 && safe[0] { mu.RWMutex = new(sync.RWMutex) }