mirror of
https://gitee.com/johng/gf
synced 2026-06-10 03:23:59 +08:00
Compare commits
15 Commits
v2.9.1
...
v2.9.3-rc2
| Author | SHA1 | Date | |
|---|---|---|---|
| 5073f25691 | |||
| 40e97f1325 | |||
| 502d158bc0 | |||
| f08897a114 | |||
| b6181e4bde | |||
| f8cdeae2d7 | |||
| bea060af4c | |||
| 94cc233325 | |||
| 71743e6903 | |||
| f9ec3b19f7 | |||
| ee24da4e72 | |||
| 26f20787ba | |||
| 1371b3bad5 | |||
| 1da73451b9 | |||
| 94b623e126 |
9
.github/workflows/ci-main.yml
vendored
9
.github/workflows/ci-main.yml
vendored
@ -38,7 +38,6 @@ jobs:
|
||||
# 🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥
|
||||
# When adding new go version to the list, make sure:
|
||||
# 1. Update the `LATEST_GO_VERSION` env variable.
|
||||
# 2. Update the `Report Coverage` action.
|
||||
# 🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥
|
||||
go-version: [ "1.23", "1.24", "1.25" ]
|
||||
goarch: [ "386", "amd64" ]
|
||||
@ -48,9 +47,9 @@ jobs:
|
||||
# Service containers to run with `code-test`
|
||||
services:
|
||||
# Etcd service.
|
||||
# docker run -d --name etcd -p 2379:2379 -e ALLOW_NONE_AUTHENTICATION=yes bitnami/etcd:3.4.24
|
||||
# docker run -d --name etcd -p 2379:2379 -e ALLOW_NONE_AUTHENTICATION=yes bitnamilegacy/etcd:3.4.24
|
||||
etcd:
|
||||
image: bitnami/etcd:3.4.24
|
||||
image: bitnamilegacy/etcd:3.4.24
|
||||
env:
|
||||
ALLOW_NONE_AUTHENTICATION: yes
|
||||
ports:
|
||||
@ -263,8 +262,8 @@ jobs:
|
||||
|
||||
- name: Report Coverage
|
||||
uses: codecov/codecov-action@v4
|
||||
# Only report coverage on the latest go version and amd64 arch
|
||||
if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && matrix.go-version == '1.23' && matrix.goarch == 'amd64' }}
|
||||
# Only report coverage on the latest go version
|
||||
if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && matrix.go-version == env.LATEST_GO_VERSION }}
|
||||
with:
|
||||
flags: go-${{ matrix.go-version }}-${{ matrix.goarch }}
|
||||
token: ${{ secrets.CODECOV_TOKEN }}
|
||||
|
||||
2
.github/workflows/ci-sub.yml
vendored
2
.github/workflows/ci-sub.yml
vendored
@ -30,7 +30,7 @@ concurrency:
|
||||
env:
|
||||
TZ: "Asia/Shanghai"
|
||||
# for unit testing cases of some components that only execute on the latest go version.
|
||||
LATEST_GO_VERSION: "1.24"
|
||||
LATEST_GO_VERSION: "1.25"
|
||||
|
||||
jobs:
|
||||
code-test:
|
||||
|
||||
4
.github/workflows/golangci-lint.yml
vendored
4
.github/workflows/golangci-lint.yml
vendored
@ -4,7 +4,7 @@
|
||||
# If a copy of the MIT was not distributed with this file,
|
||||
# You can obtain one at https://github.com/gogf/gf.
|
||||
|
||||
name: GolangCI Lint
|
||||
name: golangci-lint
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
@ -36,6 +36,8 @@ jobs:
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v5
|
||||
with:
|
||||
fetch-depth: 0
|
||||
- name: Setup Golang ${{ matrix.go-version }}
|
||||
uses: actions/setup-go@v5
|
||||
with:
|
||||
|
||||
50
.github/workflows/scripts/update_version.sh
vendored
Executable file
50
.github/workflows/scripts/update_version.sh
vendored
Executable file
@ -0,0 +1,50 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
# Check if the number of parameters is 2
|
||||
if [ $# -ne 2 ]; then
|
||||
echo "Invalid parameters, please execute in format: version.sh [directory] [version]"
|
||||
echo "Example: version.sh ./contrib v1.0.0"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Check if the first parameter is a directory and exists
|
||||
if [ ! -d "$1" ]; then
|
||||
echo "Error: Directory does not exist"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Check if the second parameter starts with 'v'
|
||||
if [[ "$2" != v* ]]; then
|
||||
echo "Error: Version number does not start with 'v'"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
workdir=$1
|
||||
newVersion=$2
|
||||
echo "Preparing to replace version numbers in all go.mod files under ${workdir} directory to ${newVersion}"
|
||||
|
||||
|
||||
# Check if file exists
|
||||
if [ -f "go.work" ]; then
|
||||
# File exists, rename it
|
||||
mv go.work go.work.${newVersion}
|
||||
echo "Backup go.work file to avoid affecting the upgrade"
|
||||
fi
|
||||
|
||||
for file in `find ${workdir} -name go.mod`; do
|
||||
goModPath=$(dirname $file)
|
||||
echo ""
|
||||
echo "processing dir: $goModPath"
|
||||
cd $goModPath
|
||||
go mod tidy
|
||||
go list -f "{{if and (not .Indirect) (not .Main)}}{{.Path}}@${newVersion}{{end}}" -m all | grep "^github.com/gogf/gf"
|
||||
go list -f "{{if and (not .Indirect) (not .Main)}}{{.Path}}@${newVersion}{{end}}" -m all | grep "^github.com/gogf/gf" | xargs -L1 go get -v
|
||||
go mod tidy
|
||||
cd -
|
||||
done
|
||||
|
||||
if [ -f "go.work.${newVersion}" ]; then
|
||||
# File exists, rename it back
|
||||
mv go.work.${newVersion} go.work
|
||||
echo "Restore go.work file"
|
||||
fi
|
||||
34
.github/workflows/tag.yml
vendored
34
.github/workflows/tag.yml
vendored
@ -4,13 +4,12 @@ on:
|
||||
push:
|
||||
# Sequence of patterns matched against refs/tags
|
||||
tags:
|
||||
- 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
|
||||
- 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
|
||||
|
||||
env:
|
||||
TZ: Asia/Shanghai
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
|
||||
jobs:
|
||||
build:
|
||||
name: Auto Creating Tags
|
||||
@ -18,22 +17,43 @@ jobs:
|
||||
steps:
|
||||
- name: Checkout Github Code
|
||||
uses: actions/checkout@v5
|
||||
|
||||
- name: Auto Creating Tags For Contrib Packages
|
||||
run: |
|
||||
git config --global user.email "tagrobot@goframe.org"
|
||||
git config --global user.name "TagRobot"
|
||||
|
||||
# auto create tags for contrib packages.
|
||||
for file in `find contrib -name go.mod`; do
|
||||
tag=$(dirname $file)/$GITHUB_REF_NAME
|
||||
tag=$(dirname $file)/${{ github.ref_name }}
|
||||
git tag $tag
|
||||
git push origin $tag
|
||||
done
|
||||
|
||||
- name: Create Pull Request
|
||||
uses: peter-evans/create-pull-request@v4
|
||||
with:
|
||||
commit-message: 'update gf cli to ${{ github.ref_name }}'
|
||||
title: 'fix: update gf cli to ${{ github.ref_name }}'
|
||||
base: master
|
||||
branch: fix/${{ github.ref_name }}
|
||||
delete-branch: true
|
||||
- name: Commit & Push changes
|
||||
uses: actions-js/push@master
|
||||
with:
|
||||
github_token: ${{ secrets.GITHUB_TOKEN }}
|
||||
branch: fix/${{ github.ref_name }}
|
||||
author_name: TagRobot
|
||||
author_email: tagrobot@goframe.org
|
||||
message: 'fix: update gf cli to ${{ github.ref_name }}'
|
||||
- name: update dependencies
|
||||
run: |
|
||||
go env -w GOPRIVATE=github.com/gogf/gf
|
||||
.github/workflows/scripts/update_version.sh ./cmd/gfly ${{ github.ref_name }}
|
||||
- name: Auto Creating Tags For cli tool
|
||||
run: |
|
||||
git config --global user.email "tagrobot@goframe.org"
|
||||
git config --global user.name "TagRobot"
|
||||
# auto create tag for cli tool
|
||||
for file in `find cmd -name go.mod`; do
|
||||
tag=$(dirname $file)/$GITHUB_REF_NAME
|
||||
tag=$(dirname $file)/${{ github.ref_name }}
|
||||
git tag $tag
|
||||
git push origin $tag
|
||||
done
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
version: "2"
|
||||
run:
|
||||
concurrency: 4
|
||||
go: "1.23"
|
||||
go: "1.25"
|
||||
modules-download-mode: readonly
|
||||
issues-exit-code: 2
|
||||
tests: false
|
||||
@ -188,7 +188,7 @@ formatters:
|
||||
- blank
|
||||
- default
|
||||
- dot
|
||||
- prefix(github.com/gogf/gf)
|
||||
- prefix(github.com/gogf/gf/v2)
|
||||
- prefix(github.com/gogf/gf/cmd)
|
||||
- prefix(github.com/gogf/gfcontrib)
|
||||
- prefix(github.com/gogf/gf/example)
|
||||
@ -196,6 +196,19 @@ formatters:
|
||||
no-lex-order: false
|
||||
gofmt:
|
||||
simplify: true
|
||||
rewrite-rules:
|
||||
- pattern: 'interface{}'
|
||||
replacement: 'any'
|
||||
- pattern: 'reflect.Ptr'
|
||||
replacement: 'reflect.Pointer'
|
||||
- pattern: 'ioutil.ReadAll'
|
||||
replacement: 'io.ReadAll'
|
||||
- pattern: 'ioutil.WriteFile'
|
||||
replacement: 'os.WriteFile'
|
||||
- pattern: 'ioutil.ReadFile'
|
||||
replacement: 'os.ReadFile'
|
||||
- pattern: 'ioutil.NopCloser'
|
||||
replacement: 'io.NopCloser'
|
||||
goimports:
|
||||
local-prefixes:
|
||||
- github.com/gogf/gf/v2
|
||||
|
||||
@ -1,4 +1,19 @@
|
||||
#!/usr/bin/env bash
|
||||
|
||||
# Function to detect OS and set sed parameters
|
||||
setup_sed() {
|
||||
if [[ "$OSTYPE" == "darwin"* ]]; then
|
||||
# macOS
|
||||
SED_INPLACE="sed -i ''"
|
||||
else
|
||||
# Linux/Windows Git Bash
|
||||
SED_INPLACE="sed -i"
|
||||
fi
|
||||
}
|
||||
|
||||
# Initialize sed command
|
||||
setup_sed
|
||||
|
||||
if [ $# -ne 2 ]; then
|
||||
echo "Parameter exception, please execute in the format of $0 [directory] [version number]"
|
||||
echo "PS：$0 ./ v2.4.0"
|
||||
@ -28,10 +43,10 @@ fi
|
||||
|
||||
if [[ true ]]; then
|
||||
# Use sed to replace the version number in version.go
|
||||
sed -i '' 's/VERSION = ".*"/VERSION = "'${newVersion}'"/' version.go
|
||||
$SED_INPLACE 's/VERSION = ".*"/VERSION = "'${newVersion}'"/' version.go
|
||||
|
||||
# Use sed to replace the version number in README.MD
|
||||
sed -i '' 's/version=[^"]*/version='${newVersion}'/' README.MD
|
||||
$SED_INPLACE 's/version=[^"]*/version='${newVersion}'/' README.MD
|
||||
fi
|
||||
|
||||
if [ -f "go.work" ]; then
|
||||
@ -67,7 +82,7 @@ for file in `find ${workdir} -name go.mod`; do
|
||||
fi
|
||||
go mod tidy
|
||||
# Remove toolchain line if exists
|
||||
sed -i '' '/^toolchain/d' go.mod
|
||||
$SED_INPLACE '/^toolchain/d' go.mod
|
||||
|
||||
# Upgrading only GoFrame related libraries, sometimes even if a version number is specified,
|
||||
# it may not be possible to successfully upgrade. Please confirm before submitting the code
|
||||
@ -75,7 +90,7 @@ for file in `find ${workdir} -name go.mod`; do
|
||||
go list -f "{{if and (not .Indirect) (not .Main)}}{{.Path}}@${newVersion}{{end}}" -m all | grep "^github.com/gogf/gf" | xargs -L1 go get -v
|
||||
go mod tidy
|
||||
# Remove toolchain line if exists
|
||||
sed -i '' '/^toolchain/d' go.mod
|
||||
$SED_INPLACE '/^toolchain/d' go.mod
|
||||
if [ $goModPath = "./cmd/gf" ]; then
|
||||
go mod edit -dropreplace github.com/gogf/gf/v2
|
||||
go mod edit -dropreplace github.com/gogf/gf/contrib/drivers/clickhouse/v2
|
||||
|
||||
@ -4,6 +4,8 @@
|
||||
|
||||
[](https://pkg.go.dev/github.com/gogf/gf/v2)
|
||||
[](https://github.com/gogf/gf/actions/workflows/ci-main.yml)
|
||||
[](https://scorecard.dev/viewer/?uri=github.com/gogf/gf)
|
||||
[](https://bestpractices.coreinfrastructure.org/projects/9233)
|
||||
[](https://goreportcard.com/report/github.com/gogf/gf/v2)
|
||||
[](https://codecov.io/gh/gogf/gf)
|
||||
[](https://github.com/gogf/gf)
|
||||
@ -36,7 +38,7 @@ A powerful framework for faster, easier, and more efficient project development.
|
||||
💖 [Thanks to all the contributors who made GoFrame possible](https://github.com/gogf/gf/graphs/contributors) 💖
|
||||
|
||||
<a href="https://github.com/gogf/gf/graphs/contributors">
|
||||
<img src="https://goframe.org/img/contributors.svg?version=v2.9.0" alt="goframe contributors"/>
|
||||
<img src="https://goframe.org/img/contributors.svg?version=v2.9.2" alt="goframe contributors"/>
|
||||
</a>
|
||||
|
||||
# License
|
||||
|
||||
@ -3,15 +3,15 @@ module github.com/gogf/gf/cmd/gf/v2
|
||||
go 1.23.0
|
||||
|
||||
require (
|
||||
github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.1
|
||||
github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.1
|
||||
github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.1
|
||||
github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.1
|
||||
github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.1
|
||||
github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.1
|
||||
github.com/gogf/gf/v2 v2.9.1
|
||||
github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.2
|
||||
github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.2
|
||||
github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.2
|
||||
github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.2
|
||||
github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.2
|
||||
github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.2
|
||||
github.com/gogf/gf/v2 v2.9.2
|
||||
github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f
|
||||
github.com/olekukonko/tablewriter v0.0.5
|
||||
github.com/olekukonko/tablewriter v1.0.9
|
||||
github.com/schollz/progressbar/v3 v3.15.0
|
||||
golang.org/x/mod v0.26.0
|
||||
golang.org/x/tools v0.35.0
|
||||
@ -42,6 +42,8 @@ require (
|
||||
github.com/mattn/go-runewidth v0.0.16 // indirect
|
||||
github.com/microsoft/go-mssqldb v1.7.1 // indirect
|
||||
github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
|
||||
github.com/olekukonko/errors v1.1.0 // indirect
|
||||
github.com/olekukonko/ll v0.0.9 // indirect
|
||||
github.com/paulmach/orb v0.7.1 // indirect
|
||||
github.com/pierrec/lz4/v4 v4.1.14 // indirect
|
||||
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
|
||||
|
||||
@ -90,7 +90,6 @@ github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHP
|
||||
github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
|
||||
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
|
||||
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
|
||||
github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
|
||||
github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
|
||||
github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
|
||||
github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
|
||||
@ -99,8 +98,12 @@ github.com/microsoft/go-mssqldb v1.7.1/go.mod h1:kOvZKUdrhhFQmxLZqbwUV0rHkNkZpth
|
||||
github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ=
|
||||
github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw=
|
||||
github.com/mkevac/debugcharts v0.0.0-20191222103121-ae1c48aa8615/go.mod h1:Ad7oeElCZqA1Ufj0U9/liOF4BtVepxRcTvr2ey7zTvM=
|
||||
github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
|
||||
github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
|
||||
github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
|
||||
github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
|
||||
github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
|
||||
github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
|
||||
github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
|
||||
github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
|
||||
github.com/paulmach/orb v0.7.1 h1:Zha++Z5OX/l168sqHK3k4z18LDvr+YAO/VjK0ReQ9rU=
|
||||
github.com/paulmach/orb v0.7.1/go.mod h1:FWRlTgl88VI1RBx/MkrwWDRhQ96ctqMCh8boXhmqB/A=
|
||||
github.com/paulmach/protoscan v0.2.1/go.mod h1:SpcSwydNLrxUGSDvXvO0P7g7AuhJ7lcKfDlhJCDw2gY=
|
||||
|
||||
@ -11,6 +11,8 @@ import (
|
||||
"context"
|
||||
|
||||
"github.com/olekukonko/tablewriter"
|
||||
"github.com/olekukonko/tablewriter/renderer"
|
||||
"github.com/olekukonko/tablewriter/tw"
|
||||
|
||||
"github.com/gogf/gf/v2/frame/g"
|
||||
"github.com/gogf/gf/v2/os/gproc"
|
||||
@ -61,10 +63,23 @@ func (c cEnv) Index(ctx context.Context, in cEnvInput) (out *cEnvOutput, err err
|
||||
}
|
||||
array = append(array, []string{gstr.Trim(match[1]), gstr.Trim(match[2])})
|
||||
}
|
||||
tw := tablewriter.NewWriter(buffer)
|
||||
tw.SetColumnAlignment([]int{tablewriter.ALIGN_LEFT, tablewriter.ALIGN_LEFT})
|
||||
tw.AppendBulk(array)
|
||||
tw.Render()
|
||||
table := tablewriter.NewTable(buffer,
|
||||
tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{
|
||||
Settings: tw.Settings{
|
||||
Separators: tw.Separators{BetweenRows: tw.Off, BetweenColumns: tw.On},
|
||||
},
|
||||
Symbols: tw.NewSymbols(tw.StyleASCII),
|
||||
})),
|
||||
tablewriter.WithConfig(tablewriter.Config{
|
||||
Row: tw.CellConfig{
|
||||
Formatting: tw.CellFormatting{AutoWrap: tw.WrapNone},
|
||||
Alignment: tw.CellAlignment{PerColumn: []tw.Align{tw.AlignLeft, tw.AlignLeft}},
|
||||
ColMaxWidths: tw.CellWidth{Global: 84},
|
||||
},
|
||||
}),
|
||||
)
|
||||
table.Bulk(array)
|
||||
table.Render()
|
||||
mlog.Print(buffer.String())
|
||||
return
|
||||
}
|
||||
|
||||
@ -104,7 +104,7 @@ func Test_Build_Single_VarMap(t *testing.T) {
|
||||
|
||||
t.Assert(gfile.Exists(binaryPath), false)
|
||||
_, err = f.Index(ctx, cBuildInput{
|
||||
VarMap: map[string]interface{}{
|
||||
VarMap: map[string]any{
|
||||
"a": "1",
|
||||
"b": "2",
|
||||
},
|
||||
|
||||
@ -378,7 +378,7 @@ func Test_Gen_Dao_Issue3459(t *testing.T) {
|
||||
filepath.FromSlash(testPath + "/model/do/table_user.go"),
|
||||
filepath.FromSlash(testPath + "/model/entity/table_user.go"),
|
||||
}
|
||||
for i, _ := range files {
|
||||
for i := range files {
|
||||
//_ = gfile.PutContents(expectFiles[i], gfile.GetContents(files[i]))
|
||||
t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
|
||||
}
|
||||
@ -450,7 +450,7 @@ func Test_Gen_Dao_Issue3749(t *testing.T) {
|
||||
filepath.FromSlash(testPath + "/model/do/table_user.go"),
|
||||
filepath.FromSlash(testPath + "/model/entity/table_user.go"),
|
||||
}
|
||||
for i, _ := range files {
|
||||
for i := range files {
|
||||
//_ = gfile.PutContents(expectFiles[i], gfile.GetContents(files[i]))
|
||||
t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
|
||||
}
|
||||
|
||||
@ -107,7 +107,7 @@ func Test_Gen_Dao_Default(t *testing.T) {
|
||||
filepath.FromSlash(testPath + "/model/do/table_user.go"),
|
||||
filepath.FromSlash(testPath + "/model/entity/table_user.go"),
|
||||
}
|
||||
for i, _ := range files {
|
||||
for i := range files {
|
||||
t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
|
||||
}
|
||||
})
|
||||
@ -208,7 +208,7 @@ func Test_Gen_Dao_TypeMapping(t *testing.T) {
|
||||
filepath.FromSlash(testPath + "/model/do/table_user.go"),
|
||||
filepath.FromSlash(testPath + "/model/entity/table_user.go"),
|
||||
}
|
||||
for i, _ := range files {
|
||||
for i := range files {
|
||||
//_ = gfile.PutContents(expectFiles[i], gfile.GetContents(files[i]))
|
||||
t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
|
||||
}
|
||||
@ -311,7 +311,7 @@ func Test_Gen_Dao_FieldMapping(t *testing.T) {
|
||||
filepath.FromSlash(testPath + "/model/do/table_user.go"),
|
||||
filepath.FromSlash(testPath + "/model/entity/table_user.go"),
|
||||
}
|
||||
for i, _ := range files {
|
||||
for i := range files {
|
||||
//_ = gfile.PutContents(expectFiles[i], gfile.GetContents(files[i]))
|
||||
t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
|
||||
}
|
||||
@ -403,7 +403,7 @@ func Test_Gen_Dao_Sqlite3(t *testing.T) {
|
||||
filepath.FromSlash(testPath + "/model/do/table_user.go"),
|
||||
filepath.FromSlash(testPath + "/model/entity/table_user.go"),
|
||||
}
|
||||
for i, _ := range files {
|
||||
for i := range files {
|
||||
//_ = gfile.PutContents(expectFiles[i], gfile.GetContents(files[i]))
|
||||
t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
|
||||
}
|
||||
|
||||
@ -9,13 +9,14 @@ package genctrl
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
|
||||
"github.com/gogf/gf/v2/container/gset"
|
||||
"github.com/gogf/gf/v2/frame/g"
|
||||
"github.com/gogf/gf/v2/os/gfile"
|
||||
"github.com/gogf/gf/v2/os/gtime"
|
||||
"github.com/gogf/gf/v2/util/gconv"
|
||||
"github.com/gogf/gf/v2/util/gtag"
|
||||
|
||||
"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
|
||||
)
|
||||
|
||||
const (
|
||||
|
||||
@ -11,6 +11,9 @@ import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"github.com/olekukonko/tablewriter"
|
||||
"github.com/olekukonko/tablewriter/renderer"
|
||||
"github.com/olekukonko/tablewriter/tw"
|
||||
"golang.org/x/mod/modfile"
|
||||
|
||||
"github.com/gogf/gf/v2/container/garray"
|
||||
@ -99,6 +102,20 @@ var (
|
||||
Type: "float64",
|
||||
},
|
||||
}
|
||||
|
||||
// tablewriter Options
|
||||
twRenderer = tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{
|
||||
Borders: tw.Border{Top: tw.Off, Bottom: tw.Off, Left: tw.Off, Right: tw.Off},
|
||||
Settings: tw.Settings{
|
||||
Separators: tw.Separators{BetweenRows: tw.Off, BetweenColumns: tw.Off},
|
||||
},
|
||||
Symbols: tw.NewSymbols(tw.StyleASCII),
|
||||
}))
|
||||
twConfig = tablewriter.WithConfig(tablewriter.Config{
|
||||
Row: tw.CellConfig{
|
||||
Formatting: tw.CellFormatting{AutoWrap: tw.WrapNone},
|
||||
},
|
||||
})
|
||||
)
|
||||
|
||||
func (c CGenDao) Dao(ctx context.Context, in CGenDaoInput) (out *CGenDaoOutput, err error) {
|
||||
|
||||
@ -211,13 +211,9 @@ func generateColumnNamesForDao(fieldMap map[string]*gdb.TableField, removeFieldP
|
||||
fmt.Sprintf(` #"%s",`, field.Name),
|
||||
}
|
||||
}
|
||||
tw := tablewriter.NewWriter(buffer)
|
||||
tw.SetBorder(false)
|
||||
tw.SetRowLine(false)
|
||||
tw.SetAutoWrapText(false)
|
||||
tw.SetColumnSeparator("")
|
||||
tw.AppendBulk(array)
|
||||
tw.Render()
|
||||
table := tablewriter.NewTable(buffer, twRenderer, twConfig)
|
||||
table.Bulk(array)
|
||||
table.Render()
|
||||
namesContent := buffer.String()
|
||||
// Let's do this hack of table writer for indent!
|
||||
namesContent = gstr.Replace(namesContent, " #", "")
|
||||
@ -252,13 +248,9 @@ func generateColumnDefinitionForDao(fieldMap map[string]*gdb.TableField, removeF
|
||||
" #" + fmt.Sprintf(`// %s`, comment),
|
||||
}
|
||||
}
|
||||
tw := tablewriter.NewWriter(buffer)
|
||||
tw.SetBorder(false)
|
||||
tw.SetRowLine(false)
|
||||
tw.SetAutoWrapText(false)
|
||||
tw.SetColumnSeparator("")
|
||||
tw.AppendBulk(array)
|
||||
tw.Render()
|
||||
table := tablewriter.NewTable(buffer, twRenderer, twConfig)
|
||||
table.Bulk(array)
|
||||
table.Render()
|
||||
defineContent := buffer.String()
|
||||
// Let's do this hack of table writer for indent!
|
||||
defineContent = gstr.Replace(defineContent, " #", "")
|
||||
|
||||
@ -45,14 +45,14 @@ func generateDo(ctx context.Context, in CGenDaoInternalInput) {
|
||||
IsDo: true,
|
||||
})
|
||||
)
|
||||
// replace all types to interface{}.
|
||||
// replace all types to any.
|
||||
structDefinition, _ = gregex.ReplaceStringFuncMatch(
|
||||
"([A-Z]\\w*?)\\s+([\\w\\*\\.]+?)\\s+(//)",
|
||||
structDefinition,
|
||||
func(match []string) string {
|
||||
// If the type is already a pointer/slice/map, it does nothing.
|
||||
if !gstr.HasPrefix(match[2], "*") && !gstr.HasPrefix(match[2], "[]") && !gstr.HasPrefix(match[2], "map") {
|
||||
return fmt.Sprintf(`%s interface{} %s`, match[1], match[3])
|
||||
return fmt.Sprintf(`%s any %s`, match[1], match[3])
|
||||
}
|
||||
return match[0]
|
||||
},
|
||||
|
||||
@ -41,22 +41,18 @@ func generateStructDefinition(ctx context.Context, in generateStructDefinitionIn
|
||||
appendImports = append(appendImports, imports)
|
||||
}
|
||||
}
|
||||
tw := tablewriter.NewWriter(buffer)
|
||||
tw.SetBorder(false)
|
||||
tw.SetRowLine(false)
|
||||
tw.SetAutoWrapText(false)
|
||||
tw.SetColumnSeparator("")
|
||||
tw.AppendBulk(array)
|
||||
tw.Render()
|
||||
table := tablewriter.NewTable(buffer, twRenderer, twConfig)
|
||||
table.Bulk(array)
|
||||
table.Render()
|
||||
stContent := buffer.String()
|
||||
// Let's do this hack of table writer for indent!
|
||||
stContent = gstr.Replace(stContent, " #", "")
|
||||
stContent = gstr.Replace(stContent, "` ", "`")
|
||||
stContent = gstr.Replace(stContent, "``", "")
|
||||
buffer.Reset()
|
||||
buffer.WriteString(fmt.Sprintf("type %s struct {\n", in.StructName))
|
||||
fmt.Fprintf(buffer, "type %s struct {\n", in.StructName)
|
||||
if in.IsDo {
|
||||
buffer.WriteString(fmt.Sprintf("g.Meta `orm:\"table:%s, do:true\"`\n", in.TableName))
|
||||
fmt.Fprintf(buffer, "g.Meta `orm:\"table:%s, do:true\"`\n", in.TableName)
|
||||
}
|
||||
buffer.WriteString(stContent)
|
||||
buffer.WriteString("}")
|
||||
|
||||
@ -113,12 +113,12 @@ func (p *EnumsParser) ParsePackage(pkg *packages.Package) {
|
||||
}
|
||||
|
||||
func (p *EnumsParser) Export() string {
|
||||
var typeEnumMap = make(map[string][]interface{})
|
||||
var typeEnumMap = make(map[string][]any)
|
||||
for _, enum := range p.enums {
|
||||
if typeEnumMap[enum.Type] == nil {
|
||||
typeEnumMap[enum.Type] = make([]interface{}, 0)
|
||||
typeEnumMap[enum.Type] = make([]any, 0)
|
||||
}
|
||||
var value interface{}
|
||||
var value any
|
||||
switch enum.Kind {
|
||||
case constant.Int:
|
||||
value = gconv.Int64(enum.Value)
|
||||
|
||||
@ -109,7 +109,7 @@ func (c CGenPb) tagCommentIntoListMap(comment string, lineTagMap *gmap.ListMap)
|
||||
|
||||
func (c CGenPb) listMapToStructTag(lineTagMap *gmap.ListMap) string {
|
||||
var tag string
|
||||
lineTagMap.Iterator(func(key, value interface{}) bool {
|
||||
lineTagMap.Iterator(func(key, value any) bool {
|
||||
if tag != "" {
|
||||
tag += " "
|
||||
}
|
||||
|
||||
@ -15,6 +15,8 @@ import (
|
||||
"strings"
|
||||
|
||||
"github.com/olekukonko/tablewriter"
|
||||
"github.com/olekukonko/tablewriter/renderer"
|
||||
"github.com/olekukonko/tablewriter/tw"
|
||||
|
||||
"github.com/gogf/gf/v2/container/garray"
|
||||
"github.com/gogf/gf/v2/container/gset"
|
||||
@ -443,13 +445,22 @@ func generateEntityMessageDefinition(entityName string, fieldMap map[string]*gdb
|
||||
appendImports = append(appendImports, imports)
|
||||
}
|
||||
}
|
||||
tw := tablewriter.NewWriter(buffer)
|
||||
tw.SetBorder(false)
|
||||
tw.SetRowLine(false)
|
||||
tw.SetAutoWrapText(false)
|
||||
tw.SetColumnSeparator("")
|
||||
tw.AppendBulk(array)
|
||||
tw.Render()
|
||||
table := tablewriter.NewTable(buffer,
|
||||
tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{
|
||||
Borders: tw.Border{Top: tw.Off, Bottom: tw.Off, Left: tw.On, Right: tw.Off},
|
||||
Settings: tw.Settings{
|
||||
Separators: tw.Separators{BetweenRows: tw.Off, BetweenColumns: tw.Off},
|
||||
},
|
||||
Symbols: tw.NewSymbolCustom("Proto").WithColumn(" "),
|
||||
})),
|
||||
tablewriter.WithConfig(tablewriter.Config{
|
||||
Row: tw.CellConfig{
|
||||
Formatting: tw.CellFormatting{AutoWrap: tw.WrapNone},
|
||||
},
|
||||
}),
|
||||
)
|
||||
table.Bulk(array)
|
||||
table.Render()
|
||||
stContent := buffer.String()
|
||||
// Let's do this hack of table writer for indent!
|
||||
stContent = regexp.MustCompile(`\s+\n`).ReplaceAllString(gstr.Replace(stContent, " #", ""), "\n")
|
||||
|
||||
@ -13,8 +13,6 @@ import (
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
|
||||
"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
|
||||
"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
|
||||
"github.com/gogf/gf/v2/container/garray"
|
||||
"github.com/gogf/gf/v2/container/gmap"
|
||||
"github.com/gogf/gf/v2/container/gset"
|
||||
@ -25,6 +23,9 @@ import (
|
||||
"github.com/gogf/gf/v2/text/gstr"
|
||||
"github.com/gogf/gf/v2/util/gconv"
|
||||
"github.com/gogf/gf/v2/util/gtag"
|
||||
|
||||
"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
|
||||
"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
|
||||
)
|
||||
|
||||
const (
|
||||
|
||||
@ -33,7 +33,7 @@ func (c CGenService) generateType(generatedContent *bytes.Buffer, srcStructFunct
|
||||
generatedContent.WriteString("type(")
|
||||
generatedContent.WriteString("\n")
|
||||
|
||||
srcStructFunctions.Iterator(func(key, value interface{}) bool {
|
||||
srcStructFunctions.Iterator(func(key, value any) bool {
|
||||
var (
|
||||
funcContents = make([]string, 0)
|
||||
funcContent string
|
||||
@ -71,7 +71,7 @@ func (c CGenService) generateVar(generatedContent *bytes.Buffer, srcStructFuncti
|
||||
// Generating variable and register definitions.
|
||||
var variableContent string
|
||||
|
||||
srcStructFunctions.Iterator(func(key, value interface{}) bool {
|
||||
srcStructFunctions.Iterator(func(key, value any) bool {
|
||||
structName := key.(string)
|
||||
variableContent += gstr.Trim(gstr.ReplaceByMap(consts.TemplateGenServiceContentVariable, g.MapStrStr{
|
||||
"{StructName}": structName,
|
||||
@ -93,7 +93,7 @@ func (c CGenService) generateVar(generatedContent *bytes.Buffer, srcStructFuncti
|
||||
// See: const.TemplateGenServiceContentRegister
|
||||
func (c CGenService) generateFunc(generatedContent *bytes.Buffer, srcStructFunctions *gmap.ListMap) {
|
||||
// Variable register function definitions.
|
||||
srcStructFunctions.Iterator(func(key, value interface{}) bool {
|
||||
srcStructFunctions.Iterator(func(key, value any) bool {
|
||||
structName := key.(string)
|
||||
generatedContent.WriteString(gstr.Trim(gstr.ReplaceByMap(consts.TemplateGenServiceContentRegister, g.MapStrStr{
|
||||
"{StructName}": structName,
|
||||
|
||||
@ -12,11 +12,11 @@ import (
|
||||
// TableUser is the golang structure of table table_user for DAO operations like Where/Data.
|
||||
type TableUser struct {
|
||||
g.Meta `orm:"table:table_user, do:true"`
|
||||
Id interface{} // User ID
|
||||
Passport interface{} // User Passport
|
||||
Password interface{} // User Password
|
||||
Nickname interface{} // User Nickname
|
||||
Score interface{} // Total score amount.
|
||||
Id any // User ID
|
||||
Passport any // User Passport
|
||||
Password any // User Password
|
||||
Nickname any // User Nickname
|
||||
Score any // Total score amount.
|
||||
CreateAt *gtime.Time // Created Time
|
||||
UpdateAt *gtime.Time // Updated Time
|
||||
}
|
||||
|
||||
@ -12,11 +12,11 @@ import (
|
||||
// TableUser is the golang structure of table table_user for DAO operations like Where/Data.
|
||||
type TableUser struct {
|
||||
g.Meta `orm:"table:table_user, do:true"`
|
||||
Id interface{} // User ID
|
||||
Passport interface{} // User Passport
|
||||
Password interface{} // User Password
|
||||
Nickname interface{} // User Nickname
|
||||
Score interface{} // Total score amount.
|
||||
Id any // User ID
|
||||
Passport any // User Passport
|
||||
Password any // User Password
|
||||
Nickname any // User Nickname
|
||||
Score any // Total score amount.
|
||||
CreateAt *gtime.Time // Created Time
|
||||
UpdateAt *gtime.Time // Updated Time
|
||||
}
|
||||
|
||||
@ -12,10 +12,10 @@ import (
|
||||
// TableUser is the golang structure of table table_user for DAO operations like Where/Data.
|
||||
type TableUser struct {
|
||||
g.Meta `orm:"table:table_user, do:true"`
|
||||
Id interface{} //
|
||||
Passport interface{} //
|
||||
Password interface{} //
|
||||
Nickname interface{} //
|
||||
Id any //
|
||||
Passport any //
|
||||
Password any //
|
||||
Nickname any //
|
||||
CreatedAt *gtime.Time //
|
||||
UpdatedAt *gtime.Time //
|
||||
}
|
||||
|
||||
@ -12,11 +12,11 @@ import (
|
||||
// TableUser is the golang structure of table table_user for DAO operations like Where/Data.
|
||||
type TableUser struct {
|
||||
g.Meta `orm:"table:table_user, do:true"`
|
||||
Id interface{} // User ID
|
||||
Passport interface{} // User Passport
|
||||
Password interface{} // User Password
|
||||
Nickname interface{} // User Nickname
|
||||
Score interface{} // Total score amount.
|
||||
Id any // User ID
|
||||
Passport any // User Passport
|
||||
Password any // User Password
|
||||
Nickname any // User Nickname
|
||||
Score any // Total score amount.
|
||||
CreateAt *gtime.Time // Created Time
|
||||
UpdateAt *gtime.Time // Updated Time
|
||||
}
|
||||
|
||||
@ -63,14 +63,14 @@ func (s *sArticle) T3(ctx context.Context, b *gdbas.Model) (c, d *gdbas.Model, e
|
||||
* random comment
|
||||
*/
|
||||
|
||||
// func (s *sArticle) T4(i interface{}) interface{}
|
||||
// func (s *sArticle) T4(i any) any
|
||||
// # $ % ^ & * ( ) _ + - = { } | [ ] \ : " ; ' < > ? , . /
|
||||
func (s *sArticle) T4(i interface{}) interface{} {
|
||||
func (s *sArticle) T4(i any) any {
|
||||
return nil
|
||||
}
|
||||
|
||||
/**
|
||||
* func (s *sArticle) T4(i interface{}) interface{} {
|
||||
* func (s *sArticle) T4(i any) any {
|
||||
* return nil
|
||||
* }
|
||||
*/
|
||||
|
||||
@ -36,9 +36,9 @@ type (
|
||||
* @author oldme
|
||||
*/
|
||||
T3(ctx context.Context, b *gdbas.Model) (c *gdbas.Model, d *gdbas.Model, err error)
|
||||
// func (s *sArticle) T4(i interface{}) interface{}
|
||||
// func (s *sArticle) T4(i any) any
|
||||
// # $ % ^ & * ( ) _ + - = { } | [ ] \ : " ; ' < > ? , . /
|
||||
T4(i interface{}) interface{}
|
||||
T4(i any) any
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@ -12,11 +12,11 @@ import (
|
||||
// User1 is the golang structure of table user1 for DAO operations like Where/Data.
|
||||
type User1 struct {
|
||||
g.Meta `orm:"table:user1, do:true"`
|
||||
Id interface{} // User ID
|
||||
Passport interface{} // User Passport
|
||||
Password interface{} // User Password
|
||||
Nickname interface{} // User Nickname
|
||||
Score interface{} // Total score amount.
|
||||
Id any // User ID
|
||||
Passport any // User Passport
|
||||
Password any // User Password
|
||||
Nickname any // User Nickname
|
||||
Score any // Total score amount.
|
||||
CreateAt *gtime.Time // Created Time
|
||||
UpdateAt *gtime.Time // Updated Time
|
||||
}
|
||||
|
||||
@ -12,11 +12,11 @@ import (
|
||||
// User2 is the golang structure of table user2 for DAO operations like Where/Data.
|
||||
type User2 struct {
|
||||
g.Meta `orm:"table:user2, do:true"`
|
||||
Id interface{} // User ID
|
||||
Passport interface{} // User Passport
|
||||
Password interface{} // User Password
|
||||
Nickname interface{} // User Nickname
|
||||
Score interface{} // Total score amount.
|
||||
Id any // User ID
|
||||
Passport any // User Passport
|
||||
Password any // User Password
|
||||
Nickname any // User Nickname
|
||||
Score any // Total score amount.
|
||||
CreateAt *gtime.Time // Created Time
|
||||
UpdateAt *gtime.Time // Updated Time
|
||||
}
|
||||
|
||||
@ -12,11 +12,11 @@ import (
|
||||
// User1 is the golang structure of table user1 for DAO operations like Where/Data.
|
||||
type User1 struct {
|
||||
g.Meta `orm:"table:user1, do:true"`
|
||||
Id interface{} // User ID
|
||||
Passport interface{} // User Passport
|
||||
Password interface{} // User Password
|
||||
Nickname interface{} // User Nickname
|
||||
Score interface{} // Total score amount.
|
||||
Id any // User ID
|
||||
Passport any // User Passport
|
||||
Password any // User Password
|
||||
Nickname any // User Nickname
|
||||
Score any // Total score amount.
|
||||
CreateAt *gtime.Time // Created Time
|
||||
UpdateAt *gtime.Time // Updated Time
|
||||
}
|
||||
|
||||
@ -12,11 +12,11 @@ import (
|
||||
// User2 is the golang structure of table user2 for DAO operations like Where/Data.
|
||||
type User2 struct {
|
||||
g.Meta `orm:"table:user2, do:true"`
|
||||
Id interface{} // User ID
|
||||
Passport interface{} // User Passport
|
||||
Password interface{} // User Password
|
||||
Nickname interface{} // User Nickname
|
||||
Score interface{} // Total score amount.
|
||||
Id any // User ID
|
||||
Passport any // User Passport
|
||||
Password any // User Password
|
||||
Nickname any // User Nickname
|
||||
Score any // Total score amount.
|
||||
CreateAt *gtime.Time // Created Time
|
||||
UpdateAt *gtime.Time // Updated Time
|
||||
}
|
||||
|
||||
@ -12,11 +12,11 @@ import (
|
||||
// TableUser is the golang structure of table table_user for DAO operations like Where/Data.
|
||||
type TableUser struct {
|
||||
g.Meta `orm:"table:table_user, do:true"`
|
||||
Id interface{} // User ID
|
||||
ParentId interface{} //
|
||||
Passport interface{} // User Passport
|
||||
PassWord interface{} // User Password
|
||||
Nickname2 interface{} // User Nickname
|
||||
Id any // User ID
|
||||
ParentId any //
|
||||
Passport any // User Passport
|
||||
PassWord any // User Password
|
||||
Nickname2 any // User Nickname
|
||||
CreateAt *gtime.Time // Created Time
|
||||
UpdateAt *gtime.Time // Updated Time
|
||||
}
|
||||
|
||||
@ -51,26 +51,26 @@ func SetHeaderPrint(enabled bool) {
|
||||
}
|
||||
}
|
||||
|
||||
func Print(v ...interface{}) {
|
||||
func Print(v ...any) {
|
||||
logger.Print(ctx, v...)
|
||||
}
|
||||
|
||||
func Printf(format string, v ...interface{}) {
|
||||
func Printf(format string, v ...any) {
|
||||
logger.Printf(ctx, format, v...)
|
||||
}
|
||||
|
||||
func Fatal(v ...interface{}) {
|
||||
func Fatal(v ...any) {
|
||||
logger.Fatal(ctx, v...)
|
||||
}
|
||||
|
||||
func Fatalf(format string, v ...interface{}) {
|
||||
func Fatalf(format string, v ...any) {
|
||||
logger.Fatalf(ctx, format, v...)
|
||||
}
|
||||
|
||||
func Debug(v ...interface{}) {
|
||||
func Debug(v ...any) {
|
||||
logger.Debug(ctx, v...)
|
||||
}
|
||||
|
||||
func Debugf(format string, v ...interface{}) {
|
||||
func Debugf(format string, v ...any) {
|
||||
logger.Debugf(ctx, format, v...)
|
||||
}
|
||||
|
||||
@ -12,12 +12,13 @@ import (
|
||||
|
||||
"golang.org/x/tools/imports"
|
||||
|
||||
"github.com/gogf/gf/cmd/gf/v2/internal/consts"
|
||||
"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
|
||||
"github.com/gogf/gf/v2/os/gfile"
|
||||
"github.com/gogf/gf/v2/os/gproc"
|
||||
"github.com/gogf/gf/v2/text/gregex"
|
||||
"github.com/gogf/gf/v2/text/gstr"
|
||||
|
||||
"github.com/gogf/gf/cmd/gf/v2/internal/consts"
|
||||
"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
|
||||
)
|
||||
|
||||
// GoFmt formats the source file and adds or removes import statements as necessary.
|
||||
|
||||
@ -28,7 +28,7 @@ import (
|
||||
// when its initialization and cannot be changed then.
|
||||
type Array struct {
|
||||
mu rwmutex.RWMutex
|
||||
array []interface{}
|
||||
array []any
|
||||
}
|
||||
|
||||
// New creates and returns an empty array.
|
||||
@ -49,7 +49,7 @@ func NewArray(safe ...bool) *Array {
|
||||
func NewArraySize(size int, cap int, safe ...bool) *Array {
|
||||
return &Array{
|
||||
mu: rwmutex.Create(safe...),
|
||||
array: make([]interface{}, size, cap),
|
||||
array: make([]any, size, cap),
|
||||
}
|
||||
}
|
||||
|
||||
@ -59,7 +59,7 @@ func NewArrayRange(start, end, step int, safe ...bool) *Array {
|
||||
if step == 0 {
|
||||
panic(fmt.Sprintf(`invalid step value: %d`, step))
|
||||
}
|
||||
slice := make([]interface{}, 0)
|
||||
slice := make([]any, 0)
|
||||
index := 0
|
||||
for i := start; i <= end; i += step {
|
||||
slice = append(slice, i)
|
||||
@ -70,20 +70,20 @@ func NewArrayRange(start, end, step int, safe ...bool) *Array {
|
||||
|
||||
// NewFrom is alias of NewArrayFrom.
|
||||
// See NewArrayFrom.
|
||||
func NewFrom(array []interface{}, safe ...bool) *Array {
|
||||
func NewFrom(array []any, safe ...bool) *Array {
|
||||
return NewArrayFrom(array, safe...)
|
||||
}
|
||||
|
||||
// NewFromCopy is alias of NewArrayFromCopy.
|
||||
// See NewArrayFromCopy.
|
||||
func NewFromCopy(array []interface{}, safe ...bool) *Array {
|
||||
func NewFromCopy(array []any, safe ...bool) *Array {
|
||||
return NewArrayFromCopy(array, safe...)
|
||||
}
|
||||
|
||||
// NewArrayFrom creates and returns an array with given slice `array`.
|
||||
// The parameter `safe` is used to specify whether using array in concurrent-safety,
|
||||
// which is false in default.
|
||||
func NewArrayFrom(array []interface{}, safe ...bool) *Array {
|
||||
func NewArrayFrom(array []any, safe ...bool) *Array {
|
||||
return &Array{
|
||||
mu: rwmutex.Create(safe...),
|
||||
array: array,
|
||||
@ -93,8 +93,8 @@ func NewArrayFrom(array []interface{}, safe ...bool) *Array {
|
||||
// NewArrayFromCopy creates and returns an array from a copy of given slice `array`.
|
||||
// The parameter `safe` is used to specify whether using array in concurrent-safety,
|
||||
// which is false in default.
|
||||
func NewArrayFromCopy(array []interface{}, safe ...bool) *Array {
|
||||
newArray := make([]interface{}, len(array))
|
||||
func NewArrayFromCopy(array []any, safe ...bool) *Array {
|
||||
newArray := make([]any, len(array))
|
||||
copy(newArray, array)
|
||||
return &Array{
|
||||
mu: rwmutex.Create(safe...),
|
||||
@ -104,14 +104,14 @@ func NewArrayFromCopy(array []interface{}, safe ...bool) *Array {
|
||||
|
||||
// At returns the value by the specified index.
|
||||
// If the given `index` is out of range of the array, it returns `nil`.
|
||||
func (a *Array) At(index int) (value interface{}) {
|
||||
func (a *Array) At(index int) (value any) {
|
||||
value, _ = a.Get(index)
|
||||
return
|
||||
}
|
||||
|
||||
// Get returns the value by the specified index.
|
||||
// If the given `index` is out of range of the array, the `found` is false.
|
||||
func (a *Array) Get(index int) (value interface{}, found bool) {
|
||||
func (a *Array) Get(index int) (value any, found bool) {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
if index < 0 || index >= len(a.array) {
|
||||
@ -121,7 +121,7 @@ func (a *Array) Get(index int) (value interface{}, found bool) {
|
||||
}
|
||||
|
||||
// Set sets value to specified index.
|
||||
func (a *Array) Set(index int, value interface{}) error {
|
||||
func (a *Array) Set(index int, value any) error {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if index < 0 || index >= len(a.array) {
|
||||
@ -132,7 +132,7 @@ func (a *Array) Set(index int, value interface{}) error {
|
||||
}
|
||||
|
||||
// SetArray sets the underlying slice array with the given `array`.
|
||||
func (a *Array) SetArray(array []interface{}) *Array {
|
||||
func (a *Array) SetArray(array []any) *Array {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
a.array = array
|
||||
@ -140,7 +140,7 @@ func (a *Array) SetArray(array []interface{}) *Array {
|
||||
}
|
||||
|
||||
// Replace replaces the array items by given `array` from the beginning of array.
|
||||
func (a *Array) Replace(array []interface{}) *Array {
|
||||
func (a *Array) Replace(array []any) *Array {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
max := len(array)
|
||||
@ -164,7 +164,7 @@ func (a *Array) Sum() (sum int) {
|
||||
}
|
||||
|
||||
// SortFunc sorts the array by custom function `less`.
|
||||
func (a *Array) SortFunc(less func(v1, v2 interface{}) bool) *Array {
|
||||
func (a *Array) SortFunc(less func(v1, v2 any) bool) *Array {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
sort.Slice(a.array, func(i, j int) bool {
|
||||
@ -174,26 +174,26 @@ func (a *Array) SortFunc(less func(v1, v2 interface{}) bool) *Array {
|
||||
}
|
||||
|
||||
// InsertBefore inserts the `values` to the front of `index`.
|
||||
func (a *Array) InsertBefore(index int, values ...interface{}) error {
|
||||
func (a *Array) InsertBefore(index int, values ...any) error {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if index < 0 || index >= len(a.array) {
|
||||
return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
|
||||
}
|
||||
rear := append([]interface{}{}, a.array[index:]...)
|
||||
rear := append([]any{}, a.array[index:]...)
|
||||
a.array = append(a.array[0:index], values...)
|
||||
a.array = append(a.array, rear...)
|
||||
return nil
|
||||
}
|
||||
|
||||
// InsertAfter inserts the `values` to the back of `index`.
|
||||
func (a *Array) InsertAfter(index int, values ...interface{}) error {
|
||||
func (a *Array) InsertAfter(index int, values ...any) error {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if index < 0 || index >= len(a.array) {
|
||||
return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
|
||||
}
|
||||
rear := append([]interface{}{}, a.array[index+1:]...)
|
||||
rear := append([]any{}, a.array[index+1:]...)
|
||||
a.array = append(a.array[0:index+1], values...)
|
||||
a.array = append(a.array, rear...)
|
||||
return nil
|
||||
@ -201,14 +201,14 @@ func (a *Array) InsertAfter(index int, values ...interface{}) error {
|
||||
|
||||
// Remove removes an item by index.
|
||||
// If the given `index` is out of range of the array, the `found` is false.
|
||||
func (a *Array) Remove(index int) (value interface{}, found bool) {
|
||||
func (a *Array) Remove(index int) (value any, found bool) {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
return a.doRemoveWithoutLock(index)
|
||||
}
|
||||
|
||||
// doRemoveWithoutLock removes an item by index without lock.
|
||||
func (a *Array) doRemoveWithoutLock(index int) (value interface{}, found bool) {
|
||||
func (a *Array) doRemoveWithoutLock(index int) (value any, found bool) {
|
||||
if index < 0 || index >= len(a.array) {
|
||||
return nil, false
|
||||
}
|
||||
@ -232,7 +232,7 @@ func (a *Array) doRemoveWithoutLock(index int) (value interface{}, found bool) {
|
||||
|
||||
// RemoveValue removes an item by value.
|
||||
// It returns true if value is found in the array, or else false if not found.
|
||||
func (a *Array) RemoveValue(value interface{}) bool {
|
||||
func (a *Array) RemoveValue(value any) bool {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if i := a.doSearchWithoutLock(value); i != -1 {
|
||||
@ -243,7 +243,7 @@ func (a *Array) RemoveValue(value interface{}) bool {
|
||||
}
|
||||
|
||||
// RemoveValues removes multiple items by `values`.
|
||||
func (a *Array) RemoveValues(values ...interface{}) {
|
||||
func (a *Array) RemoveValues(values ...any) {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
for _, value := range values {
|
||||
@ -254,7 +254,7 @@ func (a *Array) RemoveValues(values ...interface{}) {
|
||||
}
|
||||
|
||||
// PushLeft pushes one or multiple items to the beginning of array.
|
||||
func (a *Array) PushLeft(value ...interface{}) *Array {
|
||||
func (a *Array) PushLeft(value ...any) *Array {
|
||||
a.mu.Lock()
|
||||
a.array = append(value, a.array...)
|
||||
a.mu.Unlock()
|
||||
@ -263,7 +263,7 @@ func (a *Array) PushLeft(value ...interface{}) *Array {
|
||||
|
||||
// PushRight pushes one or multiple items to the end of array.
|
||||
// It equals to Append.
|
||||
func (a *Array) PushRight(value ...interface{}) *Array {
|
||||
func (a *Array) PushRight(value ...any) *Array {
|
||||
a.mu.Lock()
|
||||
a.array = append(a.array, value...)
|
||||
a.mu.Unlock()
|
||||
@ -272,14 +272,14 @@ func (a *Array) PushRight(value ...interface{}) *Array {
|
||||
|
||||
// PopRand randomly pops and return an item out of array.
|
||||
// Note that if the array is empty, the `found` is false.
|
||||
func (a *Array) PopRand() (value interface{}, found bool) {
|
||||
func (a *Array) PopRand() (value any, found bool) {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
|
||||
}
|
||||
|
||||
// PopRands randomly pops and returns `size` items out of array.
|
||||
func (a *Array) PopRands(size int) []interface{} {
|
||||
func (a *Array) PopRands(size int) []any {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if size <= 0 || len(a.array) == 0 {
|
||||
@ -288,7 +288,7 @@ func (a *Array) PopRands(size int) []interface{} {
|
||||
if size >= len(a.array) {
|
||||
size = len(a.array)
|
||||
}
|
||||
array := make([]interface{}, size)
|
||||
array := make([]any, size)
|
||||
for i := 0; i < size; i++ {
|
||||
array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
|
||||
}
|
||||
@ -297,7 +297,7 @@ func (a *Array) PopRands(size int) []interface{} {
|
||||
|
||||
// PopLeft pops and returns an item from the beginning of array.
|
||||
// Note that if the array is empty, the `found` is false.
|
||||
func (a *Array) PopLeft() (value interface{}, found bool) {
|
||||
func (a *Array) PopLeft() (value any, found bool) {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if len(a.array) == 0 {
|
||||
@ -310,7 +310,7 @@ func (a *Array) PopLeft() (value interface{}, found bool) {
|
||||
|
||||
// PopRight pops and returns an item from the end of array.
|
||||
// Note that if the array is empty, the `found` is false.
|
||||
func (a *Array) PopRight() (value interface{}, found bool) {
|
||||
func (a *Array) PopRight() (value any, found bool) {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
index := len(a.array) - 1
|
||||
@ -323,7 +323,7 @@ func (a *Array) PopRight() (value interface{}, found bool) {
|
||||
}
|
||||
|
||||
// PopLefts pops and returns `size` items from the beginning of array.
|
||||
func (a *Array) PopLefts(size int) []interface{} {
|
||||
func (a *Array) PopLefts(size int) []any {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if size <= 0 || len(a.array) == 0 {
|
||||
@ -340,7 +340,7 @@ func (a *Array) PopLefts(size int) []interface{} {
|
||||
}
|
||||
|
||||
// PopRights pops and returns `size` items from the end of array.
|
||||
func (a *Array) PopRights(size int) []interface{} {
|
||||
func (a *Array) PopRights(size int) []any {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if size <= 0 || len(a.array) == 0 {
|
||||
@ -364,7 +364,7 @@ func (a *Array) PopRights(size int) []interface{} {
|
||||
// If `end` is negative, then the offset will start from the end of array.
|
||||
// If `end` is omitted, then the sequence will have everything from start up
|
||||
// until the end of the array.
|
||||
func (a *Array) Range(start int, end ...int) []interface{} {
|
||||
func (a *Array) Range(start int, end ...int) []any {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
offsetEnd := len(a.array)
|
||||
@ -377,9 +377,9 @@ func (a *Array) Range(start int, end ...int) []interface{} {
|
||||
if start < 0 {
|
||||
start = 0
|
||||
}
|
||||
array := ([]interface{})(nil)
|
||||
array := ([]any)(nil)
|
||||
if a.mu.IsSafe() {
|
||||
array = make([]interface{}, offsetEnd-start)
|
||||
array = make([]any, offsetEnd-start)
|
||||
copy(array, a.array[start:offsetEnd])
|
||||
} else {
|
||||
array = a.array[start:offsetEnd]
|
||||
@ -400,7 +400,7 @@ func (a *Array) Range(start int, end ...int) []interface{} {
|
||||
// If it is omitted, then the sequence will have everything from offset up until the end of the array.
|
||||
//
|
||||
// Any possibility crossing the left border of array, it will fail.
|
||||
func (a *Array) SubSlice(offset int, length ...int) []interface{} {
|
||||
func (a *Array) SubSlice(offset int, length ...int) []any {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
size := len(a.array)
|
||||
@ -429,7 +429,7 @@ func (a *Array) SubSlice(offset int, length ...int) []interface{} {
|
||||
size = len(a.array) - offset
|
||||
}
|
||||
if a.mu.IsSafe() {
|
||||
s := make([]interface{}, size)
|
||||
s := make([]any, size)
|
||||
copy(s, a.array[offset:])
|
||||
return s
|
||||
} else {
|
||||
@ -438,7 +438,7 @@ func (a *Array) SubSlice(offset int, length ...int) []interface{} {
|
||||
}
|
||||
|
||||
// Append is alias of PushRight, please See PushRight.
|
||||
func (a *Array) Append(value ...interface{}) *Array {
|
||||
func (a *Array) Append(value ...any) *Array {
|
||||
a.PushRight(value...)
|
||||
return a
|
||||
}
|
||||
@ -454,11 +454,11 @@ func (a *Array) Len() int {
|
||||
// Slice returns the underlying data of array.
|
||||
// Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
|
||||
// or else a pointer to the underlying data.
|
||||
func (a *Array) Slice() []interface{} {
|
||||
func (a *Array) Slice() []any {
|
||||
if a.mu.IsSafe() {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
array := make([]interface{}, len(a.array))
|
||||
array := make([]any, len(a.array))
|
||||
copy(array, a.array)
|
||||
return array
|
||||
} else {
|
||||
@ -466,15 +466,15 @@ func (a *Array) Slice() []interface{} {
|
||||
}
|
||||
}
|
||||
|
||||
// Interfaces returns current array as []interface{}.
|
||||
func (a *Array) Interfaces() []interface{} {
|
||||
// Interfaces returns current array as []any.
|
||||
func (a *Array) Interfaces() []any {
|
||||
return a.Slice()
|
||||
}
|
||||
|
||||
// Clone returns 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))
|
||||
array := make([]any, len(a.array))
|
||||
copy(array, a.array)
|
||||
a.mu.RUnlock()
|
||||
return NewArrayFrom(array, a.mu.IsSafe())
|
||||
@ -484,26 +484,26 @@ func (a *Array) Clone() (newArray *Array) {
|
||||
func (a *Array) Clear() *Array {
|
||||
a.mu.Lock()
|
||||
if len(a.array) > 0 {
|
||||
a.array = make([]interface{}, 0)
|
||||
a.array = make([]any, 0)
|
||||
}
|
||||
a.mu.Unlock()
|
||||
return a
|
||||
}
|
||||
|
||||
// Contains checks whether a value exists in the array.
|
||||
func (a *Array) Contains(value interface{}) bool {
|
||||
func (a *Array) Contains(value any) bool {
|
||||
return a.Search(value) != -1
|
||||
}
|
||||
|
||||
// Search searches array by `value`, returns the index of `value`,
|
||||
// or returns -1 if not exists.
|
||||
func (a *Array) Search(value interface{}) int {
|
||||
func (a *Array) Search(value any) int {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
return a.doSearchWithoutLock(value)
|
||||
}
|
||||
|
||||
func (a *Array) doSearchWithoutLock(value interface{}) int {
|
||||
func (a *Array) doSearchWithoutLock(value any) int {
|
||||
if len(a.array) == 0 {
|
||||
return -1
|
||||
}
|
||||
@ -527,9 +527,9 @@ func (a *Array) Unique() *Array {
|
||||
}
|
||||
var (
|
||||
ok bool
|
||||
temp interface{}
|
||||
uniqueSet = make(map[interface{}]struct{})
|
||||
uniqueArray = make([]interface{}, 0, len(a.array))
|
||||
temp any
|
||||
uniqueSet = make(map[any]struct{})
|
||||
uniqueArray = make([]any, 0, len(a.array))
|
||||
)
|
||||
for i := 0; i < len(a.array); i++ {
|
||||
temp = a.array[i]
|
||||
@ -544,7 +544,7 @@ func (a *Array) Unique() *Array {
|
||||
}
|
||||
|
||||
// LockFunc locks writing by callback function `f`.
|
||||
func (a *Array) LockFunc(f func(array []interface{})) *Array {
|
||||
func (a *Array) LockFunc(f func(array []any)) *Array {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
f(a.array)
|
||||
@ -552,7 +552,7 @@ func (a *Array) LockFunc(f func(array []interface{})) *Array {
|
||||
}
|
||||
|
||||
// RLockFunc locks reading by callback function `f`.
|
||||
func (a *Array) RLockFunc(f func(array []interface{})) *Array {
|
||||
func (a *Array) RLockFunc(f func(array []any)) *Array {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
f(a.array)
|
||||
@ -563,13 +563,13 @@ func (a *Array) RLockFunc(f func(array []interface{})) *Array {
|
||||
// The parameter `array` can be any garray or slice type.
|
||||
// The difference between Merge and Append is Append supports only specified slice type,
|
||||
// but Merge supports more parameter types.
|
||||
func (a *Array) Merge(array interface{}) *Array {
|
||||
func (a *Array) Merge(array any) *Array {
|
||||
return a.Append(gconv.Interfaces(array)...)
|
||||
}
|
||||
|
||||
// Fill fills an array with num entries of the value `value`,
|
||||
// keys starting at the `startIndex` parameter.
|
||||
func (a *Array) Fill(startIndex int, num int, value interface{}) error {
|
||||
func (a *Array) Fill(startIndex int, num int, value any) error {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if startIndex < 0 || startIndex > len(a.array) {
|
||||
@ -588,7 +588,7 @@ func (a *Array) Fill(startIndex int, num int, value interface{}) error {
|
||||
// Chunk splits an array into multiple arrays,
|
||||
// the size of each array is determined by `size`.
|
||||
// The last chunk may contain less than size elements.
|
||||
func (a *Array) Chunk(size int) [][]interface{} {
|
||||
func (a *Array) Chunk(size int) [][]any {
|
||||
if size < 1 {
|
||||
return nil
|
||||
}
|
||||
@ -596,7 +596,7 @@ func (a *Array) Chunk(size int) [][]interface{} {
|
||||
defer a.mu.RUnlock()
|
||||
length := len(a.array)
|
||||
chunks := int(math.Ceil(float64(length) / float64(size)))
|
||||
var n [][]interface{}
|
||||
var n [][]any
|
||||
for i, end := 0, 0; chunks > 0; chunks-- {
|
||||
end = (i + 1) * size
|
||||
if end > length {
|
||||
@ -612,7 +612,7 @@ func (a *Array) Chunk(size int) [][]interface{} {
|
||||
// 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.
|
||||
func (a *Array) Pad(size int, val interface{}) *Array {
|
||||
func (a *Array) Pad(size int, val any) *Array {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if size == 0 || (size > 0 && size < len(a.array)) || (size < 0 && size > -len(a.array)) {
|
||||
@ -623,7 +623,7 @@ func (a *Array) Pad(size int, val interface{}) *Array {
|
||||
n = -size
|
||||
}
|
||||
n -= len(a.array)
|
||||
tmp := make([]interface{}, n)
|
||||
tmp := make([]any, n)
|
||||
for i := 0; i < n; i++ {
|
||||
tmp[i] = val
|
||||
}
|
||||
@ -636,7 +636,7 @@ func (a *Array) Pad(size int, val interface{}) *Array {
|
||||
}
|
||||
|
||||
// Rand randomly returns one item from array(no deleting).
|
||||
func (a *Array) Rand() (value interface{}, found bool) {
|
||||
func (a *Array) Rand() (value any, found bool) {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
if len(a.array) == 0 {
|
||||
@ -646,13 +646,13 @@ func (a *Array) Rand() (value interface{}, found bool) {
|
||||
}
|
||||
|
||||
// Rands randomly returns `size` items from array(no deleting).
|
||||
func (a *Array) Rands(size int) []interface{} {
|
||||
func (a *Array) Rands(size int) []any {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
if size <= 0 || len(a.array) == 0 {
|
||||
return nil
|
||||
}
|
||||
array := make([]interface{}, size)
|
||||
array := make([]any, size)
|
||||
for i := 0; i < size; i++ {
|
||||
array[i] = a.array[grand.Intn(len(a.array))]
|
||||
}
|
||||
@ -697,8 +697,8 @@ func (a *Array) Join(glue string) string {
|
||||
}
|
||||
|
||||
// CountValues counts the number of occurrences of all values in the array.
|
||||
func (a *Array) CountValues() map[interface{}]int {
|
||||
m := make(map[interface{}]int)
|
||||
func (a *Array) CountValues() map[any]int {
|
||||
m := make(map[any]int)
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
for _, v := range a.array {
|
||||
@ -708,13 +708,13 @@ func (a *Array) CountValues() map[interface{}]int {
|
||||
}
|
||||
|
||||
// Iterator is alias of IteratorAsc.
|
||||
func (a *Array) Iterator(f func(k int, v interface{}) bool) {
|
||||
func (a *Array) Iterator(f func(k int, v any) bool) {
|
||||
a.IteratorAsc(f)
|
||||
}
|
||||
|
||||
// IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
func (a *Array) IteratorAsc(f func(k int, v interface{}) bool) {
|
||||
func (a *Array) IteratorAsc(f func(k int, v any) bool) {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
for k, v := range a.array {
|
||||
@ -726,7 +726,7 @@ func (a *Array) IteratorAsc(f func(k int, v interface{}) bool) {
|
||||
|
||||
// IteratorDesc iterates the array readonly in descending order with given callback function `f`.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
func (a *Array) IteratorDesc(f func(k int, v interface{}) bool) {
|
||||
func (a *Array) IteratorDesc(f func(k int, v any) bool) {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
for i := len(a.array) - 1; i >= 0; i-- {
|
||||
@ -772,7 +772,7 @@ func (a Array) MarshalJSON() ([]byte, error) {
|
||||
// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
|
||||
func (a *Array) UnmarshalJSON(b []byte) error {
|
||||
if a.array == nil {
|
||||
a.array = make([]interface{}, 0)
|
||||
a.array = make([]any, 0)
|
||||
}
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
@ -783,7 +783,7 @@ 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 {
|
||||
func (a *Array) UnmarshalValue(value any) error {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
switch value.(type) {
|
||||
@ -798,7 +798,7 @@ func (a *Array) UnmarshalValue(value interface{}) error {
|
||||
// Filter iterates array and filters elements using custom callback function.
|
||||
// It removes the element from array if callback function `filter` returns true,
|
||||
// it or else does nothing and continues iterating.
|
||||
func (a *Array) Filter(filter func(index int, value interface{}) bool) *Array {
|
||||
func (a *Array) Filter(filter func(index int, value any) bool) *Array {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
for i := 0; i < len(a.array); {
|
||||
@ -841,7 +841,7 @@ func (a *Array) FilterEmpty() *Array {
|
||||
}
|
||||
|
||||
// Walk applies a user supplied function `f` to every item of array.
|
||||
func (a *Array) Walk(f func(value interface{}) interface{}) *Array {
|
||||
func (a *Array) Walk(f func(value any) any) *Array {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
for i, v := range a.array {
|
||||
@ -856,13 +856,13 @@ func (a *Array) IsEmpty() bool {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (a *Array) DeepCopy() interface{} {
|
||||
func (a *Array) DeepCopy() any {
|
||||
if a == nil {
|
||||
return nil
|
||||
}
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
newSlice := make([]interface{}, len(a.array))
|
||||
newSlice := make([]any, len(a.array))
|
||||
for i, v := range a.array {
|
||||
newSlice[i] = deepcopy.Copy(v)
|
||||
}
|
||||
|
||||
@ -478,11 +478,11 @@ func (a *IntArray) Slice() []int {
|
||||
return array
|
||||
}
|
||||
|
||||
// Interfaces returns current array as []interface{}.
|
||||
func (a *IntArray) Interfaces() []interface{} {
|
||||
// Interfaces returns current array as []any.
|
||||
func (a *IntArray) Interfaces() []any {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
array := make([]interface{}, len(a.array))
|
||||
array := make([]any, len(a.array))
|
||||
for k, v := range a.array {
|
||||
array[k] = v
|
||||
}
|
||||
@ -581,7 +581,7 @@ func (a *IntArray) RLockFunc(f func(array []int)) *IntArray {
|
||||
// The parameter `array` can be any garray or slice type.
|
||||
// The difference between Merge and Append is Append supports only specified slice type,
|
||||
// but Merge supports more parameter types.
|
||||
func (a *IntArray) Merge(array interface{}) *IntArray {
|
||||
func (a *IntArray) Merge(array any) *IntArray {
|
||||
return a.Append(gconv.Ints(array)...)
|
||||
}
|
||||
|
||||
@ -788,7 +788,7 @@ 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 {
|
||||
func (a *IntArray) UnmarshalValue(value any) error {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
switch value.(type) {
|
||||
@ -846,7 +846,7 @@ func (a *IntArray) IsEmpty() bool {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (a *IntArray) DeepCopy() interface{} {
|
||||
func (a *IntArray) DeepCopy() any {
|
||||
if a == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -454,11 +454,11 @@ func (a *StrArray) Slice() []string {
|
||||
return array
|
||||
}
|
||||
|
||||
// Interfaces returns current array as []interface{}.
|
||||
func (a *StrArray) Interfaces() []interface{} {
|
||||
// Interfaces returns current array as []any.
|
||||
func (a *StrArray) Interfaces() []any {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
array := make([]interface{}, len(a.array))
|
||||
array := make([]any, len(a.array))
|
||||
for k, v := range a.array {
|
||||
array[k] = v
|
||||
}
|
||||
@ -573,7 +573,7 @@ func (a *StrArray) RLockFunc(f func(array []string)) *StrArray {
|
||||
// The parameter `array` can be any garray or slice type.
|
||||
// The difference between Merge and Append is Append supports only specified slice type,
|
||||
// but Merge supports more parameter types.
|
||||
func (a *StrArray) Merge(array interface{}) *StrArray {
|
||||
func (a *StrArray) Merge(array any) *StrArray {
|
||||
return a.Append(gconv.Strings(array)...)
|
||||
}
|
||||
|
||||
@ -787,7 +787,7 @@ 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 {
|
||||
func (a *StrArray) UnmarshalValue(value any) error {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
switch value.(type) {
|
||||
@ -845,7 +845,7 @@ func (a *StrArray) IsEmpty() bool {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (a *StrArray) DeepCopy() interface{} {
|
||||
func (a *StrArray) DeepCopy() any {
|
||||
if a == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -29,9 +29,9 @@ import (
|
||||
// when its initialization and cannot be changed then.
|
||||
type SortedArray struct {
|
||||
mu rwmutex.RWMutex
|
||||
array []interface{}
|
||||
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)
|
||||
array []any
|
||||
unique bool // Whether enable unique feature(false)
|
||||
comparator func(a, b any) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b)
|
||||
}
|
||||
|
||||
// NewSortedArray creates and returns an empty sorted array.
|
||||
@ -40,28 +40,28 @@ type SortedArray struct {
|
||||
// if it returns value < 0, means `a` < `b`; the `a` will be inserted before `b`;
|
||||
// if it returns value = 0, means `a` = `b`; the `a` will be replaced by `b`;
|
||||
// if it returns value > 0, means `a` > `b`; the `a` will be inserted after `b`;
|
||||
func NewSortedArray(comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
|
||||
func NewSortedArray(comparator func(a, b any) int, safe ...bool) *SortedArray {
|
||||
return NewSortedArraySize(0, comparator, safe...)
|
||||
}
|
||||
|
||||
// NewSortedArraySize create and returns an sorted array with given size and cap.
|
||||
// The parameter `safe` is used to specify whether using array in concurrent-safety,
|
||||
// which is false in default.
|
||||
func NewSortedArraySize(cap int, comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
|
||||
func NewSortedArraySize(cap int, comparator func(a, b any) int, safe ...bool) *SortedArray {
|
||||
return &SortedArray{
|
||||
mu: rwmutex.Create(safe...),
|
||||
array: make([]interface{}, 0, cap),
|
||||
array: make([]any, 0, cap),
|
||||
comparator: comparator,
|
||||
}
|
||||
}
|
||||
|
||||
// NewSortedArrayRange creates and returns an array by a range from `start` to `end`
|
||||
// with step value `step`.
|
||||
func NewSortedArrayRange(start, end, step int, comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
|
||||
func NewSortedArrayRange(start, end, step int, comparator func(a, b any) int, safe ...bool) *SortedArray {
|
||||
if step == 0 {
|
||||
panic(fmt.Sprintf(`invalid step value: %d`, step))
|
||||
}
|
||||
slice := make([]interface{}, 0)
|
||||
slice := make([]any, 0)
|
||||
index := 0
|
||||
for i := start; i <= end; i += step {
|
||||
slice = append(slice, i)
|
||||
@ -73,7 +73,7 @@ func NewSortedArrayRange(start, end, step int, comparator func(a, b interface{})
|
||||
// NewSortedArrayFrom creates and returns an sorted array with given slice `array`.
|
||||
// The parameter `safe` is used to specify whether using array in concurrent-safety,
|
||||
// which is false in default.
|
||||
func NewSortedArrayFrom(array []interface{}, comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
|
||||
func NewSortedArrayFrom(array []any, comparator func(a, b any) int, safe ...bool) *SortedArray {
|
||||
a := NewSortedArraySize(0, comparator, safe...)
|
||||
a.array = array
|
||||
sort.Slice(a.array, func(i, j int) bool {
|
||||
@ -85,21 +85,21 @@ func NewSortedArrayFrom(array []interface{}, comparator func(a, b interface{}) i
|
||||
// NewSortedArrayFromCopy creates and returns an sorted array from a copy of given slice `array`.
|
||||
// The parameter `safe` is used to specify whether using array in concurrent-safety,
|
||||
// which is false in default.
|
||||
func NewSortedArrayFromCopy(array []interface{}, comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
|
||||
newArray := make([]interface{}, len(array))
|
||||
func NewSortedArrayFromCopy(array []any, comparator func(a, b any) int, safe ...bool) *SortedArray {
|
||||
newArray := make([]any, len(array))
|
||||
copy(newArray, array)
|
||||
return NewSortedArrayFrom(newArray, comparator, safe...)
|
||||
}
|
||||
|
||||
// At returns the value by the specified index.
|
||||
// If the given `index` is out of range of the array, it returns `nil`.
|
||||
func (a *SortedArray) At(index int) (value interface{}) {
|
||||
func (a *SortedArray) At(index int) (value any) {
|
||||
value, _ = a.Get(index)
|
||||
return
|
||||
}
|
||||
|
||||
// SetArray sets the underlying slice array with the given `array`.
|
||||
func (a *SortedArray) SetArray(array []interface{}) *SortedArray {
|
||||
func (a *SortedArray) SetArray(array []any) *SortedArray {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
a.array = array
|
||||
@ -111,7 +111,7 @@ 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) {
|
||||
func (a *SortedArray) SetComparator(comparator func(a, b any) int) {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
a.comparator = comparator
|
||||
@ -134,12 +134,12 @@ func (a *SortedArray) Sort() *SortedArray {
|
||||
|
||||
// Add adds one or multiple values to sorted array, the array always keeps sorted.
|
||||
// It's alias of function Append, see Append.
|
||||
func (a *SortedArray) Add(values ...interface{}) *SortedArray {
|
||||
func (a *SortedArray) Add(values ...any) *SortedArray {
|
||||
return a.Append(values...)
|
||||
}
|
||||
|
||||
// Append adds one or multiple values to sorted array, the array always keeps sorted.
|
||||
func (a *SortedArray) Append(values ...interface{}) *SortedArray {
|
||||
func (a *SortedArray) Append(values ...any) *SortedArray {
|
||||
if len(values) == 0 {
|
||||
return a
|
||||
}
|
||||
@ -157,14 +157,14 @@ func (a *SortedArray) Append(values ...interface{}) *SortedArray {
|
||||
if cmp > 0 {
|
||||
index++
|
||||
}
|
||||
a.array = append(a.array[:index], append([]interface{}{value}, a.array[index:]...)...)
|
||||
a.array = append(a.array[:index], append([]any{value}, a.array[index:]...)...)
|
||||
}
|
||||
return a
|
||||
}
|
||||
|
||||
// Get returns the value by the specified index.
|
||||
// If the given `index` is out of range of the array, the `found` is false.
|
||||
func (a *SortedArray) Get(index int) (value interface{}, found bool) {
|
||||
func (a *SortedArray) Get(index int) (value any, found bool) {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
if index < 0 || index >= len(a.array) {
|
||||
@ -175,14 +175,14 @@ func (a *SortedArray) Get(index int) (value interface{}, found bool) {
|
||||
|
||||
// Remove removes an item by index.
|
||||
// If the given `index` is out of range of the array, the `found` is false.
|
||||
func (a *SortedArray) Remove(index int) (value interface{}, found bool) {
|
||||
func (a *SortedArray) Remove(index int) (value any, found bool) {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
return a.doRemoveWithoutLock(index)
|
||||
}
|
||||
|
||||
// doRemoveWithoutLock removes an item by index without lock.
|
||||
func (a *SortedArray) doRemoveWithoutLock(index int) (value interface{}, found bool) {
|
||||
func (a *SortedArray) doRemoveWithoutLock(index int) (value any, found bool) {
|
||||
if index < 0 || index >= len(a.array) {
|
||||
return nil, false
|
||||
}
|
||||
@ -206,7 +206,7 @@ func (a *SortedArray) doRemoveWithoutLock(index int) (value interface{}, found b
|
||||
|
||||
// RemoveValue removes an item by value.
|
||||
// It returns true if value is found in the array, or else false if not found.
|
||||
func (a *SortedArray) RemoveValue(value interface{}) bool {
|
||||
func (a *SortedArray) RemoveValue(value any) bool {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if i, r := a.binSearch(value, false); r == 0 {
|
||||
@ -217,7 +217,7 @@ func (a *SortedArray) RemoveValue(value interface{}) bool {
|
||||
}
|
||||
|
||||
// RemoveValues removes an item by `values`.
|
||||
func (a *SortedArray) RemoveValues(values ...interface{}) {
|
||||
func (a *SortedArray) RemoveValues(values ...any) {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
for _, value := range values {
|
||||
@ -229,7 +229,7 @@ func (a *SortedArray) RemoveValues(values ...interface{}) {
|
||||
|
||||
// PopLeft pops and returns an item from the beginning of array.
|
||||
// Note that if the array is empty, the `found` is false.
|
||||
func (a *SortedArray) PopLeft() (value interface{}, found bool) {
|
||||
func (a *SortedArray) PopLeft() (value any, found bool) {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if len(a.array) == 0 {
|
||||
@ -242,7 +242,7 @@ func (a *SortedArray) PopLeft() (value interface{}, found bool) {
|
||||
|
||||
// PopRight pops and returns an item from the end of array.
|
||||
// Note that if the array is empty, the `found` is false.
|
||||
func (a *SortedArray) PopRight() (value interface{}, found bool) {
|
||||
func (a *SortedArray) PopRight() (value any, found bool) {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
index := len(a.array) - 1
|
||||
@ -256,14 +256,14 @@ func (a *SortedArray) PopRight() (value interface{}, found bool) {
|
||||
|
||||
// PopRand randomly pops and return an item out of array.
|
||||
// Note that if the array is empty, the `found` is false.
|
||||
func (a *SortedArray) PopRand() (value interface{}, found bool) {
|
||||
func (a *SortedArray) PopRand() (value any, found bool) {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
|
||||
}
|
||||
|
||||
// PopRands randomly pops and returns `size` items out of array.
|
||||
func (a *SortedArray) PopRands(size int) []interface{} {
|
||||
func (a *SortedArray) PopRands(size int) []any {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if size <= 0 || len(a.array) == 0 {
|
||||
@ -272,7 +272,7 @@ func (a *SortedArray) PopRands(size int) []interface{} {
|
||||
if size >= len(a.array) {
|
||||
size = len(a.array)
|
||||
}
|
||||
array := make([]interface{}, size)
|
||||
array := make([]any, size)
|
||||
for i := 0; i < size; i++ {
|
||||
array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
|
||||
}
|
||||
@ -280,7 +280,7 @@ func (a *SortedArray) PopRands(size int) []interface{} {
|
||||
}
|
||||
|
||||
// PopLefts pops and returns `size` items from the beginning of array.
|
||||
func (a *SortedArray) PopLefts(size int) []interface{} {
|
||||
func (a *SortedArray) PopLefts(size int) []any {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if size <= 0 || len(a.array) == 0 {
|
||||
@ -297,7 +297,7 @@ func (a *SortedArray) PopLefts(size int) []interface{} {
|
||||
}
|
||||
|
||||
// PopRights pops and returns `size` items from the end of array.
|
||||
func (a *SortedArray) PopRights(size int) []interface{} {
|
||||
func (a *SortedArray) PopRights(size int) []any {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
if size <= 0 || len(a.array) == 0 {
|
||||
@ -321,7 +321,7 @@ func (a *SortedArray) PopRights(size int) []interface{} {
|
||||
// If `end` is negative, then the offset will start from the end of array.
|
||||
// If `end` is omitted, then the sequence will have everything from start up
|
||||
// until the end of the array.
|
||||
func (a *SortedArray) Range(start int, end ...int) []interface{} {
|
||||
func (a *SortedArray) Range(start int, end ...int) []any {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
offsetEnd := len(a.array)
|
||||
@ -334,9 +334,9 @@ func (a *SortedArray) Range(start int, end ...int) []interface{} {
|
||||
if start < 0 {
|
||||
start = 0
|
||||
}
|
||||
array := ([]interface{})(nil)
|
||||
array := ([]any)(nil)
|
||||
if a.mu.IsSafe() {
|
||||
array = make([]interface{}, offsetEnd-start)
|
||||
array = make([]any, offsetEnd-start)
|
||||
copy(array, a.array[start:offsetEnd])
|
||||
} else {
|
||||
array = a.array[start:offsetEnd]
|
||||
@ -357,7 +357,7 @@ func (a *SortedArray) Range(start int, end ...int) []interface{} {
|
||||
// If it is omitted, then the sequence will have everything from offset up until the end of the array.
|
||||
//
|
||||
// Any possibility crossing the left border of array, it will fail.
|
||||
func (a *SortedArray) SubSlice(offset int, length ...int) []interface{} {
|
||||
func (a *SortedArray) SubSlice(offset int, length ...int) []any {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
size := len(a.array)
|
||||
@ -386,7 +386,7 @@ func (a *SortedArray) SubSlice(offset int, length ...int) []interface{} {
|
||||
size = len(a.array) - offset
|
||||
}
|
||||
if a.mu.IsSafe() {
|
||||
s := make([]interface{}, size)
|
||||
s := make([]any, size)
|
||||
copy(s, a.array[offset:])
|
||||
return s
|
||||
} else {
|
||||
@ -415,12 +415,12 @@ func (a *SortedArray) Len() int {
|
||||
// Slice returns the underlying data of array.
|
||||
// Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
|
||||
// or else a pointer to the underlying data.
|
||||
func (a *SortedArray) Slice() []interface{} {
|
||||
var array []interface{}
|
||||
func (a *SortedArray) Slice() []any {
|
||||
var array []any
|
||||
if a.mu.IsSafe() {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
array = make([]interface{}, len(a.array))
|
||||
array = make([]any, len(a.array))
|
||||
copy(array, a.array)
|
||||
} else {
|
||||
array = a.array
|
||||
@ -428,19 +428,19 @@ func (a *SortedArray) Slice() []interface{} {
|
||||
return array
|
||||
}
|
||||
|
||||
// Interfaces returns current array as []interface{}.
|
||||
func (a *SortedArray) Interfaces() []interface{} {
|
||||
// Interfaces returns current array as []any.
|
||||
func (a *SortedArray) Interfaces() []any {
|
||||
return a.Slice()
|
||||
}
|
||||
|
||||
// Contains checks whether a value exists in the array.
|
||||
func (a *SortedArray) Contains(value interface{}) bool {
|
||||
func (a *SortedArray) Contains(value any) bool {
|
||||
return a.Search(value) != -1
|
||||
}
|
||||
|
||||
// Search searches array by `value`, returns the index of `value`,
|
||||
// or returns -1 if not exists.
|
||||
func (a *SortedArray) Search(value interface{}) (index int) {
|
||||
func (a *SortedArray) Search(value any) (index int) {
|
||||
if i, r := a.binSearch(value, true); r == 0 {
|
||||
return i
|
||||
}
|
||||
@ -452,7 +452,7 @@ func (a *SortedArray) Search(value interface{}) (index int) {
|
||||
// If `result` equals to 0, it means the value at `index` is equals to `value`.
|
||||
// If `result` lesser than 0, it means the value at `index` is lesser than `value`.
|
||||
// If `result` greater than 0, it means the value at `index` is greater than `value`.
|
||||
func (a *SortedArray) binSearch(value interface{}, lock bool) (index int, result int) {
|
||||
func (a *SortedArray) binSearch(value any, lock bool) (index int, result int) {
|
||||
if lock {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
@ -498,13 +498,9 @@ func (a *SortedArray) Unique() *SortedArray {
|
||||
if len(a.array) == 0 {
|
||||
return a
|
||||
}
|
||||
i := 0
|
||||
for {
|
||||
if i == len(a.array)-1 {
|
||||
break
|
||||
}
|
||||
for i := 0; i < len(a.array)-1; {
|
||||
if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
|
||||
a.array = append(a.array[:i+1], a.array[i+1+1:]...)
|
||||
a.array = append(a.array[:i+1], a.array[i+2:]...)
|
||||
} else {
|
||||
i++
|
||||
}
|
||||
@ -515,7 +511,7 @@ func (a *SortedArray) Unique() *SortedArray {
|
||||
// Clone returns 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))
|
||||
array := make([]any, len(a.array))
|
||||
copy(array, a.array)
|
||||
a.mu.RUnlock()
|
||||
return NewSortedArrayFrom(array, a.comparator, a.mu.IsSafe())
|
||||
@ -525,14 +521,14 @@ func (a *SortedArray) Clone() (newArray *SortedArray) {
|
||||
func (a *SortedArray) Clear() *SortedArray {
|
||||
a.mu.Lock()
|
||||
if len(a.array) > 0 {
|
||||
a.array = make([]interface{}, 0)
|
||||
a.array = make([]any, 0)
|
||||
}
|
||||
a.mu.Unlock()
|
||||
return a
|
||||
}
|
||||
|
||||
// LockFunc locks writing by callback function `f`.
|
||||
func (a *SortedArray) LockFunc(f func(array []interface{})) *SortedArray {
|
||||
func (a *SortedArray) LockFunc(f func(array []any)) *SortedArray {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
|
||||
@ -546,7 +542,7 @@ func (a *SortedArray) LockFunc(f func(array []interface{})) *SortedArray {
|
||||
}
|
||||
|
||||
// RLockFunc locks reading by callback function `f`.
|
||||
func (a *SortedArray) RLockFunc(f func(array []interface{})) *SortedArray {
|
||||
func (a *SortedArray) RLockFunc(f func(array []any)) *SortedArray {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
f(a.array)
|
||||
@ -557,14 +553,14 @@ func (a *SortedArray) RLockFunc(f func(array []interface{})) *SortedArray {
|
||||
// The parameter `array` can be any garray or slice type.
|
||||
// The difference between Merge and Append is Append supports only specified slice type,
|
||||
// but Merge supports more parameter types.
|
||||
func (a *SortedArray) Merge(array interface{}) *SortedArray {
|
||||
func (a *SortedArray) Merge(array any) *SortedArray {
|
||||
return a.Add(gconv.Interfaces(array)...)
|
||||
}
|
||||
|
||||
// Chunk splits an array into multiple arrays,
|
||||
// the size of each array is determined by `size`.
|
||||
// The last chunk may contain less than size elements.
|
||||
func (a *SortedArray) Chunk(size int) [][]interface{} {
|
||||
func (a *SortedArray) Chunk(size int) [][]any {
|
||||
if size < 1 {
|
||||
return nil
|
||||
}
|
||||
@ -572,7 +568,7 @@ func (a *SortedArray) Chunk(size int) [][]interface{} {
|
||||
defer a.mu.RUnlock()
|
||||
length := len(a.array)
|
||||
chunks := int(math.Ceil(float64(length) / float64(size)))
|
||||
var n [][]interface{}
|
||||
var n [][]any
|
||||
for i, end := 0, 0; chunks > 0; chunks-- {
|
||||
end = (i + 1) * size
|
||||
if end > length {
|
||||
@ -585,7 +581,7 @@ func (a *SortedArray) Chunk(size int) [][]interface{} {
|
||||
}
|
||||
|
||||
// Rand randomly returns one item from array(no deleting).
|
||||
func (a *SortedArray) Rand() (value interface{}, found bool) {
|
||||
func (a *SortedArray) Rand() (value any, found bool) {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
if len(a.array) == 0 {
|
||||
@ -595,13 +591,13 @@ func (a *SortedArray) Rand() (value interface{}, found bool) {
|
||||
}
|
||||
|
||||
// Rands randomly returns `size` items from array(no deleting).
|
||||
func (a *SortedArray) Rands(size int) []interface{} {
|
||||
func (a *SortedArray) Rands(size int) []any {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
if size <= 0 || len(a.array) == 0 {
|
||||
return nil
|
||||
}
|
||||
array := make([]interface{}, size)
|
||||
array := make([]any, size)
|
||||
for i := 0; i < size; i++ {
|
||||
array[i] = a.array[grand.Intn(len(a.array))]
|
||||
}
|
||||
@ -626,8 +622,8 @@ func (a *SortedArray) Join(glue string) string {
|
||||
}
|
||||
|
||||
// CountValues counts the number of occurrences of all values in the array.
|
||||
func (a *SortedArray) CountValues() map[interface{}]int {
|
||||
m := make(map[interface{}]int)
|
||||
func (a *SortedArray) CountValues() map[any]int {
|
||||
m := make(map[any]int)
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
for _, v := range a.array {
|
||||
@ -637,13 +633,13 @@ func (a *SortedArray) CountValues() map[interface{}]int {
|
||||
}
|
||||
|
||||
// Iterator is alias of IteratorAsc.
|
||||
func (a *SortedArray) Iterator(f func(k int, v interface{}) bool) {
|
||||
func (a *SortedArray) Iterator(f func(k int, v any) bool) {
|
||||
a.IteratorAsc(f)
|
||||
}
|
||||
|
||||
// IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
func (a *SortedArray) IteratorAsc(f func(k int, v interface{}) bool) {
|
||||
func (a *SortedArray) IteratorAsc(f func(k int, v any) bool) {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
for k, v := range a.array {
|
||||
@ -655,7 +651,7 @@ func (a *SortedArray) IteratorAsc(f func(k int, v interface{}) bool) {
|
||||
|
||||
// IteratorDesc iterates the array readonly in descending order with given callback function `f`.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
func (a *SortedArray) IteratorDesc(f func(k int, v interface{}) bool) {
|
||||
func (a *SortedArray) IteratorDesc(f func(k int, v any) bool) {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
for i := len(a.array) - 1; i >= 0; i-- {
|
||||
@ -702,7 +698,7 @@ func (a SortedArray) MarshalJSON() ([]byte, error) {
|
||||
// Note that the comparator is set as string comparator in default.
|
||||
func (a *SortedArray) UnmarshalJSON(b []byte) error {
|
||||
if a.comparator == nil {
|
||||
a.array = make([]interface{}, 0)
|
||||
a.array = make([]any, 0)
|
||||
a.comparator = gutil.ComparatorString
|
||||
}
|
||||
a.mu.Lock()
|
||||
@ -720,7 +716,7 @@ 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) {
|
||||
func (a *SortedArray) UnmarshalValue(value any) (err error) {
|
||||
if a.comparator == nil {
|
||||
a.comparator = gutil.ComparatorString
|
||||
}
|
||||
@ -764,7 +760,7 @@ func (a *SortedArray) FilterNil() *SortedArray {
|
||||
// Filter iterates array and filters elements using custom callback function.
|
||||
// It removes the element from array if callback function `filter` returns true,
|
||||
// it or else does nothing and continues iterating.
|
||||
func (a *SortedArray) Filter(filter func(index int, value interface{}) bool) *SortedArray {
|
||||
func (a *SortedArray) Filter(filter func(index int, value any) bool) *SortedArray {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
for i := 0; i < len(a.array); {
|
||||
@ -800,7 +796,7 @@ func (a *SortedArray) FilterEmpty() *SortedArray {
|
||||
}
|
||||
|
||||
// Walk applies a user supplied function `f` to every item of array.
|
||||
func (a *SortedArray) Walk(f func(value interface{}) interface{}) *SortedArray {
|
||||
func (a *SortedArray) Walk(f func(value any) any) *SortedArray {
|
||||
a.mu.Lock()
|
||||
defer a.mu.Unlock()
|
||||
// Keep the array always sorted.
|
||||
@ -820,7 +816,7 @@ func (a *SortedArray) IsEmpty() bool {
|
||||
|
||||
// getComparator returns the comparator if it's previously set,
|
||||
// or else it panics.
|
||||
func (a *SortedArray) getComparator() func(a, b interface{}) int {
|
||||
func (a *SortedArray) getComparator() func(a, b any) int {
|
||||
if a.comparator == nil {
|
||||
panic("comparator is missing for sorted array")
|
||||
}
|
||||
@ -828,13 +824,13 @@ func (a *SortedArray) getComparator() func(a, b interface{}) int {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (a *SortedArray) DeepCopy() interface{} {
|
||||
func (a *SortedArray) DeepCopy() any {
|
||||
if a == nil {
|
||||
return nil
|
||||
}
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
newSlice := make([]interface{}, len(a.array))
|
||||
newSlice := make([]any, len(a.array))
|
||||
for i, v := range a.array {
|
||||
newSlice[i] = deepcopy.Copy(v)
|
||||
}
|
||||
|
||||
@ -420,11 +420,11 @@ func (a *SortedIntArray) Slice() []int {
|
||||
return array
|
||||
}
|
||||
|
||||
// Interfaces returns current array as []interface{}.
|
||||
func (a *SortedIntArray) Interfaces() []interface{} {
|
||||
// Interfaces returns current array as []any.
|
||||
func (a *SortedIntArray) Interfaces() []any {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
array := make([]interface{}, len(a.array))
|
||||
array := make([]any, len(a.array))
|
||||
for k, v := range a.array {
|
||||
array[k] = v
|
||||
}
|
||||
@ -496,13 +496,9 @@ func (a *SortedIntArray) Unique() *SortedIntArray {
|
||||
if len(a.array) == 0 {
|
||||
return a
|
||||
}
|
||||
i := 0
|
||||
for {
|
||||
if i == len(a.array)-1 {
|
||||
break
|
||||
}
|
||||
for i := 0; i < len(a.array)-1; {
|
||||
if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
|
||||
a.array = append(a.array[:i+1], a.array[i+1+1:]...)
|
||||
a.array = append(a.array[:i+1], a.array[i+2:]...)
|
||||
} else {
|
||||
i++
|
||||
}
|
||||
@ -549,7 +545,7 @@ func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray {
|
||||
// The parameter `array` can be any garray or slice type.
|
||||
// The difference between Merge and Append is Append supports only specified slice type,
|
||||
// but Merge supports more parameter types.
|
||||
func (a *SortedIntArray) Merge(array interface{}) *SortedIntArray {
|
||||
func (a *SortedIntArray) Merge(array any) *SortedIntArray {
|
||||
return a.Add(gconv.Ints(array)...)
|
||||
}
|
||||
|
||||
@ -691,7 +687,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) {
|
||||
func (a *SortedIntArray) UnmarshalValue(value any) (err error) {
|
||||
if a.comparator == nil {
|
||||
a.comparator = defaultComparatorInt
|
||||
}
|
||||
@ -775,7 +771,7 @@ func (a *SortedIntArray) getComparator() func(a, b int) int {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (a *SortedIntArray) DeepCopy() interface{} {
|
||||
func (a *SortedIntArray) DeepCopy() any {
|
||||
if a == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -406,11 +406,11 @@ func (a *SortedStrArray) Slice() []string {
|
||||
return array
|
||||
}
|
||||
|
||||
// Interfaces returns current array as []interface{}.
|
||||
func (a *SortedStrArray) Interfaces() []interface{} {
|
||||
// Interfaces returns current array as []any.
|
||||
func (a *SortedStrArray) Interfaces() []any {
|
||||
a.mu.RLock()
|
||||
defer a.mu.RUnlock()
|
||||
array := make([]interface{}, len(a.array))
|
||||
array := make([]any, len(a.array))
|
||||
for k, v := range a.array {
|
||||
array[k] = v
|
||||
}
|
||||
@ -498,13 +498,9 @@ func (a *SortedStrArray) Unique() *SortedStrArray {
|
||||
if len(a.array) == 0 {
|
||||
return a
|
||||
}
|
||||
i := 0
|
||||
for {
|
||||
if i == len(a.array)-1 {
|
||||
break
|
||||
}
|
||||
for i := 0; i < len(a.array)-1; {
|
||||
if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
|
||||
a.array = append(a.array[:i+1], a.array[i+1+1:]...)
|
||||
a.array = append(a.array[:i+1], a.array[i+2:]...)
|
||||
} else {
|
||||
i++
|
||||
}
|
||||
@ -551,7 +547,7 @@ func (a *SortedStrArray) RLockFunc(f func(array []string)) *SortedStrArray {
|
||||
// The parameter `array` can be any garray or slice type.
|
||||
// The difference between Merge and Append is Append supports only specified slice type,
|
||||
// but Merge supports more parameter types.
|
||||
func (a *SortedStrArray) Merge(array interface{}) *SortedStrArray {
|
||||
func (a *SortedStrArray) Merge(array any) *SortedStrArray {
|
||||
return a.Add(gconv.Strings(array)...)
|
||||
}
|
||||
|
||||
@ -704,7 +700,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) {
|
||||
func (a *SortedStrArray) UnmarshalValue(value any) (err error) {
|
||||
if a.comparator == nil {
|
||||
a.comparator = defaultComparatorStr
|
||||
}
|
||||
@ -788,7 +784,7 @@ func (a *SortedStrArray) getComparator() func(a, b string) int {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (a *SortedStrArray) DeepCopy() interface{} {
|
||||
func (a *SortedStrArray) DeepCopy() any {
|
||||
if a == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -14,12 +14,12 @@ import (
|
||||
|
||||
type anySortedArrayItem struct {
|
||||
priority int64
|
||||
value interface{}
|
||||
value any
|
||||
}
|
||||
|
||||
var (
|
||||
anyArray = garray.NewArray()
|
||||
anySortedArray = garray.NewSortedArray(func(a, b interface{}) int {
|
||||
anySortedArray = garray.NewSortedArray(func(a, b any) int {
|
||||
return int(a.(anySortedArrayItem).priority - b.(anySortedArrayItem).priority)
|
||||
})
|
||||
)
|
||||
|
||||
@ -81,13 +81,13 @@ func ExampleArray_Iterator() {
|
||||
// Iterator is alias of IteratorAsc, which iterates the array readonly in ascending order
|
||||
// with given callback function `f`.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
array.Iterator(func(k int, v interface{}) bool {
|
||||
array.Iterator(func(k int, v any) bool {
|
||||
fmt.Println(k, v)
|
||||
return true
|
||||
})
|
||||
// IteratorDesc iterates the array readonly in descending order with given callback function `f`.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
array.IteratorDesc(func(k int, v interface{}) bool {
|
||||
array.IteratorDesc(func(k int, v any) bool {
|
||||
fmt.Println(k, v)
|
||||
return true
|
||||
})
|
||||
@ -163,7 +163,7 @@ func ExampleArray_Chunk() {
|
||||
}
|
||||
|
||||
func ExampleArray_PopLeft() {
|
||||
array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
|
||||
array := garray.NewFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
|
||||
|
||||
// Any Pop* functions pick, delete and return the item from array.
|
||||
|
||||
@ -180,7 +180,7 @@ func ExampleArray_PopLeft() {
|
||||
}
|
||||
|
||||
func ExampleArray_PopLefts() {
|
||||
array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
|
||||
array := garray.NewFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
|
||||
|
||||
// Any Pop* functions pick, delete and return the item from array.
|
||||
|
||||
@ -197,7 +197,7 @@ func ExampleArray_PopLefts() {
|
||||
}
|
||||
|
||||
func ExampleArray_PopRight() {
|
||||
array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
|
||||
array := garray.NewFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
|
||||
|
||||
// Any Pop* functions pick, delete and return the item from array.
|
||||
|
||||
@ -214,7 +214,7 @@ func ExampleArray_PopRight() {
|
||||
}
|
||||
|
||||
func ExampleArray_PopRights() {
|
||||
array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
|
||||
array := garray.NewFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
|
||||
|
||||
// Any Pop* functions pick, delete and return the item from array.
|
||||
|
||||
@ -265,10 +265,10 @@ func ExampleArray_Merge() {
|
||||
func ExampleArray_Filter() {
|
||||
array1 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
|
||||
array2 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
|
||||
fmt.Printf("%#v\n", array1.Filter(func(index int, value interface{}) bool {
|
||||
fmt.Printf("%#v\n", array1.Filter(func(index int, value any) bool {
|
||||
return empty.IsNil(value)
|
||||
}).Slice())
|
||||
fmt.Printf("%#v\n", array2.Filter(func(index int, value interface{}) bool {
|
||||
fmt.Printf("%#v\n", array2.Filter(func(index int, value any) bool {
|
||||
return empty.IsEmpty(value)
|
||||
}).Slice())
|
||||
|
||||
|
||||
@ -131,7 +131,7 @@ func Test_SortedStrArray2(t *testing.T) {
|
||||
func Test_SortedArray1(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
|
||||
array := garray.NewSortedArray(func(v1, v2 interface{}) int {
|
||||
array := garray.NewSortedArray(func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
})
|
||||
for i := 10; i > -1; i-- {
|
||||
@ -144,7 +144,7 @@ func Test_SortedArray1(t *testing.T) {
|
||||
func Test_SortedArray2(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array := garray.NewSortedArray(func1)
|
||||
@ -161,7 +161,7 @@ func Test_SortedArray2(t *testing.T) {
|
||||
|
||||
func TestNewFromCopy(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"100", "200", "300", "400", "500", "600"}
|
||||
a1 := []any{"100", "200", "300", "400", "500", "600"}
|
||||
array1 := garray.NewFromCopy(a1)
|
||||
t.AssertIN(array1.PopRands(2), a1)
|
||||
t.Assert(len(array1.PopRands(1)), 1)
|
||||
|
||||
@ -22,10 +22,10 @@ import (
|
||||
|
||||
func Test_Array_Basic(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := []interface{}{0, 1, 2, 3}
|
||||
expect := []any{0, 1, 2, 3}
|
||||
array := garray.NewArrayFrom(expect)
|
||||
array2 := garray.NewArrayFrom(expect)
|
||||
array3 := garray.NewArrayFrom([]interface{}{})
|
||||
array3 := garray.NewArrayFrom([]any{})
|
||||
array4 := garray.NewArrayRange(1, 5, 1)
|
||||
|
||||
t.Assert(array.Slice(), expect)
|
||||
@ -86,10 +86,10 @@ func Test_Array_Basic(t *testing.T) {
|
||||
t.Assert(array.Len(), 4)
|
||||
array.InsertBefore(0, 100)
|
||||
array.InsertAfter(0, 200)
|
||||
t.Assert(array.Slice(), []interface{}{100, 200, 2, 2, 3, 4})
|
||||
t.Assert(array.Slice(), []any{100, 200, 2, 2, 3, 4})
|
||||
array.InsertBefore(5, 300)
|
||||
array.InsertAfter(6, 400)
|
||||
t.Assert(array.Slice(), []interface{}{100, 200, 2, 2, 3, 300, 4, 400})
|
||||
t.Assert(array.Slice(), []any{100, 200, 2, 2, 3, 300, 4, 400})
|
||||
t.Assert(array.Clear().Len(), 0)
|
||||
err = array.InsertBefore(99, 9900)
|
||||
t.AssertNE(err, nil)
|
||||
@ -102,17 +102,17 @@ func Test_Array_Basic(t *testing.T) {
|
||||
|
||||
func TestArray_Sort(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect1 := []interface{}{0, 1, 2, 3}
|
||||
expect2 := []interface{}{3, 2, 1, 0}
|
||||
expect1 := []any{0, 1, 2, 3}
|
||||
expect2 := []any{3, 2, 1, 0}
|
||||
array := garray.NewArray()
|
||||
for i := 3; i >= 0; i-- {
|
||||
array.Append(i)
|
||||
}
|
||||
array.SortFunc(func(v1, v2 interface{}) bool {
|
||||
array.SortFunc(func(v1, v2 any) bool {
|
||||
return v1.(int) < v2.(int)
|
||||
})
|
||||
t.Assert(array.Slice(), expect1)
|
||||
array.SortFunc(func(v1, v2 interface{}) bool {
|
||||
array.SortFunc(func(v1, v2 any) bool {
|
||||
return v1.(int) > v2.(int)
|
||||
})
|
||||
t.Assert(array.Slice(), expect2)
|
||||
@ -121,20 +121,20 @@ func TestArray_Sort(t *testing.T) {
|
||||
|
||||
func TestArray_Unique(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := []interface{}{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
|
||||
expect := []any{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
|
||||
array := garray.NewArrayFrom(expect)
|
||||
t.Assert(array.Unique().Slice(), []interface{}{1, 2, 3, 4, 5})
|
||||
t.Assert(array.Unique().Slice(), []any{1, 2, 3, 4, 5})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := []interface{}{}
|
||||
expect := []any{}
|
||||
array := garray.NewArrayFrom(expect)
|
||||
t.Assert(array.Unique().Slice(), []interface{}{})
|
||||
t.Assert(array.Unique().Slice(), []any{})
|
||||
})
|
||||
}
|
||||
|
||||
func TestArray_PushAndPop(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := []interface{}{0, 1, 2, 3}
|
||||
expect := []any{0, 1, 2, 3}
|
||||
array := garray.NewArrayFrom(expect)
|
||||
t.Assert(array.Slice(), expect)
|
||||
|
||||
@ -147,24 +147,24 @@ func TestArray_PushAndPop(t *testing.T) {
|
||||
t.Assert(ok, true)
|
||||
|
||||
v, ok = array.PopRand()
|
||||
t.AssertIN(v, []interface{}{1, 2})
|
||||
t.AssertIN(v, []any{1, 2})
|
||||
t.Assert(ok, true)
|
||||
|
||||
v, ok = array.PopRand()
|
||||
t.AssertIN(v, []interface{}{1, 2})
|
||||
t.AssertIN(v, []any{1, 2})
|
||||
t.Assert(ok, true)
|
||||
|
||||
t.Assert(array.Len(), 0)
|
||||
array.PushLeft(1).PushRight(2)
|
||||
t.Assert(array.Slice(), []interface{}{1, 2})
|
||||
t.Assert(array.Slice(), []any{1, 2})
|
||||
})
|
||||
}
|
||||
|
||||
func TestArray_PopRands(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{100, 200, 300, 400, 500, 600}
|
||||
a1 := []any{100, 200, 300, 400, 500, 600}
|
||||
array := garray.NewFromCopy(a1)
|
||||
t.AssertIN(array.PopRands(2), []interface{}{100, 200, 300, 400, 500, 600})
|
||||
t.AssertIN(array.PopRands(2), []any{100, 200, 300, 400, 500, 600})
|
||||
})
|
||||
}
|
||||
|
||||
@ -247,56 +247,56 @@ func TestArray_PopLeftsAndPopRights(t *testing.T) {
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
value1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
|
||||
value2 := []interface{}{0, 1, 2, 3, 4, 5, 6}
|
||||
value1 := []any{0, 1, 2, 3, 4, 5, 6}
|
||||
value2 := []any{0, 1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewArrayFrom(value1)
|
||||
array2 := garray.NewArrayFrom(value2)
|
||||
t.Assert(array1.PopLefts(2), []interface{}{0, 1})
|
||||
t.Assert(array1.Slice(), []interface{}{2, 3, 4, 5, 6})
|
||||
t.Assert(array1.PopRights(2), []interface{}{5, 6})
|
||||
t.Assert(array1.Slice(), []interface{}{2, 3, 4})
|
||||
t.Assert(array1.PopRights(20), []interface{}{2, 3, 4})
|
||||
t.Assert(array1.Slice(), []interface{}{})
|
||||
t.Assert(array2.PopLefts(20), []interface{}{0, 1, 2, 3, 4, 5, 6})
|
||||
t.Assert(array2.Slice(), []interface{}{})
|
||||
t.Assert(array1.PopLefts(2), []any{0, 1})
|
||||
t.Assert(array1.Slice(), []any{2, 3, 4, 5, 6})
|
||||
t.Assert(array1.PopRights(2), []any{5, 6})
|
||||
t.Assert(array1.Slice(), []any{2, 3, 4})
|
||||
t.Assert(array1.PopRights(20), []any{2, 3, 4})
|
||||
t.Assert(array1.Slice(), []any{})
|
||||
t.Assert(array2.PopLefts(20), []any{0, 1, 2, 3, 4, 5, 6})
|
||||
t.Assert(array2.Slice(), []any{})
|
||||
})
|
||||
}
|
||||
|
||||
func TestArray_Range(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
value1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
|
||||
value1 := []any{0, 1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewArrayFrom(value1)
|
||||
array2 := garray.NewArrayFrom(value1, true)
|
||||
t.Assert(array1.Range(0, 1), []interface{}{0})
|
||||
t.Assert(array1.Range(1, 2), []interface{}{1})
|
||||
t.Assert(array1.Range(0, 2), []interface{}{0, 1})
|
||||
t.Assert(array1.Range(0, 1), []any{0})
|
||||
t.Assert(array1.Range(1, 2), []any{1})
|
||||
t.Assert(array1.Range(0, 2), []any{0, 1})
|
||||
t.Assert(array1.Range(-1, 10), value1)
|
||||
t.Assert(array1.Range(10, 2), nil)
|
||||
t.Assert(array2.Range(1, 3), []interface{}{1, 2})
|
||||
t.Assert(array2.Range(1, 3), []any{1, 2})
|
||||
})
|
||||
}
|
||||
|
||||
func TestArray_Merge(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
if gconv.Int(v1) < gconv.Int(v2) {
|
||||
return 0
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
i1 := []interface{}{0, 1, 2, 3}
|
||||
i2 := []interface{}{4, 5, 6, 7}
|
||||
i1 := []any{0, 1, 2, 3}
|
||||
i2 := []any{4, 5, 6, 7}
|
||||
array1 := garray.NewArrayFrom(i1)
|
||||
array2 := garray.NewArrayFrom(i2)
|
||||
t.Assert(array1.Merge(array2).Slice(), []interface{}{0, 1, 2, 3, 4, 5, 6, 7})
|
||||
t.Assert(array1.Merge(array2).Slice(), []any{0, 1, 2, 3, 4, 5, 6, 7})
|
||||
|
||||
// s1 := []string{"a", "b", "c", "d"}
|
||||
s2 := []string{"e", "f"}
|
||||
i3 := garray.NewIntArrayFrom([]int{1, 2, 3})
|
||||
i4 := garray.NewArrayFrom([]interface{}{3})
|
||||
i4 := garray.NewArrayFrom([]any{3})
|
||||
s3 := garray.NewStrArrayFrom([]string{"g", "h"})
|
||||
s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
|
||||
s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
|
||||
s5 := garray.NewSortedStrArrayFrom(s2)
|
||||
s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
|
||||
a1 := garray.NewArrayFrom(i1)
|
||||
@ -313,92 +313,92 @@ func TestArray_Merge(t *testing.T) {
|
||||
|
||||
func TestArray_Fill(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0}
|
||||
a2 := []interface{}{0}
|
||||
a1 := []any{0}
|
||||
a2 := []any{0}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
array2 := garray.NewArrayFrom(a2, true)
|
||||
|
||||
t.Assert(array1.Fill(1, 2, 100), nil)
|
||||
t.Assert(array1.Slice(), []interface{}{0, 100, 100})
|
||||
t.Assert(array1.Slice(), []any{0, 100, 100})
|
||||
|
||||
t.Assert(array2.Fill(0, 2, 100), nil)
|
||||
t.Assert(array2.Slice(), []interface{}{100, 100})
|
||||
t.Assert(array2.Slice(), []any{100, 100})
|
||||
|
||||
t.AssertNE(array2.Fill(-1, 2, 100), nil)
|
||||
t.Assert(array2.Slice(), []interface{}{100, 100})
|
||||
t.Assert(array2.Slice(), []any{100, 100})
|
||||
})
|
||||
}
|
||||
|
||||
func TestArray_Chunk(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{1, 2, 3, 4, 5}
|
||||
a1 := []any{1, 2, 3, 4, 5}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
chunks := array1.Chunk(2)
|
||||
t.Assert(len(chunks), 3)
|
||||
t.Assert(chunks[0], []interface{}{1, 2})
|
||||
t.Assert(chunks[1], []interface{}{3, 4})
|
||||
t.Assert(chunks[2], []interface{}{5})
|
||||
t.Assert(chunks[0], []any{1, 2})
|
||||
t.Assert(chunks[1], []any{3, 4})
|
||||
t.Assert(chunks[2], []any{5})
|
||||
t.Assert(array1.Chunk(0), nil)
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{1, 2, 3, 4, 5}
|
||||
a1 := []any{1, 2, 3, 4, 5}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
chunks := array1.Chunk(3)
|
||||
t.Assert(len(chunks), 2)
|
||||
t.Assert(chunks[0], []interface{}{1, 2, 3})
|
||||
t.Assert(chunks[1], []interface{}{4, 5})
|
||||
t.Assert(chunks[0], []any{1, 2, 3})
|
||||
t.Assert(chunks[1], []any{4, 5})
|
||||
t.Assert(array1.Chunk(0), nil)
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{1, 2, 3, 4, 5, 6}
|
||||
a1 := []any{1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
chunks := array1.Chunk(2)
|
||||
t.Assert(len(chunks), 3)
|
||||
t.Assert(chunks[0], []interface{}{1, 2})
|
||||
t.Assert(chunks[1], []interface{}{3, 4})
|
||||
t.Assert(chunks[2], []interface{}{5, 6})
|
||||
t.Assert(chunks[0], []any{1, 2})
|
||||
t.Assert(chunks[1], []any{3, 4})
|
||||
t.Assert(chunks[2], []any{5, 6})
|
||||
t.Assert(array1.Chunk(0), nil)
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{1, 2, 3, 4, 5, 6}
|
||||
a1 := []any{1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
chunks := array1.Chunk(3)
|
||||
t.Assert(len(chunks), 2)
|
||||
t.Assert(chunks[0], []interface{}{1, 2, 3})
|
||||
t.Assert(chunks[1], []interface{}{4, 5, 6})
|
||||
t.Assert(chunks[0], []any{1, 2, 3})
|
||||
t.Assert(chunks[1], []any{4, 5, 6})
|
||||
t.Assert(array1.Chunk(0), nil)
|
||||
})
|
||||
}
|
||||
|
||||
func TestArray_Pad(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0}
|
||||
a1 := []any{0}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
t.Assert(array1.Pad(3, 1).Slice(), []interface{}{0, 1, 1})
|
||||
t.Assert(array1.Pad(-4, 1).Slice(), []interface{}{1, 0, 1, 1})
|
||||
t.Assert(array1.Pad(3, 1).Slice(), []interface{}{1, 0, 1, 1})
|
||||
t.Assert(array1.Pad(3, 1).Slice(), []any{0, 1, 1})
|
||||
t.Assert(array1.Pad(-4, 1).Slice(), []any{1, 0, 1, 1})
|
||||
t.Assert(array1.Pad(3, 1).Slice(), []any{1, 0, 1, 1})
|
||||
})
|
||||
}
|
||||
|
||||
func TestArray_SubSlice(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
|
||||
a1 := []any{0, 1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
array2 := garray.NewArrayFrom(a1, true)
|
||||
t.Assert(array1.SubSlice(0, 2), []interface{}{0, 1})
|
||||
t.Assert(array1.SubSlice(2, 2), []interface{}{2, 3})
|
||||
t.Assert(array1.SubSlice(5, 8), []interface{}{5, 6})
|
||||
t.Assert(array1.SubSlice(0, 2), []any{0, 1})
|
||||
t.Assert(array1.SubSlice(2, 2), []any{2, 3})
|
||||
t.Assert(array1.SubSlice(5, 8), []any{5, 6})
|
||||
t.Assert(array1.SubSlice(9, 1), nil)
|
||||
t.Assert(array1.SubSlice(-2, 2), []interface{}{5, 6})
|
||||
t.Assert(array1.SubSlice(-2, 2), []any{5, 6})
|
||||
t.Assert(array1.SubSlice(-9, 2), nil)
|
||||
t.Assert(array1.SubSlice(1, -2), nil)
|
||||
t.Assert(array2.SubSlice(0, 2), []interface{}{0, 1})
|
||||
t.Assert(array2.SubSlice(0, 2), []any{0, 1})
|
||||
})
|
||||
}
|
||||
|
||||
func TestArray_Rand(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
|
||||
a1 := []any{0, 1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
t.Assert(len(array1.Rands(2)), 2)
|
||||
t.Assert(len(array1.Rands(10)), 10)
|
||||
@ -406,7 +406,7 @@ func TestArray_Rand(t *testing.T) {
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := []interface{}{"a", "b", "c", "d"}
|
||||
s1 := []any{"a", "b", "c", "d"}
|
||||
a1 := garray.NewArrayFrom(s1)
|
||||
i1, ok := a1.Rand()
|
||||
t.Assert(ok, true)
|
||||
@ -415,7 +415,7 @@ func TestArray_Rand(t *testing.T) {
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{}
|
||||
a1 := []any{}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
rand, found := array1.Rand()
|
||||
t.AssertNil(rand)
|
||||
@ -423,7 +423,7 @@ func TestArray_Rand(t *testing.T) {
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{}
|
||||
a1 := []any{}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
rand := array1.Rands(1)
|
||||
t.AssertNil(rand)
|
||||
@ -432,7 +432,7 @@ func TestArray_Rand(t *testing.T) {
|
||||
|
||||
func TestArray_Shuffle(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
|
||||
a1 := []any{0, 1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
t.Assert(array1.Shuffle().Len(), 7)
|
||||
})
|
||||
@ -440,27 +440,27 @@ func TestArray_Shuffle(t *testing.T) {
|
||||
|
||||
func TestArray_Reverse(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
|
||||
a1 := []any{0, 1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
t.Assert(array1.Reverse().Slice(), []interface{}{6, 5, 4, 3, 2, 1, 0})
|
||||
t.Assert(array1.Reverse().Slice(), []any{6, 5, 4, 3, 2, 1, 0})
|
||||
})
|
||||
}
|
||||
|
||||
func TestArray_Join(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
|
||||
a1 := []any{0, 1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
t.Assert(array1.Join("."), `0.1.2.3.4.5.6`)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, `"a"`, `\a`}
|
||||
a1 := []any{0, 1, `"a"`, `\a`}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
t.Assert(array1.Join("."), `0.1."a".\a`)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{}
|
||||
a1 := []any{}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
t.Assert(len(array1.Join(".")), 0)
|
||||
})
|
||||
@ -468,7 +468,7 @@ func TestArray_Join(t *testing.T) {
|
||||
|
||||
func TestArray_String(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
|
||||
a1 := []any{0, 1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
t.Assert(array1.String(), `[0,1,2,3,4,5,6]`)
|
||||
array1 = nil
|
||||
@ -478,9 +478,9 @@ func TestArray_String(t *testing.T) {
|
||||
|
||||
func TestArray_Replace(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
|
||||
a2 := []interface{}{"a", "b", "c"}
|
||||
a3 := []interface{}{"m", "n", "p", "z", "x", "y", "d", "u"}
|
||||
a1 := []any{0, 1, 2, 3, 4, 5, 6}
|
||||
a2 := []any{"a", "b", "c"}
|
||||
a3 := []any{"m", "n", "p", "z", "x", "y", "d", "u"}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
array2 := array1.Replace(a2)
|
||||
t.Assert(array2.Len(), 7)
|
||||
@ -497,8 +497,8 @@ func TestArray_Replace(t *testing.T) {
|
||||
|
||||
func TestArray_SetArray(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
|
||||
a2 := []interface{}{"a", "b", "c"}
|
||||
a1 := []any{0, 1, 2, 3, 4, 5, 6}
|
||||
a2 := []any{"a", "b", "c"}
|
||||
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
array1 = array1.SetArray(a2)
|
||||
@ -510,9 +510,9 @@ func TestArray_SetArray(t *testing.T) {
|
||||
|
||||
func TestArray_Sum(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, 2, 3}
|
||||
a2 := []interface{}{"a", "b", "c"}
|
||||
a3 := []interface{}{"a", "1", "2"}
|
||||
a1 := []any{0, 1, 2, 3}
|
||||
a2 := []any{"a", "b", "c"}
|
||||
a3 := []any{"a", "1", "2"}
|
||||
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
array2 := garray.NewArrayFrom(a2)
|
||||
@ -527,7 +527,7 @@ func TestArray_Sum(t *testing.T) {
|
||||
|
||||
func TestArray_Clone(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, 2, 3}
|
||||
a1 := []any{0, 1, 2, 3}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
array2 := array1.Clone()
|
||||
|
||||
@ -540,7 +540,7 @@ func TestArray_Clone(t *testing.T) {
|
||||
|
||||
func TestArray_CountValues(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "b", "c", "d", "e", "d"}
|
||||
a1 := []any{"a", "b", "c", "d", "e", "d"}
|
||||
array1 := garray.NewArrayFrom(a1)
|
||||
array2 := array1.CountValues()
|
||||
t.Assert(len(array2), 5)
|
||||
@ -551,13 +551,13 @@ func TestArray_CountValues(t *testing.T) {
|
||||
|
||||
func TestArray_LockFunc(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := []interface{}{"a", "b", "c", "d"}
|
||||
s1 := []any{"a", "b", "c", "d"}
|
||||
a1 := garray.NewArrayFrom(s1, true)
|
||||
|
||||
ch1 := make(chan int64, 3)
|
||||
ch2 := make(chan int64, 3)
|
||||
// go1
|
||||
go a1.LockFunc(func(n1 []interface{}) { // 读写锁
|
||||
go a1.LockFunc(func(n1 []any) { // 读写锁
|
||||
time.Sleep(2 * time.Second) // 暂停2秒
|
||||
n1[2] = "g"
|
||||
ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
|
||||
@ -583,13 +583,13 @@ func TestArray_LockFunc(t *testing.T) {
|
||||
|
||||
func TestArray_RLockFunc(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := []interface{}{"a", "b", "c", "d"}
|
||||
s1 := []any{"a", "b", "c", "d"}
|
||||
a1 := garray.NewArrayFrom(s1, true)
|
||||
|
||||
ch1 := make(chan int64, 3)
|
||||
ch2 := make(chan int64, 1)
|
||||
// go1
|
||||
go a1.RLockFunc(func(n1 []interface{}) { // 读锁
|
||||
go a1.RLockFunc(func(n1 []any) { // 读锁
|
||||
time.Sleep(2 * time.Second) // 暂停1秒
|
||||
n1[2] = "g"
|
||||
ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
|
||||
@ -616,7 +616,7 @@ func TestArray_RLockFunc(t *testing.T) {
|
||||
func TestArray_Json(t *testing.T) {
|
||||
// pointer
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := []interface{}{"a", "b", "d", "c"}
|
||||
s1 := []any{"a", "b", "d", "c"}
|
||||
a1 := garray.NewArrayFrom(s1)
|
||||
b1, err1 := json.Marshal(a1)
|
||||
b2, err2 := json.Marshal(s1)
|
||||
@ -635,7 +635,7 @@ func TestArray_Json(t *testing.T) {
|
||||
})
|
||||
// value.
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := []interface{}{"a", "b", "d", "c"}
|
||||
s1 := []any{"a", "b", "d", "c"}
|
||||
a1 := *garray.NewArrayFrom(s1)
|
||||
b1, err1 := json.Marshal(a1)
|
||||
b2, err2 := json.Marshal(s1)
|
||||
@ -696,26 +696,26 @@ func TestArray_Iterator(t *testing.T) {
|
||||
slice := g.Slice{"a", "b", "d", "c"}
|
||||
array := garray.NewArrayFrom(slice)
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array.Iterator(func(k int, v interface{}) bool {
|
||||
array.Iterator(func(k int, v any) bool {
|
||||
t.Assert(v, slice[k])
|
||||
return true
|
||||
})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array.IteratorAsc(func(k int, v interface{}) bool {
|
||||
array.IteratorAsc(func(k int, v any) bool {
|
||||
t.Assert(v, slice[k])
|
||||
return true
|
||||
})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array.IteratorDesc(func(k int, v interface{}) bool {
|
||||
array.IteratorDesc(func(k int, v any) bool {
|
||||
t.Assert(v, slice[k])
|
||||
return true
|
||||
})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
index := 0
|
||||
array.Iterator(func(k int, v interface{}) bool {
|
||||
array.Iterator(func(k int, v any) bool {
|
||||
index++
|
||||
return false
|
||||
})
|
||||
@ -723,7 +723,7 @@ func TestArray_Iterator(t *testing.T) {
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
index := 0
|
||||
array.IteratorAsc(func(k int, v interface{}) bool {
|
||||
array.IteratorAsc(func(k int, v any) bool {
|
||||
index++
|
||||
return false
|
||||
})
|
||||
@ -731,7 +731,7 @@ func TestArray_Iterator(t *testing.T) {
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
index := 0
|
||||
array.IteratorDesc(func(k int, v interface{}) bool {
|
||||
array.IteratorDesc(func(k int, v any) bool {
|
||||
index++
|
||||
return false
|
||||
})
|
||||
@ -805,27 +805,27 @@ func TestArray_Filter(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
|
||||
array := garray.NewArrayFromCopy(values)
|
||||
t.Assert(array.Filter(func(index int, value interface{}) bool {
|
||||
t.Assert(array.Filter(func(index int, value any) bool {
|
||||
return empty.IsNil(value)
|
||||
}).Slice(), values)
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil})
|
||||
t.Assert(array.Filter(func(index int, value interface{}) bool {
|
||||
t.Assert(array.Filter(func(index int, value any) bool {
|
||||
return empty.IsNil(value)
|
||||
}), g.Slice{1, 2, 3, 4})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}})
|
||||
|
||||
t.Assert(array.Filter(func(index int, value interface{}) bool {
|
||||
t.Assert(array.Filter(func(index int, value any) bool {
|
||||
return empty.IsEmpty(value)
|
||||
}), g.Slice{1, 2, 3, 4})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewArrayFrom(g.Slice{1, 2, 3, 4})
|
||||
|
||||
t.Assert(array.Filter(func(index int, value interface{}) bool {
|
||||
t.Assert(array.Filter(func(index int, value any) bool {
|
||||
return empty.IsEmpty(value)
|
||||
}), g.Slice{1, 2, 3, 4})
|
||||
})
|
||||
@ -845,7 +845,7 @@ func TestArray_FilterEmpty(t *testing.T) {
|
||||
func TestArray_Walk(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewArrayFrom(g.Slice{"1", "2"})
|
||||
t.Assert(array.Walk(func(value interface{}) interface{} {
|
||||
t.Assert(array.Walk(func(value any) any {
|
||||
return "key-" + gconv.String(value)
|
||||
}), g.Slice{"key-1", "key-2"})
|
||||
})
|
||||
|
||||
@ -195,7 +195,7 @@ func TestIntArray_Range(t *testing.T) {
|
||||
|
||||
func TestIntArray_Merge(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
if gconv.Int(v1) < gconv.Int(v2) {
|
||||
return 0
|
||||
}
|
||||
@ -204,7 +204,7 @@ func TestIntArray_Merge(t *testing.T) {
|
||||
|
||||
n1 := []int{0, 1, 2, 3}
|
||||
n2 := []int{4, 5, 6, 7}
|
||||
i1 := []interface{}{"1", "2"}
|
||||
i1 := []any{"1", "2"}
|
||||
s1 := []string{"a", "b", "c"}
|
||||
s2 := []string{"e", "f"}
|
||||
a1 := garray.NewIntArrayFrom(n1)
|
||||
@ -216,7 +216,7 @@ func TestIntArray_Merge(t *testing.T) {
|
||||
a6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
|
||||
|
||||
a7 := garray.NewSortedStrArrayFrom(s1)
|
||||
a8 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
|
||||
a8 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
|
||||
|
||||
t.Assert(a1.Merge(a2).Slice(), []int{0, 1, 2, 3, 4, 5, 6, 7})
|
||||
t.Assert(a1.Merge(a3).Len(), 10)
|
||||
|
||||
@ -235,14 +235,14 @@ func TestStrArray_PopLeftsAndPopRights(t *testing.T) {
|
||||
value2 := []string{"0", "1", "2", "3", "4", "5", "6"}
|
||||
array1 := garray.NewStrArrayFrom(value1)
|
||||
array2 := garray.NewStrArrayFrom(value2)
|
||||
t.Assert(array1.PopLefts(2), []interface{}{"0", "1"})
|
||||
t.Assert(array1.Slice(), []interface{}{"2", "3", "4", "5", "6"})
|
||||
t.Assert(array1.PopRights(2), []interface{}{"5", "6"})
|
||||
t.Assert(array1.Slice(), []interface{}{"2", "3", "4"})
|
||||
t.Assert(array1.PopRights(20), []interface{}{"2", "3", "4"})
|
||||
t.Assert(array1.Slice(), []interface{}{})
|
||||
t.Assert(array2.PopLefts(20), []interface{}{"0", "1", "2", "3", "4", "5", "6"})
|
||||
t.Assert(array2.Slice(), []interface{}{})
|
||||
t.Assert(array1.PopLefts(2), []any{"0", "1"})
|
||||
t.Assert(array1.Slice(), []any{"2", "3", "4", "5", "6"})
|
||||
t.Assert(array1.PopRights(2), []any{"5", "6"})
|
||||
t.Assert(array1.Slice(), []any{"2", "3", "4"})
|
||||
t.Assert(array1.PopRights(20), []any{"2", "3", "4"})
|
||||
t.Assert(array1.Slice(), []any{})
|
||||
t.Assert(array2.PopLefts(20), []any{"0", "1", "2", "3", "4", "5", "6"})
|
||||
t.Assert(array2.Slice(), []any{})
|
||||
})
|
||||
}
|
||||
|
||||
@ -251,12 +251,12 @@ func TestString_Range(t *testing.T) {
|
||||
value1 := []string{"0", "1", "2", "3", "4", "5", "6"}
|
||||
array1 := garray.NewStrArrayFrom(value1)
|
||||
array2 := garray.NewStrArrayFrom(value1, true)
|
||||
t.Assert(array1.Range(0, 1), []interface{}{"0"})
|
||||
t.Assert(array1.Range(1, 2), []interface{}{"1"})
|
||||
t.Assert(array1.Range(0, 2), []interface{}{"0", "1"})
|
||||
t.Assert(array1.Range(0, 1), []any{"0"})
|
||||
t.Assert(array1.Range(1, 2), []any{"1"})
|
||||
t.Assert(array1.Range(0, 2), []any{"0", "1"})
|
||||
t.Assert(array1.Range(-1, 10), value1)
|
||||
t.Assert(array1.Range(10, 1), nil)
|
||||
t.Assert(array2.Range(0, 1), []interface{}{"0"})
|
||||
t.Assert(array2.Range(0, 1), []any{"0"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -268,7 +268,7 @@ func TestStrArray_Merge(t *testing.T) {
|
||||
array2 := garray.NewStrArrayFrom(a21)
|
||||
t.Assert(array1.Merge(array2).Slice(), []string{"0", "1", "2", "3", "4", "5", "6", "7"})
|
||||
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
if gconv.Int(v1) < gconv.Int(v2) {
|
||||
return 0
|
||||
}
|
||||
@ -278,9 +278,9 @@ func TestStrArray_Merge(t *testing.T) {
|
||||
s1 := []string{"a", "b", "c", "d"}
|
||||
s2 := []string{"e", "f"}
|
||||
i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
|
||||
i2 := garray.NewArrayFrom([]interface{}{3})
|
||||
i2 := garray.NewArrayFrom([]any{3})
|
||||
s3 := garray.NewStrArrayFrom([]string{"g", "h"})
|
||||
s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
|
||||
s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
|
||||
s5 := garray.NewSortedStrArrayFrom(s2)
|
||||
s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
|
||||
a1 := garray.NewStrArrayFrom(s1)
|
||||
|
||||
@ -24,91 +24,91 @@ import (
|
||||
|
||||
func TestSortedArray_NewSortedArrayFrom(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "f", "c"}
|
||||
a2 := []interface{}{"h", "j", "i", "k"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "f", "c"}
|
||||
a2 := []any{"h", "j", "i", "k"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
func2 := func(v1, v2 interface{}) int {
|
||||
func2 := func(v1, v2 any) int {
|
||||
return -1
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
array2 := garray.NewSortedArrayFrom(a2, func2)
|
||||
|
||||
t.Assert(array1.Len(), 3)
|
||||
t.Assert(array1, []interface{}{"a", "c", "f"})
|
||||
t.Assert(array1, []any{"a", "c", "f"})
|
||||
|
||||
t.Assert(array2.Len(), 4)
|
||||
t.Assert(array2, []interface{}{"k", "i", "j", "h"})
|
||||
t.Assert(array2, []any{"k", "i", "j", "h"})
|
||||
})
|
||||
}
|
||||
|
||||
func TestNewSortedArrayFromCopy(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "f", "c"}
|
||||
a1 := []any{"a", "f", "c"}
|
||||
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
func2 := func(v1, v2 interface{}) int {
|
||||
func2 := func(v1, v2 any) int {
|
||||
return -1
|
||||
}
|
||||
array1 := garray.NewSortedArrayFromCopy(a1, func1)
|
||||
array2 := garray.NewSortedArrayFromCopy(a1, func2)
|
||||
t.Assert(array1.Len(), 3)
|
||||
t.Assert(array1, []interface{}{"a", "c", "f"})
|
||||
t.Assert(array1, []any{"a", "c", "f"})
|
||||
t.Assert(array1.Len(), 3)
|
||||
t.Assert(array2, []interface{}{"c", "f", "a"})
|
||||
t.Assert(array2, []any{"c", "f", "a"})
|
||||
})
|
||||
}
|
||||
|
||||
func TestNewSortedArrayRange(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return gconv.Int(v1) - gconv.Int(v2)
|
||||
}
|
||||
|
||||
array1 := garray.NewSortedArrayRange(1, 5, 1, func1)
|
||||
t.Assert(array1.Len(), 5)
|
||||
t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
|
||||
t.Assert(array1, []any{1, 2, 3, 4, 5})
|
||||
})
|
||||
}
|
||||
|
||||
func TestSortedArray_SetArray(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "f", "c"}
|
||||
a2 := []interface{}{"e", "h", "g", "k"}
|
||||
a1 := []any{"a", "f", "c"}
|
||||
a2 := []any{"e", "h", "g", "k"}
|
||||
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
array1.SetArray(a2)
|
||||
t.Assert(array1.Len(), 4)
|
||||
t.Assert(array1, []interface{}{"e", "g", "h", "k"})
|
||||
t.Assert(array1, []any{"e", "g", "h", "k"})
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
func TestSortedArray_Sort(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "f", "c"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "f", "c"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
array1.Sort()
|
||||
t.Assert(array1.Len(), 3)
|
||||
t.Assert(array1, []interface{}{"a", "c", "f"})
|
||||
t.Assert(array1, []any{"a", "c", "f"})
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
func TestSortedArray_Get(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "f", "c"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "f", "c"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
@ -129,8 +129,8 @@ func TestSortedArray_Get(t *testing.T) {
|
||||
|
||||
func TestSortedArray_At(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "f", "c"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "f", "c"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
@ -141,8 +141,8 @@ func TestSortedArray_At(t *testing.T) {
|
||||
|
||||
func TestSortedArray_Remove(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "b"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "d", "c", "b"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
@ -178,14 +178,14 @@ func TestSortedArray_Remove(t *testing.T) {
|
||||
func TestSortedArray_PopLeft(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array1 := garray.NewSortedArrayFrom(
|
||||
[]interface{}{"a", "d", "c", "b"},
|
||||
[]any{"a", "d", "c", "b"},
|
||||
gutil.ComparatorString,
|
||||
)
|
||||
i1, ok := array1.PopLeft()
|
||||
t.Assert(ok, true)
|
||||
t.Assert(gconv.String(i1), "a")
|
||||
t.Assert(array1.Len(), 3)
|
||||
t.Assert(array1, []interface{}{"b", "c", "d"})
|
||||
t.Assert(array1, []any{"b", "c", "d"})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewSortedArrayFrom(g.Slice{1, 2, 3}, gutil.ComparatorInt)
|
||||
@ -207,14 +207,14 @@ func TestSortedArray_PopLeft(t *testing.T) {
|
||||
func TestSortedArray_PopRight(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array1 := garray.NewSortedArrayFrom(
|
||||
[]interface{}{"a", "d", "c", "b"},
|
||||
[]any{"a", "d", "c", "b"},
|
||||
gutil.ComparatorString,
|
||||
)
|
||||
i1, ok := array1.PopRight()
|
||||
t.Assert(ok, true)
|
||||
t.Assert(gconv.String(i1), "d")
|
||||
t.Assert(array1.Len(), 3)
|
||||
t.Assert(array1, []interface{}{"a", "b", "c"})
|
||||
t.Assert(array1, []any{"a", "b", "c"})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewSortedArrayFrom(g.Slice{1, 2, 3}, gutil.ComparatorInt)
|
||||
@ -237,14 +237,14 @@ func TestSortedArray_PopRight(t *testing.T) {
|
||||
|
||||
func TestSortedArray_PopRand(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "b"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "d", "c", "b"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
i1, ok := array1.PopRand()
|
||||
t.Assert(ok, true)
|
||||
t.AssertIN(i1, []interface{}{"a", "d", "c", "b"})
|
||||
t.AssertIN(i1, []any{"a", "d", "c", "b"})
|
||||
t.Assert(array1.Len(), 3)
|
||||
|
||||
})
|
||||
@ -252,19 +252,19 @@ func TestSortedArray_PopRand(t *testing.T) {
|
||||
|
||||
func TestSortedArray_PopRands(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "b"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "d", "c", "b"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
i1 := array1.PopRands(2)
|
||||
t.Assert(len(i1), 2)
|
||||
t.AssertIN(i1, []interface{}{"a", "d", "c", "b"})
|
||||
t.AssertIN(i1, []any{"a", "d", "c", "b"})
|
||||
t.Assert(array1.Len(), 2)
|
||||
|
||||
i2 := array1.PopRands(3)
|
||||
t.Assert(len(i1), 2)
|
||||
t.AssertIN(i2, []interface{}{"a", "d", "c", "b"})
|
||||
t.AssertIN(i2, []any{"a", "d", "c", "b"})
|
||||
t.Assert(array1.Len(), 0)
|
||||
|
||||
})
|
||||
@ -292,33 +292,33 @@ func TestSortedArray_Empty(t *testing.T) {
|
||||
|
||||
func TestSortedArray_PopLefts(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "d", "c", "b", "e", "f"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
i1 := array1.PopLefts(2)
|
||||
t.Assert(len(i1), 2)
|
||||
t.AssertIN(i1, []interface{}{"a", "d", "c", "b", "e", "f"})
|
||||
t.AssertIN(i1, []any{"a", "d", "c", "b", "e", "f"})
|
||||
t.Assert(array1.Len(), 4)
|
||||
|
||||
i2 := array1.PopLefts(5)
|
||||
t.Assert(len(i2), 4)
|
||||
t.AssertIN(i1, []interface{}{"a", "d", "c", "b", "e", "f"})
|
||||
t.AssertIN(i1, []any{"a", "d", "c", "b", "e", "f"})
|
||||
t.Assert(array1.Len(), 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestSortedArray_PopRights(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "d", "c", "b", "e", "f"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
i1 := array1.PopRights(2)
|
||||
t.Assert(len(i1), 2)
|
||||
t.Assert(i1, []interface{}{"e", "f"})
|
||||
t.Assert(i1, []any{"e", "f"})
|
||||
t.Assert(array1.Len(), 4)
|
||||
|
||||
i2 := array1.PopRights(10)
|
||||
@ -329,36 +329,36 @@ func TestSortedArray_PopRights(t *testing.T) {
|
||||
|
||||
func TestSortedArray_Range(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "d", "c", "b", "e", "f"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
array2 := garray.NewSortedArrayFrom(a1, func1, true)
|
||||
i1 := array1.Range(2, 5)
|
||||
t.Assert(i1, []interface{}{"c", "d", "e"})
|
||||
t.Assert(i1, []any{"c", "d", "e"})
|
||||
t.Assert(array1.Len(), 6)
|
||||
|
||||
i2 := array1.Range(7, 5)
|
||||
t.Assert(len(i2), 0)
|
||||
i2 = array1.Range(-1, 2)
|
||||
t.Assert(i2, []interface{}{"a", "b"})
|
||||
t.Assert(i2, []any{"a", "b"})
|
||||
|
||||
i2 = array1.Range(4, 10)
|
||||
t.Assert(len(i2), 2)
|
||||
t.Assert(i2, []interface{}{"e", "f"})
|
||||
t.Assert(i2, []any{"e", "f"})
|
||||
|
||||
t.Assert(array2.Range(1, 3), []interface{}{"b", "c"})
|
||||
t.Assert(array2.Range(1, 3), []any{"b", "c"})
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestSortedArray_Sum(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
|
||||
a2 := []interface{}{"1", "2", "3", "b", "e", "f"}
|
||||
a3 := []interface{}{"4", "5", "6"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "d", "c", "b", "e", "f"}
|
||||
a2 := []any{"1", "2", "3", "b", "e", "f"}
|
||||
a3 := []any{"4", "5", "6"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
@ -373,9 +373,9 @@ func TestSortedArray_Sum(t *testing.T) {
|
||||
|
||||
func TestSortedArray_Clone(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
|
||||
a1 := []any{"a", "d", "c", "b", "e", "f"}
|
||||
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
@ -389,9 +389,9 @@ func TestSortedArray_Clone(t *testing.T) {
|
||||
|
||||
func TestSortedArray_Clear(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
|
||||
a1 := []any{"a", "d", "c", "b", "e", "f"}
|
||||
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
@ -404,66 +404,66 @@ func TestSortedArray_Clear(t *testing.T) {
|
||||
|
||||
func TestSortedArray_Chunk(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "b", "e"}
|
||||
a1 := []any{"a", "d", "c", "b", "e"}
|
||||
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
i1 := array1.Chunk(2)
|
||||
t.Assert(len(i1), 3)
|
||||
t.Assert(i1[0], []interface{}{"a", "b"})
|
||||
t.Assert(i1[2], []interface{}{"e"})
|
||||
t.Assert(i1[0], []any{"a", "b"})
|
||||
t.Assert(i1[2], []any{"e"})
|
||||
|
||||
i1 = array1.Chunk(0)
|
||||
t.Assert(len(i1), 0)
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{1, 2, 3, 4, 5}
|
||||
a1 := []any{1, 2, 3, 4, 5}
|
||||
array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
|
||||
chunks := array1.Chunk(3)
|
||||
t.Assert(len(chunks), 2)
|
||||
t.Assert(chunks[0], []interface{}{1, 2, 3})
|
||||
t.Assert(chunks[1], []interface{}{4, 5})
|
||||
t.Assert(chunks[0], []any{1, 2, 3})
|
||||
t.Assert(chunks[1], []any{4, 5})
|
||||
t.Assert(array1.Chunk(0), nil)
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{1, 2, 3, 4, 5, 6}
|
||||
a1 := []any{1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
|
||||
chunks := array1.Chunk(2)
|
||||
t.Assert(len(chunks), 3)
|
||||
t.Assert(chunks[0], []interface{}{1, 2})
|
||||
t.Assert(chunks[1], []interface{}{3, 4})
|
||||
t.Assert(chunks[2], []interface{}{5, 6})
|
||||
t.Assert(chunks[0], []any{1, 2})
|
||||
t.Assert(chunks[1], []any{3, 4})
|
||||
t.Assert(chunks[2], []any{5, 6})
|
||||
t.Assert(array1.Chunk(0), nil)
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{1, 2, 3, 4, 5, 6}
|
||||
a1 := []any{1, 2, 3, 4, 5, 6}
|
||||
array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
|
||||
chunks := array1.Chunk(3)
|
||||
t.Assert(len(chunks), 2)
|
||||
t.Assert(chunks[0], []interface{}{1, 2, 3})
|
||||
t.Assert(chunks[1], []interface{}{4, 5, 6})
|
||||
t.Assert(chunks[0], []any{1, 2, 3})
|
||||
t.Assert(chunks[1], []any{4, 5, 6})
|
||||
t.Assert(array1.Chunk(0), nil)
|
||||
})
|
||||
}
|
||||
|
||||
func TestSortedArray_SubSlice(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "b", "e"}
|
||||
a1 := []any{"a", "d", "c", "b", "e"}
|
||||
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
array2 := garray.NewSortedArrayFrom(a1, func1, true)
|
||||
i1 := array1.SubSlice(2, 3)
|
||||
t.Assert(len(i1), 3)
|
||||
t.Assert(i1, []interface{}{"c", "d", "e"})
|
||||
t.Assert(i1, []any{"c", "d", "e"})
|
||||
|
||||
i1 = array1.SubSlice(2, 6)
|
||||
t.Assert(len(i1), 3)
|
||||
t.Assert(i1, []interface{}{"c", "d", "e"})
|
||||
t.Assert(i1, []any{"c", "d", "e"})
|
||||
|
||||
i1 = array1.SubSlice(7, 2)
|
||||
t.Assert(len(i1), 0)
|
||||
@ -473,25 +473,25 @@ func TestSortedArray_SubSlice(t *testing.T) {
|
||||
|
||||
s1 = array1.SubSlice(-9, 2)
|
||||
t.Assert(s1, nil)
|
||||
t.Assert(array2.SubSlice(1, 3), []interface{}{"b", "c", "d"})
|
||||
t.Assert(array2.SubSlice(1, 3), []any{"b", "c", "d"})
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestSortedArray_Rand(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c"}
|
||||
a1 := []any{"a", "d", "c"}
|
||||
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
i1, ok := array1.Rand()
|
||||
t.Assert(ok, true)
|
||||
t.AssertIN(i1, []interface{}{"a", "d", "c"})
|
||||
t.AssertIN(i1, []any{"a", "d", "c"})
|
||||
t.Assert(array1.Len(), 3)
|
||||
|
||||
array2 := garray.NewSortedArrayFrom([]interface{}{}, func1)
|
||||
array2 := garray.NewSortedArrayFrom([]any{}, func1)
|
||||
v, ok := array2.Rand()
|
||||
t.Assert(ok, false)
|
||||
t.Assert(v, nil)
|
||||
@ -500,21 +500,21 @@ func TestSortedArray_Rand(t *testing.T) {
|
||||
|
||||
func TestSortedArray_Rands(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c"}
|
||||
a1 := []any{"a", "d", "c"}
|
||||
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
i1 := array1.Rands(2)
|
||||
t.AssertIN(i1, []interface{}{"a", "d", "c"})
|
||||
t.AssertIN(i1, []any{"a", "d", "c"})
|
||||
t.Assert(len(i1), 2)
|
||||
t.Assert(array1.Len(), 3)
|
||||
|
||||
i1 = array1.Rands(4)
|
||||
t.Assert(len(i1), 4)
|
||||
|
||||
array2 := garray.NewSortedArrayFrom([]interface{}{}, func1)
|
||||
array2 := garray.NewSortedArrayFrom([]any{}, func1)
|
||||
v := array2.Rands(1)
|
||||
t.Assert(v, nil)
|
||||
})
|
||||
@ -522,8 +522,8 @@ func TestSortedArray_Rands(t *testing.T) {
|
||||
|
||||
func TestSortedArray_Join(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c"}
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
a1 := []any{"a", "d", "c"}
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
@ -532,13 +532,13 @@ func TestSortedArray_Join(t *testing.T) {
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, `"a"`, `\a`}
|
||||
a1 := []any{0, 1, `"a"`, `\a`}
|
||||
array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
|
||||
t.Assert(array1.Join("."), `"a".0.1.\a`)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{}
|
||||
a1 := []any{}
|
||||
array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
|
||||
t.Assert(array1.Join("."), "")
|
||||
})
|
||||
@ -546,7 +546,7 @@ func TestSortedArray_Join(t *testing.T) {
|
||||
|
||||
func TestSortedArray_String(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{0, 1, "a", "b"}
|
||||
a1 := []any{0, 1, "a", "b"}
|
||||
array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
|
||||
t.Assert(array1.String(), `[0,1,"a","b"]`)
|
||||
|
||||
@ -557,9 +557,9 @@ func TestSortedArray_String(t *testing.T) {
|
||||
|
||||
func TestSortedArray_CountValues(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{"a", "d", "c", "c"}
|
||||
a1 := []any{"a", "d", "c", "c"}
|
||||
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
array1 := garray.NewSortedArrayFrom(a1, func1)
|
||||
@ -573,41 +573,41 @@ func TestSortedArray_CountValues(t *testing.T) {
|
||||
|
||||
func TestSortedArray_SetUnique(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
|
||||
a1 := []any{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
|
||||
array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
|
||||
array1.SetUnique(true)
|
||||
t.Assert(array1.Len(), 5)
|
||||
t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
|
||||
t.Assert(array1, []any{1, 2, 3, 4, 5})
|
||||
})
|
||||
}
|
||||
|
||||
func TestSortedArray_Unique(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a1 := []interface{}{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
|
||||
a1 := []any{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
|
||||
array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
|
||||
array1.Unique()
|
||||
t.Assert(array1.Len(), 5)
|
||||
t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
|
||||
t.Assert(array1, []any{1, 2, 3, 4, 5})
|
||||
|
||||
array2 := garray.NewSortedArrayFrom([]interface{}{}, gutil.ComparatorInt)
|
||||
array2 := garray.NewSortedArrayFrom([]any{}, gutil.ComparatorInt)
|
||||
array2.Unique()
|
||||
t.Assert(array2.Len(), 0)
|
||||
t.Assert(array2, []interface{}{})
|
||||
t.Assert(array2, []any{})
|
||||
})
|
||||
}
|
||||
|
||||
func TestSortedArray_LockFunc(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
s1 := []interface{}{"a", "b", "c", "d"}
|
||||
s1 := []any{"a", "b", "c", "d"}
|
||||
a1 := garray.NewSortedArrayFrom(s1, func1, true)
|
||||
|
||||
ch1 := make(chan int64, 3)
|
||||
ch2 := make(chan int64, 3)
|
||||
// go1
|
||||
go a1.LockFunc(func(n1 []interface{}) { // 读写锁
|
||||
go a1.LockFunc(func(n1 []any) { // 读写锁
|
||||
time.Sleep(2 * time.Second) // 暂停2秒
|
||||
n1[2] = "g"
|
||||
ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
|
||||
@ -633,16 +633,16 @@ func TestSortedArray_LockFunc(t *testing.T) {
|
||||
|
||||
func TestSortedArray_RLockFunc(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
return strings.Compare(gconv.String(v1), gconv.String(v2))
|
||||
}
|
||||
s1 := []interface{}{"a", "b", "c", "d"}
|
||||
s1 := []any{"a", "b", "c", "d"}
|
||||
a1 := garray.NewSortedArrayFrom(s1, func1, true)
|
||||
|
||||
ch1 := make(chan int64, 3)
|
||||
ch2 := make(chan int64, 3)
|
||||
// go1
|
||||
go a1.RLockFunc(func(n1 []interface{}) { // 读写锁
|
||||
go a1.RLockFunc(func(n1 []any) { // 读写锁
|
||||
time.Sleep(2 * time.Second) // 暂停2秒
|
||||
n1[2] = "g"
|
||||
ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
|
||||
@ -668,19 +668,19 @@ func TestSortedArray_RLockFunc(t *testing.T) {
|
||||
|
||||
func TestSortedArray_Merge(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
if gconv.Int(v1) < gconv.Int(v2) {
|
||||
return 0
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
s1 := []interface{}{"a", "b", "c", "d"}
|
||||
s1 := []any{"a", "b", "c", "d"}
|
||||
s2 := []string{"e", "f"}
|
||||
i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
|
||||
i2 := garray.NewArrayFrom([]interface{}{3})
|
||||
i2 := garray.NewArrayFrom([]any{3})
|
||||
s3 := garray.NewStrArrayFrom([]string{"g", "h"})
|
||||
s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
|
||||
s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
|
||||
s5 := garray.NewSortedStrArrayFrom(s2)
|
||||
s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
|
||||
|
||||
@ -699,8 +699,8 @@ func TestSortedArray_Merge(t *testing.T) {
|
||||
func TestSortedArray_Json(t *testing.T) {
|
||||
// array pointer
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := []interface{}{"a", "b", "d", "c"}
|
||||
s2 := []interface{}{"a", "b", "c", "d"}
|
||||
s1 := []any{"a", "b", "d", "c"}
|
||||
s2 := []any{"a", "b", "c", "d"}
|
||||
a1 := garray.NewSortedArrayFrom(s1, gutil.ComparatorString)
|
||||
b1, err1 := json.Marshal(a1)
|
||||
b2, err2 := json.Marshal(s1)
|
||||
@ -720,8 +720,8 @@ func TestSortedArray_Json(t *testing.T) {
|
||||
})
|
||||
// array value
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := []interface{}{"a", "b", "d", "c"}
|
||||
s2 := []interface{}{"a", "b", "c", "d"}
|
||||
s1 := []any{"a", "b", "d", "c"}
|
||||
s2 := []any{"a", "b", "c", "d"}
|
||||
a1 := *garray.NewSortedArrayFrom(s1, gutil.ComparatorString)
|
||||
b1, err1 := json.Marshal(a1)
|
||||
b2, err2 := json.Marshal(s1)
|
||||
@ -817,26 +817,26 @@ func TestSortedArray_Iterator(t *testing.T) {
|
||||
slice := g.Slice{"a", "b", "d", "c"}
|
||||
array := garray.NewSortedArrayFrom(slice, gutil.ComparatorString)
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array.Iterator(func(k int, v interface{}) bool {
|
||||
array.Iterator(func(k int, v any) bool {
|
||||
t.Assert(v, slice[k])
|
||||
return true
|
||||
})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array.IteratorAsc(func(k int, v interface{}) bool {
|
||||
array.IteratorAsc(func(k int, v any) bool {
|
||||
t.Assert(v, slice[k])
|
||||
return true
|
||||
})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array.IteratorDesc(func(k int, v interface{}) bool {
|
||||
array.IteratorDesc(func(k int, v any) bool {
|
||||
t.Assert(v, slice[k])
|
||||
return true
|
||||
})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
index := 0
|
||||
array.Iterator(func(k int, v interface{}) bool {
|
||||
array.Iterator(func(k int, v any) bool {
|
||||
index++
|
||||
return false
|
||||
})
|
||||
@ -844,7 +844,7 @@ func TestSortedArray_Iterator(t *testing.T) {
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
index := 0
|
||||
array.IteratorAsc(func(k int, v interface{}) bool {
|
||||
array.IteratorAsc(func(k int, v any) bool {
|
||||
index++
|
||||
return false
|
||||
})
|
||||
@ -852,7 +852,7 @@ func TestSortedArray_Iterator(t *testing.T) {
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
index := 0
|
||||
array.IteratorDesc(func(k int, v interface{}) bool {
|
||||
array.IteratorDesc(func(k int, v any) bool {
|
||||
index++
|
||||
return false
|
||||
})
|
||||
@ -913,25 +913,25 @@ func TestSortedArray_Filter(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
|
||||
array := garray.NewSortedArrayFromCopy(values, gutil.ComparatorInt)
|
||||
t.Assert(array.Filter(func(index int, value interface{}) bool {
|
||||
t.Assert(array.Filter(func(index int, value any) bool {
|
||||
return empty.IsNil(value)
|
||||
}).Slice(), g.Slice{0, "", g.Slice{}, 1, 2, 3, 4})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewSortedArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil}, gutil.ComparatorInt)
|
||||
t.Assert(array.Filter(func(index int, value interface{}) bool {
|
||||
t.Assert(array.Filter(func(index int, value any) bool {
|
||||
return empty.IsNil(value)
|
||||
}), g.Slice{1, 2, 3, 4})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewSortedArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}, gutil.ComparatorInt)
|
||||
t.Assert(array.Filter(func(index int, value interface{}) bool {
|
||||
t.Assert(array.Filter(func(index int, value any) bool {
|
||||
return empty.IsEmpty(value)
|
||||
}), g.Slice{1, 2, 3, 4})
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewSortedArrayFrom(g.Slice{1, 2, 3, 4}, gutil.ComparatorInt)
|
||||
t.Assert(array.Filter(func(index int, value interface{}) bool {
|
||||
t.Assert(array.Filter(func(index int, value any) bool {
|
||||
return empty.IsEmpty(value)
|
||||
}), g.Slice{1, 2, 3, 4})
|
||||
})
|
||||
@ -963,7 +963,7 @@ func TestSortedArray_FilterEmpty(t *testing.T) {
|
||||
func TestSortedArray_Walk(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewSortedArrayFrom(g.Slice{"1", "2"}, gutil.ComparatorString)
|
||||
t.Assert(array.Walk(func(value interface{}) interface{} {
|
||||
t.Assert(array.Walk(func(value any) any {
|
||||
return "key-" + gconv.String(value)
|
||||
}), g.Slice{"key-1", "key-2"})
|
||||
})
|
||||
@ -971,14 +971,14 @@ func TestSortedArray_Walk(t *testing.T) {
|
||||
|
||||
func TestSortedArray_IsEmpty(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewSortedArrayFrom([]interface{}{}, gutil.ComparatorString)
|
||||
array := garray.NewSortedArrayFrom([]any{}, gutil.ComparatorString)
|
||||
t.Assert(array.IsEmpty(), true)
|
||||
})
|
||||
}
|
||||
|
||||
func TestSortedArray_DeepCopy(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
array := garray.NewSortedArrayFrom([]interface{}{1, 2, 3, 4, 5}, gutil.ComparatorString)
|
||||
array := garray.NewSortedArrayFrom([]any{1, 2, 3, 4, 5}, gutil.ComparatorString)
|
||||
copyArray := array.DeepCopy().(*garray.SortedArray)
|
||||
array.Add(6)
|
||||
copyArray.Add(7)
|
||||
|
||||
@ -573,7 +573,7 @@ func TestSortedIntArray_RLockFunc(t *testing.T) {
|
||||
|
||||
func TestSortedIntArray_Merge(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
if gconv.Int(v1) < gconv.Int(v2) {
|
||||
return 0
|
||||
}
|
||||
@ -582,9 +582,9 @@ func TestSortedIntArray_Merge(t *testing.T) {
|
||||
i0 := []int{1, 2, 3, 4}
|
||||
s2 := []string{"e", "f"}
|
||||
i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
|
||||
i2 := garray.NewArrayFrom([]interface{}{3})
|
||||
i2 := garray.NewArrayFrom([]any{3})
|
||||
s3 := garray.NewStrArrayFrom([]string{"g", "h"})
|
||||
s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
|
||||
s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
|
||||
s5 := garray.NewSortedStrArrayFrom(s2)
|
||||
s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
|
||||
a1 := garray.NewSortedIntArrayFrom(i0)
|
||||
|
||||
@ -581,7 +581,7 @@ func TestSortedStrArray_RLockFunc(t *testing.T) {
|
||||
|
||||
func TestSortedStrArray_Merge(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
func1 := func(v1, v2 interface{}) int {
|
||||
func1 := func(v1, v2 any) int {
|
||||
if gconv.Int(v1) < gconv.Int(v2) {
|
||||
return 0
|
||||
}
|
||||
@ -591,9 +591,9 @@ func TestSortedStrArray_Merge(t *testing.T) {
|
||||
s1 := []string{"a", "b", "c", "d"}
|
||||
s2 := []string{"e", "f"}
|
||||
i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
|
||||
i2 := garray.NewArrayFrom([]interface{}{3})
|
||||
i2 := garray.NewArrayFrom([]any{3})
|
||||
s3 := garray.NewStrArrayFrom([]string{"g", "h"})
|
||||
s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
|
||||
s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
|
||||
s5 := garray.NewSortedStrArrayFrom(s2)
|
||||
s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
|
||||
a1 := garray.NewSortedStrArrayFrom(s1)
|
||||
|
||||
@ -41,7 +41,7 @@ func New(safe ...bool) *List {
|
||||
// NewFrom creates and returns a list from a copy of given slice `array`.
|
||||
// The parameter `safe` is used to specify whether using list in concurrent-safety,
|
||||
// which is false in default.
|
||||
func NewFrom(array []interface{}, safe ...bool) *List {
|
||||
func NewFrom(array []any, safe ...bool) *List {
|
||||
l := list.New()
|
||||
for _, v := range array {
|
||||
l.PushBack(v)
|
||||
@ -53,7 +53,7 @@ func NewFrom(array []interface{}, safe ...bool) *List {
|
||||
}
|
||||
|
||||
// PushFront inserts a new element `e` with value `v` at the front of list `l` and returns `e`.
|
||||
func (l *List) PushFront(v interface{}) (e *Element) {
|
||||
func (l *List) PushFront(v any) (e *Element) {
|
||||
l.mu.Lock()
|
||||
if l.list == nil {
|
||||
l.list = list.New()
|
||||
@ -64,7 +64,7 @@ func (l *List) PushFront(v interface{}) (e *Element) {
|
||||
}
|
||||
|
||||
// PushBack inserts a new element `e` with value `v` at the back of list `l` and returns `e`.
|
||||
func (l *List) PushBack(v interface{}) (e *Element) {
|
||||
func (l *List) PushBack(v any) (e *Element) {
|
||||
l.mu.Lock()
|
||||
if l.list == nil {
|
||||
l.list = list.New()
|
||||
@ -75,7 +75,7 @@ func (l *List) PushBack(v interface{}) (e *Element) {
|
||||
}
|
||||
|
||||
// PushFronts inserts multiple new elements with values `values` at the front of list `l`.
|
||||
func (l *List) PushFronts(values []interface{}) {
|
||||
func (l *List) PushFronts(values []any) {
|
||||
l.mu.Lock()
|
||||
if l.list == nil {
|
||||
l.list = list.New()
|
||||
@ -87,7 +87,7 @@ func (l *List) PushFronts(values []interface{}) {
|
||||
}
|
||||
|
||||
// PushBacks inserts multiple new elements with values `values` at the back of list `l`.
|
||||
func (l *List) PushBacks(values []interface{}) {
|
||||
func (l *List) PushBacks(values []any) {
|
||||
l.mu.Lock()
|
||||
if l.list == nil {
|
||||
l.list = list.New()
|
||||
@ -99,7 +99,7 @@ func (l *List) PushBacks(values []interface{}) {
|
||||
}
|
||||
|
||||
// PopBack removes the element from back of `l` and returns the value of the element.
|
||||
func (l *List) PopBack() (value interface{}) {
|
||||
func (l *List) PopBack() (value any) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
if l.list == nil {
|
||||
@ -113,7 +113,7 @@ func (l *List) PopBack() (value interface{}) {
|
||||
}
|
||||
|
||||
// PopFront removes the element from front of `l` and returns the value of the element.
|
||||
func (l *List) PopFront() (value interface{}) {
|
||||
func (l *List) PopFront() (value any) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
if l.list == nil {
|
||||
@ -128,7 +128,7 @@ func (l *List) PopFront() (value interface{}) {
|
||||
|
||||
// PopBacks removes `max` elements from back of `l`
|
||||
// and returns values of the removed elements as slice.
|
||||
func (l *List) PopBacks(max int) (values []interface{}) {
|
||||
func (l *List) PopBacks(max int) (values []any) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
if l.list == nil {
|
||||
@ -140,7 +140,7 @@ func (l *List) PopBacks(max int) (values []interface{}) {
|
||||
if max > 0 && max < length {
|
||||
length = max
|
||||
}
|
||||
values = make([]interface{}, length)
|
||||
values = make([]any, length)
|
||||
for i := 0; i < length; i++ {
|
||||
values[i] = l.list.Remove(l.list.Back())
|
||||
}
|
||||
@ -150,7 +150,7 @@ func (l *List) PopBacks(max int) (values []interface{}) {
|
||||
|
||||
// PopFronts removes `max` elements from front of `l`
|
||||
// and returns values of the removed elements as slice.
|
||||
func (l *List) PopFronts(max int) (values []interface{}) {
|
||||
func (l *List) PopFronts(max int) (values []any) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
if l.list == nil {
|
||||
@ -162,7 +162,7 @@ func (l *List) PopFronts(max int) (values []interface{}) {
|
||||
if max > 0 && max < length {
|
||||
length = max
|
||||
}
|
||||
values = make([]interface{}, length)
|
||||
values = make([]any, length)
|
||||
for i := 0; i < length; i++ {
|
||||
values[i] = l.list.Remove(l.list.Front())
|
||||
}
|
||||
@ -172,18 +172,18 @@ func (l *List) PopFronts(max int) (values []interface{}) {
|
||||
|
||||
// PopBackAll removes all elements from back of `l`
|
||||
// and returns values of the removed elements as slice.
|
||||
func (l *List) PopBackAll() []interface{} {
|
||||
func (l *List) PopBackAll() []any {
|
||||
return l.PopBacks(-1)
|
||||
}
|
||||
|
||||
// PopFrontAll removes all elements from front of `l`
|
||||
// and returns values of the removed elements as slice.
|
||||
func (l *List) PopFrontAll() []interface{} {
|
||||
func (l *List) PopFrontAll() []any {
|
||||
return l.PopFronts(-1)
|
||||
}
|
||||
|
||||
// FrontAll copies and returns values of all elements from front of `l` as slice.
|
||||
func (l *List) FrontAll() (values []interface{}) {
|
||||
func (l *List) FrontAll() (values []any) {
|
||||
l.mu.RLock()
|
||||
defer l.mu.RUnlock()
|
||||
if l.list == nil {
|
||||
@ -191,7 +191,7 @@ func (l *List) FrontAll() (values []interface{}) {
|
||||
}
|
||||
length := l.list.Len()
|
||||
if length > 0 {
|
||||
values = make([]interface{}, length)
|
||||
values = make([]any, length)
|
||||
for i, e := 0, l.list.Front(); i < length; i, e = i+1, e.Next() {
|
||||
values[i] = e.Value
|
||||
}
|
||||
@ -200,7 +200,7 @@ func (l *List) FrontAll() (values []interface{}) {
|
||||
}
|
||||
|
||||
// BackAll copies and returns values of all elements from back of `l` as slice.
|
||||
func (l *List) BackAll() (values []interface{}) {
|
||||
func (l *List) BackAll() (values []any) {
|
||||
l.mu.RLock()
|
||||
defer l.mu.RUnlock()
|
||||
if l.list == nil {
|
||||
@ -208,7 +208,7 @@ func (l *List) BackAll() (values []interface{}) {
|
||||
}
|
||||
length := l.list.Len()
|
||||
if length > 0 {
|
||||
values = make([]interface{}, length)
|
||||
values = make([]any, length)
|
||||
for i, e := 0, l.list.Back(); i < length; i, e = i+1, e.Prev() {
|
||||
values[i] = e.Value
|
||||
}
|
||||
@ -217,7 +217,7 @@ func (l *List) BackAll() (values []interface{}) {
|
||||
}
|
||||
|
||||
// FrontValue returns value of the first element of `l` or nil if the list is empty.
|
||||
func (l *List) FrontValue() (value interface{}) {
|
||||
func (l *List) FrontValue() (value any) {
|
||||
l.mu.RLock()
|
||||
defer l.mu.RUnlock()
|
||||
if l.list == nil {
|
||||
@ -230,7 +230,7 @@ func (l *List) FrontValue() (value interface{}) {
|
||||
}
|
||||
|
||||
// BackValue returns value of the last element of `l` or nil if the list is empty.
|
||||
func (l *List) BackValue() (value interface{}) {
|
||||
func (l *List) BackValue() (value any) {
|
||||
l.mu.RLock()
|
||||
defer l.mu.RUnlock()
|
||||
if l.list == nil {
|
||||
@ -362,7 +362,7 @@ func (l *List) PushFrontList(other *List) {
|
||||
// InsertAfter inserts a new element `e` with value `v` immediately after `p` and returns `e`.
|
||||
// If `p` is not an element of `l`, the list is not modified.
|
||||
// The `p` must not be nil.
|
||||
func (l *List) InsertAfter(p *Element, v interface{}) (e *Element) {
|
||||
func (l *List) InsertAfter(p *Element, v any) (e *Element) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
if l.list == nil {
|
||||
@ -375,7 +375,7 @@ func (l *List) InsertAfter(p *Element, v interface{}) (e *Element) {
|
||||
// InsertBefore inserts a new element `e` with value `v` immediately before `p` and returns `e`.
|
||||
// If `p` is not an element of `l`, the list is not modified.
|
||||
// The `p` must not be nil.
|
||||
func (l *List) InsertBefore(p *Element, v interface{}) (e *Element) {
|
||||
func (l *List) InsertBefore(p *Element, v any) (e *Element) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
if l.list == nil {
|
||||
@ -388,7 +388,7 @@ func (l *List) InsertBefore(p *Element, v interface{}) (e *Element) {
|
||||
// Remove removes `e` from `l` if `e` is an element of list `l`.
|
||||
// It returns the element value e.Value.
|
||||
// The element must not be nil.
|
||||
func (l *List) Remove(e *Element) (value interface{}) {
|
||||
func (l *List) Remove(e *Element) (value any) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
if l.list == nil {
|
||||
@ -522,7 +522,7 @@ func (l *List) UnmarshalJSON(b []byte) error {
|
||||
if l.list == nil {
|
||||
l.list = list.New()
|
||||
}
|
||||
var array []interface{}
|
||||
var array []any
|
||||
if err := json.UnmarshalUseNumber(b, &array); err != nil {
|
||||
return err
|
||||
}
|
||||
@ -531,13 +531,13 @@ func (l *List) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for list.
|
||||
func (l *List) UnmarshalValue(value interface{}) (err error) {
|
||||
func (l *List) UnmarshalValue(value any) (err error) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
if l.list == nil {
|
||||
l.list = list.New()
|
||||
}
|
||||
var array []interface{}
|
||||
var array []any
|
||||
switch value.(type) {
|
||||
case string, []byte:
|
||||
err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
|
||||
@ -549,7 +549,7 @@ func (l *List) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (l *List) DeepCopy() interface{} {
|
||||
func (l *List) DeepCopy() any {
|
||||
if l == nil {
|
||||
return nil
|
||||
}
|
||||
@ -562,7 +562,7 @@ func (l *List) DeepCopy() interface{} {
|
||||
}
|
||||
var (
|
||||
length = l.list.Len()
|
||||
values = make([]interface{}, length)
|
||||
values = make([]any, length)
|
||||
)
|
||||
if length > 0 {
|
||||
for i, e := 0, l.list.Front(); i < length; i, e = i+1, e.Next() {
|
||||
|
||||
@ -198,7 +198,7 @@ func TestList(t *testing.T) {
|
||||
})
|
||||
}
|
||||
|
||||
func checkList(t *gtest.T, l *List, es []interface{}) {
|
||||
func checkList(t *gtest.T, l *List, es []any) {
|
||||
if !checkListLen(t, l, len(es)) {
|
||||
return
|
||||
}
|
||||
@ -244,36 +244,36 @@ func TestExtending(t *testing.T) {
|
||||
|
||||
l3 := New()
|
||||
l3.PushBackList(l1)
|
||||
checkList(t, l3, []interface{}{1, 2, 3})
|
||||
checkList(t, l3, []any{1, 2, 3})
|
||||
l3.PushBackList(l2)
|
||||
checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
|
||||
checkList(t, l3, []any{1, 2, 3, 4, 5})
|
||||
|
||||
l3 = New()
|
||||
l3.PushFrontList(l2)
|
||||
checkList(t, l3, []interface{}{4, 5})
|
||||
checkList(t, l3, []any{4, 5})
|
||||
l3.PushFrontList(l1)
|
||||
checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
|
||||
checkList(t, l3, []any{1, 2, 3, 4, 5})
|
||||
|
||||
checkList(t, l1, []interface{}{1, 2, 3})
|
||||
checkList(t, l2, []interface{}{4, 5})
|
||||
checkList(t, l1, []any{1, 2, 3})
|
||||
checkList(t, l2, []any{4, 5})
|
||||
|
||||
l3 = New()
|
||||
l3.PushBackList(l1)
|
||||
checkList(t, l3, []interface{}{1, 2, 3})
|
||||
checkList(t, l3, []any{1, 2, 3})
|
||||
l3.PushBackList(l3)
|
||||
checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
|
||||
checkList(t, l3, []any{1, 2, 3, 1, 2, 3})
|
||||
|
||||
l3 = New()
|
||||
l3.PushFrontList(l1)
|
||||
checkList(t, l3, []interface{}{1, 2, 3})
|
||||
checkList(t, l3, []any{1, 2, 3})
|
||||
l3.PushFrontList(l3)
|
||||
checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
|
||||
checkList(t, l3, []any{1, 2, 3, 1, 2, 3})
|
||||
|
||||
l3 = New()
|
||||
l1.PushBackList(l3)
|
||||
checkList(t, l1, []interface{}{1, 2, 3})
|
||||
checkList(t, l1, []any{1, 2, 3})
|
||||
l1.PushFrontList(l3)
|
||||
checkList(t, l1, []interface{}{1, 2, 3})
|
||||
checkList(t, l1, []any{1, 2, 3})
|
||||
})
|
||||
}
|
||||
|
||||
@ -371,19 +371,19 @@ func TestZeroList(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var l1 = New()
|
||||
l1.PushFront(1)
|
||||
checkList(t, l1, []interface{}{1})
|
||||
checkList(t, l1, []any{1})
|
||||
|
||||
var l2 = New()
|
||||
l2.PushBack(1)
|
||||
checkList(t, l2, []interface{}{1})
|
||||
checkList(t, l2, []any{1})
|
||||
|
||||
var l3 = New()
|
||||
l3.PushFrontList(l1)
|
||||
checkList(t, l3, []interface{}{1})
|
||||
checkList(t, l3, []any{1})
|
||||
|
||||
var l4 = New()
|
||||
l4.PushBackList(l2)
|
||||
checkList(t, l4, []interface{}{1})
|
||||
checkList(t, l4, []any{1})
|
||||
})
|
||||
}
|
||||
|
||||
@ -395,7 +395,7 @@ func TestInsertBeforeUnknownMark(t *testing.T) {
|
||||
l.PushBack(2)
|
||||
l.PushBack(3)
|
||||
l.InsertBefore(new(Element), 1)
|
||||
checkList(t, l, []interface{}{1, 2, 3})
|
||||
checkList(t, l, []any{1, 2, 3})
|
||||
})
|
||||
}
|
||||
|
||||
@ -407,7 +407,7 @@ func TestInsertAfterUnknownMark(t *testing.T) {
|
||||
l.PushBack(2)
|
||||
l.PushBack(3)
|
||||
l.InsertAfter(new(Element), 1)
|
||||
checkList(t, l, []interface{}{1, 2, 3})
|
||||
checkList(t, l, []any{1, 2, 3})
|
||||
})
|
||||
}
|
||||
|
||||
@ -421,12 +421,12 @@ func TestMoveUnknownMark(t *testing.T) {
|
||||
e2 := l2.PushBack(2)
|
||||
|
||||
l1.MoveAfter(e1, e2)
|
||||
checkList(t, l1, []interface{}{1})
|
||||
checkList(t, l2, []interface{}{2})
|
||||
checkList(t, l1, []any{1})
|
||||
checkList(t, l2, []any{2})
|
||||
|
||||
l1.MoveBefore(e1, e2)
|
||||
checkList(t, l1, []interface{}{1})
|
||||
checkList(t, l2, []interface{}{2})
|
||||
checkList(t, l1, []any{1})
|
||||
checkList(t, l2, []any{2})
|
||||
})
|
||||
}
|
||||
|
||||
@ -435,58 +435,58 @@ func TestList_RemoveAll(t *testing.T) {
|
||||
l := New()
|
||||
l.PushBack(1)
|
||||
l.RemoveAll()
|
||||
checkList(t, l, []interface{}{})
|
||||
checkList(t, l, []any{})
|
||||
l.PushBack(2)
|
||||
checkList(t, l, []interface{}{2})
|
||||
checkList(t, l, []any{2})
|
||||
})
|
||||
}
|
||||
|
||||
func TestList_PushFronts(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2}
|
||||
a1 := []any{1, 2}
|
||||
l.PushFronts(a1)
|
||||
checkList(t, l, []interface{}{2, 1})
|
||||
a1 = []interface{}{3, 4, 5}
|
||||
checkList(t, l, []any{2, 1})
|
||||
a1 = []any{3, 4, 5}
|
||||
l.PushFronts(a1)
|
||||
checkList(t, l, []interface{}{5, 4, 3, 2, 1})
|
||||
checkList(t, l, []any{5, 4, 3, 2, 1})
|
||||
})
|
||||
}
|
||||
|
||||
func TestList_PushBacks(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2}
|
||||
a1 := []any{1, 2}
|
||||
l.PushBacks(a1)
|
||||
checkList(t, l, []interface{}{1, 2})
|
||||
a1 = []interface{}{3, 4, 5}
|
||||
checkList(t, l, []any{1, 2})
|
||||
a1 = []any{3, 4, 5}
|
||||
l.PushBacks(a1)
|
||||
checkList(t, l, []interface{}{1, 2, 3, 4, 5})
|
||||
checkList(t, l, []any{1, 2, 3, 4, 5})
|
||||
})
|
||||
}
|
||||
|
||||
func TestList_PopBacks(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a2 := []interface{}{"a", "c", "b", "e"}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
a2 := []any{"a", "c", "b", "e"}
|
||||
l.PushFronts(a1)
|
||||
i1 := l.PopBacks(2)
|
||||
t.Assert(i1, []interface{}{1, 2})
|
||||
t.Assert(i1, []any{1, 2})
|
||||
|
||||
l.PushBacks(a2) // 4.3,a,c,b,e
|
||||
i1 = l.PopBacks(3)
|
||||
t.Assert(i1, []interface{}{"e", "b", "c"})
|
||||
t.Assert(i1, []any{"e", "b", "c"})
|
||||
})
|
||||
}
|
||||
|
||||
func TestList_PopFronts(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
i1 := l.PopFronts(2)
|
||||
t.Assert(i1, []interface{}{4, 3})
|
||||
t.Assert(i1, []any{4, 3})
|
||||
t.Assert(l.Len(), 2)
|
||||
})
|
||||
}
|
||||
@ -494,10 +494,10 @@ func TestList_PopFronts(t *testing.T) {
|
||||
func TestList_PopBackAll(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
i1 := l.PopBackAll()
|
||||
t.Assert(i1, []interface{}{1, 2, 3, 4})
|
||||
t.Assert(i1, []any{1, 2, 3, 4})
|
||||
t.Assert(l.Len(), 0)
|
||||
})
|
||||
}
|
||||
@ -505,10 +505,10 @@ func TestList_PopBackAll(t *testing.T) {
|
||||
func TestList_PopFrontAll(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
i1 := l.PopFrontAll()
|
||||
t.Assert(i1, []interface{}{4, 3, 2, 1})
|
||||
t.Assert(i1, []any{4, 3, 2, 1})
|
||||
t.Assert(l.Len(), 0)
|
||||
})
|
||||
}
|
||||
@ -516,10 +516,10 @@ func TestList_PopFrontAll(t *testing.T) {
|
||||
func TestList_FrontAll(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
i1 := l.FrontAll()
|
||||
t.Assert(i1, []interface{}{4, 3, 2, 1})
|
||||
t.Assert(i1, []any{4, 3, 2, 1})
|
||||
t.Assert(l.Len(), 4)
|
||||
})
|
||||
}
|
||||
@ -527,10 +527,10 @@ func TestList_FrontAll(t *testing.T) {
|
||||
func TestList_BackAll(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
i1 := l.BackAll()
|
||||
t.Assert(i1, []interface{}{1, 2, 3, 4})
|
||||
t.Assert(i1, []any{1, 2, 3, 4})
|
||||
t.Assert(l.Len(), 4)
|
||||
})
|
||||
}
|
||||
@ -539,7 +539,7 @@ func TestList_FrontValue(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
l2 := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
i1 := l.FrontValue()
|
||||
t.Assert(gconv.Int(i1), 4)
|
||||
@ -554,7 +554,7 @@ func TestList_BackValue(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
l2 := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
i1 := l.BackValue()
|
||||
t.Assert(gconv.Int(i1), 1)
|
||||
@ -568,7 +568,7 @@ func TestList_BackValue(t *testing.T) {
|
||||
func TestList_Back(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
e1 := l.Back()
|
||||
t.Assert(e1.Value, 1)
|
||||
@ -579,7 +579,7 @@ func TestList_Back(t *testing.T) {
|
||||
func TestList_Size(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
t.Assert(l.Size(), 4)
|
||||
l.PopFront()
|
||||
@ -590,7 +590,7 @@ func TestList_Size(t *testing.T) {
|
||||
func TestList_Removes(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
e1 := l.Back()
|
||||
l.Removes([]*Element{e1})
|
||||
@ -599,25 +599,25 @@ func TestList_Removes(t *testing.T) {
|
||||
e2 := l.Back()
|
||||
l.Removes([]*Element{e2})
|
||||
t.Assert(l.Len(), 2)
|
||||
checkList(t, l, []interface{}{4, 3})
|
||||
checkList(t, l, []any{4, 3})
|
||||
})
|
||||
}
|
||||
|
||||
func TestList_Pop(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
|
||||
l := NewFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
|
||||
|
||||
t.Assert(l.PopBack(), 9)
|
||||
t.Assert(l.PopBacks(2), []interface{}{8, 7})
|
||||
t.Assert(l.PopBacks(2), []any{8, 7})
|
||||
t.Assert(l.PopFront(), 1)
|
||||
t.Assert(l.PopFronts(2), []interface{}{2, 3})
|
||||
t.Assert(l.PopFronts(2), []any{2, 3})
|
||||
})
|
||||
}
|
||||
|
||||
func TestList_Clear(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
l.Clear()
|
||||
t.Assert(l.Len(), 0)
|
||||
@ -627,22 +627,22 @@ func TestList_Clear(t *testing.T) {
|
||||
func TestList_IteratorAsc(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 5, 6, 3, 4}
|
||||
a1 := []any{1, 2, 5, 6, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
e1 := l.Back()
|
||||
fun1 := func(e *Element) bool {
|
||||
return gconv.Int(e1.Value) > 2
|
||||
}
|
||||
checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
|
||||
checkList(t, l, []any{4, 3, 6, 5, 2, 1})
|
||||
l.IteratorAsc(fun1)
|
||||
checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
|
||||
checkList(t, l, []any{4, 3, 6, 5, 2, 1})
|
||||
})
|
||||
}
|
||||
|
||||
func TestList_IteratorDesc(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{1, 2, 3, 4}
|
||||
a1 := []any{1, 2, 3, 4}
|
||||
l.PushFronts(a1)
|
||||
e1 := l.Back()
|
||||
fun1 := func(e *Element) bool {
|
||||
@ -650,28 +650,28 @@ func TestList_IteratorDesc(t *testing.T) {
|
||||
}
|
||||
l.IteratorDesc(fun1)
|
||||
t.Assert(l.Len(), 4)
|
||||
checkList(t, l, []interface{}{4, 3, 2, 1})
|
||||
checkList(t, l, []any{4, 3, 2, 1})
|
||||
})
|
||||
}
|
||||
|
||||
func TestList_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := New()
|
||||
a1 := []interface{}{"a", "b", "c", "d", "e"}
|
||||
a1 := []any{"a", "b", "c", "d", "e"}
|
||||
l.PushFronts(a1)
|
||||
e1 := l.Back()
|
||||
fun1 := func(e *Element) bool {
|
||||
return gconv.String(e1.Value) > "c"
|
||||
}
|
||||
checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
|
||||
checkList(t, l, []any{"e", "d", "c", "b", "a"})
|
||||
l.Iterator(fun1)
|
||||
checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
|
||||
checkList(t, l, []any{"e", "d", "c", "b", "a"})
|
||||
})
|
||||
}
|
||||
|
||||
func TestList_Join(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := NewFrom([]interface{}{1, 2, "a", `"b"`, `\c`})
|
||||
l := NewFrom([]any{1, 2, "a", `"b"`, `\c`})
|
||||
t.Assert(l.Join(","), `1,2,a,"b",\c`)
|
||||
t.Assert(l.Join("."), `1.2.a."b".\c`)
|
||||
})
|
||||
@ -679,7 +679,7 @@ func TestList_Join(t *testing.T) {
|
||||
|
||||
func TestList_String(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := NewFrom([]interface{}{1, 2, "a", `"b"`, `\c`})
|
||||
l := NewFrom([]any{1, 2, "a", `"b"`, `\c`})
|
||||
t.Assert(l.String(), `[1,2,a,"b",\c]`)
|
||||
})
|
||||
}
|
||||
@ -687,7 +687,7 @@ func TestList_String(t *testing.T) {
|
||||
func TestList_Json(t *testing.T) {
|
||||
// Marshal
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a := []interface{}{"a", "b", "c"}
|
||||
a := []any{"a", "b", "c"}
|
||||
l := New()
|
||||
l.PushBacks(a)
|
||||
b1, err1 := json.Marshal(l)
|
||||
@ -697,7 +697,7 @@ func TestList_Json(t *testing.T) {
|
||||
})
|
||||
// Unmarshal
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
a := []interface{}{"a", "b", "c"}
|
||||
a := []any{"a", "b", "c"}
|
||||
l := New()
|
||||
b, err := json.Marshal(a)
|
||||
t.AssertNil(err)
|
||||
@ -708,7 +708,7 @@ func TestList_Json(t *testing.T) {
|
||||
})
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var l List
|
||||
a := []interface{}{"a", "b", "c"}
|
||||
a := []any{"a", "b", "c"}
|
||||
b, err := json.Marshal(a)
|
||||
t.AssertNil(err)
|
||||
|
||||
@ -726,30 +726,30 @@ func TestList_UnmarshalValue(t *testing.T) {
|
||||
// JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var tlist *TList
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"list": []byte(`[1,2,3]`),
|
||||
}, &tlist)
|
||||
t.AssertNil(err)
|
||||
t.Assert(tlist.Name, "john")
|
||||
t.Assert(tlist.List.FrontAll(), []interface{}{1, 2, 3})
|
||||
t.Assert(tlist.List.FrontAll(), []any{1, 2, 3})
|
||||
})
|
||||
// Map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var tlist *TList
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"list": []interface{}{1, 2, 3},
|
||||
"list": []any{1, 2, 3},
|
||||
}, &tlist)
|
||||
t.AssertNil(err)
|
||||
t.Assert(tlist.Name, "john")
|
||||
t.Assert(tlist.List.FrontAll(), []interface{}{1, 2, 3})
|
||||
t.Assert(tlist.List.FrontAll(), []any{1, 2, 3})
|
||||
})
|
||||
}
|
||||
|
||||
func TestList_DeepCopy(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
l := NewFrom([]interface{}{1, 2, "a", `"b"`, `\c`})
|
||||
l := NewFrom([]any{1, 2, "a", `"b"`, `\c`})
|
||||
copyList := l.DeepCopy()
|
||||
cl := copyList.(*List)
|
||||
cl.PopBack()
|
||||
|
||||
@ -24,7 +24,7 @@ func New(safe ...bool) *Map {
|
||||
// there might be some concurrent-safe issues when changing the map outside.
|
||||
// The parameter `safe` is used to specify whether using tree in concurrent-safety,
|
||||
// which is false in default.
|
||||
func NewFrom(data map[interface{}]interface{}, safe ...bool) *Map {
|
||||
func NewFrom(data map[any]any, safe ...bool) *Map {
|
||||
return NewAnyAnyMapFrom(data, safe...)
|
||||
}
|
||||
|
||||
@ -40,6 +40,6 @@ func NewHashMap(safe ...bool) *Map {
|
||||
// there might be some concurrent-safe issues when changing the map outside.
|
||||
// The parameter `safe` is used to specify whether using tree in concurrent-safety,
|
||||
// which is false in default.
|
||||
func NewHashMapFrom(data map[interface{}]interface{}, safe ...bool) *Map {
|
||||
func NewHashMapFrom(data map[any]any, safe ...bool) *Map {
|
||||
return NewAnyAnyMapFrom(data, safe...)
|
||||
}
|
||||
|
||||
@ -17,10 +17,10 @@ import (
|
||||
"github.com/gogf/gf/v2/util/gconv"
|
||||
)
|
||||
|
||||
// AnyAnyMap wraps map type `map[interface{}]interface{}` and provides more map features.
|
||||
// AnyAnyMap wraps map type `map[any]any` and provides more map features.
|
||||
type AnyAnyMap struct {
|
||||
mu rwmutex.RWMutex
|
||||
data map[interface{}]interface{}
|
||||
data map[any]any
|
||||
}
|
||||
|
||||
// NewAnyAnyMap creates and returns an empty hash map.
|
||||
@ -29,14 +29,14 @@ type AnyAnyMap struct {
|
||||
func NewAnyAnyMap(safe ...bool) *AnyAnyMap {
|
||||
return &AnyAnyMap{
|
||||
mu: rwmutex.Create(safe...),
|
||||
data: make(map[interface{}]interface{}),
|
||||
data: make(map[any]any),
|
||||
}
|
||||
}
|
||||
|
||||
// NewAnyAnyMapFrom creates and returns a hash map from given map `data`.
|
||||
// Note that, the param `data` map will be set as the underlying data map(no deep copy),
|
||||
// there might be some concurrent-safe issues when changing the map outside.
|
||||
func NewAnyAnyMapFrom(data map[interface{}]interface{}, safe ...bool) *AnyAnyMap {
|
||||
func NewAnyAnyMapFrom(data map[any]any, safe ...bool) *AnyAnyMap {
|
||||
return &AnyAnyMap{
|
||||
mu: rwmutex.Create(safe...),
|
||||
data: data,
|
||||
@ -45,7 +45,7 @@ func NewAnyAnyMapFrom(data map[interface{}]interface{}, safe ...bool) *AnyAnyMap
|
||||
|
||||
// Iterator iterates the hash map readonly with custom callback function `f`.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
func (m *AnyAnyMap) Iterator(f func(k interface{}, v interface{}) bool) {
|
||||
func (m *AnyAnyMap) Iterator(f func(k any, v any) bool) {
|
||||
for k, v := range m.Map() {
|
||||
if !f(k, v) {
|
||||
break
|
||||
@ -61,13 +61,13 @@ func (m *AnyAnyMap) Clone(safe ...bool) *AnyAnyMap {
|
||||
// Map returns the underlying data map.
|
||||
// Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
|
||||
// or else a pointer to the underlying data.
|
||||
func (m *AnyAnyMap) Map() map[interface{}]interface{} {
|
||||
func (m *AnyAnyMap) Map() map[any]any {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
if !m.mu.IsSafe() {
|
||||
return m.data
|
||||
}
|
||||
data := make(map[interface{}]interface{}, len(m.data))
|
||||
data := make(map[any]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[k] = v
|
||||
}
|
||||
@ -75,21 +75,21 @@ func (m *AnyAnyMap) Map() map[interface{}]interface{} {
|
||||
}
|
||||
|
||||
// MapCopy returns a shallow copy of the underlying data of the hash map.
|
||||
func (m *AnyAnyMap) MapCopy() map[interface{}]interface{} {
|
||||
func (m *AnyAnyMap) MapCopy() map[any]any {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
data := make(map[interface{}]interface{}, len(m.data))
|
||||
data := make(map[any]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[k] = v
|
||||
}
|
||||
return data
|
||||
}
|
||||
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
|
||||
func (m *AnyAnyMap) MapStrAny() map[string]interface{} {
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]any.
|
||||
func (m *AnyAnyMap) MapStrAny() map[string]any {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
data := make(map[string]interface{}, len(m.data))
|
||||
data := make(map[string]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[gconv.String(k)] = v
|
||||
}
|
||||
@ -120,17 +120,17 @@ func (m *AnyAnyMap) FilterNil() {
|
||||
}
|
||||
|
||||
// Set sets key-value to the hash map.
|
||||
func (m *AnyAnyMap) Set(key interface{}, value interface{}) {
|
||||
func (m *AnyAnyMap) Set(key any, value any) {
|
||||
m.mu.Lock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[interface{}]interface{})
|
||||
m.data = make(map[any]any)
|
||||
}
|
||||
m.data[key] = value
|
||||
m.mu.Unlock()
|
||||
}
|
||||
|
||||
// Sets batch sets key-values to the hash map.
|
||||
func (m *AnyAnyMap) Sets(data map[interface{}]interface{}) {
|
||||
func (m *AnyAnyMap) Sets(data map[any]any) {
|
||||
m.mu.Lock()
|
||||
if m.data == nil {
|
||||
m.data = data
|
||||
@ -144,7 +144,7 @@ func (m *AnyAnyMap) Sets(data map[interface{}]interface{}) {
|
||||
|
||||
// Search searches the map with given `key`.
|
||||
// Second return parameter `found` is true if key was found, otherwise false.
|
||||
func (m *AnyAnyMap) Search(key interface{}) (value interface{}, found bool) {
|
||||
func (m *AnyAnyMap) Search(key any) (value any, found bool) {
|
||||
m.mu.RLock()
|
||||
if m.data != nil {
|
||||
value, found = m.data[key]
|
||||
@ -154,7 +154,7 @@ func (m *AnyAnyMap) Search(key interface{}) (value interface{}, found bool) {
|
||||
}
|
||||
|
||||
// Get returns the value by given `key`.
|
||||
func (m *AnyAnyMap) Get(key interface{}) (value interface{}) {
|
||||
func (m *AnyAnyMap) Get(key any) (value any) {
|
||||
m.mu.RLock()
|
||||
if m.data != nil {
|
||||
value = m.data[key]
|
||||
@ -164,7 +164,7 @@ func (m *AnyAnyMap) Get(key interface{}) (value interface{}) {
|
||||
}
|
||||
|
||||
// Pop retrieves and deletes an item from the map.
|
||||
func (m *AnyAnyMap) Pop() (key, value interface{}) {
|
||||
func (m *AnyAnyMap) Pop() (key, value any) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
for key, value = range m.data {
|
||||
@ -176,7 +176,7 @@ func (m *AnyAnyMap) Pop() (key, value interface{}) {
|
||||
|
||||
// Pops retrieves and deletes `size` items from the map.
|
||||
// It returns all items if size == -1.
|
||||
func (m *AnyAnyMap) Pops(size int) map[interface{}]interface{} {
|
||||
func (m *AnyAnyMap) Pops(size int) map[any]any {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if size > len(m.data) || size == -1 {
|
||||
@ -187,7 +187,7 @@ func (m *AnyAnyMap) Pops(size int) map[interface{}]interface{} {
|
||||
}
|
||||
var (
|
||||
index = 0
|
||||
newMap = make(map[interface{}]interface{}, size)
|
||||
newMap = make(map[any]any, size)
|
||||
)
|
||||
for k, v := range m.data {
|
||||
delete(m.data, k)
|
||||
@ -209,16 +209,16 @@ func (m *AnyAnyMap) Pops(size int) map[interface{}]interface{} {
|
||||
// and its return value will be set to the map with `key`.
|
||||
//
|
||||
// It returns value with given `key`.
|
||||
func (m *AnyAnyMap) doSetWithLockCheck(key interface{}, value interface{}) interface{} {
|
||||
func (m *AnyAnyMap) doSetWithLockCheck(key any, value any) any {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[interface{}]interface{})
|
||||
m.data = make(map[any]any)
|
||||
}
|
||||
if v, ok := m.data[key]; ok {
|
||||
return v
|
||||
}
|
||||
if f, ok := value.(func() interface{}); ok {
|
||||
if f, ok := value.(func() any); ok {
|
||||
value = f()
|
||||
}
|
||||
if value != nil {
|
||||
@ -229,7 +229,7 @@ func (m *AnyAnyMap) doSetWithLockCheck(key interface{}, value interface{}) inter
|
||||
|
||||
// GetOrSet returns the value by key,
|
||||
// or sets value with given `value` if it does not exist and then returns this value.
|
||||
func (m *AnyAnyMap) GetOrSet(key interface{}, value interface{}) interface{} {
|
||||
func (m *AnyAnyMap) GetOrSet(key any, value any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, value)
|
||||
} else {
|
||||
@ -240,7 +240,7 @@ func (m *AnyAnyMap) GetOrSet(key interface{}, value interface{}) interface{} {
|
||||
// GetOrSetFunc returns the value by key,
|
||||
// or sets value with returned value of callback function `f` if it does not exist
|
||||
// and then returns this value.
|
||||
func (m *AnyAnyMap) GetOrSetFunc(key interface{}, f func() interface{}) interface{} {
|
||||
func (m *AnyAnyMap) GetOrSetFunc(key any, f func() any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, f())
|
||||
} else {
|
||||
@ -254,7 +254,7 @@ func (m *AnyAnyMap) GetOrSetFunc(key interface{}, f func() interface{}) interfac
|
||||
//
|
||||
// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
|
||||
// with mutex.Lock of the hash map.
|
||||
func (m *AnyAnyMap) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{} {
|
||||
func (m *AnyAnyMap) GetOrSetFuncLock(key any, f func() any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, f)
|
||||
} else {
|
||||
@ -264,31 +264,31 @@ func (m *AnyAnyMap) GetOrSetFuncLock(key interface{}, f func() interface{}) inte
|
||||
|
||||
// GetVar returns a Var with the value by given `key`.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *AnyAnyMap) GetVar(key interface{}) *gvar.Var {
|
||||
func (m *AnyAnyMap) GetVar(key any) *gvar.Var {
|
||||
return gvar.New(m.Get(key))
|
||||
}
|
||||
|
||||
// GetVarOrSet returns a Var with result from GetOrSet.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *AnyAnyMap) GetVarOrSet(key interface{}, value interface{}) *gvar.Var {
|
||||
func (m *AnyAnyMap) GetVarOrSet(key any, value any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSet(key, value))
|
||||
}
|
||||
|
||||
// GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *AnyAnyMap) GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var {
|
||||
func (m *AnyAnyMap) GetVarOrSetFunc(key any, f func() any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSetFunc(key, f))
|
||||
}
|
||||
|
||||
// GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *AnyAnyMap) GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var {
|
||||
func (m *AnyAnyMap) GetVarOrSetFuncLock(key any, f func() any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSetFuncLock(key, f))
|
||||
}
|
||||
|
||||
// SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
|
||||
// It returns false if `key` exists, and `value` would be ignored.
|
||||
func (m *AnyAnyMap) SetIfNotExist(key interface{}, value interface{}) bool {
|
||||
func (m *AnyAnyMap) SetIfNotExist(key any, value any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, value)
|
||||
return true
|
||||
@ -298,7 +298,7 @@ func (m *AnyAnyMap) SetIfNotExist(key interface{}, value interface{}) bool {
|
||||
|
||||
// SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
|
||||
// It returns false if `key` exists, and `value` would be ignored.
|
||||
func (m *AnyAnyMap) SetIfNotExistFunc(key interface{}, f func() interface{}) bool {
|
||||
func (m *AnyAnyMap) SetIfNotExistFunc(key any, f func() any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, f())
|
||||
return true
|
||||
@ -311,7 +311,7 @@ func (m *AnyAnyMap) SetIfNotExistFunc(key interface{}, f func() interface{}) boo
|
||||
//
|
||||
// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
|
||||
// it executes function `f` with mutex.Lock of the hash map.
|
||||
func (m *AnyAnyMap) SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool {
|
||||
func (m *AnyAnyMap) SetIfNotExistFuncLock(key any, f func() any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, f)
|
||||
return true
|
||||
@ -320,7 +320,7 @@ func (m *AnyAnyMap) SetIfNotExistFuncLock(key interface{}, f func() interface{})
|
||||
}
|
||||
|
||||
// Remove deletes value from map by given `key`, and return this deleted value.
|
||||
func (m *AnyAnyMap) Remove(key interface{}) (value interface{}) {
|
||||
func (m *AnyAnyMap) Remove(key any) (value any) {
|
||||
m.mu.Lock()
|
||||
if m.data != nil {
|
||||
var ok bool
|
||||
@ -333,7 +333,7 @@ func (m *AnyAnyMap) Remove(key interface{}) (value interface{}) {
|
||||
}
|
||||
|
||||
// Removes batch deletes values of the map by keys.
|
||||
func (m *AnyAnyMap) Removes(keys []interface{}) {
|
||||
func (m *AnyAnyMap) Removes(keys []any) {
|
||||
m.mu.Lock()
|
||||
if m.data != nil {
|
||||
for _, key := range keys {
|
||||
@ -344,11 +344,11 @@ func (m *AnyAnyMap) Removes(keys []interface{}) {
|
||||
}
|
||||
|
||||
// Keys returns all keys of the map as a slice.
|
||||
func (m *AnyAnyMap) Keys() []interface{} {
|
||||
func (m *AnyAnyMap) Keys() []any {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
var (
|
||||
keys = make([]interface{}, len(m.data))
|
||||
keys = make([]any, len(m.data))
|
||||
index = 0
|
||||
)
|
||||
for key := range m.data {
|
||||
@ -359,11 +359,11 @@ func (m *AnyAnyMap) Keys() []interface{} {
|
||||
}
|
||||
|
||||
// Values returns all values of the map as a slice.
|
||||
func (m *AnyAnyMap) Values() []interface{} {
|
||||
func (m *AnyAnyMap) Values() []any {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
var (
|
||||
values = make([]interface{}, len(m.data))
|
||||
values = make([]any, len(m.data))
|
||||
index = 0
|
||||
)
|
||||
for _, value := range m.data {
|
||||
@ -375,7 +375,7 @@ func (m *AnyAnyMap) Values() []interface{} {
|
||||
|
||||
// Contains checks whether a key exists.
|
||||
// It returns true if the `key` exists, or else false.
|
||||
func (m *AnyAnyMap) Contains(key interface{}) bool {
|
||||
func (m *AnyAnyMap) Contains(key any) bool {
|
||||
var ok bool
|
||||
m.mu.RLock()
|
||||
if m.data != nil {
|
||||
@ -402,26 +402,26 @@ func (m *AnyAnyMap) IsEmpty() bool {
|
||||
// Clear deletes all data of the map, it will remake a new underlying data map.
|
||||
func (m *AnyAnyMap) Clear() {
|
||||
m.mu.Lock()
|
||||
m.data = make(map[interface{}]interface{})
|
||||
m.data = make(map[any]any)
|
||||
m.mu.Unlock()
|
||||
}
|
||||
|
||||
// Replace the data of the map with given `data`.
|
||||
func (m *AnyAnyMap) Replace(data map[interface{}]interface{}) {
|
||||
func (m *AnyAnyMap) Replace(data map[any]any) {
|
||||
m.mu.Lock()
|
||||
m.data = data
|
||||
m.mu.Unlock()
|
||||
}
|
||||
|
||||
// LockFunc locks writing with given callback function `f` within RWMutex.Lock.
|
||||
func (m *AnyAnyMap) LockFunc(f func(m map[interface{}]interface{})) {
|
||||
func (m *AnyAnyMap) LockFunc(f func(m map[any]any)) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
f(m.data)
|
||||
}
|
||||
|
||||
// RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
|
||||
func (m *AnyAnyMap) RLockFunc(f func(m map[interface{}]interface{})) {
|
||||
func (m *AnyAnyMap) RLockFunc(f func(m map[any]any)) {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
f(m.data)
|
||||
@ -431,7 +431,7 @@ func (m *AnyAnyMap) RLockFunc(f func(m map[interface{}]interface{})) {
|
||||
func (m *AnyAnyMap) Flip() {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
n := make(map[interface{}]interface{}, len(m.data))
|
||||
n := make(map[any]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
n[v] = k
|
||||
}
|
||||
@ -475,9 +475,9 @@ func (m *AnyAnyMap) UnmarshalJSON(b []byte) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[interface{}]interface{})
|
||||
m.data = make(map[any]any)
|
||||
}
|
||||
var data map[string]interface{}
|
||||
var data map[string]any
|
||||
if err := json.UnmarshalUseNumber(b, &data); err != nil {
|
||||
return err
|
||||
}
|
||||
@ -488,11 +488,11 @@ func (m *AnyAnyMap) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for map.
|
||||
func (m *AnyAnyMap) UnmarshalValue(value interface{}) (err error) {
|
||||
func (m *AnyAnyMap) UnmarshalValue(value any) (err error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[interface{}]interface{})
|
||||
m.data = make(map[any]any)
|
||||
}
|
||||
for k, v := range gconv.Map(value) {
|
||||
m.data[k] = v
|
||||
@ -501,14 +501,14 @@ func (m *AnyAnyMap) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (m *AnyAnyMap) DeepCopy() interface{} {
|
||||
func (m *AnyAnyMap) DeepCopy() any {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
data := make(map[interface{}]interface{}, len(m.data))
|
||||
data := make(map[any]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[k] = deepcopy.Copy(v)
|
||||
}
|
||||
@ -540,7 +540,7 @@ func (m *AnyAnyMap) IsSubOf(other *AnyAnyMap) bool {
|
||||
// The returned `addedKeys` are the keys that are in map `m` but not in map `other`.
|
||||
// The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
|
||||
// The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
|
||||
func (m *AnyAnyMap) Diff(other *AnyAnyMap) (addedKeys, removedKeys, updatedKeys []interface{}) {
|
||||
func (m *AnyAnyMap) Diff(other *AnyAnyMap) (addedKeys, removedKeys, updatedKeys []any) {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
other.mu.RLock()
|
||||
|
||||
@ -18,10 +18,10 @@ import (
|
||||
"github.com/gogf/gf/v2/util/gconv"
|
||||
)
|
||||
|
||||
// IntAnyMap implements map[int]interface{} with RWMutex that has switch.
|
||||
// IntAnyMap implements map[int]any with RWMutex that has switch.
|
||||
type IntAnyMap struct {
|
||||
mu rwmutex.RWMutex
|
||||
data map[int]interface{}
|
||||
data map[int]any
|
||||
}
|
||||
|
||||
// NewIntAnyMap returns an empty IntAnyMap object.
|
||||
@ -30,14 +30,14 @@ type IntAnyMap struct {
|
||||
func NewIntAnyMap(safe ...bool) *IntAnyMap {
|
||||
return &IntAnyMap{
|
||||
mu: rwmutex.Create(safe...),
|
||||
data: make(map[int]interface{}),
|
||||
data: make(map[int]any),
|
||||
}
|
||||
}
|
||||
|
||||
// NewIntAnyMapFrom creates and returns a hash map from given map `data`.
|
||||
// Note that, the param `data` map will be set as the underlying data map(no deep copy),
|
||||
// there might be some concurrent-safe issues when changing the map outside.
|
||||
func NewIntAnyMapFrom(data map[int]interface{}, safe ...bool) *IntAnyMap {
|
||||
func NewIntAnyMapFrom(data map[int]any, safe ...bool) *IntAnyMap {
|
||||
return &IntAnyMap{
|
||||
mu: rwmutex.Create(safe...),
|
||||
data: data,
|
||||
@ -46,7 +46,7 @@ func NewIntAnyMapFrom(data map[int]interface{}, safe ...bool) *IntAnyMap {
|
||||
|
||||
// Iterator iterates the hash map readonly with custom callback function `f`.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
func (m *IntAnyMap) Iterator(f func(k int, v interface{}) bool) {
|
||||
func (m *IntAnyMap) Iterator(f func(k int, v any) bool) {
|
||||
for k, v := range m.Map() {
|
||||
if !f(k, v) {
|
||||
break
|
||||
@ -62,23 +62,23 @@ func (m *IntAnyMap) Clone() *IntAnyMap {
|
||||
// Map returns the underlying data map.
|
||||
// Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
|
||||
// or else a pointer to the underlying data.
|
||||
func (m *IntAnyMap) Map() map[int]interface{} {
|
||||
func (m *IntAnyMap) Map() map[int]any {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
if !m.mu.IsSafe() {
|
||||
return m.data
|
||||
}
|
||||
data := make(map[int]interface{}, len(m.data))
|
||||
data := make(map[int]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[k] = v
|
||||
}
|
||||
return data
|
||||
}
|
||||
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
|
||||
func (m *IntAnyMap) MapStrAny() map[string]interface{} {
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]any.
|
||||
func (m *IntAnyMap) MapStrAny() map[string]any {
|
||||
m.mu.RLock()
|
||||
data := make(map[string]interface{}, len(m.data))
|
||||
data := make(map[string]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[gconv.String(k)] = v
|
||||
}
|
||||
@ -87,10 +87,10 @@ func (m *IntAnyMap) MapStrAny() map[string]interface{} {
|
||||
}
|
||||
|
||||
// MapCopy returns a copy of the underlying data of the hash map.
|
||||
func (m *IntAnyMap) MapCopy() map[int]interface{} {
|
||||
func (m *IntAnyMap) MapCopy() map[int]any {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
data := make(map[int]interface{}, len(m.data))
|
||||
data := make(map[int]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[k] = v
|
||||
}
|
||||
@ -121,17 +121,17 @@ func (m *IntAnyMap) FilterNil() {
|
||||
}
|
||||
|
||||
// Set sets key-value to the hash map.
|
||||
func (m *IntAnyMap) Set(key int, val interface{}) {
|
||||
func (m *IntAnyMap) Set(key int, val any) {
|
||||
m.mu.Lock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[int]interface{})
|
||||
m.data = make(map[int]any)
|
||||
}
|
||||
m.data[key] = val
|
||||
m.mu.Unlock()
|
||||
}
|
||||
|
||||
// Sets batch sets key-values to the hash map.
|
||||
func (m *IntAnyMap) Sets(data map[int]interface{}) {
|
||||
func (m *IntAnyMap) Sets(data map[int]any) {
|
||||
m.mu.Lock()
|
||||
if m.data == nil {
|
||||
m.data = data
|
||||
@ -145,7 +145,7 @@ func (m *IntAnyMap) Sets(data map[int]interface{}) {
|
||||
|
||||
// Search searches the map with given `key`.
|
||||
// Second return parameter `found` is true if key was found, otherwise false.
|
||||
func (m *IntAnyMap) Search(key int) (value interface{}, found bool) {
|
||||
func (m *IntAnyMap) Search(key int) (value any, found bool) {
|
||||
m.mu.RLock()
|
||||
if m.data != nil {
|
||||
value, found = m.data[key]
|
||||
@ -155,7 +155,7 @@ func (m *IntAnyMap) Search(key int) (value interface{}, found bool) {
|
||||
}
|
||||
|
||||
// Get returns the value by given `key`.
|
||||
func (m *IntAnyMap) Get(key int) (value interface{}) {
|
||||
func (m *IntAnyMap) Get(key int) (value any) {
|
||||
m.mu.RLock()
|
||||
if m.data != nil {
|
||||
value = m.data[key]
|
||||
@ -165,7 +165,7 @@ func (m *IntAnyMap) Get(key int) (value interface{}) {
|
||||
}
|
||||
|
||||
// Pop retrieves and deletes an item from the map.
|
||||
func (m *IntAnyMap) Pop() (key int, value interface{}) {
|
||||
func (m *IntAnyMap) Pop() (key int, value any) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
for key, value = range m.data {
|
||||
@ -177,7 +177,7 @@ func (m *IntAnyMap) Pop() (key int, value interface{}) {
|
||||
|
||||
// Pops retrieves and deletes `size` items from the map.
|
||||
// It returns all items if size == -1.
|
||||
func (m *IntAnyMap) Pops(size int) map[int]interface{} {
|
||||
func (m *IntAnyMap) Pops(size int) map[int]any {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if size > len(m.data) || size == -1 {
|
||||
@ -188,7 +188,7 @@ func (m *IntAnyMap) Pops(size int) map[int]interface{} {
|
||||
}
|
||||
var (
|
||||
index = 0
|
||||
newMap = make(map[int]interface{}, size)
|
||||
newMap = make(map[int]any, size)
|
||||
)
|
||||
for k, v := range m.data {
|
||||
delete(m.data, k)
|
||||
@ -210,16 +210,16 @@ func (m *IntAnyMap) Pops(size int) map[int]interface{} {
|
||||
// and its return value will be set to the map with `key`.
|
||||
//
|
||||
// It returns value with given `key`.
|
||||
func (m *IntAnyMap) doSetWithLockCheck(key int, value interface{}) interface{} {
|
||||
func (m *IntAnyMap) doSetWithLockCheck(key int, value any) any {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[int]interface{})
|
||||
m.data = make(map[int]any)
|
||||
}
|
||||
if v, ok := m.data[key]; ok {
|
||||
return v
|
||||
}
|
||||
if f, ok := value.(func() interface{}); ok {
|
||||
if f, ok := value.(func() any); ok {
|
||||
value = f()
|
||||
}
|
||||
if value != nil {
|
||||
@ -230,7 +230,7 @@ func (m *IntAnyMap) doSetWithLockCheck(key int, value interface{}) interface{} {
|
||||
|
||||
// GetOrSet returns the value by key,
|
||||
// or sets value with given `value` if it does not exist and then returns this value.
|
||||
func (m *IntAnyMap) GetOrSet(key int, value interface{}) interface{} {
|
||||
func (m *IntAnyMap) GetOrSet(key int, value any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, value)
|
||||
} else {
|
||||
@ -240,7 +240,7 @@ func (m *IntAnyMap) GetOrSet(key int, value interface{}) interface{} {
|
||||
|
||||
// GetOrSetFunc returns the value by key,
|
||||
// or sets value with returned value of callback function `f` if it does not exist and returns this value.
|
||||
func (m *IntAnyMap) GetOrSetFunc(key int, f func() interface{}) interface{} {
|
||||
func (m *IntAnyMap) GetOrSetFunc(key int, f func() any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, f())
|
||||
} else {
|
||||
@ -253,7 +253,7 @@ func (m *IntAnyMap) GetOrSetFunc(key int, f func() interface{}) interface{} {
|
||||
//
|
||||
// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
|
||||
// with mutex.Lock of the hash map.
|
||||
func (m *IntAnyMap) GetOrSetFuncLock(key int, f func() interface{}) interface{} {
|
||||
func (m *IntAnyMap) GetOrSetFuncLock(key int, f func() any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, f)
|
||||
} else {
|
||||
@ -269,25 +269,25 @@ func (m *IntAnyMap) GetVar(key int) *gvar.Var {
|
||||
|
||||
// GetVarOrSet returns a Var with result from GetVarOrSet.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *IntAnyMap) GetVarOrSet(key int, value interface{}) *gvar.Var {
|
||||
func (m *IntAnyMap) GetVarOrSet(key int, value any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSet(key, value))
|
||||
}
|
||||
|
||||
// GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *IntAnyMap) GetVarOrSetFunc(key int, f func() interface{}) *gvar.Var {
|
||||
func (m *IntAnyMap) GetVarOrSetFunc(key int, f func() any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSetFunc(key, f))
|
||||
}
|
||||
|
||||
// GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *IntAnyMap) GetVarOrSetFuncLock(key int, f func() interface{}) *gvar.Var {
|
||||
func (m *IntAnyMap) GetVarOrSetFuncLock(key int, f func() any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSetFuncLock(key, f))
|
||||
}
|
||||
|
||||
// SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
|
||||
// It returns false if `key` exists, and `value` would be ignored.
|
||||
func (m *IntAnyMap) SetIfNotExist(key int, value interface{}) bool {
|
||||
func (m *IntAnyMap) SetIfNotExist(key int, value any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, value)
|
||||
return true
|
||||
@ -297,7 +297,7 @@ func (m *IntAnyMap) SetIfNotExist(key int, value interface{}) bool {
|
||||
|
||||
// SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
|
||||
// It returns false if `key` exists, and `value` would be ignored.
|
||||
func (m *IntAnyMap) SetIfNotExistFunc(key int, f func() interface{}) bool {
|
||||
func (m *IntAnyMap) SetIfNotExistFunc(key int, f func() any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, f())
|
||||
return true
|
||||
@ -310,7 +310,7 @@ func (m *IntAnyMap) SetIfNotExistFunc(key int, f func() interface{}) bool {
|
||||
//
|
||||
// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
|
||||
// it executes function `f` with mutex.Lock of the hash map.
|
||||
func (m *IntAnyMap) SetIfNotExistFuncLock(key int, f func() interface{}) bool {
|
||||
func (m *IntAnyMap) SetIfNotExistFuncLock(key int, f func() any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, f)
|
||||
return true
|
||||
@ -330,7 +330,7 @@ func (m *IntAnyMap) Removes(keys []int) {
|
||||
}
|
||||
|
||||
// Remove deletes value from map by given `key`, and return this deleted value.
|
||||
func (m *IntAnyMap) Remove(key int) (value interface{}) {
|
||||
func (m *IntAnyMap) Remove(key int) (value any) {
|
||||
m.mu.Lock()
|
||||
if m.data != nil {
|
||||
var ok bool
|
||||
@ -358,10 +358,10 @@ func (m *IntAnyMap) Keys() []int {
|
||||
}
|
||||
|
||||
// Values returns all values of the map as a slice.
|
||||
func (m *IntAnyMap) Values() []interface{} {
|
||||
func (m *IntAnyMap) Values() []any {
|
||||
m.mu.RLock()
|
||||
var (
|
||||
values = make([]interface{}, len(m.data))
|
||||
values = make([]any, len(m.data))
|
||||
index = 0
|
||||
)
|
||||
for _, value := range m.data {
|
||||
@ -401,26 +401,26 @@ func (m *IntAnyMap) IsEmpty() bool {
|
||||
// Clear deletes all data of the map, it will remake a new underlying data map.
|
||||
func (m *IntAnyMap) Clear() {
|
||||
m.mu.Lock()
|
||||
m.data = make(map[int]interface{})
|
||||
m.data = make(map[int]any)
|
||||
m.mu.Unlock()
|
||||
}
|
||||
|
||||
// Replace the data of the map with given `data`.
|
||||
func (m *IntAnyMap) Replace(data map[int]interface{}) {
|
||||
func (m *IntAnyMap) Replace(data map[int]any) {
|
||||
m.mu.Lock()
|
||||
m.data = data
|
||||
m.mu.Unlock()
|
||||
}
|
||||
|
||||
// LockFunc locks writing with given callback function `f` within RWMutex.Lock.
|
||||
func (m *IntAnyMap) LockFunc(f func(m map[int]interface{})) {
|
||||
func (m *IntAnyMap) LockFunc(f func(m map[int]any)) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
f(m.data)
|
||||
}
|
||||
|
||||
// RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
|
||||
func (m *IntAnyMap) RLockFunc(f func(m map[int]interface{})) {
|
||||
func (m *IntAnyMap) RLockFunc(f func(m map[int]any)) {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
f(m.data)
|
||||
@ -430,7 +430,7 @@ func (m *IntAnyMap) RLockFunc(f func(m map[int]interface{})) {
|
||||
func (m *IntAnyMap) Flip() {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
n := make(map[int]interface{}, len(m.data))
|
||||
n := make(map[int]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
n[gconv.Int(v)] = k
|
||||
}
|
||||
@ -476,7 +476,7 @@ func (m *IntAnyMap) UnmarshalJSON(b []byte) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[int]interface{})
|
||||
m.data = make(map[int]any)
|
||||
}
|
||||
if err := json.UnmarshalUseNumber(b, &m.data); err != nil {
|
||||
return err
|
||||
@ -485,11 +485,11 @@ func (m *IntAnyMap) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for map.
|
||||
func (m *IntAnyMap) UnmarshalValue(value interface{}) (err error) {
|
||||
func (m *IntAnyMap) UnmarshalValue(value any) (err error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[int]interface{})
|
||||
m.data = make(map[int]any)
|
||||
}
|
||||
switch value.(type) {
|
||||
case string, []byte:
|
||||
@ -503,13 +503,13 @@ func (m *IntAnyMap) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (m *IntAnyMap) DeepCopy() interface{} {
|
||||
func (m *IntAnyMap) DeepCopy() any {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
data := make(map[int]interface{}, len(m.data))
|
||||
data := make(map[int]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[k] = deepcopy.Copy(v)
|
||||
}
|
||||
|
||||
@ -70,10 +70,10 @@ func (m *IntIntMap) Map() map[int]int {
|
||||
return data
|
||||
}
|
||||
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
|
||||
func (m *IntIntMap) MapStrAny() map[string]interface{} {
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]any.
|
||||
func (m *IntIntMap) MapStrAny() map[string]any {
|
||||
m.mu.RLock()
|
||||
data := make(map[string]interface{}, len(m.data))
|
||||
data := make(map[string]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[gconv.String(k)] = v
|
||||
}
|
||||
@ -453,7 +453,7 @@ func (m *IntIntMap) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for map.
|
||||
func (m *IntIntMap) UnmarshalValue(value interface{}) (err error) {
|
||||
func (m *IntIntMap) UnmarshalValue(value any) (err error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
@ -471,7 +471,7 @@ func (m *IntIntMap) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (m *IntIntMap) DeepCopy() interface{} {
|
||||
func (m *IntIntMap) DeepCopy() any {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -70,10 +70,10 @@ func (m *IntStrMap) Map() map[int]string {
|
||||
return data
|
||||
}
|
||||
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
|
||||
func (m *IntStrMap) MapStrAny() map[string]interface{} {
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]any.
|
||||
func (m *IntStrMap) MapStrAny() map[string]any {
|
||||
m.mu.RLock()
|
||||
data := make(map[string]interface{}, len(m.data))
|
||||
data := make(map[string]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[gconv.String(k)] = v
|
||||
}
|
||||
@ -453,7 +453,7 @@ func (m *IntStrMap) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for map.
|
||||
func (m *IntStrMap) UnmarshalValue(value interface{}) (err error) {
|
||||
func (m *IntStrMap) UnmarshalValue(value any) (err error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
@ -471,7 +471,7 @@ func (m *IntStrMap) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (m *IntStrMap) DeepCopy() interface{} {
|
||||
func (m *IntStrMap) DeepCopy() any {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -18,10 +18,10 @@ import (
|
||||
"github.com/gogf/gf/v2/util/gconv"
|
||||
)
|
||||
|
||||
// StrAnyMap implements map[string]interface{} with RWMutex that has switch.
|
||||
// StrAnyMap implements map[string]any with RWMutex that has switch.
|
||||
type StrAnyMap struct {
|
||||
mu rwmutex.RWMutex
|
||||
data map[string]interface{}
|
||||
data map[string]any
|
||||
}
|
||||
|
||||
// NewStrAnyMap returns an empty StrAnyMap object.
|
||||
@ -30,14 +30,14 @@ type StrAnyMap struct {
|
||||
func NewStrAnyMap(safe ...bool) *StrAnyMap {
|
||||
return &StrAnyMap{
|
||||
mu: rwmutex.Create(safe...),
|
||||
data: make(map[string]interface{}),
|
||||
data: make(map[string]any),
|
||||
}
|
||||
}
|
||||
|
||||
// NewStrAnyMapFrom creates and returns a hash map from given map `data`.
|
||||
// Note that, the param `data` map will be set as the underlying data map(no deep copy),
|
||||
// there might be some concurrent-safe issues when changing the map outside.
|
||||
func NewStrAnyMapFrom(data map[string]interface{}, safe ...bool) *StrAnyMap {
|
||||
func NewStrAnyMapFrom(data map[string]any, safe ...bool) *StrAnyMap {
|
||||
return &StrAnyMap{
|
||||
mu: rwmutex.Create(safe...),
|
||||
data: data,
|
||||
@ -46,7 +46,7 @@ func NewStrAnyMapFrom(data map[string]interface{}, safe ...bool) *StrAnyMap {
|
||||
|
||||
// Iterator iterates the hash map readonly with custom callback function `f`.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
func (m *StrAnyMap) Iterator(f func(k string, v interface{}) bool) {
|
||||
func (m *StrAnyMap) Iterator(f func(k string, v any) bool) {
|
||||
for k, v := range m.Map() {
|
||||
if !f(k, v) {
|
||||
break
|
||||
@ -62,29 +62,29 @@ func (m *StrAnyMap) Clone() *StrAnyMap {
|
||||
// Map returns the underlying data map.
|
||||
// Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
|
||||
// or else a pointer to the underlying data.
|
||||
func (m *StrAnyMap) Map() map[string]interface{} {
|
||||
func (m *StrAnyMap) Map() map[string]any {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
if !m.mu.IsSafe() {
|
||||
return m.data
|
||||
}
|
||||
data := make(map[string]interface{}, len(m.data))
|
||||
data := make(map[string]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[k] = v
|
||||
}
|
||||
return data
|
||||
}
|
||||
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
|
||||
func (m *StrAnyMap) MapStrAny() map[string]interface{} {
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]any.
|
||||
func (m *StrAnyMap) MapStrAny() map[string]any {
|
||||
return m.Map()
|
||||
}
|
||||
|
||||
// MapCopy returns a copy of the underlying data of the hash map.
|
||||
func (m *StrAnyMap) MapCopy() map[string]interface{} {
|
||||
func (m *StrAnyMap) MapCopy() map[string]any {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
data := make(map[string]interface{}, len(m.data))
|
||||
data := make(map[string]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[k] = v
|
||||
}
|
||||
@ -115,17 +115,17 @@ func (m *StrAnyMap) FilterNil() {
|
||||
}
|
||||
|
||||
// Set sets key-value to the hash map.
|
||||
func (m *StrAnyMap) Set(key string, val interface{}) {
|
||||
func (m *StrAnyMap) Set(key string, val any) {
|
||||
m.mu.Lock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[string]interface{})
|
||||
m.data = make(map[string]any)
|
||||
}
|
||||
m.data[key] = val
|
||||
m.mu.Unlock()
|
||||
}
|
||||
|
||||
// Sets batch sets key-values to the hash map.
|
||||
func (m *StrAnyMap) Sets(data map[string]interface{}) {
|
||||
func (m *StrAnyMap) Sets(data map[string]any) {
|
||||
m.mu.Lock()
|
||||
if m.data == nil {
|
||||
m.data = data
|
||||
@ -139,7 +139,7 @@ func (m *StrAnyMap) Sets(data map[string]interface{}) {
|
||||
|
||||
// Search searches the map with given `key`.
|
||||
// Second return parameter `found` is true if key was found, otherwise false.
|
||||
func (m *StrAnyMap) Search(key string) (value interface{}, found bool) {
|
||||
func (m *StrAnyMap) Search(key string) (value any, found bool) {
|
||||
m.mu.RLock()
|
||||
if m.data != nil {
|
||||
value, found = m.data[key]
|
||||
@ -149,7 +149,7 @@ func (m *StrAnyMap) Search(key string) (value interface{}, found bool) {
|
||||
}
|
||||
|
||||
// Get returns the value by given `key`.
|
||||
func (m *StrAnyMap) Get(key string) (value interface{}) {
|
||||
func (m *StrAnyMap) Get(key string) (value any) {
|
||||
m.mu.RLock()
|
||||
if m.data != nil {
|
||||
value = m.data[key]
|
||||
@ -159,7 +159,7 @@ func (m *StrAnyMap) Get(key string) (value interface{}) {
|
||||
}
|
||||
|
||||
// Pop retrieves and deletes an item from the map.
|
||||
func (m *StrAnyMap) Pop() (key string, value interface{}) {
|
||||
func (m *StrAnyMap) Pop() (key string, value any) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
for key, value = range m.data {
|
||||
@ -171,7 +171,7 @@ func (m *StrAnyMap) Pop() (key string, value interface{}) {
|
||||
|
||||
// Pops retrieves and deletes `size` items from the map.
|
||||
// It returns all items if size == -1.
|
||||
func (m *StrAnyMap) Pops(size int) map[string]interface{} {
|
||||
func (m *StrAnyMap) Pops(size int) map[string]any {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if size > len(m.data) || size == -1 {
|
||||
@ -182,7 +182,7 @@ func (m *StrAnyMap) Pops(size int) map[string]interface{} {
|
||||
}
|
||||
var (
|
||||
index = 0
|
||||
newMap = make(map[string]interface{}, size)
|
||||
newMap = make(map[string]any, size)
|
||||
)
|
||||
for k, v := range m.data {
|
||||
delete(m.data, k)
|
||||
@ -204,16 +204,16 @@ func (m *StrAnyMap) Pops(size int) map[string]interface{} {
|
||||
// and its return value will be set to the map with `key`.
|
||||
//
|
||||
// It returns value with given `key`.
|
||||
func (m *StrAnyMap) doSetWithLockCheck(key string, value interface{}) interface{} {
|
||||
func (m *StrAnyMap) doSetWithLockCheck(key string, value any) any {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[string]interface{})
|
||||
m.data = make(map[string]any)
|
||||
}
|
||||
if v, ok := m.data[key]; ok {
|
||||
return v
|
||||
}
|
||||
if f, ok := value.(func() interface{}); ok {
|
||||
if f, ok := value.(func() any); ok {
|
||||
value = f()
|
||||
}
|
||||
if value != nil {
|
||||
@ -224,7 +224,7 @@ func (m *StrAnyMap) doSetWithLockCheck(key string, value interface{}) interface{
|
||||
|
||||
// GetOrSet returns the value by key,
|
||||
// or sets value with given `value` if it does not exist and then returns this value.
|
||||
func (m *StrAnyMap) GetOrSet(key string, value interface{}) interface{} {
|
||||
func (m *StrAnyMap) GetOrSet(key string, value any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, value)
|
||||
} else {
|
||||
@ -235,7 +235,7 @@ func (m *StrAnyMap) GetOrSet(key string, value interface{}) interface{} {
|
||||
// GetOrSetFunc returns the value by key,
|
||||
// or sets value with returned value of callback function `f` if it does not exist
|
||||
// and then returns this value.
|
||||
func (m *StrAnyMap) GetOrSetFunc(key string, f func() interface{}) interface{} {
|
||||
func (m *StrAnyMap) GetOrSetFunc(key string, f func() any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, f())
|
||||
} else {
|
||||
@ -249,7 +249,7 @@ func (m *StrAnyMap) GetOrSetFunc(key string, f func() interface{}) interface{} {
|
||||
//
|
||||
// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
|
||||
// with mutex.Lock of the hash map.
|
||||
func (m *StrAnyMap) GetOrSetFuncLock(key string, f func() interface{}) interface{} {
|
||||
func (m *StrAnyMap) GetOrSetFuncLock(key string, f func() any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, f)
|
||||
} else {
|
||||
@ -265,25 +265,25 @@ func (m *StrAnyMap) GetVar(key string) *gvar.Var {
|
||||
|
||||
// GetVarOrSet returns a Var with result from GetVarOrSet.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *StrAnyMap) GetVarOrSet(key string, value interface{}) *gvar.Var {
|
||||
func (m *StrAnyMap) GetVarOrSet(key string, value any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSet(key, value))
|
||||
}
|
||||
|
||||
// GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *StrAnyMap) GetVarOrSetFunc(key string, f func() interface{}) *gvar.Var {
|
||||
func (m *StrAnyMap) GetVarOrSetFunc(key string, f func() any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSetFunc(key, f))
|
||||
}
|
||||
|
||||
// GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *StrAnyMap) GetVarOrSetFuncLock(key string, f func() interface{}) *gvar.Var {
|
||||
func (m *StrAnyMap) GetVarOrSetFuncLock(key string, f func() any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSetFuncLock(key, f))
|
||||
}
|
||||
|
||||
// SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
|
||||
// It returns false if `key` exists, and `value` would be ignored.
|
||||
func (m *StrAnyMap) SetIfNotExist(key string, value interface{}) bool {
|
||||
func (m *StrAnyMap) SetIfNotExist(key string, value any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, value)
|
||||
return true
|
||||
@ -293,7 +293,7 @@ func (m *StrAnyMap) SetIfNotExist(key string, value interface{}) bool {
|
||||
|
||||
// SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
|
||||
// It returns false if `key` exists, and `value` would be ignored.
|
||||
func (m *StrAnyMap) SetIfNotExistFunc(key string, f func() interface{}) bool {
|
||||
func (m *StrAnyMap) SetIfNotExistFunc(key string, f func() any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, f())
|
||||
return true
|
||||
@ -306,7 +306,7 @@ func (m *StrAnyMap) SetIfNotExistFunc(key string, f func() interface{}) bool {
|
||||
//
|
||||
// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
|
||||
// it executes function `f` with mutex.Lock of the hash map.
|
||||
func (m *StrAnyMap) SetIfNotExistFuncLock(key string, f func() interface{}) bool {
|
||||
func (m *StrAnyMap) SetIfNotExistFuncLock(key string, f func() any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, f)
|
||||
return true
|
||||
@ -326,7 +326,7 @@ func (m *StrAnyMap) Removes(keys []string) {
|
||||
}
|
||||
|
||||
// Remove deletes value from map by given `key`, and return this deleted value.
|
||||
func (m *StrAnyMap) Remove(key string) (value interface{}) {
|
||||
func (m *StrAnyMap) Remove(key string) (value any) {
|
||||
m.mu.Lock()
|
||||
if m.data != nil {
|
||||
var ok bool
|
||||
@ -354,10 +354,10 @@ func (m *StrAnyMap) Keys() []string {
|
||||
}
|
||||
|
||||
// Values returns all values of the map as a slice.
|
||||
func (m *StrAnyMap) Values() []interface{} {
|
||||
func (m *StrAnyMap) Values() []any {
|
||||
m.mu.RLock()
|
||||
var (
|
||||
values = make([]interface{}, len(m.data))
|
||||
values = make([]any, len(m.data))
|
||||
index = 0
|
||||
)
|
||||
for _, value := range m.data {
|
||||
@ -397,26 +397,26 @@ func (m *StrAnyMap) IsEmpty() bool {
|
||||
// Clear deletes all data of the map, it will remake a new underlying data map.
|
||||
func (m *StrAnyMap) Clear() {
|
||||
m.mu.Lock()
|
||||
m.data = make(map[string]interface{})
|
||||
m.data = make(map[string]any)
|
||||
m.mu.Unlock()
|
||||
}
|
||||
|
||||
// Replace the data of the map with given `data`.
|
||||
func (m *StrAnyMap) Replace(data map[string]interface{}) {
|
||||
func (m *StrAnyMap) Replace(data map[string]any) {
|
||||
m.mu.Lock()
|
||||
m.data = data
|
||||
m.mu.Unlock()
|
||||
}
|
||||
|
||||
// LockFunc locks writing with given callback function `f` within RWMutex.Lock.
|
||||
func (m *StrAnyMap) LockFunc(f func(m map[string]interface{})) {
|
||||
func (m *StrAnyMap) LockFunc(f func(m map[string]any)) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
f(m.data)
|
||||
}
|
||||
|
||||
// RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
|
||||
func (m *StrAnyMap) RLockFunc(f func(m map[string]interface{})) {
|
||||
func (m *StrAnyMap) RLockFunc(f func(m map[string]any)) {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
f(m.data)
|
||||
@ -426,7 +426,7 @@ func (m *StrAnyMap) RLockFunc(f func(m map[string]interface{})) {
|
||||
func (m *StrAnyMap) Flip() {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
n := make(map[string]interface{}, len(m.data))
|
||||
n := make(map[string]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
n[gconv.String(v)] = k
|
||||
}
|
||||
@ -472,7 +472,7 @@ func (m *StrAnyMap) UnmarshalJSON(b []byte) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[string]interface{})
|
||||
m.data = make(map[string]any)
|
||||
}
|
||||
if err := json.UnmarshalUseNumber(b, &m.data); err != nil {
|
||||
return err
|
||||
@ -481,7 +481,7 @@ func (m *StrAnyMap) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for map.
|
||||
func (m *StrAnyMap) UnmarshalValue(value interface{}) (err error) {
|
||||
func (m *StrAnyMap) UnmarshalValue(value any) (err error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
m.data = gconv.Map(value)
|
||||
@ -489,13 +489,13 @@ func (m *StrAnyMap) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (m *StrAnyMap) DeepCopy() interface{} {
|
||||
func (m *StrAnyMap) DeepCopy() any {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
data := make(map[string]interface{}, len(m.data))
|
||||
data := make(map[string]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[k] = deepcopy.Copy(v)
|
||||
}
|
||||
|
||||
@ -71,11 +71,11 @@ func (m *StrIntMap) Map() map[string]int {
|
||||
return data
|
||||
}
|
||||
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
|
||||
func (m *StrIntMap) MapStrAny() map[string]interface{} {
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]any.
|
||||
func (m *StrIntMap) MapStrAny() map[string]any {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
data := make(map[string]interface{}, len(m.data))
|
||||
data := make(map[string]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[k] = v
|
||||
}
|
||||
@ -457,7 +457,7 @@ func (m *StrIntMap) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for map.
|
||||
func (m *StrIntMap) UnmarshalValue(value interface{}) (err error) {
|
||||
func (m *StrIntMap) UnmarshalValue(value any) (err error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
@ -475,7 +475,7 @@ func (m *StrIntMap) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (m *StrIntMap) DeepCopy() interface{} {
|
||||
func (m *StrIntMap) DeepCopy() any {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -71,10 +71,10 @@ func (m *StrStrMap) Map() map[string]string {
|
||||
return data
|
||||
}
|
||||
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
|
||||
func (m *StrStrMap) MapStrAny() map[string]interface{} {
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]any.
|
||||
func (m *StrStrMap) MapStrAny() map[string]any {
|
||||
m.mu.RLock()
|
||||
data := make(map[string]interface{}, len(m.data))
|
||||
data := make(map[string]any, len(m.data))
|
||||
for k, v := range m.data {
|
||||
data[k] = v
|
||||
}
|
||||
@ -456,7 +456,7 @@ func (m *StrStrMap) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for map.
|
||||
func (m *StrStrMap) UnmarshalValue(value interface{}) (err error) {
|
||||
func (m *StrStrMap) UnmarshalValue(value any) (err error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
m.data = gconv.MapStrStr(value)
|
||||
@ -464,7 +464,7 @@ func (m *StrStrMap) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (m *StrStrMap) DeepCopy() interface{} {
|
||||
func (m *StrStrMap) DeepCopy() any {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -28,13 +28,13 @@ import (
|
||||
// Reference: http://en.wikipedia.org/wiki/Associative_array
|
||||
type ListMap struct {
|
||||
mu rwmutex.RWMutex
|
||||
data map[interface{}]*glist.Element
|
||||
data map[any]*glist.Element
|
||||
list *glist.List
|
||||
}
|
||||
|
||||
type gListMapNode struct {
|
||||
key interface{}
|
||||
value interface{}
|
||||
key any
|
||||
value any
|
||||
}
|
||||
|
||||
// NewListMap returns an empty link map.
|
||||
@ -44,7 +44,7 @@ type gListMapNode struct {
|
||||
func NewListMap(safe ...bool) *ListMap {
|
||||
return &ListMap{
|
||||
mu: rwmutex.Create(safe...),
|
||||
data: make(map[interface{}]*glist.Element),
|
||||
data: make(map[any]*glist.Element),
|
||||
list: glist.New(),
|
||||
}
|
||||
}
|
||||
@ -52,20 +52,20 @@ func NewListMap(safe ...bool) *ListMap {
|
||||
// NewListMapFrom returns a link map from given map `data`.
|
||||
// Note that, the param `data` map will be set as the underlying data map(no deep copy),
|
||||
// there might be some concurrent-safe issues when changing the map outside.
|
||||
func NewListMapFrom(data map[interface{}]interface{}, safe ...bool) *ListMap {
|
||||
func NewListMapFrom(data map[any]any, safe ...bool) *ListMap {
|
||||
m := NewListMap(safe...)
|
||||
m.Sets(data)
|
||||
return m
|
||||
}
|
||||
|
||||
// Iterator is alias of IteratorAsc.
|
||||
func (m *ListMap) Iterator(f func(key, value interface{}) bool) {
|
||||
func (m *ListMap) Iterator(f func(key, value any) bool) {
|
||||
m.IteratorAsc(f)
|
||||
}
|
||||
|
||||
// IteratorAsc iterates the map readonly in ascending order with given callback function `f`.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
func (m *ListMap) IteratorAsc(f func(key interface{}, value interface{}) bool) {
|
||||
func (m *ListMap) IteratorAsc(f func(key any, value any) bool) {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
if m.list != nil {
|
||||
@ -79,7 +79,7 @@ func (m *ListMap) IteratorAsc(f func(key interface{}, value interface{}) bool) {
|
||||
|
||||
// IteratorDesc iterates the map readonly in descending order with given callback function `f`.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
func (m *ListMap) IteratorDesc(f func(key interface{}, value interface{}) bool) {
|
||||
func (m *ListMap) IteratorDesc(f func(key any, value any) bool) {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
if m.list != nil {
|
||||
@ -99,15 +99,15 @@ func (m *ListMap) Clone(safe ...bool) *ListMap {
|
||||
// Clear deletes all data of the map, it will remake a new underlying data map.
|
||||
func (m *ListMap) Clear() {
|
||||
m.mu.Lock()
|
||||
m.data = make(map[interface{}]*glist.Element)
|
||||
m.data = make(map[any]*glist.Element)
|
||||
m.list = glist.New()
|
||||
m.mu.Unlock()
|
||||
}
|
||||
|
||||
// Replace the data of the map with given `data`.
|
||||
func (m *ListMap) Replace(data map[interface{}]interface{}) {
|
||||
func (m *ListMap) Replace(data map[any]any) {
|
||||
m.mu.Lock()
|
||||
m.data = make(map[interface{}]*glist.Element)
|
||||
m.data = make(map[any]*glist.Element)
|
||||
m.list = glist.New()
|
||||
for key, value := range data {
|
||||
if e, ok := m.data[key]; !ok {
|
||||
@ -120,12 +120,12 @@ func (m *ListMap) Replace(data map[interface{}]interface{}) {
|
||||
}
|
||||
|
||||
// Map returns a copy of the underlying data of the map.
|
||||
func (m *ListMap) Map() map[interface{}]interface{} {
|
||||
func (m *ListMap) Map() map[any]any {
|
||||
m.mu.RLock()
|
||||
var node *gListMapNode
|
||||
var data map[interface{}]interface{}
|
||||
var data map[any]any
|
||||
if m.list != nil {
|
||||
data = make(map[interface{}]interface{}, len(m.data))
|
||||
data = make(map[any]any, len(m.data))
|
||||
m.list.IteratorAsc(func(e *glist.Element) bool {
|
||||
node = e.Value.(*gListMapNode)
|
||||
data[node.key] = node.value
|
||||
@ -136,13 +136,13 @@ func (m *ListMap) Map() map[interface{}]interface{} {
|
||||
return data
|
||||
}
|
||||
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
|
||||
func (m *ListMap) MapStrAny() map[string]interface{} {
|
||||
// MapStrAny returns a copy of the underlying data of the map as map[string]any.
|
||||
func (m *ListMap) MapStrAny() map[string]any {
|
||||
m.mu.RLock()
|
||||
var node *gListMapNode
|
||||
var data map[string]interface{}
|
||||
var data map[string]any
|
||||
if m.list != nil {
|
||||
data = make(map[string]interface{}, len(m.data))
|
||||
data = make(map[string]any, len(m.data))
|
||||
m.list.IteratorAsc(func(e *glist.Element) bool {
|
||||
node = e.Value.(*gListMapNode)
|
||||
data[gconv.String(node.key)] = node.value
|
||||
@ -158,7 +158,7 @@ func (m *ListMap) FilterEmpty() {
|
||||
m.mu.Lock()
|
||||
if m.list != nil {
|
||||
var (
|
||||
keys = make([]interface{}, 0)
|
||||
keys = make([]any, 0)
|
||||
node *gListMapNode
|
||||
)
|
||||
m.list.IteratorAsc(func(e *glist.Element) bool {
|
||||
@ -181,10 +181,10 @@ func (m *ListMap) FilterEmpty() {
|
||||
}
|
||||
|
||||
// Set sets key-value to the map.
|
||||
func (m *ListMap) Set(key interface{}, value interface{}) {
|
||||
func (m *ListMap) Set(key any, value any) {
|
||||
m.mu.Lock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[interface{}]*glist.Element)
|
||||
m.data = make(map[any]*glist.Element)
|
||||
m.list = glist.New()
|
||||
}
|
||||
if e, ok := m.data[key]; !ok {
|
||||
@ -196,10 +196,10 @@ func (m *ListMap) Set(key interface{}, value interface{}) {
|
||||
}
|
||||
|
||||
// Sets batch sets key-values to the map.
|
||||
func (m *ListMap) Sets(data map[interface{}]interface{}) {
|
||||
func (m *ListMap) Sets(data map[any]any) {
|
||||
m.mu.Lock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[interface{}]*glist.Element)
|
||||
m.data = make(map[any]*glist.Element)
|
||||
m.list = glist.New()
|
||||
}
|
||||
for key, value := range data {
|
||||
@ -214,7 +214,7 @@ func (m *ListMap) Sets(data map[interface{}]interface{}) {
|
||||
|
||||
// Search searches the map with given `key`.
|
||||
// Second return parameter `found` is true if key was found, otherwise false.
|
||||
func (m *ListMap) Search(key interface{}) (value interface{}, found bool) {
|
||||
func (m *ListMap) Search(key any) (value any, found bool) {
|
||||
m.mu.RLock()
|
||||
if m.data != nil {
|
||||
if e, ok := m.data[key]; ok {
|
||||
@ -227,7 +227,7 @@ func (m *ListMap) Search(key interface{}) (value interface{}, found bool) {
|
||||
}
|
||||
|
||||
// Get returns the value by given `key`.
|
||||
func (m *ListMap) Get(key interface{}) (value interface{}) {
|
||||
func (m *ListMap) Get(key any) (value any) {
|
||||
m.mu.RLock()
|
||||
if m.data != nil {
|
||||
if e, ok := m.data[key]; ok {
|
||||
@ -239,7 +239,7 @@ func (m *ListMap) Get(key interface{}) (value interface{}) {
|
||||
}
|
||||
|
||||
// Pop retrieves and deletes an item from the map.
|
||||
func (m *ListMap) Pop() (key, value interface{}) {
|
||||
func (m *ListMap) Pop() (key, value any) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
for k, e := range m.data {
|
||||
@ -253,7 +253,7 @@ func (m *ListMap) Pop() (key, value interface{}) {
|
||||
|
||||
// Pops retrieves and deletes `size` items from the map.
|
||||
// It returns all items if size == -1.
|
||||
func (m *ListMap) Pops(size int) map[interface{}]interface{} {
|
||||
func (m *ListMap) Pops(size int) map[any]any {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if size > len(m.data) || size == -1 {
|
||||
@ -263,7 +263,7 @@ func (m *ListMap) Pops(size int) map[interface{}]interface{} {
|
||||
return nil
|
||||
}
|
||||
index := 0
|
||||
newMap := make(map[interface{}]interface{}, size)
|
||||
newMap := make(map[any]any, size)
|
||||
for k, e := range m.data {
|
||||
value := e.Value.(*gListMapNode).value
|
||||
delete(m.data, k)
|
||||
@ -286,17 +286,17 @@ func (m *ListMap) Pops(size int) map[interface{}]interface{} {
|
||||
// and its return value will be set to the map with `key`.
|
||||
//
|
||||
// It returns value with given `key`.
|
||||
func (m *ListMap) doSetWithLockCheck(key interface{}, value interface{}) interface{} {
|
||||
func (m *ListMap) doSetWithLockCheck(key any, value any) any {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[interface{}]*glist.Element)
|
||||
m.data = make(map[any]*glist.Element)
|
||||
m.list = glist.New()
|
||||
}
|
||||
if e, ok := m.data[key]; ok {
|
||||
return e.Value.(*gListMapNode).value
|
||||
}
|
||||
if f, ok := value.(func() interface{}); ok {
|
||||
if f, ok := value.(func() any); ok {
|
||||
value = f()
|
||||
}
|
||||
if value != nil {
|
||||
@ -307,7 +307,7 @@ func (m *ListMap) doSetWithLockCheck(key interface{}, value interface{}) interfa
|
||||
|
||||
// GetOrSet returns the value by key,
|
||||
// or sets value with given `value` if it does not exist and then returns this value.
|
||||
func (m *ListMap) GetOrSet(key interface{}, value interface{}) interface{} {
|
||||
func (m *ListMap) GetOrSet(key any, value any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, value)
|
||||
} else {
|
||||
@ -318,7 +318,7 @@ func (m *ListMap) GetOrSet(key interface{}, value interface{}) interface{} {
|
||||
// GetOrSetFunc returns the value by key,
|
||||
// or sets value with returned value of callback function `f` if it does not exist
|
||||
// and then returns this value.
|
||||
func (m *ListMap) GetOrSetFunc(key interface{}, f func() interface{}) interface{} {
|
||||
func (m *ListMap) GetOrSetFunc(key any, f func() any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, f())
|
||||
} else {
|
||||
@ -332,7 +332,7 @@ func (m *ListMap) GetOrSetFunc(key interface{}, f func() interface{}) interface{
|
||||
//
|
||||
// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
|
||||
// with mutex.Lock of the map.
|
||||
func (m *ListMap) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{} {
|
||||
func (m *ListMap) GetOrSetFuncLock(key any, f func() any) any {
|
||||
if v, ok := m.Search(key); !ok {
|
||||
return m.doSetWithLockCheck(key, f)
|
||||
} else {
|
||||
@ -342,31 +342,31 @@ func (m *ListMap) GetOrSetFuncLock(key interface{}, f func() interface{}) interf
|
||||
|
||||
// GetVar returns a Var with the value by given `key`.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *ListMap) GetVar(key interface{}) *gvar.Var {
|
||||
func (m *ListMap) GetVar(key any) *gvar.Var {
|
||||
return gvar.New(m.Get(key))
|
||||
}
|
||||
|
||||
// GetVarOrSet returns a Var with result from GetVarOrSet.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *ListMap) GetVarOrSet(key interface{}, value interface{}) *gvar.Var {
|
||||
func (m *ListMap) GetVarOrSet(key any, value any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSet(key, value))
|
||||
}
|
||||
|
||||
// GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *ListMap) GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var {
|
||||
func (m *ListMap) GetVarOrSetFunc(key any, f func() any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSetFunc(key, f))
|
||||
}
|
||||
|
||||
// GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
|
||||
// The returned Var is un-concurrent safe.
|
||||
func (m *ListMap) GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var {
|
||||
func (m *ListMap) GetVarOrSetFuncLock(key any, f func() any) *gvar.Var {
|
||||
return gvar.New(m.GetOrSetFuncLock(key, f))
|
||||
}
|
||||
|
||||
// SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
|
||||
// It returns false if `key` exists, and `value` would be ignored.
|
||||
func (m *ListMap) SetIfNotExist(key interface{}, value interface{}) bool {
|
||||
func (m *ListMap) SetIfNotExist(key any, value any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, value)
|
||||
return true
|
||||
@ -376,7 +376,7 @@ func (m *ListMap) SetIfNotExist(key interface{}, value interface{}) bool {
|
||||
|
||||
// SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
|
||||
// It returns false if `key` exists, and `value` would be ignored.
|
||||
func (m *ListMap) SetIfNotExistFunc(key interface{}, f func() interface{}) bool {
|
||||
func (m *ListMap) SetIfNotExistFunc(key any, f func() any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, f())
|
||||
return true
|
||||
@ -389,7 +389,7 @@ func (m *ListMap) SetIfNotExistFunc(key interface{}, f func() interface{}) bool
|
||||
//
|
||||
// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
|
||||
// it executes function `f` with mutex.Lock of the map.
|
||||
func (m *ListMap) SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool {
|
||||
func (m *ListMap) SetIfNotExistFuncLock(key any, f func() any) bool {
|
||||
if !m.Contains(key) {
|
||||
m.doSetWithLockCheck(key, f)
|
||||
return true
|
||||
@ -398,7 +398,7 @@ func (m *ListMap) SetIfNotExistFuncLock(key interface{}, f func() interface{}) b
|
||||
}
|
||||
|
||||
// Remove deletes value from map by given `key`, and return this deleted value.
|
||||
func (m *ListMap) Remove(key interface{}) (value interface{}) {
|
||||
func (m *ListMap) Remove(key any) (value any) {
|
||||
m.mu.Lock()
|
||||
if m.data != nil {
|
||||
if e, ok := m.data[key]; ok {
|
||||
@ -412,7 +412,7 @@ func (m *ListMap) Remove(key interface{}) (value interface{}) {
|
||||
}
|
||||
|
||||
// Removes batch deletes values of the map by keys.
|
||||
func (m *ListMap) Removes(keys []interface{}) {
|
||||
func (m *ListMap) Removes(keys []any) {
|
||||
m.mu.Lock()
|
||||
if m.data != nil {
|
||||
for _, key := range keys {
|
||||
@ -426,10 +426,10 @@ func (m *ListMap) Removes(keys []interface{}) {
|
||||
}
|
||||
|
||||
// Keys returns all keys of the map as a slice in ascending order.
|
||||
func (m *ListMap) Keys() []interface{} {
|
||||
func (m *ListMap) Keys() []any {
|
||||
m.mu.RLock()
|
||||
var (
|
||||
keys = make([]interface{}, m.list.Len())
|
||||
keys = make([]any, m.list.Len())
|
||||
index = 0
|
||||
)
|
||||
if m.list != nil {
|
||||
@ -444,10 +444,10 @@ func (m *ListMap) Keys() []interface{} {
|
||||
}
|
||||
|
||||
// Values returns all values of the map as a slice.
|
||||
func (m *ListMap) Values() []interface{} {
|
||||
func (m *ListMap) Values() []any {
|
||||
m.mu.RLock()
|
||||
var (
|
||||
values = make([]interface{}, m.list.Len())
|
||||
values = make([]any, m.list.Len())
|
||||
index = 0
|
||||
)
|
||||
if m.list != nil {
|
||||
@ -463,7 +463,7 @@ func (m *ListMap) Values() []interface{} {
|
||||
|
||||
// Contains checks whether a key exists.
|
||||
// It returns true if the `key` exists, or else false.
|
||||
func (m *ListMap) Contains(key interface{}) (ok bool) {
|
||||
func (m *ListMap) Contains(key any) (ok bool) {
|
||||
m.mu.RLock()
|
||||
if m.data != nil {
|
||||
_, ok = m.data[key]
|
||||
@ -501,7 +501,7 @@ func (m *ListMap) Merge(other *ListMap) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[interface{}]*glist.Element)
|
||||
m.data = make(map[any]*glist.Element)
|
||||
m.list = glist.New()
|
||||
}
|
||||
if other != m {
|
||||
@ -536,7 +536,7 @@ func (m ListMap) MarshalJSON() (jsonBytes []byte, err error) {
|
||||
}
|
||||
buffer := bytes.NewBuffer(nil)
|
||||
buffer.WriteByte('{')
|
||||
m.Iterator(func(key, value interface{}) bool {
|
||||
m.Iterator(func(key, value any) bool {
|
||||
valueBytes, valueJSONErr := json.Marshal(value)
|
||||
if valueJSONErr != nil {
|
||||
err = valueJSONErr
|
||||
@ -545,7 +545,7 @@ func (m ListMap) MarshalJSON() (jsonBytes []byte, err error) {
|
||||
if buffer.Len() > 1 {
|
||||
buffer.WriteByte(',')
|
||||
}
|
||||
buffer.WriteString(fmt.Sprintf(`"%v":%s`, key, valueBytes))
|
||||
fmt.Fprintf(buffer, `"%v":%s`, key, valueBytes)
|
||||
return true
|
||||
})
|
||||
buffer.WriteByte('}')
|
||||
@ -557,10 +557,10 @@ func (m *ListMap) UnmarshalJSON(b []byte) error {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[interface{}]*glist.Element)
|
||||
m.data = make(map[any]*glist.Element)
|
||||
m.list = glist.New()
|
||||
}
|
||||
var data map[string]interface{}
|
||||
var data map[string]any
|
||||
if err := json.UnmarshalUseNumber(b, &data); err != nil {
|
||||
return err
|
||||
}
|
||||
@ -575,11 +575,11 @@ func (m *ListMap) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for map.
|
||||
func (m *ListMap) UnmarshalValue(value interface{}) (err error) {
|
||||
func (m *ListMap) UnmarshalValue(value any) (err error) {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
if m.data == nil {
|
||||
m.data = make(map[interface{}]*glist.Element)
|
||||
m.data = make(map[any]*glist.Element)
|
||||
m.list = glist.New()
|
||||
}
|
||||
for k, v := range gconv.Map(value) {
|
||||
@ -593,13 +593,13 @@ func (m *ListMap) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (m *ListMap) DeepCopy() interface{} {
|
||||
func (m *ListMap) DeepCopy() any {
|
||||
if m == nil {
|
||||
return nil
|
||||
}
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
data := make(map[interface{}]interface{}, len(m.data))
|
||||
data := make(map[any]any, len(m.data))
|
||||
if m.list != nil {
|
||||
var node *gListMapNode
|
||||
m.list.IteratorAsc(func(e *glist.Element) bool {
|
||||
|
||||
@ -16,7 +16,7 @@ type TreeMap = gtree.RedBlackTree
|
||||
// NewTreeMap instantiates a tree map with the custom comparator.
|
||||
// The parameter `safe` is used to specify whether using tree in concurrent-safety,
|
||||
// which is false in default.
|
||||
func NewTreeMap(comparator func(v1, v2 interface{}) int, safe ...bool) *TreeMap {
|
||||
func NewTreeMap(comparator func(v1, v2 any) int, safe ...bool) *TreeMap {
|
||||
return gtree.NewRedBlackTree(comparator, safe...)
|
||||
}
|
||||
|
||||
@ -25,6 +25,6 @@ func NewTreeMap(comparator func(v1, v2 interface{}) int, safe ...bool) *TreeMap
|
||||
// there might be some concurrent-safe issues when changing the map outside.
|
||||
// The parameter `safe` is used to specify whether using tree in concurrent-safety,
|
||||
// which is false in default.
|
||||
func NewTreeMapFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, safe ...bool) *TreeMap {
|
||||
func NewTreeMapFrom(comparator func(v1, v2 any) int, data map[any]any, safe ...bool) *TreeMap {
|
||||
return gtree.NewRedBlackTreeFrom(comparator, data, safe...)
|
||||
}
|
||||
|
||||
@ -14,7 +14,7 @@ import (
|
||||
"github.com/gogf/gf/v2/util/gutil"
|
||||
)
|
||||
|
||||
func getValue() interface{} {
|
||||
func getValue() any {
|
||||
return 3
|
||||
}
|
||||
|
||||
@ -71,7 +71,7 @@ func Test_Map_Basic(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.New()
|
||||
m.Set("key1", "val1")
|
||||
t.Assert(m.Keys(), []interface{}{"key1"})
|
||||
t.Assert(m.Keys(), []any{"key1"})
|
||||
|
||||
t.Assert(m.Get("key1"), "val1")
|
||||
t.Assert(m.Size(), 1)
|
||||
@ -91,14 +91,14 @@ func Test_Map_Basic(t *testing.T) {
|
||||
t.AssertIN("val1", m.Values())
|
||||
|
||||
m.Flip()
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"val3": "key3", "val1": "key1"})
|
||||
t.Assert(m.Map(), map[any]any{"val3": "key3", "val1": "key1"})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
t.Assert(m.IsEmpty(), true)
|
||||
|
||||
m2 := gmap.NewFrom(map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m2 := gmap.NewFrom(map[any]any{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[any]any{1: 1, "key1": "val1"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -118,30 +118,30 @@ func Test_Map_Set_Fun(t *testing.T) {
|
||||
func Test_Map_Batch(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.New()
|
||||
m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]interface{}{"key1", 1})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
|
||||
m.Sets(map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]any{"key1", 1})
|
||||
t.Assert(m.Map(), map[any]any{"key2": "val2", "key3": "val3"})
|
||||
})
|
||||
}
|
||||
|
||||
func Test_Map_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
|
||||
expect := map[any]any{1: 1, "key1": "val1"}
|
||||
|
||||
m := gmap.NewFrom(expect)
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
t.Assert(expect[k], v)
|
||||
return true
|
||||
})
|
||||
// 断言返回值对遍历控制
|
||||
i := 0
|
||||
j := 0
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -152,12 +152,12 @@ func Test_Map_Iterator(t *testing.T) {
|
||||
|
||||
func Test_Map_Lock(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
|
||||
expect := map[any]any{1: 1, "key1": "val1"}
|
||||
m := gmap.NewFrom(expect)
|
||||
m.LockFunc(func(m map[interface{}]interface{}) {
|
||||
m.LockFunc(func(m map[any]any) {
|
||||
t.Assert(m, expect)
|
||||
})
|
||||
m.RLockFunc(func(m map[interface{}]interface{}) {
|
||||
m.RLockFunc(func(m map[any]any) {
|
||||
t.Assert(m, expect)
|
||||
})
|
||||
})
|
||||
@ -166,7 +166,7 @@ func Test_Map_Lock(t *testing.T) {
|
||||
func Test_Map_Clone(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
// clone 方法是深克隆
|
||||
m := gmap.NewFrom(map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m := gmap.NewFrom(map[any]any{1: 1, "key1": "val1"})
|
||||
m_clone := m.Clone()
|
||||
m.Remove(1)
|
||||
// 修改原 map,clone 后的 map 不影响
|
||||
@ -185,6 +185,6 @@ func Test_Map_Basic_Merge(t *testing.T) {
|
||||
m1.Set("key1", "val1")
|
||||
m2.Set("key2", "val2")
|
||||
m1.Merge(m2)
|
||||
t.Assert(m1.Map(), map[interface{}]interface{}{"key1": "val1", "key2": "val2"})
|
||||
t.Assert(m1.Map(), map[any]any{"key1": "val1", "key2": "val2"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -22,7 +22,7 @@ func ExampleAnyAnyMap_Iterator() {
|
||||
}
|
||||
|
||||
var totalKey, totalValue int
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
totalKey += k.(int)
|
||||
totalValue += v.(int)
|
||||
|
||||
@ -149,7 +149,7 @@ func ExampleAnyAnyMap_Set() {
|
||||
func ExampleAnyAnyMap_Sets() {
|
||||
m := gmap.New()
|
||||
|
||||
addMap := make(map[interface{}]interface{})
|
||||
addMap := make(map[any]any)
|
||||
addMap["key1"] = "val1"
|
||||
addMap["key2"] = "val2"
|
||||
addMap["key3"] = "val3"
|
||||
@ -252,10 +252,10 @@ func ExampleAnyAnyMap_GetOrSetFunc() {
|
||||
m := gmap.New()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFunc("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetOrSetFunc("key2", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFunc("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -268,10 +268,10 @@ func ExampleAnyAnyMap_GetOrSetFuncLock() {
|
||||
m := gmap.New()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFuncLock("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetOrSetFuncLock("key2", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFuncLock("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -308,10 +308,10 @@ func ExampleAnyAnyMap_GetVarOrSetFunc() {
|
||||
m := gmap.New()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetVarOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFunc("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetVarOrSetFunc("key2", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFunc("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -324,10 +324,10 @@ func ExampleAnyAnyMap_GetVarOrSetFuncLock() {
|
||||
m := gmap.New()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key2", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -350,10 +350,10 @@ func ExampleAnyAnyMap_SetIfNotExist() {
|
||||
|
||||
func ExampleAnyAnyMap_SetIfNotExistFunc() {
|
||||
var m gmap.Map
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() any {
|
||||
return "v1"
|
||||
}))
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() any {
|
||||
return "v2"
|
||||
}))
|
||||
fmt.Println(m.Map())
|
||||
@ -366,10 +366,10 @@ func ExampleAnyAnyMap_SetIfNotExistFunc() {
|
||||
|
||||
func ExampleAnyAnyMap_SetIfNotExistFuncLock() {
|
||||
var m gmap.Map
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() any {
|
||||
return "v1"
|
||||
}))
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() any {
|
||||
return "v2"
|
||||
}))
|
||||
fmt.Println(m.Map())
|
||||
@ -403,7 +403,7 @@ func ExampleAnyAnyMap_Removes() {
|
||||
"k4": "v4",
|
||||
})
|
||||
|
||||
removeList := make([]interface{}, 2)
|
||||
removeList := make([]any, 2)
|
||||
removeList = append(removeList, "k1")
|
||||
removeList = append(removeList, "k2")
|
||||
|
||||
@ -538,7 +538,7 @@ func ExampleAnyAnyMap_LockFunc() {
|
||||
"k4": 4,
|
||||
})
|
||||
|
||||
m.LockFunc(func(m map[interface{}]interface{}) {
|
||||
m.LockFunc(func(m map[any]any) {
|
||||
totalValue := 0
|
||||
for _, v := range m {
|
||||
totalValue += v.(int)
|
||||
@ -559,7 +559,7 @@ func ExampleAnyAnyMap_RLockFunc() {
|
||||
"k4": 4,
|
||||
})
|
||||
|
||||
m.RLockFunc(func(m map[interface{}]interface{}) {
|
||||
m.RLockFunc(func(m map[any]any) {
|
||||
totalValue := 0
|
||||
for _, v := range m {
|
||||
totalValue += v.(int)
|
||||
|
||||
@ -22,7 +22,7 @@ func ExampleIntAnyMap_Iterator() {
|
||||
}
|
||||
|
||||
var totalKey, totalValue int
|
||||
m.Iterator(func(k int, v interface{}) bool {
|
||||
m.Iterator(func(k int, v any) bool {
|
||||
totalKey += k
|
||||
totalValue += v.(int)
|
||||
|
||||
@ -149,7 +149,7 @@ func ExampleIntAnyMap_Set() {
|
||||
func ExampleIntAnyMap_Sets() {
|
||||
m := gmap.NewIntAnyMap()
|
||||
|
||||
addMap := make(map[int]interface{})
|
||||
addMap := make(map[int]any)
|
||||
addMap[1] = "val1"
|
||||
addMap[2] = "val2"
|
||||
addMap[3] = "val3"
|
||||
@ -252,10 +252,10 @@ func ExampleIntAnyMap_GetOrSetFunc() {
|
||||
m := gmap.NewIntAnyMap()
|
||||
m.Set(1, "val1")
|
||||
|
||||
fmt.Println(m.GetOrSetFunc(1, func() interface{} {
|
||||
fmt.Println(m.GetOrSetFunc(1, func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetOrSetFunc(2, func() interface{} {
|
||||
fmt.Println(m.GetOrSetFunc(2, func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -268,10 +268,10 @@ func ExampleIntAnyMap_GetOrSetFuncLock() {
|
||||
m := gmap.NewIntAnyMap()
|
||||
m.Set(1, "val1")
|
||||
|
||||
fmt.Println(m.GetOrSetFuncLock(1, func() interface{} {
|
||||
fmt.Println(m.GetOrSetFuncLock(1, func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetOrSetFuncLock(2, func() interface{} {
|
||||
fmt.Println(m.GetOrSetFuncLock(2, func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -308,10 +308,10 @@ func ExampleIntAnyMap_GetVarOrSetFunc() {
|
||||
m := gmap.NewIntAnyMap()
|
||||
m.Set(1, "val1")
|
||||
|
||||
fmt.Println(m.GetVarOrSetFunc(1, func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFunc(1, func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetVarOrSetFunc(2, func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFunc(2, func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -324,10 +324,10 @@ func ExampleIntAnyMap_GetVarOrSetFuncLock() {
|
||||
m := gmap.NewIntAnyMap()
|
||||
m.Set(1, "val1")
|
||||
|
||||
fmt.Println(m.GetVarOrSetFuncLock(1, func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFuncLock(1, func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetVarOrSetFuncLock(2, func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFuncLock(2, func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -350,10 +350,10 @@ func ExampleIntAnyMap_SetIfNotExist() {
|
||||
|
||||
func ExampleIntAnyMap_SetIfNotExistFunc() {
|
||||
var m gmap.IntAnyMap
|
||||
fmt.Println(m.SetIfNotExistFunc(1, func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFunc(1, func() any {
|
||||
return "v1"
|
||||
}))
|
||||
fmt.Println(m.SetIfNotExistFunc(1, func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFunc(1, func() any {
|
||||
return "v2"
|
||||
}))
|
||||
fmt.Println(m.Map())
|
||||
@ -366,10 +366,10 @@ func ExampleIntAnyMap_SetIfNotExistFunc() {
|
||||
|
||||
func ExampleIntAnyMap_SetIfNotExistFuncLock() {
|
||||
var m gmap.IntAnyMap
|
||||
fmt.Println(m.SetIfNotExistFuncLock(1, func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFuncLock(1, func() any {
|
||||
return "v1"
|
||||
}))
|
||||
fmt.Println(m.SetIfNotExistFuncLock(1, func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFuncLock(1, func() any {
|
||||
return "v2"
|
||||
}))
|
||||
fmt.Println(m.Map())
|
||||
@ -538,7 +538,7 @@ func ExampleIntAnyMap_LockFunc() {
|
||||
4: 4,
|
||||
})
|
||||
|
||||
m.LockFunc(func(m map[int]interface{}) {
|
||||
m.LockFunc(func(m map[int]any) {
|
||||
totalValue := 0
|
||||
for _, v := range m {
|
||||
totalValue += v.(int)
|
||||
@ -559,7 +559,7 @@ func ExampleIntAnyMap_RLockFunc() {
|
||||
4: 4,
|
||||
})
|
||||
|
||||
m.RLockFunc(func(m map[int]interface{}) {
|
||||
m.RLockFunc(func(m map[int]any) {
|
||||
totalValue := 0
|
||||
for _, v := range m {
|
||||
totalValue += v.(int)
|
||||
@ -651,7 +651,7 @@ func ExampleIntAnyMap_UnmarshalJSON() {
|
||||
func ExampleIntAnyMap_UnmarshalValue() {
|
||||
var m gmap.IntAnyMap
|
||||
|
||||
goWeb := map[int]interface{}{
|
||||
goWeb := map[int]any{
|
||||
1: "goframe",
|
||||
2: "gin",
|
||||
3: "echo",
|
||||
|
||||
@ -22,7 +22,7 @@ func ExampleListMap_Iterator() {
|
||||
}
|
||||
|
||||
var totalKey, totalValue int
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
totalKey += k.(int)
|
||||
totalValue += v.(int)
|
||||
|
||||
@ -44,7 +44,7 @@ func ExampleListMap_IteratorAsc() {
|
||||
}
|
||||
|
||||
var totalKey, totalValue int
|
||||
m.IteratorAsc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorAsc(func(k any, v any) bool {
|
||||
totalKey += k.(int)
|
||||
totalValue += v.(int)
|
||||
|
||||
@ -66,7 +66,7 @@ func ExampleListMap_IteratorDesc() {
|
||||
}
|
||||
|
||||
var totalKey, totalValue int
|
||||
m.IteratorDesc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorDesc(func(k any, v any) bool {
|
||||
totalKey += k.(int)
|
||||
totalValue += v.(int)
|
||||
|
||||
@ -188,7 +188,7 @@ func ExampleListMap_Set() {
|
||||
func ExampleListMap_Sets() {
|
||||
m := gmap.NewListMap()
|
||||
|
||||
addMap := make(map[interface{}]interface{})
|
||||
addMap := make(map[any]any)
|
||||
addMap["key1"] = "val1"
|
||||
addMap["key2"] = "val2"
|
||||
addMap["key3"] = "val3"
|
||||
@ -291,10 +291,10 @@ func ExampleListMap_GetOrSetFunc() {
|
||||
m := gmap.NewListMap()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFunc("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetOrSetFunc("key2", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFunc("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -307,10 +307,10 @@ func ExampleListMap_GetOrSetFuncLock() {
|
||||
m := gmap.NewListMap()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFuncLock("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetOrSetFuncLock("key2", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFuncLock("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -347,10 +347,10 @@ func ExampleListMap_GetVarOrSetFunc() {
|
||||
m := gmap.NewListMap()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetVarOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFunc("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetVarOrSetFunc("key2", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFunc("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -363,10 +363,10 @@ func ExampleListMap_GetVarOrSetFuncLock() {
|
||||
m := gmap.NewListMap()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key2", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -389,10 +389,10 @@ func ExampleListMap_SetIfNotExist() {
|
||||
|
||||
func ExampleListMap_SetIfNotExistFunc() {
|
||||
var m gmap.ListMap
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() any {
|
||||
return "v1"
|
||||
}))
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() any {
|
||||
return "v2"
|
||||
}))
|
||||
fmt.Println(m.Map())
|
||||
@ -405,10 +405,10 @@ func ExampleListMap_SetIfNotExistFunc() {
|
||||
|
||||
func ExampleListMap_SetIfNotExistFuncLock() {
|
||||
var m gmap.ListMap
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() any {
|
||||
return "v1"
|
||||
}))
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() any {
|
||||
return "v2"
|
||||
}))
|
||||
fmt.Println(m.Map())
|
||||
@ -442,7 +442,7 @@ func ExampleListMap_Removes() {
|
||||
"k4": "v4",
|
||||
})
|
||||
|
||||
removeList := make([]interface{}, 2)
|
||||
removeList := make([]any, 2)
|
||||
removeList = append(removeList, "k1")
|
||||
removeList = append(removeList, "k2")
|
||||
|
||||
|
||||
@ -22,7 +22,7 @@ func ExampleStrAnyMap_Iterator() {
|
||||
}
|
||||
|
||||
var totalValue int
|
||||
m.Iterator(func(k string, v interface{}) bool {
|
||||
m.Iterator(func(k string, v any) bool {
|
||||
totalValue += v.(int)
|
||||
|
||||
return totalValue < 50
|
||||
@ -146,7 +146,7 @@ func ExampleStrAnyMap_Set() {
|
||||
func ExampleStrAnyMap_Sets() {
|
||||
m := gmap.NewStrAnyMap()
|
||||
|
||||
addMap := make(map[string]interface{})
|
||||
addMap := make(map[string]any)
|
||||
addMap["key1"] = "val1"
|
||||
addMap["key2"] = "val2"
|
||||
addMap["key3"] = "val3"
|
||||
@ -249,10 +249,10 @@ func ExampleStrAnyMap_GetOrSetFunc() {
|
||||
m := gmap.NewStrAnyMap()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFunc("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetOrSetFunc("key2", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFunc("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -265,10 +265,10 @@ func ExampleStrAnyMap_GetOrSetFuncLock() {
|
||||
m := gmap.NewStrAnyMap()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFuncLock("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetOrSetFuncLock("key2", func() interface{} {
|
||||
fmt.Println(m.GetOrSetFuncLock("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -305,10 +305,10 @@ func ExampleStrAnyMap_GetVarOrSetFunc() {
|
||||
m := gmap.NewStrAnyMap()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetVarOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFunc("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetVarOrSetFunc("key2", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFunc("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -321,10 +321,10 @@ func ExampleStrAnyMap_GetVarOrSetFuncLock() {
|
||||
m := gmap.NewStrAnyMap()
|
||||
m.Set("key1", "val1")
|
||||
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key1", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key2", func() interface{} {
|
||||
fmt.Println(m.GetVarOrSetFuncLock("key2", func() any {
|
||||
return "NotExistValue"
|
||||
}))
|
||||
|
||||
@ -347,10 +347,10 @@ func ExampleStrAnyMap_SetIfNotExist() {
|
||||
|
||||
func ExampleStrAnyMap_SetIfNotExistFunc() {
|
||||
var m gmap.StrAnyMap
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() any {
|
||||
return "v1"
|
||||
}))
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFunc("k1", func() any {
|
||||
return "v2"
|
||||
}))
|
||||
fmt.Println(m.Map())
|
||||
@ -363,10 +363,10 @@ func ExampleStrAnyMap_SetIfNotExistFunc() {
|
||||
|
||||
func ExampleStrAnyMap_SetIfNotExistFuncLock() {
|
||||
var m gmap.StrAnyMap
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() any {
|
||||
return "v1"
|
||||
}))
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() interface{} {
|
||||
fmt.Println(m.SetIfNotExistFuncLock("k1", func() any {
|
||||
return "v2"
|
||||
}))
|
||||
fmt.Println(m.Map())
|
||||
@ -535,7 +535,7 @@ func ExampleStrAnyMap_LockFunc() {
|
||||
"k4": 4,
|
||||
})
|
||||
|
||||
m.LockFunc(func(m map[string]interface{}) {
|
||||
m.LockFunc(func(m map[string]any) {
|
||||
totalValue := 0
|
||||
for _, v := range m {
|
||||
totalValue += v.(int)
|
||||
@ -556,7 +556,7 @@ func ExampleStrAnyMap_RLockFunc() {
|
||||
"k4": 4,
|
||||
})
|
||||
|
||||
m.RLockFunc(func(m map[string]interface{}) {
|
||||
m.RLockFunc(func(m map[string]any) {
|
||||
totalValue := 0
|
||||
for _, v := range m {
|
||||
totalValue += v.(int)
|
||||
@ -648,7 +648,7 @@ func ExampleStrAnyMap_UnmarshalJSON() {
|
||||
func ExampleStrAnyMap_UnmarshalValue() {
|
||||
var m gmap.StrAnyMap
|
||||
|
||||
goWeb := map[string]interface{}{
|
||||
goWeb := map[string]any{
|
||||
"goframe": "https://goframe.org",
|
||||
"gin": "https://gin-gonic.com/",
|
||||
"echo": "https://echo.labstack.com/",
|
||||
|
||||
@ -22,7 +22,7 @@ func ExampleNew() {
|
||||
// Print size.
|
||||
fmt.Println(m.Size())
|
||||
|
||||
addMap := make(map[interface{}]interface{})
|
||||
addMap := make(map[any]any)
|
||||
addMap["key2"] = "val2"
|
||||
addMap["key3"] = "val3"
|
||||
addMap[1] = 1
|
||||
@ -46,7 +46,7 @@ func ExampleNew() {
|
||||
fmt.Println(m.Keys())
|
||||
|
||||
// Batch remove keys.
|
||||
m.Removes([]interface{}{"key1", 1})
|
||||
m.Removes([]any{"key1", 1})
|
||||
fmt.Println(m.Keys())
|
||||
|
||||
// Contains checks whether a key exists.
|
||||
|
||||
@ -40,7 +40,7 @@ func Test_AnyAnyMap_Var(t *testing.T) {
|
||||
t.AssertIN(3, m.Values())
|
||||
t.AssertIN(1, m.Values())
|
||||
m.Flip()
|
||||
t.Assert(m.Map(), map[interface{}]int{1: 1, 3: 3})
|
||||
t.Assert(m.Map(), map[any]int{1: 1, 3: 3})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
@ -70,14 +70,14 @@ func Test_AnyAnyMap_Basic(t *testing.T) {
|
||||
t.AssertIN(3, m.Values())
|
||||
t.AssertIN(1, m.Values())
|
||||
m.Flip()
|
||||
t.Assert(m.Map(), map[interface{}]int{1: 1, 3: 3})
|
||||
t.Assert(m.Map(), map[any]int{1: 1, 3: 3})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
t.Assert(m.IsEmpty(), true)
|
||||
|
||||
m2 := gmap.NewAnyAnyMapFrom(map[interface{}]interface{}{1: 1, 2: "2"})
|
||||
t.Assert(m2.Map(), map[interface{}]interface{}{1: 1, 2: "2"})
|
||||
m2 := gmap.NewAnyAnyMapFrom(map[any]any{1: 1, 2: "2"})
|
||||
t.Assert(m2.Map(), map[any]any{1: 1, 2: "2"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -103,23 +103,23 @@ func Test_AnyAnyMap_Batch(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.NewAnyAnyMap()
|
||||
|
||||
m.Sets(map[interface{}]interface{}{1: 1, 2: "2", 3: 3})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{1: 1, 2: "2", 3: 3})
|
||||
m.Removes([]interface{}{1, 2})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{3: 3})
|
||||
m.Sets(map[any]any{1: 1, 2: "2", 3: 3})
|
||||
t.Assert(m.Map(), map[any]any{1: 1, 2: "2", 3: 3})
|
||||
m.Removes([]any{1, 2})
|
||||
t.Assert(m.Map(), map[any]any{3: 3})
|
||||
})
|
||||
}
|
||||
|
||||
func Test_AnyAnyMap_Iterator_Deadlock(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.NewAnyAnyMapFrom(map[interface{}]interface{}{1: 1, 2: "2", "3": "3", "4": 4}, true)
|
||||
m.Iterator(func(k interface{}, _ interface{}) bool {
|
||||
m := gmap.NewAnyAnyMapFrom(map[any]any{1: 1, 2: "2", "3": "3", "4": 4}, true)
|
||||
m.Iterator(func(k any, _ any) bool {
|
||||
if gconv.Int(k)%2 == 0 {
|
||||
m.Remove(k)
|
||||
}
|
||||
return true
|
||||
})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{
|
||||
t.Assert(m.Map(), map[any]any{
|
||||
1: 1,
|
||||
"3": "3",
|
||||
})
|
||||
@ -128,20 +128,20 @@ func Test_AnyAnyMap_Iterator_Deadlock(t *testing.T) {
|
||||
|
||||
func Test_AnyAnyMap_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := map[interface{}]interface{}{1: 1, 2: "2"}
|
||||
expect := map[any]any{1: 1, 2: "2"}
|
||||
m := gmap.NewAnyAnyMapFrom(expect)
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
t.Assert(expect[k], v)
|
||||
return true
|
||||
})
|
||||
// 断言返回值对遍历控制
|
||||
i := 0
|
||||
j := 0
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -152,12 +152,12 @@ func Test_AnyAnyMap_Iterator(t *testing.T) {
|
||||
|
||||
func Test_AnyAnyMap_Lock(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := map[interface{}]interface{}{1: 1, 2: "2"}
|
||||
expect := map[any]any{1: 1, 2: "2"}
|
||||
m := gmap.NewAnyAnyMapFrom(expect)
|
||||
m.LockFunc(func(m map[interface{}]interface{}) {
|
||||
m.LockFunc(func(m map[any]any) {
|
||||
t.Assert(m, expect)
|
||||
})
|
||||
m.RLockFunc(func(m map[interface{}]interface{}) {
|
||||
m.RLockFunc(func(m map[any]any) {
|
||||
t.Assert(m, expect)
|
||||
})
|
||||
})
|
||||
@ -166,7 +166,7 @@ func Test_AnyAnyMap_Lock(t *testing.T) {
|
||||
func Test_AnyAnyMap_Clone(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
// clone 方法是深克隆
|
||||
m := gmap.NewAnyAnyMapFrom(map[interface{}]interface{}{1: 1, 2: "2"})
|
||||
m := gmap.NewAnyAnyMapFrom(map[any]any{1: 1, 2: "2"})
|
||||
|
||||
m_clone := m.Clone()
|
||||
m.Remove(1)
|
||||
@ -186,7 +186,7 @@ func Test_AnyAnyMap_Merge(t *testing.T) {
|
||||
m1.Set(1, 1)
|
||||
m2.Set(2, "2")
|
||||
m1.Merge(m2)
|
||||
t.Assert(m1.Map(), map[interface{}]interface{}{1: 1, 2: "2"})
|
||||
t.Assert(m1.Map(), map[any]any{1: 1, 2: "2"})
|
||||
m3 := gmap.NewAnyAnyMapFrom(nil)
|
||||
m3.Merge(m2)
|
||||
t.Assert(m3.Map(), m2.Map())
|
||||
@ -366,7 +366,7 @@ func TestAnyAnyMap_UnmarshalValue(t *testing.T) {
|
||||
// JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": []byte(`{"k1":"v1","k2":"v2"}`),
|
||||
}, &v)
|
||||
@ -379,7 +379,7 @@ func TestAnyAnyMap_UnmarshalValue(t *testing.T) {
|
||||
// Map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": g.Map{
|
||||
"k1": "v1",
|
||||
@ -438,8 +438,8 @@ func Test_AnyAnyMap_Diff(t *testing.T) {
|
||||
4: "v4",
|
||||
})
|
||||
addedKeys, removedKeys, updatedKeys := m1.Diff(m2)
|
||||
t.Assert(addedKeys, []interface{}{4})
|
||||
t.Assert(removedKeys, []interface{}{"1"})
|
||||
t.Assert(updatedKeys, []interface{}{3})
|
||||
t.Assert(addedKeys, []any{4})
|
||||
t.Assert(removedKeys, []any{"1"})
|
||||
t.Assert(updatedKeys, []any{3})
|
||||
})
|
||||
}
|
||||
|
||||
@ -17,7 +17,7 @@ import (
|
||||
"github.com/gogf/gf/v2/util/gconv"
|
||||
)
|
||||
|
||||
func getAny() interface{} {
|
||||
func getAny() any {
|
||||
return 123
|
||||
}
|
||||
|
||||
@ -43,7 +43,7 @@ func Test_IntAnyMap_Var(t *testing.T) {
|
||||
t.AssertIN(3, m.Values())
|
||||
t.AssertIN(1, m.Values())
|
||||
m.Flip()
|
||||
t.Assert(m.Map(), map[interface{}]int{1: 1, 3: 3})
|
||||
t.Assert(m.Map(), map[any]int{1: 1, 3: 3})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
@ -73,20 +73,20 @@ func Test_IntAnyMap_Basic(t *testing.T) {
|
||||
t.AssertIN(3, m.Values())
|
||||
t.AssertIN(1, m.Values())
|
||||
m.Flip()
|
||||
t.Assert(m.Map(), map[interface{}]int{1: 1, 3: 3})
|
||||
t.Assert(m.Map(), map[any]int{1: 1, 3: 3})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
t.Assert(m.IsEmpty(), true)
|
||||
|
||||
m2 := gmap.NewIntAnyMapFrom(map[int]interface{}{1: 1, 2: "2"})
|
||||
t.Assert(m2.Map(), map[int]interface{}{1: 1, 2: "2"})
|
||||
m2 := gmap.NewIntAnyMapFrom(map[int]any{1: 1, 2: "2"})
|
||||
t.Assert(m2.Map(), map[int]any{1: 1, 2: "2"})
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.NewIntAnyMap(true)
|
||||
m.Set(1, 1)
|
||||
t.Assert(m.Map(), map[int]interface{}{1: 1})
|
||||
t.Assert(m.Map(), map[int]any{1: 1})
|
||||
})
|
||||
}
|
||||
|
||||
@ -111,23 +111,23 @@ func Test_IntAnyMap_Batch(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.NewIntAnyMap()
|
||||
|
||||
m.Sets(map[int]interface{}{1: 1, 2: "2", 3: 3})
|
||||
t.Assert(m.Map(), map[int]interface{}{1: 1, 2: "2", 3: 3})
|
||||
m.Sets(map[int]any{1: 1, 2: "2", 3: 3})
|
||||
t.Assert(m.Map(), map[int]any{1: 1, 2: "2", 3: 3})
|
||||
m.Removes([]int{1, 2})
|
||||
t.Assert(m.Map(), map[int]interface{}{3: 3})
|
||||
t.Assert(m.Map(), map[int]any{3: 3})
|
||||
})
|
||||
}
|
||||
|
||||
func Test_IntAnyMap_Iterator_Deadlock(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.NewIntAnyMapFrom(map[int]interface{}{1: 1, 2: 2, 3: "3", 4: 4}, true)
|
||||
m.Iterator(func(k int, _ interface{}) bool {
|
||||
m := gmap.NewIntAnyMapFrom(map[int]any{1: 1, 2: 2, 3: "3", 4: 4}, true)
|
||||
m.Iterator(func(k int, _ any) bool {
|
||||
if k%2 == 0 {
|
||||
m.Remove(k)
|
||||
}
|
||||
return true
|
||||
})
|
||||
t.Assert(m.Map(), map[int]interface{}{
|
||||
t.Assert(m.Map(), map[int]any{
|
||||
1: 1,
|
||||
3: "3",
|
||||
})
|
||||
@ -136,20 +136,20 @@ func Test_IntAnyMap_Iterator_Deadlock(t *testing.T) {
|
||||
|
||||
func Test_IntAnyMap_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := map[int]interface{}{1: 1, 2: "2"}
|
||||
expect := map[int]any{1: 1, 2: "2"}
|
||||
m := gmap.NewIntAnyMapFrom(expect)
|
||||
m.Iterator(func(k int, v interface{}) bool {
|
||||
m.Iterator(func(k int, v any) bool {
|
||||
t.Assert(expect[k], v)
|
||||
return true
|
||||
})
|
||||
// 断言返回值对遍历控制
|
||||
i := 0
|
||||
j := 0
|
||||
m.Iterator(func(k int, v interface{}) bool {
|
||||
m.Iterator(func(k int, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.Iterator(func(k int, v interface{}) bool {
|
||||
m.Iterator(func(k int, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -161,12 +161,12 @@ func Test_IntAnyMap_Iterator(t *testing.T) {
|
||||
|
||||
func Test_IntAnyMap_Lock(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := map[int]interface{}{1: 1, 2: "2"}
|
||||
expect := map[int]any{1: 1, 2: "2"}
|
||||
m := gmap.NewIntAnyMapFrom(expect)
|
||||
m.LockFunc(func(m map[int]interface{}) {
|
||||
m.LockFunc(func(m map[int]any) {
|
||||
t.Assert(m, expect)
|
||||
})
|
||||
m.RLockFunc(func(m map[int]interface{}) {
|
||||
m.RLockFunc(func(m map[int]any) {
|
||||
t.Assert(m, expect)
|
||||
})
|
||||
})
|
||||
@ -175,7 +175,7 @@ func Test_IntAnyMap_Lock(t *testing.T) {
|
||||
func Test_IntAnyMap_Clone(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
// clone 方法是深克隆
|
||||
m := gmap.NewIntAnyMapFrom(map[int]interface{}{1: 1, 2: "2"})
|
||||
m := gmap.NewIntAnyMapFrom(map[int]any{1: 1, 2: "2"})
|
||||
|
||||
m_clone := m.Clone()
|
||||
m.Remove(1)
|
||||
@ -195,7 +195,7 @@ func Test_IntAnyMap_Merge(t *testing.T) {
|
||||
m1.Set(1, 1)
|
||||
m2.Set(2, "2")
|
||||
m1.Merge(m2)
|
||||
t.Assert(m1.Map(), map[int]interface{}{1: 1, 2: "2"})
|
||||
t.Assert(m1.Map(), map[int]any{1: 1, 2: "2"})
|
||||
m3 := gmap.NewIntAnyMapFrom(nil)
|
||||
m3.Merge(m2)
|
||||
t.Assert(m3.Map(), m2.Map())
|
||||
@ -350,7 +350,7 @@ func TestIntAnyMap_UnmarshalValue(t *testing.T) {
|
||||
// JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": []byte(`{"1":"v1","2":"v2"}`),
|
||||
}, &v)
|
||||
@ -363,7 +363,7 @@ func TestIntAnyMap_UnmarshalValue(t *testing.T) {
|
||||
// Map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": g.MapIntAny{
|
||||
1: "v1",
|
||||
|
||||
@ -358,7 +358,7 @@ func TestIntIntMap_UnmarshalValue(t *testing.T) {
|
||||
// JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": []byte(`{"1":1,"2":2}`),
|
||||
}, &v)
|
||||
@ -371,7 +371,7 @@ func TestIntIntMap_UnmarshalValue(t *testing.T) {
|
||||
// Map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": g.MapIntAny{
|
||||
1: 1,
|
||||
|
||||
@ -149,7 +149,7 @@ func Test_IntStrMap_Batch(t *testing.T) {
|
||||
m.Sets(map[int]string{1: "a", 2: "b", 3: "c"})
|
||||
t.Assert(m.Map(), map[int]string{1: "a", 2: "b", 3: "c"})
|
||||
m.Removes([]int{1, 2})
|
||||
t.Assert(m.Map(), map[int]interface{}{3: "c"})
|
||||
t.Assert(m.Map(), map[int]any{3: "c"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -384,7 +384,7 @@ func TestIntStrMap_UnmarshalValue(t *testing.T) {
|
||||
// JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": []byte(`{"1":"v1","2":"v2"}`),
|
||||
}, &v)
|
||||
@ -397,7 +397,7 @@ func TestIntStrMap_UnmarshalValue(t *testing.T) {
|
||||
// Map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": g.MapIntAny{
|
||||
1: "v1",
|
||||
|
||||
@ -41,7 +41,7 @@ func Test_StrAnyMap_Var(t *testing.T) {
|
||||
t.AssertIN(1, m.Values())
|
||||
|
||||
m.Flip()
|
||||
t.Assert(m.Map(), map[string]interface{}{"1": "a", "3": "c"})
|
||||
t.Assert(m.Map(), map[string]any{"1": "a", "3": "c"})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
@ -72,14 +72,14 @@ func Test_StrAnyMap_Basic(t *testing.T) {
|
||||
t.AssertIN(1, m.Values())
|
||||
|
||||
m.Flip()
|
||||
t.Assert(m.Map(), map[string]interface{}{"1": "a", "3": "c"})
|
||||
t.Assert(m.Map(), map[string]any{"1": "a", "3": "c"})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
t.Assert(m.IsEmpty(), true)
|
||||
|
||||
m2 := gmap.NewStrAnyMapFrom(map[string]interface{}{"a": 1, "b": "2"})
|
||||
t.Assert(m2.Map(), map[string]interface{}{"a": 1, "b": "2"})
|
||||
m2 := gmap.NewStrAnyMapFrom(map[string]any{"a": 1, "b": "2"})
|
||||
t.Assert(m2.Map(), map[string]any{"a": 1, "b": "2"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -103,24 +103,24 @@ func Test_StrAnyMap_Batch(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.NewStrAnyMap()
|
||||
|
||||
m.Sets(map[string]interface{}{"a": 1, "b": "2", "c": 3})
|
||||
t.Assert(m.Map(), map[string]interface{}{"a": 1, "b": "2", "c": 3})
|
||||
m.Sets(map[string]any{"a": 1, "b": "2", "c": 3})
|
||||
t.Assert(m.Map(), map[string]any{"a": 1, "b": "2", "c": 3})
|
||||
m.Removes([]string{"a", "b"})
|
||||
t.Assert(m.Map(), map[string]interface{}{"c": 3})
|
||||
t.Assert(m.Map(), map[string]any{"c": 3})
|
||||
})
|
||||
}
|
||||
|
||||
func Test_StrAnyMap_Iterator_Deadlock(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.NewStrAnyMapFrom(map[string]interface{}{"1": "1", "2": "2", "3": "3", "4": "4"}, true)
|
||||
m.Iterator(func(k string, _ interface{}) bool {
|
||||
m := gmap.NewStrAnyMapFrom(map[string]any{"1": "1", "2": "2", "3": "3", "4": "4"}, true)
|
||||
m.Iterator(func(k string, _ any) bool {
|
||||
kInt, _ := strconv.Atoi(k)
|
||||
if kInt%2 == 0 {
|
||||
m.Remove(k)
|
||||
}
|
||||
return true
|
||||
})
|
||||
t.Assert(m.Map(), map[string]interface{}{
|
||||
t.Assert(m.Map(), map[string]any{
|
||||
"1": "1",
|
||||
"3": "3",
|
||||
})
|
||||
@ -129,20 +129,20 @@ func Test_StrAnyMap_Iterator_Deadlock(t *testing.T) {
|
||||
|
||||
func Test_StrAnyMap_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := map[string]interface{}{"a": true, "b": false}
|
||||
expect := map[string]any{"a": true, "b": false}
|
||||
m := gmap.NewStrAnyMapFrom(expect)
|
||||
m.Iterator(func(k string, v interface{}) bool {
|
||||
m.Iterator(func(k string, v any) bool {
|
||||
t.Assert(expect[k], v)
|
||||
return true
|
||||
})
|
||||
// 断言返回值对遍历控制
|
||||
i := 0
|
||||
j := 0
|
||||
m.Iterator(func(k string, v interface{}) bool {
|
||||
m.Iterator(func(k string, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.Iterator(func(k string, v interface{}) bool {
|
||||
m.Iterator(func(k string, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -153,13 +153,13 @@ func Test_StrAnyMap_Iterator(t *testing.T) {
|
||||
|
||||
func Test_StrAnyMap_Lock(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := map[string]interface{}{"a": true, "b": false}
|
||||
expect := map[string]any{"a": true, "b": false}
|
||||
|
||||
m := gmap.NewStrAnyMapFrom(expect)
|
||||
m.LockFunc(func(m map[string]interface{}) {
|
||||
m.LockFunc(func(m map[string]any) {
|
||||
t.Assert(m, expect)
|
||||
})
|
||||
m.RLockFunc(func(m map[string]interface{}) {
|
||||
m.RLockFunc(func(m map[string]any) {
|
||||
t.Assert(m, expect)
|
||||
})
|
||||
})
|
||||
@ -168,7 +168,7 @@ func Test_StrAnyMap_Lock(t *testing.T) {
|
||||
func Test_StrAnyMap_Clone(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
// clone 方法是深克隆
|
||||
m := gmap.NewStrAnyMapFrom(map[string]interface{}{"a": 1, "b": "2"})
|
||||
m := gmap.NewStrAnyMapFrom(map[string]any{"a": 1, "b": "2"})
|
||||
|
||||
m_clone := m.Clone()
|
||||
m.Remove("a")
|
||||
@ -188,7 +188,7 @@ func Test_StrAnyMap_Merge(t *testing.T) {
|
||||
m1.Set("a", 1)
|
||||
m2.Set("b", "2")
|
||||
m1.Merge(m2)
|
||||
t.Assert(m1.Map(), map[string]interface{}{"a": 1, "b": "2"})
|
||||
t.Assert(m1.Map(), map[string]any{"a": 1, "b": "2"})
|
||||
|
||||
m3 := gmap.NewStrAnyMapFrom(nil)
|
||||
m3.Merge(m2)
|
||||
@ -358,7 +358,7 @@ func TestStrAnyMap_UnmarshalValue(t *testing.T) {
|
||||
// JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": []byte(`{"k1":"v1","k2":"v2"}`),
|
||||
}, &v)
|
||||
@ -371,7 +371,7 @@ func TestStrAnyMap_UnmarshalValue(t *testing.T) {
|
||||
// Map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": g.Map{
|
||||
"k1": "v1",
|
||||
|
||||
@ -363,7 +363,7 @@ func TestStrIntMap_UnmarshalValue(t *testing.T) {
|
||||
// JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": []byte(`{"k1":1,"k2":2}`),
|
||||
}, &v)
|
||||
@ -376,7 +376,7 @@ func TestStrIntMap_UnmarshalValue(t *testing.T) {
|
||||
// Map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": g.Map{
|
||||
"k1": 1,
|
||||
|
||||
@ -362,7 +362,7 @@ func TestStrStrMap_UnmarshalValue(t *testing.T) {
|
||||
// JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": []byte(`{"k1":"v1","k2":"v2"}`),
|
||||
}, &v)
|
||||
@ -375,7 +375,7 @@ func TestStrStrMap_UnmarshalValue(t *testing.T) {
|
||||
// Map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": g.Map{
|
||||
"k1": "v1",
|
||||
|
||||
@ -21,7 +21,7 @@ func Test_ListMap_Var(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var m gmap.ListMap
|
||||
m.Set("key1", "val1")
|
||||
t.Assert(m.Keys(), []interface{}{"key1"})
|
||||
t.Assert(m.Keys(), []any{"key1"})
|
||||
|
||||
t.Assert(m.Get("key1"), "val1")
|
||||
t.Assert(m.Size(), 1)
|
||||
@ -41,7 +41,7 @@ func Test_ListMap_Var(t *testing.T) {
|
||||
|
||||
m.Flip()
|
||||
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"val3": "key3", "val1": "key1"})
|
||||
t.Assert(m.Map(), map[any]any{"val3": "key3", "val1": "key1"})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
@ -53,7 +53,7 @@ func Test_ListMap_Basic(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.NewListMap()
|
||||
m.Set("key1", "val1")
|
||||
t.Assert(m.Keys(), []interface{}{"key1"})
|
||||
t.Assert(m.Keys(), []any{"key1"})
|
||||
|
||||
t.Assert(m.Get("key1"), "val1")
|
||||
t.Assert(m.Size(), 1)
|
||||
@ -73,14 +73,14 @@ func Test_ListMap_Basic(t *testing.T) {
|
||||
|
||||
m.Flip()
|
||||
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"val3": "key3", "val1": "key1"})
|
||||
t.Assert(m.Map(), map[any]any{"val3": "key3", "val1": "key1"})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
t.Assert(m.IsEmpty(), true)
|
||||
|
||||
m2 := gmap.NewListMapFrom(map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m2 := gmap.NewListMapFrom(map[any]any{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[any]any{1: 1, "key1": "val1"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -100,30 +100,30 @@ func Test_ListMap_Set_Fun(t *testing.T) {
|
||||
func Test_ListMap_Batch(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.NewListMap()
|
||||
m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]interface{}{"key1", 1})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
|
||||
m.Sets(map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]any{"key1", 1})
|
||||
t.Assert(m.Map(), map[any]any{"key2": "val2", "key3": "val3"})
|
||||
})
|
||||
}
|
||||
|
||||
func Test_ListMap_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
|
||||
expect := map[any]any{1: 1, "key1": "val1"}
|
||||
|
||||
m := gmap.NewListMapFrom(expect)
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
t.Assert(expect[k], v)
|
||||
return true
|
||||
})
|
||||
// 断言返回值对遍历控制
|
||||
i := 0
|
||||
j := 0
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -135,7 +135,7 @@ func Test_ListMap_Iterator(t *testing.T) {
|
||||
func Test_ListMap_Clone(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
// clone 方法是深克隆
|
||||
m := gmap.NewListMapFrom(map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m := gmap.NewListMapFrom(map[any]any{1: 1, "key1": "val1"})
|
||||
m_clone := m.Clone()
|
||||
m.Remove(1)
|
||||
// 修改原 map,clone 后的 map 不影响
|
||||
@ -154,7 +154,7 @@ func Test_ListMap_Basic_Merge(t *testing.T) {
|
||||
m1.Set("key1", "val1")
|
||||
m2.Set("key2", "val2")
|
||||
m1.Merge(m2)
|
||||
t.Assert(m1.Map(), map[interface{}]interface{}{"key1": "val1", "key2": "val2"})
|
||||
t.Assert(m1.Map(), map[any]any{"key1": "val1", "key2": "val2"})
|
||||
m3 := gmap.NewListMapFrom(nil)
|
||||
m3.Merge(m2)
|
||||
t.Assert(m3.Map(), m2.Map())
|
||||
@ -321,7 +321,7 @@ func TestListMap_UnmarshalValue(t *testing.T) {
|
||||
// JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": []byte(`{"1":"v1","2":"v2"}`),
|
||||
}, &v)
|
||||
@ -334,7 +334,7 @@ func TestListMap_UnmarshalValue(t *testing.T) {
|
||||
// Map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": g.MapIntAny{
|
||||
1: "v1",
|
||||
|
||||
@ -22,7 +22,7 @@ func Test_TreeMap_Var(t *testing.T) {
|
||||
var m gmap.TreeMap
|
||||
m.SetComparator(gutil.ComparatorString)
|
||||
m.Set("key1", "val1")
|
||||
t.Assert(m.Keys(), []interface{}{"key1"})
|
||||
t.Assert(m.Keys(), []any{"key1"})
|
||||
|
||||
t.Assert(m.Get("key1"), "val1")
|
||||
t.Assert(m.Size(), 1)
|
||||
@ -42,7 +42,7 @@ func Test_TreeMap_Var(t *testing.T) {
|
||||
t.AssertIN("val1", m.Values())
|
||||
|
||||
m.Flip()
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"val3": "key3", "val1": "key1"})
|
||||
t.Assert(m.Map(), map[any]any{"val3": "key3", "val1": "key1"})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
@ -54,7 +54,7 @@ func Test_TreeMap_Basic(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.NewTreeMap(gutil.ComparatorString)
|
||||
m.Set("key1", "val1")
|
||||
t.Assert(m.Keys(), []interface{}{"key1"})
|
||||
t.Assert(m.Keys(), []any{"key1"})
|
||||
|
||||
t.Assert(m.Get("key1"), "val1")
|
||||
t.Assert(m.Size(), 1)
|
||||
@ -74,14 +74,14 @@ func Test_TreeMap_Basic(t *testing.T) {
|
||||
t.AssertIN("val1", m.Values())
|
||||
|
||||
m.Flip()
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"val3": "key3", "val1": "key1"})
|
||||
t.Assert(m.Map(), map[any]any{"val3": "key3", "val1": "key1"})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
t.Assert(m.IsEmpty(), true)
|
||||
|
||||
m2 := gmap.NewTreeMapFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m2 := gmap.NewTreeMapFrom(gutil.ComparatorString, map[any]any{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[any]any{1: 1, "key1": "val1"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -101,29 +101,29 @@ func Test_TreeMap_Set_Fun(t *testing.T) {
|
||||
func Test_TreeMap_Batch(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gmap.NewTreeMap(gutil.ComparatorString)
|
||||
m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]interface{}{"key1", 1})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
|
||||
m.Sets(map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]any{"key1", 1})
|
||||
t.Assert(m.Map(), map[any]any{"key2": "val2", "key3": "val3"})
|
||||
})
|
||||
}
|
||||
|
||||
func Test_TreeMap_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
|
||||
expect := map[any]any{1: 1, "key1": "val1"}
|
||||
m := gmap.NewTreeMapFrom(gutil.ComparatorString, expect)
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
t.Assert(expect[k], v)
|
||||
return true
|
||||
})
|
||||
// 断言返回值对遍历控制
|
||||
i := 0
|
||||
j := 0
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -132,17 +132,17 @@ func Test_TreeMap_Iterator(t *testing.T) {
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
|
||||
expect := map[any]any{1: 1, "key1": "val1"}
|
||||
m := gmap.NewTreeMapFrom(gutil.ComparatorString, expect)
|
||||
for i := 0; i < 10; i++ {
|
||||
m.IteratorAsc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorAsc(func(k any, v any) bool {
|
||||
t.Assert(expect[k], v)
|
||||
return true
|
||||
})
|
||||
}
|
||||
j := 0
|
||||
for i := 0; i < 10; i++ {
|
||||
m.IteratorAsc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorAsc(func(k any, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -154,7 +154,7 @@ func Test_TreeMap_Iterator(t *testing.T) {
|
||||
func Test_TreeMap_Clone(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
// clone 方法是深克隆
|
||||
m := gmap.NewTreeMapFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m := gmap.NewTreeMapFrom(gutil.ComparatorString, map[any]any{1: 1, "key1": "val1"})
|
||||
m_clone := m.Clone()
|
||||
m.Remove(1)
|
||||
// 修改原 map,clone 后的 map 不影响
|
||||
@ -218,7 +218,7 @@ func TestTreeMap_UnmarshalValue(t *testing.T) {
|
||||
// JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": []byte(`{"k1":"v1","k2":"v2"}`),
|
||||
}, &v)
|
||||
@ -231,7 +231,7 @@ func TestTreeMap_UnmarshalValue(t *testing.T) {
|
||||
// Map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var v *V
|
||||
err := gconv.Struct(map[string]interface{}{
|
||||
err := gconv.Struct(map[string]any{
|
||||
"name": "john",
|
||||
"map": g.Map{
|
||||
"k1": "v1",
|
||||
|
||||
@ -21,28 +21,28 @@ import (
|
||||
|
||||
// Pool is an Object-Reusable Pool.
|
||||
type Pool struct {
|
||||
list *glist.List // Available/idle items list.
|
||||
closed *gtype.Bool // Whether the pool is closed.
|
||||
TTL time.Duration // Time To Live for pool items.
|
||||
NewFunc func() (interface{}, error) // Callback function to create pool item.
|
||||
list *glist.List // Available/idle items list.
|
||||
closed *gtype.Bool // Whether the pool is closed.
|
||||
TTL time.Duration // Time To Live for pool items.
|
||||
NewFunc func() (any, error) // Callback function to create pool item.
|
||||
// ExpireFunc is the function for expired items destruction.
|
||||
// This function needs to be defined when the pool items
|
||||
// need to perform additional destruction operations.
|
||||
// Eg: net.Conn, os.File, etc.
|
||||
ExpireFunc func(interface{})
|
||||
ExpireFunc func(any)
|
||||
}
|
||||
|
||||
// Pool item.
|
||||
type poolItem struct {
|
||||
value interface{} // Item value.
|
||||
expireAt int64 // Expire timestamp in milliseconds.
|
||||
value any // Item value.
|
||||
expireAt int64 // Expire timestamp in milliseconds.
|
||||
}
|
||||
|
||||
// NewFunc Creation function for object.
|
||||
type NewFunc func() (interface{}, error)
|
||||
type NewFunc func() (any, error)
|
||||
|
||||
// ExpireFunc Destruction function for object.
|
||||
type ExpireFunc func(interface{})
|
||||
type ExpireFunc func(any)
|
||||
|
||||
// New creates and returns a new object pool.
|
||||
// To ensure execution efficiency, the expiration time cannot be modified once it is set.
|
||||
@ -66,7 +66,7 @@ func New(ttl time.Duration, newFunc NewFunc, expireFunc ...ExpireFunc) *Pool {
|
||||
}
|
||||
|
||||
// Put puts an item to pool.
|
||||
func (p *Pool) Put(value interface{}) error {
|
||||
func (p *Pool) Put(value any) error {
|
||||
if p.closed.Val() {
|
||||
return gerror.NewCode(gcode.CodeInvalidOperation, "pool is closed")
|
||||
}
|
||||
@ -85,7 +85,7 @@ func (p *Pool) Put(value interface{}) error {
|
||||
}
|
||||
|
||||
// MustPut puts an item to pool, it panics if any error occurs.
|
||||
func (p *Pool) MustPut(value interface{}) {
|
||||
func (p *Pool) MustPut(value any) {
|
||||
if err := p.Put(value); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
@ -108,7 +108,7 @@ func (p *Pool) Clear() {
|
||||
|
||||
// Get picks and returns an item from pool. If the pool is empty and NewFunc is defined,
|
||||
// it creates and returns one from NewFunc.
|
||||
func (p *Pool) Get() (interface{}, error) {
|
||||
func (p *Pool) Get() (any, error) {
|
||||
for !p.closed.Val() {
|
||||
if r := p.list.PopFront(); r != nil {
|
||||
f := r.(*poolItem)
|
||||
@ -166,10 +166,7 @@ func (p *Pool) checkExpireItems(ctx context.Context) {
|
||||
// by comparing with this timestamp. It is not accurate comparison for
|
||||
// every item expired, but high performance.
|
||||
var timestampMilli = gtime.TimestampMilli()
|
||||
for {
|
||||
if latestExpire > timestampMilli {
|
||||
break
|
||||
}
|
||||
for latestExpire <= timestampMilli {
|
||||
if r := p.list.PopFront(); r != nil {
|
||||
item := r.(*poolItem)
|
||||
latestExpire = item.expireAt
|
||||
|
||||
@ -20,11 +20,11 @@ func ExampleNew() {
|
||||
}
|
||||
|
||||
dbConnPool := gpool.New(time.Hour,
|
||||
func() (interface{}, error) {
|
||||
func() (any, error) {
|
||||
dbConn := new(DBConn)
|
||||
return dbConn, nil
|
||||
},
|
||||
func(i interface{}) {
|
||||
func(i any) {
|
||||
// sample : close db conn
|
||||
// i.(DBConn).Conn.Close()
|
||||
})
|
||||
@ -42,12 +42,12 @@ func ExamplePool_Put() {
|
||||
}
|
||||
|
||||
dbConnPool := gpool.New(time.Hour,
|
||||
func() (interface{}, error) {
|
||||
func() (any, error) {
|
||||
dbConn := new(DBConn)
|
||||
dbConn.Limit = 10
|
||||
return dbConn, nil
|
||||
},
|
||||
func(i interface{}) {
|
||||
func(i any) {
|
||||
// sample : close db conn
|
||||
// i.(DBConn).Conn.Close()
|
||||
})
|
||||
@ -76,12 +76,12 @@ func ExamplePool_Clear() {
|
||||
}
|
||||
|
||||
dbConnPool := gpool.New(time.Hour,
|
||||
func() (interface{}, error) {
|
||||
func() (any, error) {
|
||||
dbConn := new(DBConn)
|
||||
dbConn.Limit = 10
|
||||
return dbConn, nil
|
||||
},
|
||||
func(i interface{}) {
|
||||
func(i any) {
|
||||
i.(*DBConn).Limit = 0
|
||||
// sample : close db conn
|
||||
// i.(DBConn).Conn.Close()
|
||||
@ -106,12 +106,12 @@ func ExamplePool_Get() {
|
||||
}
|
||||
|
||||
dbConnPool := gpool.New(time.Hour,
|
||||
func() (interface{}, error) {
|
||||
func() (any, error) {
|
||||
dbConn := new(DBConn)
|
||||
dbConn.Limit = 10
|
||||
return dbConn, nil
|
||||
},
|
||||
func(i interface{}) {
|
||||
func(i any) {
|
||||
// sample : close db conn
|
||||
// i.(DBConn).Conn.Close()
|
||||
})
|
||||
@ -132,12 +132,12 @@ func ExamplePool_Size() {
|
||||
}
|
||||
|
||||
dbConnPool := gpool.New(time.Hour,
|
||||
func() (interface{}, error) {
|
||||
func() (any, error) {
|
||||
dbConn := new(DBConn)
|
||||
dbConn.Limit = 10
|
||||
return dbConn, nil
|
||||
},
|
||||
func(i interface{}) {
|
||||
func(i any) {
|
||||
// sample : close db conn
|
||||
// i.(DBConn).Conn.Close()
|
||||
})
|
||||
@ -159,12 +159,12 @@ func ExamplePool_Close() {
|
||||
Limit int
|
||||
}
|
||||
var (
|
||||
newFunc = func() (interface{}, error) {
|
||||
newFunc = func() (any, error) {
|
||||
dbConn := new(DBConn)
|
||||
dbConn.Limit = 10
|
||||
return dbConn, nil
|
||||
}
|
||||
closeFunc = func(i interface{}) {
|
||||
closeFunc = func(i any) {
|
||||
fmt.Println("Close The Pool")
|
||||
// sample : close db conn
|
||||
// i.(DBConn).Conn.Close()
|
||||
|
||||
@ -17,13 +17,13 @@ import (
|
||||
"github.com/gogf/gf/v2/test/gtest"
|
||||
)
|
||||
|
||||
var nf gpool.NewFunc = func() (i interface{}, e error) {
|
||||
var nf gpool.NewFunc = func() (i any, e error) {
|
||||
return "hello", nil
|
||||
}
|
||||
|
||||
var assertIndex = gtype.NewInt(0)
|
||||
|
||||
var ef gpool.ExpireFunc = func(i interface{}) {
|
||||
var ef gpool.ExpireFunc = func(i any) {
|
||||
assertIndex.Add(1)
|
||||
gtest.Assert(i, assertIndex)
|
||||
}
|
||||
@ -100,7 +100,7 @@ func Test_Gpool(t *testing.T) {
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
p := gpool.New(time.Millisecond*200, nil, func(i interface{}) {})
|
||||
p := gpool.New(time.Millisecond*200, nil, func(i any) {})
|
||||
p.Put(1)
|
||||
time.Sleep(time.Millisecond * 100)
|
||||
p.Put(2)
|
||||
@ -109,7 +109,7 @@ func Test_Gpool(t *testing.T) {
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := make([]int, 0)
|
||||
p := gpool.New(time.Millisecond*200, nil, func(i interface{}) {
|
||||
p := gpool.New(time.Millisecond*200, nil, func(i any) {
|
||||
s = append(s, i.(int))
|
||||
})
|
||||
for i := 0; i < 5; i++ {
|
||||
|
||||
@ -26,11 +26,11 @@ import (
|
||||
|
||||
// Queue is a concurrent-safe queue built on doubly linked list and channel.
|
||||
type Queue struct {
|
||||
limit int // Limit for queue size.
|
||||
list *glist.List // Underlying list structure for data maintaining.
|
||||
closed *gtype.Bool // Whether queue is closed.
|
||||
events chan struct{} // Events for data writing.
|
||||
C chan interface{} // Underlying channel for data reading.
|
||||
limit int // Limit for queue size.
|
||||
list *glist.List // Underlying list structure for data maintaining.
|
||||
closed *gtype.Bool // Whether queue is closed.
|
||||
events chan struct{} // Events for data writing.
|
||||
C chan any // Underlying channel for data reading.
|
||||
}
|
||||
|
||||
const (
|
||||
@ -47,11 +47,11 @@ func New(limit ...int) *Queue {
|
||||
}
|
||||
if len(limit) > 0 && limit[0] > 0 {
|
||||
q.limit = limit[0]
|
||||
q.C = make(chan interface{}, limit[0])
|
||||
q.C = make(chan any, limit[0])
|
||||
} else {
|
||||
q.list = glist.New(true)
|
||||
q.events = make(chan struct{}, math.MaxInt32)
|
||||
q.C = make(chan interface{}, defaultQueueSize)
|
||||
q.C = make(chan any, defaultQueueSize)
|
||||
go q.asyncLoopFromListToChannel()
|
||||
}
|
||||
return q
|
||||
@ -59,7 +59,7 @@ func New(limit ...int) *Queue {
|
||||
|
||||
// Push pushes the data `v` into the queue.
|
||||
// Note that it would panic if Push is called after the queue is closed.
|
||||
func (q *Queue) Push(v interface{}) {
|
||||
func (q *Queue) Push(v any) {
|
||||
if q.limit > 0 {
|
||||
q.C <- v
|
||||
} else {
|
||||
@ -72,7 +72,7 @@ func (q *Queue) Push(v interface{}) {
|
||||
|
||||
// Pop pops an item from the queue in FIFO way.
|
||||
// Note that it would return nil immediately if Pop is called after the queue is closed.
|
||||
func (q *Queue) Pop() interface{} {
|
||||
func (q *Queue) Pop() any {
|
||||
return <-q.C
|
||||
}
|
||||
|
||||
|
||||
@ -22,7 +22,7 @@ var qstatic = gqueue.New(length)
|
||||
|
||||
var qdynamic = gqueue.New()
|
||||
|
||||
var cany = make(chan interface{}, length)
|
||||
var cany = make(chan any, length)
|
||||
|
||||
func Benchmark_Gqueue_StaticPushAndPop(b *testing.B) {
|
||||
b.N = bn
|
||||
|
||||
@ -29,7 +29,7 @@ type Ring struct {
|
||||
|
||||
// internalRingItem stores the ring element value.
|
||||
type internalRingItem struct {
|
||||
Value interface{}
|
||||
Value any
|
||||
}
|
||||
|
||||
// New creates and returns a Ring structure of `cap` elements.
|
||||
@ -48,8 +48,8 @@ func New(cap int, safe ...bool) *Ring {
|
||||
}
|
||||
|
||||
// Val returns the item's value of current position.
|
||||
func (r *Ring) Val() interface{} {
|
||||
var value interface{}
|
||||
func (r *Ring) Val() any {
|
||||
var value any
|
||||
r.mu.RLock()
|
||||
if r.ring.Value != nil {
|
||||
value = r.ring.Value.(internalRingItem).Value
|
||||
@ -97,7 +97,7 @@ func (r *Ring) checkAndUpdateLenAndCap() {
|
||||
}
|
||||
|
||||
// Set sets value to the item of current position.
|
||||
func (r *Ring) Set(value interface{}) *Ring {
|
||||
func (r *Ring) Set(value any) *Ring {
|
||||
r.mu.Lock()
|
||||
if r.ring.Value == nil {
|
||||
r.len.Add(1)
|
||||
@ -108,7 +108,7 @@ func (r *Ring) Set(value interface{}) *Ring {
|
||||
}
|
||||
|
||||
// Put sets `value` to current item of ring and moves position to next item.
|
||||
func (r *Ring) Put(value interface{}) *Ring {
|
||||
func (r *Ring) Put(value any) *Ring {
|
||||
r.mu.Lock()
|
||||
if r.ring.Value == nil {
|
||||
r.len.Add(1)
|
||||
@ -187,7 +187,7 @@ func (r *Ring) Unlink(n int) *Ring {
|
||||
// RLockIteratorNext iterates and locks reading forward
|
||||
// with given callback function `f` within RWMutex.RLock.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
func (r *Ring) RLockIteratorNext(f func(value interface{}) bool) {
|
||||
func (r *Ring) RLockIteratorNext(f func(value any) bool) {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
if r.ring.Value != nil && !f(r.ring.Value.(internalRingItem).Value) {
|
||||
@ -203,7 +203,7 @@ func (r *Ring) RLockIteratorNext(f func(value interface{}) bool) {
|
||||
// RLockIteratorPrev iterates and locks writing backward
|
||||
// with given callback function `f` within RWMutex.RLock.
|
||||
// If `f` returns true, then it continues iterating; or false to stop.
|
||||
func (r *Ring) RLockIteratorPrev(f func(value interface{}) bool) {
|
||||
func (r *Ring) RLockIteratorPrev(f func(value any) bool) {
|
||||
r.mu.RLock()
|
||||
defer r.mu.RUnlock()
|
||||
if r.ring.Value != nil && !f(r.ring.Value.(internalRingItem).Value) {
|
||||
@ -217,8 +217,8 @@ func (r *Ring) RLockIteratorPrev(f func(value interface{}) bool) {
|
||||
}
|
||||
|
||||
// SliceNext returns a copy of all item values as slice forward from current position.
|
||||
func (r *Ring) SliceNext() []interface{} {
|
||||
s := make([]interface{}, 0)
|
||||
func (r *Ring) SliceNext() []any {
|
||||
s := make([]any, 0)
|
||||
r.mu.RLock()
|
||||
if r.ring.Value != nil {
|
||||
s = append(s, r.ring.Value.(internalRingItem).Value)
|
||||
@ -234,8 +234,8 @@ func (r *Ring) SliceNext() []interface{} {
|
||||
}
|
||||
|
||||
// SlicePrev returns a copy of all item values as slice backward from current position.
|
||||
func (r *Ring) SlicePrev() []interface{} {
|
||||
s := make([]interface{}, 0)
|
||||
func (r *Ring) SlicePrev() []any {
|
||||
s := make([]any, 0)
|
||||
r.mu.RLock()
|
||||
if r.ring.Value != nil {
|
||||
s = append(s, r.ring.Value.(internalRingItem).Value)
|
||||
|
||||
@ -222,7 +222,7 @@ func ExampleRing_RLockIteratorNext() {
|
||||
r.Set(i).Next()
|
||||
}
|
||||
|
||||
r.RLockIteratorNext(func(value interface{}) bool {
|
||||
r.RLockIteratorNext(func(value any) bool {
|
||||
if value.(int) < 5 {
|
||||
fmt.Println("IteratorNext Success, Value:", value)
|
||||
return true
|
||||
@ -248,7 +248,7 @@ func ExampleRing_RLockIteratorPrev() {
|
||||
// move r to pos 9
|
||||
r.Prev()
|
||||
|
||||
r.RLockIteratorPrev(func(value interface{}) bool {
|
||||
r.RLockIteratorPrev(func(value any) bool {
|
||||
if value.(int) >= 5 {
|
||||
fmt.Println("IteratorPrev Success, Value:", value)
|
||||
return true
|
||||
|
||||
@ -193,7 +193,7 @@ func TestRing_RLockIteratorNext(t *testing.T) {
|
||||
}
|
||||
|
||||
iterVal := 0
|
||||
r.RLockIteratorNext(func(value interface{}) bool {
|
||||
r.RLockIteratorNext(func(value any) bool {
|
||||
if value.(int) == 0 {
|
||||
iterVal = value.(int)
|
||||
return false
|
||||
@ -213,7 +213,7 @@ func TestRing_RLockIteratorPrev(t *testing.T) {
|
||||
}
|
||||
|
||||
iterVal := 0
|
||||
r.RLockIteratorPrev(func(value interface{}) bool {
|
||||
r.RLockIteratorPrev(func(value any) bool {
|
||||
if value.(int) == 0 {
|
||||
iterVal = value.(int)
|
||||
return false
|
||||
|
||||
@ -16,10 +16,10 @@ import (
|
||||
"github.com/gogf/gf/v2/util/gconv"
|
||||
)
|
||||
|
||||
// Set is consisted of interface{} items.
|
||||
// Set is consisted of any items.
|
||||
type Set struct {
|
||||
mu rwmutex.RWMutex
|
||||
data map[interface{}]struct{}
|
||||
data map[any]struct{}
|
||||
}
|
||||
|
||||
// New create and returns a new set, which contains un-repeated items.
|
||||
@ -33,15 +33,15 @@ func New(safe ...bool) *Set {
|
||||
// Also see New.
|
||||
func NewSet(safe ...bool) *Set {
|
||||
return &Set{
|
||||
data: make(map[interface{}]struct{}),
|
||||
data: make(map[any]struct{}),
|
||||
mu: rwmutex.Create(safe...),
|
||||
}
|
||||
}
|
||||
|
||||
// NewFrom returns a new set from `items`.
|
||||
// Parameter `items` can be either a variable of any type, or a slice.
|
||||
func NewFrom(items interface{}, safe ...bool) *Set {
|
||||
m := make(map[interface{}]struct{})
|
||||
func NewFrom(items any, safe ...bool) *Set {
|
||||
m := make(map[any]struct{})
|
||||
for _, v := range gconv.Interfaces(items) {
|
||||
m[v] = struct{}{}
|
||||
}
|
||||
@ -53,7 +53,7 @@ func NewFrom(items interface{}, safe ...bool) *Set {
|
||||
|
||||
// Iterator iterates the set readonly with given callback function `f`,
|
||||
// if `f` returns true then continue iterating; or false to stop.
|
||||
func (set *Set) Iterator(f func(v interface{}) bool) {
|
||||
func (set *Set) Iterator(f func(v any) bool) {
|
||||
for _, k := range set.Slice() {
|
||||
if !f(k) {
|
||||
break
|
||||
@ -62,10 +62,10 @@ func (set *Set) Iterator(f func(v interface{}) bool) {
|
||||
}
|
||||
|
||||
// Add adds one or multiple items to the set.
|
||||
func (set *Set) Add(items ...interface{}) {
|
||||
func (set *Set) Add(items ...any) {
|
||||
set.mu.Lock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[interface{}]struct{})
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
for _, v := range items {
|
||||
set.data[v] = struct{}{}
|
||||
@ -78,7 +78,7 @@ func (set *Set) Add(items ...interface{}) {
|
||||
// or else it does nothing and returns false.
|
||||
//
|
||||
// Note that, if `item` is nil, it does nothing and returns false.
|
||||
func (set *Set) AddIfNotExist(item interface{}) bool {
|
||||
func (set *Set) AddIfNotExist(item any) bool {
|
||||
if item == nil {
|
||||
return false
|
||||
}
|
||||
@ -86,7 +86,7 @@ func (set *Set) AddIfNotExist(item interface{}) bool {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[interface{}]struct{})
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
@ -102,7 +102,7 @@ func (set *Set) AddIfNotExist(item interface{}) bool {
|
||||
//
|
||||
// Note that, if `item` is nil, it does nothing and returns false. The function `f`
|
||||
// is executed without writing lock.
|
||||
func (set *Set) AddIfNotExistFunc(item interface{}, f func() bool) bool {
|
||||
func (set *Set) AddIfNotExistFunc(item any, f func() bool) bool {
|
||||
if item == nil {
|
||||
return false
|
||||
}
|
||||
@ -111,7 +111,7 @@ func (set *Set) AddIfNotExistFunc(item interface{}, f func() bool) bool {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[interface{}]struct{})
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
@ -128,7 +128,7 @@ func (set *Set) AddIfNotExistFunc(item interface{}, f func() bool) bool {
|
||||
//
|
||||
// Note that, if `item` is nil, it does nothing and returns false. The function `f`
|
||||
// is executed within writing lock.
|
||||
func (set *Set) AddIfNotExistFuncLock(item interface{}, f func() bool) bool {
|
||||
func (set *Set) AddIfNotExistFuncLock(item any, f func() bool) bool {
|
||||
if item == nil {
|
||||
return false
|
||||
}
|
||||
@ -136,7 +136,7 @@ func (set *Set) AddIfNotExistFuncLock(item interface{}, f func() bool) bool {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[interface{}]struct{})
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
if f() {
|
||||
if _, ok := set.data[item]; !ok {
|
||||
@ -149,7 +149,7 @@ func (set *Set) AddIfNotExistFuncLock(item interface{}, f func() bool) bool {
|
||||
}
|
||||
|
||||
// Contains checks whether the set contains `item`.
|
||||
func (set *Set) Contains(item interface{}) bool {
|
||||
func (set *Set) Contains(item any) bool {
|
||||
var ok bool
|
||||
set.mu.RLock()
|
||||
if set.data != nil {
|
||||
@ -160,7 +160,7 @@ func (set *Set) Contains(item interface{}) bool {
|
||||
}
|
||||
|
||||
// Remove deletes `item` from set.
|
||||
func (set *Set) Remove(item interface{}) {
|
||||
func (set *Set) Remove(item any) {
|
||||
set.mu.Lock()
|
||||
if set.data != nil {
|
||||
delete(set.data, item)
|
||||
@ -179,16 +179,16 @@ func (set *Set) Size() int {
|
||||
// Clear deletes all items of the set.
|
||||
func (set *Set) Clear() {
|
||||
set.mu.Lock()
|
||||
set.data = make(map[interface{}]struct{})
|
||||
set.data = make(map[any]struct{})
|
||||
set.mu.Unlock()
|
||||
}
|
||||
|
||||
// Slice returns all items of the set as slice.
|
||||
func (set *Set) Slice() []interface{} {
|
||||
func (set *Set) Slice() []any {
|
||||
set.mu.RLock()
|
||||
var (
|
||||
i = 0
|
||||
ret = make([]interface{}, len(set.data))
|
||||
ret = make([]any, len(set.data))
|
||||
)
|
||||
for item := range set.data {
|
||||
ret[i] = item
|
||||
@ -251,14 +251,14 @@ func (set *Set) String() string {
|
||||
}
|
||||
|
||||
// LockFunc locks writing with callback function `f`.
|
||||
func (set *Set) LockFunc(f func(m map[interface{}]struct{})) {
|
||||
func (set *Set) LockFunc(f func(m map[any]struct{})) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
f(set.data)
|
||||
}
|
||||
|
||||
// RLockFunc locks reading with callback function `f`.
|
||||
func (set *Set) RLockFunc(f func(m map[interface{}]struct{})) {
|
||||
func (set *Set) RLockFunc(f func(m map[any]struct{})) {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
f(set.data)
|
||||
@ -422,7 +422,7 @@ func (set *Set) Sum() (sum int) {
|
||||
}
|
||||
|
||||
// Pop randomly pops an item from set.
|
||||
func (set *Set) Pop() interface{} {
|
||||
func (set *Set) Pop() any {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
for k := range set.data {
|
||||
@ -434,7 +434,7 @@ func (set *Set) Pop() interface{} {
|
||||
|
||||
// Pops randomly pops `size` items from set.
|
||||
// It returns all items if size == -1.
|
||||
func (set *Set) Pops(size int) []interface{} {
|
||||
func (set *Set) Pops(size int) []any {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if size > len(set.data) || size == -1 {
|
||||
@ -444,7 +444,7 @@ func (set *Set) Pops(size int) []interface{} {
|
||||
return nil
|
||||
}
|
||||
index := 0
|
||||
array := make([]interface{}, size)
|
||||
array := make([]any, size)
|
||||
for k := range set.data {
|
||||
delete(set.data, k)
|
||||
array[index] = k
|
||||
@ -457,10 +457,10 @@ func (set *Set) Pops(size int) []interface{} {
|
||||
}
|
||||
|
||||
// Walk applies a user supplied function `f` to every item of set.
|
||||
func (set *Set) Walk(f func(item interface{}) interface{}) *Set {
|
||||
func (set *Set) Walk(f func(item any) any) *Set {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
m := make(map[interface{}]struct{}, len(set.data))
|
||||
m := make(map[any]struct{}, len(set.data))
|
||||
for k, v := range set.data {
|
||||
m[f(k)] = v
|
||||
}
|
||||
@ -478,9 +478,9 @@ func (set *Set) UnmarshalJSON(b []byte) error {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[interface{}]struct{})
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
var array []interface{}
|
||||
var array []any
|
||||
if err := json.UnmarshalUseNumber(b, &array); err != nil {
|
||||
return err
|
||||
}
|
||||
@ -491,13 +491,13 @@ func (set *Set) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for set.
|
||||
func (set *Set) UnmarshalValue(value interface{}) (err error) {
|
||||
func (set *Set) UnmarshalValue(value any) (err error) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[interface{}]struct{})
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
var array []interface{}
|
||||
var array []any
|
||||
switch value.(type) {
|
||||
case string, []byte:
|
||||
err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
|
||||
@ -511,13 +511,13 @@ func (set *Set) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (set *Set) DeepCopy() interface{} {
|
||||
func (set *Set) DeepCopy() any {
|
||||
if set == nil {
|
||||
return nil
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
data := make([]interface{}, 0)
|
||||
data := make([]any, 0)
|
||||
for k := range set.data {
|
||||
data = append(data, k)
|
||||
}
|
||||
|
||||
@ -450,7 +450,7 @@ func (set *IntSet) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for set.
|
||||
func (set *IntSet) UnmarshalValue(value interface{}) (err error) {
|
||||
func (set *IntSet) UnmarshalValue(value any) (err error) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
@ -470,7 +470,7 @@ func (set *IntSet) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (set *IntSet) DeepCopy() interface{} {
|
||||
func (set *IntSet) DeepCopy() any {
|
||||
if set == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -480,7 +480,7 @@ func (set *StrSet) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for set.
|
||||
func (set *StrSet) UnmarshalValue(value interface{}) (err error) {
|
||||
func (set *StrSet) UnmarshalValue(value any) (err error) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
@ -500,7 +500,7 @@ func (set *StrSet) UnmarshalValue(value interface{}) (err error) {
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (set *StrSet) DeepCopy() interface{} {
|
||||
func (set *StrSet) DeepCopy() any {
|
||||
if set == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
@ -26,7 +26,7 @@ func TestSet_Var(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var s gset.Set
|
||||
s.Add(1, 1, 2)
|
||||
s.Add([]interface{}{3, 4}...)
|
||||
s.Add([]any{3, 4}...)
|
||||
t.Assert(s.Size(), 4)
|
||||
t.AssertIN(1, s.Slice())
|
||||
t.AssertIN(2, s.Slice())
|
||||
@ -46,7 +46,7 @@ func TestSet_New(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.New()
|
||||
s.Add(1, 1, 2)
|
||||
s.Add([]interface{}{3, 4}...)
|
||||
s.Add([]any{3, 4}...)
|
||||
t.Assert(s.Size(), 4)
|
||||
t.AssertIN(1, s.Slice())
|
||||
t.AssertIN(2, s.Slice())
|
||||
@ -66,7 +66,7 @@ func TestSet_Basic(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewSet()
|
||||
s.Add(1, 1, 2)
|
||||
s.Add([]interface{}{3, 4}...)
|
||||
s.Add([]any{3, 4}...)
|
||||
t.Assert(s.Size(), 4)
|
||||
t.AssertIN(1, s.Slice())
|
||||
t.AssertIN(2, s.Slice())
|
||||
@ -84,8 +84,8 @@ func TestSet_Basic(t *testing.T) {
|
||||
|
||||
func TestSet_Iterator_Deadlock(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
set := gset.NewFrom([]interface{}{1, 2, 3, 4, 5}, true)
|
||||
set.Iterator(func(k interface{}) bool {
|
||||
set := gset.NewFrom([]any{1, 2, 3, 4, 5}, true)
|
||||
set.Iterator(func(k any) bool {
|
||||
if gconv.Int(k)%2 == 0 {
|
||||
set.Remove(k)
|
||||
}
|
||||
@ -107,11 +107,11 @@ func TestSet_Iterator(t *testing.T) {
|
||||
|
||||
a1 := garray.New(true)
|
||||
a2 := garray.New(true)
|
||||
s.Iterator(func(v interface{}) bool {
|
||||
s.Iterator(func(v any) bool {
|
||||
a1.Append(1)
|
||||
return false
|
||||
})
|
||||
s.Iterator(func(v interface{}) bool {
|
||||
s.Iterator(func(v any) bool {
|
||||
a2.Append(1)
|
||||
return true
|
||||
})
|
||||
@ -125,12 +125,12 @@ func TestSet_LockFunc(t *testing.T) {
|
||||
s := gset.NewSet()
|
||||
s.Add(1, 2, 3)
|
||||
t.Assert(s.Size(), 3)
|
||||
s.LockFunc(func(m map[interface{}]struct{}) {
|
||||
s.LockFunc(func(m map[any]struct{}) {
|
||||
delete(m, 1)
|
||||
})
|
||||
t.Assert(s.Size(), 2)
|
||||
s.RLockFunc(func(m map[interface{}]struct{}) {
|
||||
t.Assert(m, map[interface{}]struct{}{
|
||||
s.RLockFunc(func(m map[any]struct{}) {
|
||||
t.Assert(m, map[any]struct{}{
|
||||
3: {},
|
||||
2: {},
|
||||
})
|
||||
@ -352,7 +352,7 @@ func TestSet_Pops(t *testing.T) {
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.New(true)
|
||||
a := []interface{}{1, 2, 3, 4}
|
||||
a := []any{1, 2, 3, 4}
|
||||
s.Add(a...)
|
||||
t.Assert(s.Size(), 4)
|
||||
t.Assert(s.Pops(-2), nil)
|
||||
@ -362,7 +362,7 @@ func TestSet_Pops(t *testing.T) {
|
||||
|
||||
func TestSet_Json(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := []interface{}{"a", "b", "d", "c"}
|
||||
s1 := []any{"a", "b", "d", "c"}
|
||||
a1 := gset.NewFrom(s1)
|
||||
b1, err1 := json.Marshal(a1)
|
||||
b2, err2 := json.Marshal(s1)
|
||||
@ -442,7 +442,7 @@ func TestSet_Walk(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var set gset.Set
|
||||
set.Add(g.Slice{1, 2}...)
|
||||
set.Walk(func(item interface{}) interface{} {
|
||||
set.Walk(func(item any) any {
|
||||
return gconv.Int(item) + 10
|
||||
})
|
||||
t.Assert(set.Size(), 2)
|
||||
|
||||
@ -14,77 +14,77 @@ import "github.com/gogf/gf/v2/container/gvar"
|
||||
// iTree defines the interface for basic operations of a tree.
|
||||
type iTree interface {
|
||||
// Set sets key-value pair into the tree.
|
||||
Set(key interface{}, value interface{})
|
||||
Set(key any, value any)
|
||||
|
||||
// Sets batch sets key-values to the tree.
|
||||
Sets(data map[interface{}]interface{})
|
||||
Sets(data map[any]any)
|
||||
|
||||
// SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
|
||||
// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
|
||||
SetIfNotExist(key interface{}, value interface{}) bool
|
||||
SetIfNotExist(key any, value any) bool
|
||||
|
||||
// SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
|
||||
// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
|
||||
SetIfNotExistFunc(key interface{}, f func() interface{}) bool
|
||||
SetIfNotExistFunc(key any, f func() any) bool
|
||||
|
||||
// SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
|
||||
// It returns false if `key` exists, and such setting key-value pair operation would be ignored.
|
||||
//
|
||||
// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
|
||||
// it executes function `f` within mutex.Lock of the hash map.
|
||||
SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool
|
||||
SetIfNotExistFuncLock(key any, f func() any) bool
|
||||
|
||||
// Get searches the `key` in the tree and returns its associated `value` or nil if key is not found in tree.
|
||||
//
|
||||
// Note that, the `nil` value from Get function cannot be used to determine key existence, please use Contains
|
||||
// function to do so.
|
||||
Get(key interface{}) (value interface{})
|
||||
Get(key any) (value any)
|
||||
|
||||
// GetOrSet returns its `value` of `key`, or sets value with given `value` if it does not exist and then returns
|
||||
// this value.
|
||||
GetOrSet(key interface{}, value interface{}) interface{}
|
||||
GetOrSet(key any, value any) any
|
||||
|
||||
// GetOrSetFunc returns its `value` of `key`, or sets value with returned value of callback function `f` if it does
|
||||
// not exist and then returns this value.
|
||||
GetOrSetFunc(key interface{}, f func() interface{}) interface{}
|
||||
GetOrSetFunc(key any, f func() any) any
|
||||
|
||||
// GetOrSetFuncLock returns its `value` of `key`, or sets value with returned value of callback function `f` if it
|
||||
// does not exist and then returns this value.
|
||||
//
|
||||
// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f` within mutex.Lock of the
|
||||
// hash map.
|
||||
GetOrSetFuncLock(key interface{}, f func() interface{}) interface{}
|
||||
GetOrSetFuncLock(key any, f func() any) any
|
||||
|
||||
// GetVar returns a gvar.Var with the value by given `key`.
|
||||
// Note that, the returned gvar.Var is un-concurrent safe.
|
||||
//
|
||||
// Also see function Get.
|
||||
GetVar(key interface{}) *gvar.Var
|
||||
GetVar(key any) *gvar.Var
|
||||
|
||||
// GetVarOrSet returns a gvar.Var with result from GetVarOrSet.
|
||||
// Note that, the returned gvar.Var is un-concurrent safe.
|
||||
//
|
||||
// Also see function GetOrSet.
|
||||
GetVarOrSet(key interface{}, value interface{}) *gvar.Var
|
||||
GetVarOrSet(key any, value any) *gvar.Var
|
||||
|
||||
// GetVarOrSetFunc returns a gvar.Var with result from GetOrSetFunc.
|
||||
// Note that, the returned gvar.Var is un-concurrent safe.
|
||||
//
|
||||
// Also see function GetOrSetFunc.
|
||||
GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var
|
||||
GetVarOrSetFunc(key any, f func() any) *gvar.Var
|
||||
|
||||
// GetVarOrSetFuncLock returns a gvar.Var with result from GetOrSetFuncLock.
|
||||
// Note that, the returned gvar.Var is un-concurrent safe.
|
||||
//
|
||||
// Also see function GetOrSetFuncLock.
|
||||
GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var
|
||||
GetVarOrSetFuncLock(key any, f func() any) *gvar.Var
|
||||
|
||||
// Search searches the tree with given `key`.
|
||||
// Second return parameter `found` is true if key was found, otherwise false.
|
||||
Search(key interface{}) (value interface{}, found bool)
|
||||
Search(key any) (value any, found bool)
|
||||
|
||||
// Contains checks and returns whether given `key` exists in the tree.
|
||||
Contains(key interface{}) bool
|
||||
Contains(key any) bool
|
||||
|
||||
// Size returns number of nodes in the tree.
|
||||
Size() int
|
||||
@ -94,22 +94,22 @@ type iTree interface {
|
||||
|
||||
// Remove removes the node from the tree by `key`, and returns its associated value of `key`.
|
||||
// The given `key` should adhere to the comparator's type assertion, otherwise method panics.
|
||||
Remove(key interface{}) (value interface{})
|
||||
Remove(key any) (value any)
|
||||
|
||||
// Removes batch deletes key-value pairs from the tree by `keys`.
|
||||
Removes(keys []interface{})
|
||||
Removes(keys []any)
|
||||
|
||||
// Clear removes all nodes from the tree.
|
||||
Clear()
|
||||
|
||||
// Keys returns all keys from the tree in order by its comparator.
|
||||
Keys() []interface{}
|
||||
Keys() []any
|
||||
|
||||
// Values returns all values from the true in order by its comparator based on the key.
|
||||
Values() []interface{}
|
||||
Values() []any
|
||||
|
||||
// Replace clears the data of the tree and sets the nodes by given `data`.
|
||||
Replace(data map[interface{}]interface{})
|
||||
Replace(data map[any]any)
|
||||
|
||||
// Print prints the tree to stdout.
|
||||
Print()
|
||||
@ -121,24 +121,24 @@ type iTree interface {
|
||||
MarshalJSON() (jsonBytes []byte, err error)
|
||||
|
||||
// Map returns all key-value pairs as map.
|
||||
Map() map[interface{}]interface{}
|
||||
Map() map[any]any
|
||||
|
||||
// MapStrAny returns all key-value items as map[string]any.
|
||||
MapStrAny() map[string]interface{}
|
||||
MapStrAny() map[string]any
|
||||
|
||||
// Iterator is alias of IteratorAsc.
|
||||
//
|
||||
// Also see IteratorAsc.
|
||||
Iterator(f func(key, value interface{}) bool)
|
||||
Iterator(f func(key, value any) bool)
|
||||
|
||||
// IteratorFrom is alias of IteratorAscFrom.
|
||||
//
|
||||
// Also see IteratorAscFrom.
|
||||
IteratorFrom(key interface{}, match bool, f func(key, value interface{}) bool)
|
||||
IteratorFrom(key any, match bool, f func(key, value any) bool)
|
||||
|
||||
// IteratorAsc iterates the tree readonly in ascending order with given callback function `f`.
|
||||
// If callback function `f` returns true, then it continues iterating; or false to stop.
|
||||
IteratorAsc(f func(key, value interface{}) bool)
|
||||
IteratorAsc(f func(key, value any) bool)
|
||||
|
||||
// IteratorAscFrom iterates the tree readonly in ascending order with given callback function `f`.
|
||||
//
|
||||
@ -146,12 +146,12 @@ type iTree interface {
|
||||
// The parameter `match` specifies whether starting iterating only if the `key` is fully matched, or else using
|
||||
// index searching iterating.
|
||||
// If callback function `f` returns true, then it continues iterating; or false to stop.
|
||||
IteratorAscFrom(key interface{}, match bool, f func(key, value interface{}) bool)
|
||||
IteratorAscFrom(key any, match bool, f func(key, value any) bool)
|
||||
|
||||
// IteratorDesc iterates the tree readonly in descending order with given callback function `f`.
|
||||
//
|
||||
// If callback function `f` returns true, then it continues iterating; or false to stop.
|
||||
IteratorDesc(f func(key, value interface{}) bool)
|
||||
IteratorDesc(f func(key, value any) bool)
|
||||
|
||||
// IteratorDescFrom iterates the tree readonly in descending order with given callback function `f`.
|
||||
//
|
||||
@ -159,7 +159,7 @@ type iTree interface {
|
||||
// The parameter `match` specifies whether starting iterating only if the `key` is fully matched, or else using
|
||||
// index searching iterating.
|
||||
// If callback function `f` returns true, then it continues iterating; or false to stop.
|
||||
IteratorDescFrom(key interface{}, match bool, f func(key, value interface{}) bool)
|
||||
IteratorDescFrom(key any, match bool, f func(key, value any) bool)
|
||||
}
|
||||
|
||||
// iteratorFromGetIndex returns the index of the key in the keys slice.
|
||||
|
||||
@ -20,7 +20,7 @@ func Test_AVLTree_Basic(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gtree.NewAVLTree(gutil.ComparatorString)
|
||||
m.Set("key1", "val1")
|
||||
t.Assert(m.Keys(), []interface{}{"key1"})
|
||||
t.Assert(m.Keys(), []any{"key1"})
|
||||
|
||||
t.Assert(m.Get("key1"), "val1")
|
||||
t.Assert(m.Size(), 1)
|
||||
@ -40,20 +40,20 @@ func Test_AVLTree_Basic(t *testing.T) {
|
||||
t.AssertIN("val3", m.Values())
|
||||
t.AssertIN("val1", m.Values())
|
||||
|
||||
m.Sets(map[interface{}]interface{}{"key3": "val3", "key1": "val1"})
|
||||
m.Sets(map[any]any{"key3": "val3", "key1": "val1"})
|
||||
|
||||
m.Flip()
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"val3": "key3", "val1": "key1"})
|
||||
t.Assert(m.Map(), map[any]any{"val3": "key3", "val1": "key1"})
|
||||
|
||||
m.Flip(gutil.ComparatorString)
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"key3": "val3", "key1": "val1"})
|
||||
t.Assert(m.Map(), map[any]any{"key3": "val3", "key1": "val1"})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
t.Assert(m.IsEmpty(), true)
|
||||
|
||||
m2 := gtree.NewAVLTreeFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m2 := gtree.NewAVLTreeFrom(gutil.ComparatorString, map[any]any{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[any]any{1: 1, "key1": "val1"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -102,10 +102,10 @@ func Test_AVLTree_Get_Set_Var(t *testing.T) {
|
||||
func Test_AVLTree_Batch(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gtree.NewAVLTree(gutil.ComparatorString)
|
||||
m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]interface{}{"key1", 1})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
|
||||
m.Sets(map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]any{"key1", 1})
|
||||
t.Assert(m.Map(), map[any]any{"key2": "val2", "key3": "val3"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -115,19 +115,19 @@ func Test_AVLTree_Iterator(t *testing.T) {
|
||||
keyLen := len(keys)
|
||||
index := 0
|
||||
|
||||
expect := map[interface{}]interface{}{"key4": "val4", 1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
expect := map[any]any{"key4": "val4", 1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
|
||||
m := gtree.NewAVLTreeFrom(gutil.ComparatorString, expect)
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
t.Assert(k, keys[index])
|
||||
index++
|
||||
t.Assert(expect[k], v)
|
||||
return true
|
||||
})
|
||||
|
||||
m.IteratorDesc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorDesc(func(k any, v any) bool {
|
||||
index--
|
||||
t.Assert(k, keys[index])
|
||||
t.Assert(expect[k], v)
|
||||
@ -140,11 +140,11 @@ func Test_AVLTree_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
i := 0
|
||||
j := 0
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -155,11 +155,11 @@ func Test_AVLTree_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
i := 0
|
||||
j := 0
|
||||
m.IteratorDesc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorDesc(func(k any, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.IteratorDesc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorDesc(func(k any, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -170,7 +170,7 @@ func Test_AVLTree_Iterator(t *testing.T) {
|
||||
}
|
||||
|
||||
func Test_AVLTree_IteratorFrom(t *testing.T) {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 10; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
@ -178,7 +178,7 @@ func Test_AVLTree_IteratorFrom(t *testing.T) {
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
n := 5
|
||||
tree.IteratorFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorFrom(5, true, func(key, value any) bool {
|
||||
t.Assert(n, key)
|
||||
t.Assert(n*10, value)
|
||||
n++
|
||||
@ -186,7 +186,7 @@ func Test_AVLTree_IteratorFrom(t *testing.T) {
|
||||
})
|
||||
|
||||
i := 5
|
||||
tree.IteratorAscFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(5, true, func(key, value any) bool {
|
||||
t.Assert(i, key)
|
||||
t.Assert(i*10, value)
|
||||
i++
|
||||
@ -194,7 +194,7 @@ func Test_AVLTree_IteratorFrom(t *testing.T) {
|
||||
})
|
||||
|
||||
j := 5
|
||||
tree.IteratorDescFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorDescFrom(5, true, func(key, value any) bool {
|
||||
t.Assert(j, key)
|
||||
t.Assert(j*10, value)
|
||||
j--
|
||||
@ -206,7 +206,7 @@ func Test_AVLTree_IteratorFrom(t *testing.T) {
|
||||
func Test_AVLTree_Clone(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
//clone 方法是深克隆
|
||||
m := gtree.NewAVLTreeFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m := gtree.NewAVLTreeFrom(gutil.ComparatorString, map[any]any{1: 1, "key1": "val1"})
|
||||
m_clone := m.Clone()
|
||||
m.Remove(1)
|
||||
//修改原 map,clone 后的 map 不影响
|
||||
@ -219,7 +219,7 @@ func Test_AVLTree_Clone(t *testing.T) {
|
||||
}
|
||||
|
||||
func Test_AVLTree_LRNode(t *testing.T) {
|
||||
expect := map[interface{}]interface{}{"key4": "val4", "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
expect := map[any]any{"key4": "val4", "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
//safe
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gtree.NewAVLTreeFrom(gutil.ComparatorString, expect)
|
||||
@ -235,7 +235,7 @@ func Test_AVLTree_LRNode(t *testing.T) {
|
||||
}
|
||||
|
||||
func Test_AVLTree_CeilingFloor(t *testing.T) {
|
||||
expect := map[interface{}]interface{}{
|
||||
expect := map[any]any{
|
||||
20: "val20",
|
||||
6: "val6",
|
||||
10: "val10",
|
||||
|
||||
@ -23,7 +23,7 @@ func Test_BTree_Basic(t *testing.T) {
|
||||
|
||||
t.Assert(m.Height(), 1)
|
||||
|
||||
t.Assert(m.Keys(), []interface{}{"key1"})
|
||||
t.Assert(m.Keys(), []any{"key1"})
|
||||
|
||||
t.Assert(m.Get("key1"), "val1")
|
||||
t.Assert(m.Size(), 1)
|
||||
@ -46,8 +46,8 @@ func Test_BTree_Basic(t *testing.T) {
|
||||
t.Assert(m.Size(), 0)
|
||||
t.Assert(m.IsEmpty(), true)
|
||||
|
||||
m2 := gtree.NewBTreeFrom(3, gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m2 := gtree.NewBTreeFrom(3, gutil.ComparatorString, map[any]any{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[any]any{1: 1, "key1": "val1"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -96,10 +96,10 @@ func Test_BTree_Get_Set_Var(t *testing.T) {
|
||||
func Test_BTree_Batch(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gtree.NewBTree(3, gutil.ComparatorString)
|
||||
m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]interface{}{"key1", 1})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
|
||||
m.Sets(map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]any{"key1", 1})
|
||||
t.Assert(m.Map(), map[any]any{"key2": "val2", "key3": "val3"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -108,19 +108,19 @@ func Test_BTree_Iterator(t *testing.T) {
|
||||
keyLen := len(keys)
|
||||
index := 0
|
||||
|
||||
expect := map[interface{}]interface{}{"key4": "val4", 1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
expect := map[any]any{"key4": "val4", 1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
|
||||
m := gtree.NewBTreeFrom(3, gutil.ComparatorString, expect)
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
t.Assert(k, keys[index])
|
||||
index++
|
||||
t.Assert(expect[k], v)
|
||||
return true
|
||||
})
|
||||
|
||||
m.IteratorDesc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorDesc(func(k any, v any) bool {
|
||||
index--
|
||||
t.Assert(k, keys[index])
|
||||
t.Assert(expect[k], v)
|
||||
@ -133,11 +133,11 @@ func Test_BTree_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
i := 0
|
||||
j := 0
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -148,11 +148,11 @@ func Test_BTree_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
i := 0
|
||||
j := 0
|
||||
m.IteratorDesc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorDesc(func(k any, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.IteratorDesc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorDesc(func(k any, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -162,7 +162,7 @@ func Test_BTree_Iterator(t *testing.T) {
|
||||
}
|
||||
|
||||
func Test_BTree_IteratorFrom(t *testing.T) {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 10; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
@ -170,7 +170,7 @@ func Test_BTree_IteratorFrom(t *testing.T) {
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
n := 5
|
||||
tree.IteratorFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorFrom(5, true, func(key, value any) bool {
|
||||
t.Assert(n, key)
|
||||
t.Assert(n*10, value)
|
||||
n++
|
||||
@ -178,7 +178,7 @@ func Test_BTree_IteratorFrom(t *testing.T) {
|
||||
})
|
||||
|
||||
i := 5
|
||||
tree.IteratorAscFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(5, true, func(key, value any) bool {
|
||||
t.Assert(i, key)
|
||||
t.Assert(i*10, value)
|
||||
i++
|
||||
@ -186,7 +186,7 @@ func Test_BTree_IteratorFrom(t *testing.T) {
|
||||
})
|
||||
|
||||
j := 5
|
||||
tree.IteratorDescFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorDescFrom(5, true, func(key, value any) bool {
|
||||
t.Assert(j, key)
|
||||
t.Assert(j*10, value)
|
||||
j--
|
||||
@ -198,7 +198,7 @@ func Test_BTree_IteratorFrom(t *testing.T) {
|
||||
func Test_BTree_Clone(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
//clone 方法是深克隆
|
||||
m := gtree.NewBTreeFrom(3, gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m := gtree.NewBTreeFrom(3, gutil.ComparatorString, map[any]any{1: 1, "key1": "val1"})
|
||||
m_clone := m.Clone()
|
||||
m.Remove(1)
|
||||
//修改原 map,clone 后的 map 不影响
|
||||
@ -211,7 +211,7 @@ func Test_BTree_Clone(t *testing.T) {
|
||||
}
|
||||
|
||||
func Test_BTree_LRNode(t *testing.T) {
|
||||
expect := map[interface{}]interface{}{"key4": "val4", "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
expect := map[any]any{"key4": "val4", "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
//safe
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gtree.NewBTreeFrom(3, gutil.ComparatorString, expect)
|
||||
|
||||
@ -48,7 +48,7 @@ func ExampleAVLTree_Set() {
|
||||
func ExampleAVLTree_Sets() {
|
||||
tree := gtree.NewAVLTree(gutil.ComparatorString)
|
||||
|
||||
tree.Sets(map[interface{}]interface{}{
|
||||
tree.Sets(map[any]any{
|
||||
"key1": "val1",
|
||||
"key2": "val2",
|
||||
})
|
||||
@ -95,10 +95,10 @@ func ExampleAVLTree_GetOrSetFunc() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFunc("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetOrSetFunc("key6", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFunc("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -113,10 +113,10 @@ func ExampleAVLTree_GetOrSetFuncLock() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFuncLock("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetOrSetFuncLock("key6", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFuncLock("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -157,10 +157,10 @@ func ExampleAVLTree_GetVarOrSetFunc() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetVarOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFunc("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetVarOrSetFunc("key6", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFunc("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -175,10 +175,10 @@ func ExampleAVLTree_GetVarOrSetFuncLock() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key6", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -207,10 +207,10 @@ func ExampleAVLTree_SetIfNotExistFunc() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.SetIfNotExistFunc("key1", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFunc("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.SetIfNotExistFunc("key6", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFunc("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -225,10 +225,10 @@ func ExampleAVLTree_SetIfNotExistFuncLock() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key1", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key6", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -273,7 +273,7 @@ func ExampleAVLTree_Removes() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
removeKeys := make([]interface{}, 2)
|
||||
removeKeys := make([]any, 2)
|
||||
removeKeys = append(removeKeys, "key1")
|
||||
removeKeys = append(removeKeys, "key6")
|
||||
|
||||
@ -405,7 +405,7 @@ func ExampleAVLTree_Replace() {
|
||||
|
||||
fmt.Println(tree.Map())
|
||||
|
||||
data := map[interface{}]interface{}{
|
||||
data := map[any]any{
|
||||
"newKey0": "newVal0",
|
||||
"newKey1": "newVal1",
|
||||
"newKey2": "newVal2",
|
||||
@ -573,7 +573,7 @@ func ExampleAVLTree_Iterator() {
|
||||
}
|
||||
|
||||
var totalKey, totalValue int
|
||||
tree.Iterator(func(key, value interface{}) bool {
|
||||
tree.Iterator(func(key, value any) bool {
|
||||
totalKey += key.(int)
|
||||
totalValue += value.(int)
|
||||
|
||||
@ -589,13 +589,13 @@ func ExampleAVLTree_Iterator() {
|
||||
}
|
||||
|
||||
func ExampleAVLTree_IteratorFrom() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewAVLTreeFrom(gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorFrom(1, true, func(key, value interface{}) bool {
|
||||
tree.IteratorFrom(1, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -614,7 +614,7 @@ func ExampleAVLTree_IteratorAsc() {
|
||||
tree.Set(i, 10-i)
|
||||
}
|
||||
|
||||
tree.IteratorAsc(func(key, value interface{}) bool {
|
||||
tree.IteratorAsc(func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -633,13 +633,13 @@ func ExampleAVLTree_IteratorAsc() {
|
||||
}
|
||||
|
||||
func ExampleAVLTree_IteratorAscFrom_normal() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewAVLTreeFrom(gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorAscFrom(1, true, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(1, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -653,13 +653,13 @@ func ExampleAVLTree_IteratorAscFrom_normal() {
|
||||
}
|
||||
|
||||
func ExampleAVLTree_IteratorAscFrom_noExistKey() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewAVLTreeFrom(gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorAscFrom(0, true, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(0, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -668,13 +668,13 @@ func ExampleAVLTree_IteratorAscFrom_noExistKey() {
|
||||
}
|
||||
|
||||
func ExampleAVLTree_IteratorAscFrom_noExistKeyAndMatchFalse() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewAVLTreeFrom(gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorAscFrom(6, false, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(6, false, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -688,7 +688,7 @@ func ExampleAVLTree_IteratorDesc() {
|
||||
tree.Set(i, 10-i)
|
||||
}
|
||||
|
||||
tree.IteratorDesc(func(key, value interface{}) bool {
|
||||
tree.IteratorDesc(func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -707,13 +707,13 @@ func ExampleAVLTree_IteratorDesc() {
|
||||
}
|
||||
|
||||
func ExampleAVLTree_IteratorDescFrom() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewAVLTreeFrom(gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorDescFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorDescFrom(5, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
|
||||
@ -48,7 +48,7 @@ func ExampleBTree_Set() {
|
||||
func ExampleBTree_Sets() {
|
||||
tree := gtree.NewBTree(3, gutil.ComparatorString)
|
||||
|
||||
tree.Sets(map[interface{}]interface{}{
|
||||
tree.Sets(map[any]any{
|
||||
"key1": "val1",
|
||||
"key2": "val2",
|
||||
})
|
||||
@ -95,10 +95,10 @@ func ExampleBTree_GetOrSetFunc() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFunc("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetOrSetFunc("key6", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFunc("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -113,10 +113,10 @@ func ExampleBTree_GetOrSetFuncLock() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFuncLock("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetOrSetFuncLock("key6", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFuncLock("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -157,10 +157,10 @@ func ExampleBTree_GetVarOrSetFunc() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetVarOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFunc("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetVarOrSetFunc("key6", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFunc("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -175,10 +175,10 @@ func ExampleBTree_GetVarOrSetFuncLock() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key6", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -207,10 +207,10 @@ func ExampleBTree_SetIfNotExistFunc() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.SetIfNotExistFunc("key1", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFunc("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.SetIfNotExistFunc("key6", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFunc("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -225,10 +225,10 @@ func ExampleBTree_SetIfNotExistFuncLock() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key1", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key6", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -273,7 +273,7 @@ func ExampleBTree_Removes() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
removeKeys := make([]interface{}, 2)
|
||||
removeKeys := make([]any, 2)
|
||||
removeKeys = append(removeKeys, "key1")
|
||||
removeKeys = append(removeKeys, "key6")
|
||||
|
||||
@ -388,7 +388,7 @@ func ExampleBTree_Replace() {
|
||||
|
||||
fmt.Println(tree.Map())
|
||||
|
||||
data := map[interface{}]interface{}{
|
||||
data := map[any]any{
|
||||
"newKey0": "newVal0",
|
||||
"newKey1": "newVal1",
|
||||
"newKey2": "newVal2",
|
||||
@ -499,7 +499,7 @@ func ExampleBTree_Iterator() {
|
||||
}
|
||||
|
||||
var totalKey, totalValue int
|
||||
tree.Iterator(func(key, value interface{}) bool {
|
||||
tree.Iterator(func(key, value any) bool {
|
||||
totalKey += key.(int)
|
||||
totalValue += value.(int)
|
||||
|
||||
@ -515,13 +515,13 @@ func ExampleBTree_Iterator() {
|
||||
}
|
||||
|
||||
func ExampleBTree_IteratorFrom() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorFrom(1, true, func(key, value interface{}) bool {
|
||||
tree.IteratorFrom(1, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -540,7 +540,7 @@ func ExampleBTree_IteratorAsc() {
|
||||
tree.Set(i, 10-i)
|
||||
}
|
||||
|
||||
tree.IteratorAsc(func(key, value interface{}) bool {
|
||||
tree.IteratorAsc(func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -559,13 +559,13 @@ func ExampleBTree_IteratorAsc() {
|
||||
}
|
||||
|
||||
func ExampleBTree_IteratorAscFrom_normal() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorAscFrom(1, true, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(1, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -579,13 +579,13 @@ func ExampleBTree_IteratorAscFrom_normal() {
|
||||
}
|
||||
|
||||
func ExampleBTree_IteratorAscFrom_noExistKey() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorAscFrom(0, true, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(0, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -594,13 +594,13 @@ func ExampleBTree_IteratorAscFrom_noExistKey() {
|
||||
}
|
||||
|
||||
func ExampleBTree_IteratorAscFrom_noExistKeyAndMatchFalse() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorAscFrom(0, false, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(0, false, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -619,7 +619,7 @@ func ExampleBTree_IteratorDesc() {
|
||||
tree.Set(i, 10-i)
|
||||
}
|
||||
|
||||
tree.IteratorDesc(func(key, value interface{}) bool {
|
||||
tree.IteratorDesc(func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -638,13 +638,13 @@ func ExampleBTree_IteratorDesc() {
|
||||
}
|
||||
|
||||
func ExampleBTree_IteratorDescFrom() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewBTreeFrom(3, gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorDescFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorDescFrom(5, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
|
||||
@ -63,7 +63,7 @@ func ExampleRedBlackTree_Set() {
|
||||
func ExampleRedBlackTree_Sets() {
|
||||
tree := gtree.NewRedBlackTree(gutil.ComparatorString)
|
||||
|
||||
tree.Sets(map[interface{}]interface{}{
|
||||
tree.Sets(map[any]any{
|
||||
"key1": "val1",
|
||||
"key2": "val2",
|
||||
})
|
||||
@ -110,10 +110,10 @@ func ExampleRedBlackTree_GetOrSetFunc() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFunc("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetOrSetFunc("key6", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFunc("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -128,10 +128,10 @@ func ExampleRedBlackTree_GetOrSetFuncLock() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFuncLock("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetOrSetFuncLock("key6", func() interface{} {
|
||||
fmt.Println(tree.GetOrSetFuncLock("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -172,10 +172,10 @@ func ExampleRedBlackTree_GetVarOrSetFunc() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetVarOrSetFunc("key1", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFunc("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetVarOrSetFunc("key6", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFunc("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -190,10 +190,10 @@ func ExampleRedBlackTree_GetVarOrSetFuncLock() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key1", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key6", func() interface{} {
|
||||
fmt.Println(tree.GetVarOrSetFuncLock("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -222,10 +222,10 @@ func ExampleRedBlackTree_SetIfNotExistFunc() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.SetIfNotExistFunc("key1", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFunc("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.SetIfNotExistFunc("key6", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFunc("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -240,10 +240,10 @@ func ExampleRedBlackTree_SetIfNotExistFuncLock() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key1", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key1", func() any {
|
||||
return "newVal1"
|
||||
}))
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key6", func() interface{} {
|
||||
fmt.Println(tree.SetIfNotExistFuncLock("key6", func() any {
|
||||
return "val6"
|
||||
}))
|
||||
|
||||
@ -288,7 +288,7 @@ func ExampleRedBlackTree_Removes() {
|
||||
tree.Set("key"+gconv.String(i), "val"+gconv.String(i))
|
||||
}
|
||||
|
||||
removeKeys := make([]interface{}, 2)
|
||||
removeKeys := make([]any, 2)
|
||||
removeKeys = append(removeKeys, "key1")
|
||||
removeKeys = append(removeKeys, "key6")
|
||||
|
||||
@ -485,7 +485,7 @@ func ExampleRedBlackTree_Iterator() {
|
||||
}
|
||||
|
||||
var totalKey, totalValue int
|
||||
tree.Iterator(func(key, value interface{}) bool {
|
||||
tree.Iterator(func(key, value any) bool {
|
||||
totalKey += key.(int)
|
||||
totalValue += value.(int)
|
||||
|
||||
@ -501,13 +501,13 @@ func ExampleRedBlackTree_Iterator() {
|
||||
}
|
||||
|
||||
func ExampleRedBlackTree_IteratorFrom() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewRedBlackTreeFrom(gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorFrom(1, true, func(key, value interface{}) bool {
|
||||
tree.IteratorFrom(1, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -526,7 +526,7 @@ func ExampleRedBlackTree_IteratorAsc() {
|
||||
tree.Set(i, 10-i)
|
||||
}
|
||||
|
||||
tree.IteratorAsc(func(key, value interface{}) bool {
|
||||
tree.IteratorAsc(func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -545,13 +545,13 @@ func ExampleRedBlackTree_IteratorAsc() {
|
||||
}
|
||||
|
||||
func ExampleRedBlackTree_IteratorAscFrom_normal() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewRedBlackTreeFrom(gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorAscFrom(1, true, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(1, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -565,13 +565,13 @@ func ExampleRedBlackTree_IteratorAscFrom_normal() {
|
||||
}
|
||||
|
||||
func ExampleRedBlackTree_IteratorAscFrom_noExistKey() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewRedBlackTreeFrom(gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorAscFrom(0, true, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(0, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -580,13 +580,13 @@ func ExampleRedBlackTree_IteratorAscFrom_noExistKey() {
|
||||
}
|
||||
|
||||
func ExampleRedBlackTree_IteratorAscFrom_noExistKeyAndMatchFalse() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewRedBlackTreeFrom(gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorAscFrom(0, false, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(0, false, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -605,7 +605,7 @@ func ExampleRedBlackTree_IteratorDesc() {
|
||||
tree.Set(i, 10-i)
|
||||
}
|
||||
|
||||
tree.IteratorDesc(func(key, value interface{}) bool {
|
||||
tree.IteratorDesc(func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -624,13 +624,13 @@ func ExampleRedBlackTree_IteratorDesc() {
|
||||
}
|
||||
|
||||
func ExampleRedBlackTree_IteratorDescFrom() {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 5; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
tree := gtree.NewRedBlackTreeFrom(gutil.ComparatorInt, m)
|
||||
|
||||
tree.IteratorDescFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorDescFrom(5, true, func(key, value any) bool {
|
||||
fmt.Println("key:", key, ", value:", value)
|
||||
return true
|
||||
})
|
||||
@ -666,7 +666,7 @@ func ExampleRedBlackTree_Replace() {
|
||||
|
||||
fmt.Println(tree.Map())
|
||||
|
||||
data := map[interface{}]interface{}{
|
||||
data := map[any]any{
|
||||
"newKey0": "newVal0",
|
||||
"newKey1": "newVal1",
|
||||
"newKey2": "newVal2",
|
||||
|
||||
@ -16,7 +16,7 @@ import (
|
||||
"github.com/gogf/gf/v2/util/gutil"
|
||||
)
|
||||
|
||||
func getValue() interface{} {
|
||||
func getValue() any {
|
||||
return 3
|
||||
}
|
||||
|
||||
@ -24,7 +24,7 @@ func Test_RedBlackTree_Basic(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gtree.NewRedBlackTree(gutil.ComparatorString)
|
||||
m.Set("key1", "val1")
|
||||
t.Assert(m.Keys(), []interface{}{"key1"})
|
||||
t.Assert(m.Keys(), []any{"key1"})
|
||||
|
||||
t.Assert(m.Get("key1"), "val1")
|
||||
t.Assert(m.Size(), 1)
|
||||
@ -44,20 +44,20 @@ func Test_RedBlackTree_Basic(t *testing.T) {
|
||||
t.AssertIN("val3", m.Values())
|
||||
t.AssertIN("val1", m.Values())
|
||||
|
||||
m.Sets(map[interface{}]interface{}{"key3": "val3", "key1": "val1"})
|
||||
m.Sets(map[any]any{"key3": "val3", "key1": "val1"})
|
||||
|
||||
m.Flip()
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"val3": "key3", "val1": "key1"})
|
||||
t.Assert(m.Map(), map[any]any{"val3": "key3", "val1": "key1"})
|
||||
|
||||
m.Flip(gutil.ComparatorString)
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"key3": "val3", "key1": "val1"})
|
||||
t.Assert(m.Map(), map[any]any{"key3": "val3", "key1": "val1"})
|
||||
|
||||
m.Clear()
|
||||
t.Assert(m.Size(), 0)
|
||||
t.Assert(m.IsEmpty(), true)
|
||||
|
||||
m2 := gtree.NewRedBlackTreeFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m2 := gtree.NewRedBlackTreeFrom(gutil.ComparatorString, map[any]any{1: 1, "key1": "val1"})
|
||||
t.Assert(m2.Map(), map[any]any{1: 1, "key1": "val1"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -106,10 +106,10 @@ func Test_RedBlackTree_Get_Set_Var(t *testing.T) {
|
||||
func Test_RedBlackTree_Batch(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gtree.NewRedBlackTree(gutil.ComparatorString)
|
||||
m.Sets(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]interface{}{"key1", 1})
|
||||
t.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
|
||||
m.Sets(map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
t.Assert(m.Map(), map[any]any{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
|
||||
m.Removes([]any{"key1", 1})
|
||||
t.Assert(m.Map(), map[any]any{"key2": "val2", "key3": "val3"})
|
||||
})
|
||||
}
|
||||
|
||||
@ -118,19 +118,19 @@ func Test_RedBlackTree_Iterator(t *testing.T) {
|
||||
keyLen := len(keys)
|
||||
index := 0
|
||||
|
||||
expect := map[interface{}]interface{}{"key4": "val4", 1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
expect := map[any]any{"key4": "val4", 1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
m := gtree.NewRedBlackTreeFrom(gutil.ComparatorString, expect)
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
t.Assert(k, keys[index])
|
||||
index++
|
||||
t.Assert(expect[k], v)
|
||||
return true
|
||||
})
|
||||
|
||||
m.IteratorDesc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorDesc(func(k any, v any) bool {
|
||||
index--
|
||||
t.Assert(k, keys[index])
|
||||
t.Assert(expect[k], v)
|
||||
@ -142,11 +142,11 @@ func Test_RedBlackTree_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
i := 0
|
||||
j := 0
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.Iterator(func(k interface{}, v interface{}) bool {
|
||||
m.Iterator(func(k any, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -157,11 +157,11 @@ func Test_RedBlackTree_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
i := 0
|
||||
j := 0
|
||||
m.IteratorDesc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorDesc(func(k any, v any) bool {
|
||||
i++
|
||||
return true
|
||||
})
|
||||
m.IteratorDesc(func(k interface{}, v interface{}) bool {
|
||||
m.IteratorDesc(func(k any, v any) bool {
|
||||
j++
|
||||
return false
|
||||
})
|
||||
@ -171,7 +171,7 @@ func Test_RedBlackTree_Iterator(t *testing.T) {
|
||||
}
|
||||
|
||||
func Test_RedBlackTree_IteratorFrom(t *testing.T) {
|
||||
m := make(map[interface{}]interface{})
|
||||
m := make(map[any]any)
|
||||
for i := 1; i <= 10; i++ {
|
||||
m[i] = i * 10
|
||||
}
|
||||
@ -179,7 +179,7 @@ func Test_RedBlackTree_IteratorFrom(t *testing.T) {
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
n := 5
|
||||
tree.IteratorFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorFrom(5, true, func(key, value any) bool {
|
||||
t.Assert(n, key)
|
||||
t.Assert(n*10, value)
|
||||
n++
|
||||
@ -187,7 +187,7 @@ func Test_RedBlackTree_IteratorFrom(t *testing.T) {
|
||||
})
|
||||
|
||||
i := 5
|
||||
tree.IteratorAscFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorAscFrom(5, true, func(key, value any) bool {
|
||||
t.Assert(i, key)
|
||||
t.Assert(i*10, value)
|
||||
i++
|
||||
@ -195,7 +195,7 @@ func Test_RedBlackTree_IteratorFrom(t *testing.T) {
|
||||
})
|
||||
|
||||
j := 5
|
||||
tree.IteratorDescFrom(5, true, func(key, value interface{}) bool {
|
||||
tree.IteratorDescFrom(5, true, func(key, value any) bool {
|
||||
t.Assert(j, key)
|
||||
t.Assert(j*10, value)
|
||||
j--
|
||||
@ -207,7 +207,7 @@ func Test_RedBlackTree_IteratorFrom(t *testing.T) {
|
||||
func Test_RedBlackTree_Clone(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
//clone 方法是深克隆
|
||||
m := gtree.NewRedBlackTreeFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
|
||||
m := gtree.NewRedBlackTreeFrom(gutil.ComparatorString, map[any]any{1: 1, "key1": "val1"})
|
||||
m_clone := m.Clone()
|
||||
m.Remove(1)
|
||||
//修改原 map,clone 后的 map 不影响
|
||||
@ -220,7 +220,7 @@ func Test_RedBlackTree_Clone(t *testing.T) {
|
||||
}
|
||||
|
||||
func Test_RedBlackTree_LRNode(t *testing.T) {
|
||||
expect := map[interface{}]interface{}{"key4": "val4", "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
expect := map[any]any{"key4": "val4", "key1": "val1", "key2": "val2", "key3": "val3"}
|
||||
//safe
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
m := gtree.NewRedBlackTreeFrom(gutil.ComparatorString, expect)
|
||||
@ -236,7 +236,7 @@ func Test_RedBlackTree_LRNode(t *testing.T) {
|
||||
}
|
||||
|
||||
func Test_RedBlackTree_CeilingFloor(t *testing.T) {
|
||||
expect := map[interface{}]interface{}{
|
||||
expect := map[any]any{
|
||||
20: "val20",
|
||||
6: "val6",
|
||||
10: "val10",
|
||||
|
||||
@ -9,6 +9,6 @@ package gtype
|
||||
|
||||
// New is alias of NewAny.
|
||||
// See NewAny, NewInterface.
|
||||
func New(value ...interface{}) *Any {
|
||||
func New(value ...any) *Any {
|
||||
return NewAny(value...)
|
||||
}
|
||||
|
||||
@ -92,13 +92,13 @@ func (v *Bool) UnmarshalJSON(b []byte) error {
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for `v`.
|
||||
func (v *Bool) UnmarshalValue(value interface{}) error {
|
||||
func (v *Bool) UnmarshalValue(value any) error {
|
||||
v.Set(gconv.Bool(value))
|
||||
return nil
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (v *Bool) DeepCopy() interface{} {
|
||||
func (v *Bool) DeepCopy() any {
|
||||
if v == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user