diff options
Diffstat (limited to 'vendor/github.com/wk8/go-ordered-map')
| -rw-r--r-- | vendor/github.com/wk8/go-ordered-map/v2/.gitignore | 1 | ||||
| -rw-r--r-- | vendor/github.com/wk8/go-ordered-map/v2/.golangci.yml | 78 | ||||
| -rw-r--r-- | vendor/github.com/wk8/go-ordered-map/v2/CHANGELOG.md | 38 | ||||
| -rw-r--r-- | vendor/github.com/wk8/go-ordered-map/v2/LICENSE | 201 | ||||
| -rw-r--r-- | vendor/github.com/wk8/go-ordered-map/v2/Makefile | 32 | ||||
| -rw-r--r-- | vendor/github.com/wk8/go-ordered-map/v2/README.md | 207 | ||||
| -rw-r--r-- | vendor/github.com/wk8/go-ordered-map/v2/json.go | 182 | ||||
| -rw-r--r-- | vendor/github.com/wk8/go-ordered-map/v2/orderedmap.go | 373 | ||||
| -rw-r--r-- | vendor/github.com/wk8/go-ordered-map/v2/yaml.go | 71 |
9 files changed, 0 insertions, 1183 deletions
diff --git a/vendor/github.com/wk8/go-ordered-map/v2/.gitignore b/vendor/github.com/wk8/go-ordered-map/v2/.gitignore deleted file mode 100644 index 57872d0f1..000000000 --- a/vendor/github.com/wk8/go-ordered-map/v2/.gitignore +++ /dev/null @@ -1 +0,0 @@ -/vendor/ diff --git a/vendor/github.com/wk8/go-ordered-map/v2/.golangci.yml b/vendor/github.com/wk8/go-ordered-map/v2/.golangci.yml deleted file mode 100644 index f305c9db1..000000000 --- a/vendor/github.com/wk8/go-ordered-map/v2/.golangci.yml +++ /dev/null @@ -1,78 +0,0 @@ -run: - tests: false - -linters: - disable-all: true - enable: - - asciicheck - - bidichk - - bodyclose - - containedctx - - contextcheck - - decorder - # Disabling depguard as there is no guarded list of imports - # - depguard - - dogsled - - dupl - - durationcheck - - errcheck - - errchkjson - - errname - - errorlint - - exportloopref - - forbidigo - - funlen - # Don't need gci and goimports - # - gci - - gochecknoglobals - - gochecknoinits - - gocognit - - goconst - - gocritic - - gocyclo - - godox - - gofmt - - gofumpt - - goheader - - goimports - - mnd - - gomoddirectives - - gomodguard - - goprintffuncname - - gosec - - gosimple - - govet - - grouper - - importas - - ineffassign - - lll - - maintidx - - makezero - - misspell - - nakedret - - nilerr - - nilnil - - noctx - - nolintlint - - paralleltest - - prealloc - - predeclared - - promlinter - - revive - - rowserrcheck - - sqlclosecheck - - staticcheck - - stylecheck - - tagliatelle - - tenv - - testpackage - - thelper - - tparallel - # FIXME: doesn't support 1.23 yet - # - typecheck - - unconvert - - unparam - - unused - - varnamelen - - wastedassign - - whitespace diff --git a/vendor/github.com/wk8/go-ordered-map/v2/CHANGELOG.md b/vendor/github.com/wk8/go-ordered-map/v2/CHANGELOG.md deleted file mode 100644 index f27126f84..000000000 --- a/vendor/github.com/wk8/go-ordered-map/v2/CHANGELOG.md +++ /dev/null @@ -1,38 +0,0 @@ -# Changelog - -[comment]: # (Changes since last release go here) - -## 2.1.8 - Jun 27th 2023 - -* Added support for YAML serialization/deserialization - -## 2.1.7 - Apr 13th 2023 - -* Renamed test_utils.go to utils_test.go - -## 2.1.6 - Feb 15th 2023 - -* Added `GetAndMoveToBack()` and `GetAndMoveToFront()` methods - -## 2.1.5 - Dec 13th 2022 - -* Added `Value()` method - -## 2.1.4 - Dec 12th 2022 - -* Fixed a bug with UTF-8 special characters in JSON keys - -## 2.1.3 - Dec 11th 2022 - -* Added support for JSON marshalling/unmarshalling of wrapper of primitive types - -## 2.1.2 - Dec 10th 2022 -* Allowing to pass options to `New`, to give a capacity hint, or initial data -* Allowing to deserialize nested ordered maps from JSON without having to explicitly instantiate them -* Added the `AddPairs` method - -## 2.1.1 - Dec 9th 2022 -* Fixing a bug with JSON marshalling - -## 2.1.0 - Dec 7th 2022 -* Added support for JSON serialization/deserialization diff --git a/vendor/github.com/wk8/go-ordered-map/v2/LICENSE b/vendor/github.com/wk8/go-ordered-map/v2/LICENSE deleted file mode 100644 index 8dada3eda..000000000 --- a/vendor/github.com/wk8/go-ordered-map/v2/LICENSE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright {yyyy} {name of copyright owner} - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/vendor/github.com/wk8/go-ordered-map/v2/Makefile b/vendor/github.com/wk8/go-ordered-map/v2/Makefile deleted file mode 100644 index 6e0e18a1b..000000000 --- a/vendor/github.com/wk8/go-ordered-map/v2/Makefile +++ /dev/null @@ -1,32 +0,0 @@ -.DEFAULT_GOAL := all - -.PHONY: all -all: test_with_fuzz lint - -# the TEST_FLAGS env var can be set to eg run only specific tests -TEST_COMMAND = go test -v -count=1 -race -cover $(TEST_FLAGS) - -.PHONY: test -test: - $(TEST_COMMAND) - -.PHONY: bench -bench: - go test -bench=. - -FUZZ_TIME ?= 10s - -# see https://github.com/golang/go/issues/46312 -# and https://stackoverflow.com/a/72673487/4867444 -# if we end up having more fuzz tests -.PHONY: test_with_fuzz -test_with_fuzz: - $(TEST_COMMAND) -fuzz=FuzzRoundTripJSON -fuzztime=$(FUZZ_TIME) - $(TEST_COMMAND) -fuzz=FuzzRoundTripYAML -fuzztime=$(FUZZ_TIME) - -.PHONY: fuzz -fuzz: test_with_fuzz - -.PHONY: lint -lint: - golangci-lint run diff --git a/vendor/github.com/wk8/go-ordered-map/v2/README.md b/vendor/github.com/wk8/go-ordered-map/v2/README.md deleted file mode 100644 index ebd8a4d37..000000000 --- a/vendor/github.com/wk8/go-ordered-map/v2/README.md +++ /dev/null @@ -1,207 +0,0 @@ -[](https://pkg.go.dev/github.com/wk8/go-ordered-map/v2) -[](https://app.circleci.com/pipelines/github/wk8/go-ordered-map) - -# Golang Ordered Maps - -Same as regular maps, but also remembers the order in which keys were inserted, akin to [Python's `collections.OrderedDict`s](https://docs.python.org/3.7/library/collections.html#ordereddict-objects). - -It offers the following features: -* optimal runtime performance (all operations are constant time) -* optimal memory usage (only one copy of values, no unnecessary memory allocation) -* allows iterating from newest or oldest keys indifferently, without memory copy, allowing to `break` the iteration, and in time linear to the number of keys iterated over rather than the total length of the ordered map -* supports any generic types for both keys and values. If you're running go < 1.18, you can use [version 1](https://github.com/wk8/go-ordered-map/tree/v1) that takes and returns generic `interface{}`s instead of using generics -* idiomatic API, akin to that of [`container/list`](https://golang.org/pkg/container/list) -* support for JSON and YAML marshalling - -## Documentation - -[The full documentation is available on pkg.go.dev](https://pkg.go.dev/github.com/wk8/go-ordered-map/v2). - -## Installation -```bash -go get -u github.com/wk8/go-ordered-map/v2 -``` - -Or use your favorite golang vendoring tool! - -## Supported go versions - -Go >= 1.23 is required to use version >= 2.2.0 of this library, as it uses generics and iterators. - -if you're running go < 1.23, you can use [version 2.1.8](https://github.com/wk8/go-ordered-map/tree/v2.1.8) instead. - -If you're running go < 1.18, you can use [version 1](https://github.com/wk8/go-ordered-map/tree/v1) instead. - -## Example / usage - -```go -package main - -import ( - "fmt" - - "github.com/wk8/go-ordered-map/v2" -) - -func main() { - om := orderedmap.New[string, string]() - - om.Set("foo", "bar") - om.Set("bar", "baz") - om.Set("coucou", "toi") - - fmt.Println(om.Get("foo")) // => "bar", true - fmt.Println(om.Get("i dont exist")) // => "", false - - // iterating pairs from oldest to newest: - for pair := om.Oldest(); pair != nil; pair = pair.Next() { - fmt.Printf("%s => %s\n", pair.Key, pair.Value) - } // prints: - // foo => bar - // bar => baz - // coucou => toi - - // iterating over the 2 newest pairs: - i := 0 - for pair := om.Newest(); pair != nil; pair = pair.Prev() { - fmt.Printf("%s => %s\n", pair.Key, pair.Value) - i++ - if i >= 2 { - break - } - } // prints: - // coucou => toi - // bar => baz -} -``` - -An `OrderedMap`'s keys must implement `comparable`, and its values can be anything, for example: - -```go -type myStruct struct { - payload string -} - -func main() { - om := orderedmap.New[int, *myStruct]() - - om.Set(12, &myStruct{"foo"}) - om.Set(1, &myStruct{"bar"}) - - value, present := om.Get(12) - if !present { - panic("should be there!") - } - fmt.Println(value.payload) // => foo - - for pair := om.Oldest(); pair != nil; pair = pair.Next() { - fmt.Printf("%d => %s\n", pair.Key, pair.Value.payload) - } // prints: - // 12 => foo - // 1 => bar -} -``` - -Also worth noting that you can provision ordered maps with a capacity hint, as you would do by passing an optional hint to `make(map[K]V, capacity`): -```go -om := orderedmap.New[int, *myStruct](28) -``` - -You can also pass in some initial data to store in the map: -```go -om := orderedmap.New[int, string](orderedmap.WithInitialData[int, string]( - orderedmap.Pair[int, string]{ - Key: 12, - Value: "foo", - }, - orderedmap.Pair[int, string]{ - Key: 28, - Value: "bar", - }, -)) -``` - -`OrderedMap`s also support JSON serialization/deserialization, and preserves order: - -```go -// serialization -data, err := json.Marshal(om) -... - -// deserialization -om := orderedmap.New[string, string]() // or orderedmap.New[int, any](), or any type you expect -err := json.Unmarshal(data, &om) -... -``` - -Similarly, it also supports YAML serialization/deserialization using the yaml.v3 package, which also preserves order: - -```go -// serialization -data, err := yaml.Marshal(om) -... - -// deserialization -om := orderedmap.New[string, string]() // or orderedmap.New[int, any](), or any type you expect -err := yaml.Unmarshal(data, &om) -... -``` - -## Iterator support (go >= 1.23) - -The `FromOldest`, `FromNewest`, `KeysFromOldest`, `KeysFromNewest`, `ValuesFromOldest` and `ValuesFromNewest` methods return iterators over the map's pairs, starting from the oldest or newest pair, respectively. - -For example: - -```go -om := orderedmap.New[int, string]() -om.Set(1, "foo") -om.Set(2, "bar") -om.Set(3, "baz") - -for k, v := range om.FromOldest() { - fmt.Printf("%d => %s\n", k, v) -} - -// prints: -// 1 => foo -// 2 => bar -// 3 => baz - -for k := range om.KeysNewest() { - fmt.Printf("%d\n", k) -} - -// prints: -// 3 -// 2 -// 1 -``` - -`From` is a convenience function that creates a new `OrderedMap` from an iterator over key-value pairs. - -```go -om := orderedmap.New[int, string]() -om.Set(1, "foo") -om.Set(2, "bar") -om.Set(3, "baz") - -om2 := orderedmap.From(om.FromOldest()) - -for k, v := range om2.FromOldest() { - fmt.Printf("%d => %s\n", k, v) -} - -// prints: -// 1 => foo -// 2 => bar -// 3 => baz -``` - -## Alternatives - -There are several other ordered map golang implementations out there, but I believe that at the time of writing none of them offer the same functionality as this library; more specifically: -* [iancoleman/orderedmap](https://github.com/iancoleman/orderedmap) only accepts `string` keys, its `Delete` operations are linear -* [cevaris/ordered_map](https://github.com/cevaris/ordered_map) uses a channel for iterations, and leaks goroutines if the iteration is interrupted before fully traversing the map -* [mantyr/iterator](https://github.com/mantyr/iterator) also uses a channel for iterations, and its `Delete` operations are linear -* [samdolan/go-ordered-map](https://github.com/samdolan/go-ordered-map) adds unnecessary locking (users should add their own locking instead if they need it), its `Delete` and `Get` operations are linear, iterations trigger a linear memory allocation diff --git a/vendor/github.com/wk8/go-ordered-map/v2/json.go b/vendor/github.com/wk8/go-ordered-map/v2/json.go deleted file mode 100644 index 53f176a05..000000000 --- a/vendor/github.com/wk8/go-ordered-map/v2/json.go +++ /dev/null @@ -1,182 +0,0 @@ -package orderedmap - -import ( - "bytes" - "encoding" - "encoding/json" - "fmt" - "reflect" - "unicode/utf8" - - "github.com/buger/jsonparser" - "github.com/mailru/easyjson/jwriter" -) - -var ( - _ json.Marshaler = &OrderedMap[int, any]{} - _ json.Unmarshaler = &OrderedMap[int, any]{} -) - -// MarshalJSON implements the json.Marshaler interface. -func (om *OrderedMap[K, V]) MarshalJSON() ([]byte, error) { //nolint:funlen - if om == nil || om.list == nil { - return []byte("null"), nil - } - - writer := jwriter.Writer{} - writer.RawByte('{') - - for pair, firstIteration := om.Oldest(), true; pair != nil; pair = pair.Next() { - if firstIteration { - firstIteration = false - } else { - writer.RawByte(',') - } - - switch key := any(pair.Key).(type) { - case string: - writer.String(key) - case encoding.TextMarshaler: - writer.RawByte('"') - writer.Raw(key.MarshalText()) - writer.RawByte('"') - case int: - writer.IntStr(key) - case int8: - writer.Int8Str(key) - case int16: - writer.Int16Str(key) - case int32: - writer.Int32Str(key) - case int64: - writer.Int64Str(key) - case uint: - writer.UintStr(key) - case uint8: - writer.Uint8Str(key) - case uint16: - writer.Uint16Str(key) - case uint32: - writer.Uint32Str(key) - case uint64: - writer.Uint64Str(key) - default: - - // this switch takes care of wrapper types around primitive types, such as - // type myType string - switch keyValue := reflect.ValueOf(key); keyValue.Type().Kind() { - case reflect.String: - writer.String(keyValue.String()) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: - writer.Int64Str(keyValue.Int()) - case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - writer.Uint64Str(keyValue.Uint()) - default: - return nil, fmt.Errorf("unsupported key type: %T", key) - } - } - - writer.RawByte(':') - // the error is checked at the end of the function - writer.Raw(json.Marshal(pair.Value)) - } - - writer.RawByte('}') - - return dumpWriter(&writer) -} - -func dumpWriter(writer *jwriter.Writer) ([]byte, error) { - if writer.Error != nil { - return nil, writer.Error - } - - var buf bytes.Buffer - buf.Grow(writer.Size()) - if _, err := writer.DumpTo(&buf); err != nil { - return nil, err - } - - return buf.Bytes(), nil -} - -// UnmarshalJSON implements the json.Unmarshaler interface. -func (om *OrderedMap[K, V]) UnmarshalJSON(data []byte) error { - if om.list == nil { - om.initialize(0) - } - - return jsonparser.ObjectEach( - data, - func(keyData []byte, valueData []byte, dataType jsonparser.ValueType, offset int) error { - if dataType == jsonparser.String { - // jsonparser removes the enclosing quotes; we need to restore them to make a valid JSON - valueData = data[offset-len(valueData)-2 : offset] - } - - var key K - var value V - - switch typedKey := any(&key).(type) { - case *string: - s, err := decodeUTF8(keyData) - if err != nil { - return err - } - *typedKey = s - case encoding.TextUnmarshaler: - if err := typedKey.UnmarshalText(keyData); err != nil { - return err - } - case *int, *int8, *int16, *int32, *int64, *uint, *uint8, *uint16, *uint32, *uint64: - if err := json.Unmarshal(keyData, typedKey); err != nil { - return err - } - default: - // this switch takes care of wrapper types around primitive types, such as - // type myType string - switch reflect.TypeOf(key).Kind() { - case reflect.String: - s, err := decodeUTF8(keyData) - if err != nil { - return err - } - - convertedKeyData := reflect.ValueOf(s).Convert(reflect.TypeOf(key)) - reflect.ValueOf(&key).Elem().Set(convertedKeyData) - case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, - reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: - if err := json.Unmarshal(keyData, &key); err != nil { - return err - } - default: - return fmt.Errorf("unsupported key type: %T", key) - } - } - - if err := json.Unmarshal(valueData, &value); err != nil { - return err - } - - om.Set(key, value) - return nil - }) -} - -func decodeUTF8(input []byte) (string, error) { - remaining, offset := input, 0 - runes := make([]rune, 0, len(remaining)) - - for len(remaining) > 0 { - r, size := utf8.DecodeRune(remaining) - if r == utf8.RuneError && size <= 1 { - return "", fmt.Errorf("not a valid UTF-8 string (at position %d): %s", offset, string(input)) - } - - runes = append(runes, r) - remaining = remaining[size:] - offset += size - } - - return string(runes), nil -} diff --git a/vendor/github.com/wk8/go-ordered-map/v2/orderedmap.go b/vendor/github.com/wk8/go-ordered-map/v2/orderedmap.go deleted file mode 100644 index 45bf8622d..000000000 --- a/vendor/github.com/wk8/go-ordered-map/v2/orderedmap.go +++ /dev/null @@ -1,373 +0,0 @@ -// Package orderedmap implements an ordered map, i.e. a map that also keeps track of -// the order in which keys were inserted. -// -// All operations are constant-time. -// -// Github repo: https://github.com/wk8/go-ordered-map -package orderedmap - -import ( - "fmt" - "iter" - - list "github.com/bahlo/generic-list-go" -) - -type Pair[K comparable, V any] struct { - Key K - Value V - - element *list.Element[*Pair[K, V]] -} - -type OrderedMap[K comparable, V any] struct { - pairs map[K]*Pair[K, V] - list *list.List[*Pair[K, V]] -} - -type initConfig[K comparable, V any] struct { - capacity int - initialData []Pair[K, V] -} - -type InitOption[K comparable, V any] func(config *initConfig[K, V]) - -// WithCapacity allows giving a capacity hint for the map, akin to the standard make(map[K]V, capacity). -func WithCapacity[K comparable, V any](capacity int) InitOption[K, V] { - return func(c *initConfig[K, V]) { - c.capacity = capacity - } -} - -// WithInitialData allows passing in initial data for the map. -func WithInitialData[K comparable, V any](initialData ...Pair[K, V]) InitOption[K, V] { - return func(c *initConfig[K, V]) { - c.initialData = initialData - if c.capacity < len(initialData) { - c.capacity = len(initialData) - } - } -} - -// New creates a new OrderedMap. -// options can either be one or several InitOption[K, V], or a single integer, -// which is then interpreted as a capacity hint, à la make(map[K]V, capacity). -func New[K comparable, V any](options ...any) *OrderedMap[K, V] { - orderedMap := &OrderedMap[K, V]{} - - var config initConfig[K, V] - for _, untypedOption := range options { - switch option := untypedOption.(type) { - case int: - if len(options) != 1 { - invalidOption() - } - config.capacity = option - - case InitOption[K, V]: - option(&config) - - default: - invalidOption() - } - } - - orderedMap.initialize(config.capacity) - orderedMap.AddPairs(config.initialData...) - - return orderedMap -} - -const invalidOptionMessage = `when using orderedmap.New[K,V]() with options, either provide one or several InitOption[K, V]; or a single integer which is then interpreted as a capacity hint, à la make(map[K]V, capacity).` //nolint:lll - -func invalidOption() { panic(invalidOptionMessage) } - -func (om *OrderedMap[K, V]) initialize(capacity int) { - om.pairs = make(map[K]*Pair[K, V], capacity) - om.list = list.New[*Pair[K, V]]() -} - -// Get looks for the given key, and returns the value associated with it, -// or V's nil value if not found. The boolean it returns says whether the key is present in the map. -func (om *OrderedMap[K, V]) Get(key K) (val V, present bool) { - if pair, present := om.pairs[key]; present { - return pair.Value, true - } - - return -} - -// Load is an alias for Get, mostly to present an API similar to `sync.Map`'s. -func (om *OrderedMap[K, V]) Load(key K) (V, bool) { - return om.Get(key) -} - -// Value returns the value associated with the given key or the zero value. -func (om *OrderedMap[K, V]) Value(key K) (val V) { - if pair, present := om.pairs[key]; present { - val = pair.Value - } - return -} - -// GetPair looks for the given key, and returns the pair associated with it, -// or nil if not found. The Pair struct can then be used to iterate over the ordered map -// from that point, either forward or backward. -func (om *OrderedMap[K, V]) GetPair(key K) *Pair[K, V] { - return om.pairs[key] -} - -// Set sets the key-value pair, and returns what `Get` would have returned -// on that key prior to the call to `Set`. -func (om *OrderedMap[K, V]) Set(key K, value V) (val V, present bool) { - if pair, present := om.pairs[key]; present { - oldValue := pair.Value - pair.Value = value - return oldValue, true - } - - pair := &Pair[K, V]{ - Key: key, - Value: value, - } - pair.element = om.list.PushBack(pair) - om.pairs[key] = pair - - return -} - -// AddPairs allows setting multiple pairs at a time. It's equivalent to calling -// Set on each pair sequentially. -func (om *OrderedMap[K, V]) AddPairs(pairs ...Pair[K, V]) { - for _, pair := range pairs { - om.Set(pair.Key, pair.Value) - } -} - -// Store is an alias for Set, mostly to present an API similar to `sync.Map`'s. -func (om *OrderedMap[K, V]) Store(key K, value V) (V, bool) { - return om.Set(key, value) -} - -// Delete removes the key-value pair, and returns what `Get` would have returned -// on that key prior to the call to `Delete`. -func (om *OrderedMap[K, V]) Delete(key K) (val V, present bool) { - if pair, present := om.pairs[key]; present { - om.list.Remove(pair.element) - delete(om.pairs, key) - return pair.Value, true - } - return -} - -// Len returns the length of the ordered map. -func (om *OrderedMap[K, V]) Len() int { - if om == nil || om.pairs == nil { - return 0 - } - return len(om.pairs) -} - -// Oldest returns a pointer to the oldest pair. It's meant to be used to iterate on the ordered map's -// pairs from the oldest to the newest, e.g.: -// for pair := orderedMap.Oldest(); pair != nil; pair = pair.Next() { fmt.Printf("%v => %v\n", pair.Key, pair.Value) } -func (om *OrderedMap[K, V]) Oldest() *Pair[K, V] { - if om == nil || om.list == nil { - return nil - } - return listElementToPair(om.list.Front()) -} - -// Newest returns a pointer to the newest pair. It's meant to be used to iterate on the ordered map's -// pairs from the newest to the oldest, e.g.: -// for pair := orderedMap.Newest(); pair != nil; pair = pair.Prev() { fmt.Printf("%v => %v\n", pair.Key, pair.Value) } -func (om *OrderedMap[K, V]) Newest() *Pair[K, V] { - if om == nil || om.list == nil { - return nil - } - return listElementToPair(om.list.Back()) -} - -// Next returns a pointer to the next pair. -func (p *Pair[K, V]) Next() *Pair[K, V] { - return listElementToPair(p.element.Next()) -} - -// Prev returns a pointer to the previous pair. -func (p *Pair[K, V]) Prev() *Pair[K, V] { - return listElementToPair(p.element.Prev()) -} - -func listElementToPair[K comparable, V any](element *list.Element[*Pair[K, V]]) *Pair[K, V] { - if element == nil { - return nil - } - return element.Value -} - -// KeyNotFoundError may be returned by functions in this package when they're called with keys that are not present -// in the map. -type KeyNotFoundError[K comparable] struct { - MissingKey K -} - -func (e *KeyNotFoundError[K]) Error() string { - return fmt.Sprintf("missing key: %v", e.MissingKey) -} - -// MoveAfter moves the value associated with key to its new position after the one associated with markKey. -// Returns an error iff key or markKey are not present in the map. If an error is returned, -// it will be a KeyNotFoundError. -func (om *OrderedMap[K, V]) MoveAfter(key, markKey K) error { - elements, err := om.getElements(key, markKey) - if err != nil { - return err - } - om.list.MoveAfter(elements[0], elements[1]) - return nil -} - -// MoveBefore moves the value associated with key to its new position before the one associated with markKey. -// Returns an error iff key or markKey are not present in the map. If an error is returned, -// it will be a KeyNotFoundError. -func (om *OrderedMap[K, V]) MoveBefore(key, markKey K) error { - elements, err := om.getElements(key, markKey) - if err != nil { - return err - } - om.list.MoveBefore(elements[0], elements[1]) - return nil -} - -func (om *OrderedMap[K, V]) getElements(keys ...K) ([]*list.Element[*Pair[K, V]], error) { - elements := make([]*list.Element[*Pair[K, V]], len(keys)) - for i, k := range keys { - pair, present := om.pairs[k] - if !present { - return nil, &KeyNotFoundError[K]{k} - } - elements[i] = pair.element - } - return elements, nil -} - -// MoveToBack moves the value associated with key to the back of the ordered map, -// i.e. makes it the newest pair in the map. -// Returns an error iff key is not present in the map. If an error is returned, -// it will be a KeyNotFoundError. -func (om *OrderedMap[K, V]) MoveToBack(key K) error { - _, err := om.GetAndMoveToBack(key) - return err -} - -// MoveToFront moves the value associated with key to the front of the ordered map, -// i.e. makes it the oldest pair in the map. -// Returns an error iff key is not present in the map. If an error is returned, -// it will be a KeyNotFoundError. -func (om *OrderedMap[K, V]) MoveToFront(key K) error { - _, err := om.GetAndMoveToFront(key) - return err -} - -// GetAndMoveToBack combines Get and MoveToBack in the same call. If an error is returned, -// it will be a KeyNotFoundError. -func (om *OrderedMap[K, V]) GetAndMoveToBack(key K) (val V, err error) { - if pair, present := om.pairs[key]; present { - val = pair.Value - om.list.MoveToBack(pair.element) - } else { - err = &KeyNotFoundError[K]{key} - } - - return -} - -// GetAndMoveToFront combines Get and MoveToFront in the same call. If an error is returned, -// it will be a KeyNotFoundError. -func (om *OrderedMap[K, V]) GetAndMoveToFront(key K) (val V, err error) { - if pair, present := om.pairs[key]; present { - val = pair.Value - om.list.MoveToFront(pair.element) - } else { - err = &KeyNotFoundError[K]{key} - } - - return -} - -// FromOldest returns an iterator over all the key-value pairs in the map, starting from the oldest pair. -func (om *OrderedMap[K, V]) FromOldest() iter.Seq2[K, V] { - return func(yield func(K, V) bool) { - for pair := om.Oldest(); pair != nil; pair = pair.Next() { - if !yield(pair.Key, pair.Value) { - return - } - } - } -} - -// FromNewest returns an iterator over all the key-value pairs in the map, starting from the newest pair. -func (om *OrderedMap[K, V]) FromNewest() iter.Seq2[K, V] { - return func(yield func(K, V) bool) { - for pair := om.Newest(); pair != nil; pair = pair.Prev() { - if !yield(pair.Key, pair.Value) { - return - } - } - } -} - -// KeysFromOldest returns an iterator over all the keys in the map, starting from the oldest pair. -func (om *OrderedMap[K, V]) KeysFromOldest() iter.Seq[K] { - return func(yield func(K) bool) { - for pair := om.Oldest(); pair != nil; pair = pair.Next() { - if !yield(pair.Key) { - return - } - } - } -} - -// KeysFromNewest returns an iterator over all the keys in the map, starting from the newest pair. -func (om *OrderedMap[K, V]) KeysFromNewest() iter.Seq[K] { - return func(yield func(K) bool) { - for pair := om.Newest(); pair != nil; pair = pair.Prev() { - if !yield(pair.Key) { - return - } - } - } -} - -// ValuesFromOldest returns an iterator over all the values in the map, starting from the oldest pair. -func (om *OrderedMap[K, V]) ValuesFromOldest() iter.Seq[V] { - return func(yield func(V) bool) { - for pair := om.Oldest(); pair != nil; pair = pair.Next() { - if !yield(pair.Value) { - return - } - } - } -} - -// ValuesFromNewest returns an iterator over all the values in the map, starting from the newest pair. -func (om *OrderedMap[K, V]) ValuesFromNewest() iter.Seq[V] { - return func(yield func(V) bool) { - for pair := om.Newest(); pair != nil; pair = pair.Prev() { - if !yield(pair.Value) { - return - } - } - } -} - -// From creates a new OrderedMap from an iterator over key-value pairs. -func From[K comparable, V any](i iter.Seq2[K, V]) *OrderedMap[K, V] { - oMap := New[K, V]() - - for k, v := range i { - oMap.Set(k, v) - } - - return oMap -} diff --git a/vendor/github.com/wk8/go-ordered-map/v2/yaml.go b/vendor/github.com/wk8/go-ordered-map/v2/yaml.go deleted file mode 100644 index 602247128..000000000 --- a/vendor/github.com/wk8/go-ordered-map/v2/yaml.go +++ /dev/null @@ -1,71 +0,0 @@ -package orderedmap - -import ( - "fmt" - - "gopkg.in/yaml.v3" -) - -var ( - _ yaml.Marshaler = &OrderedMap[int, any]{} - _ yaml.Unmarshaler = &OrderedMap[int, any]{} -) - -// MarshalYAML implements the yaml.Marshaler interface. -func (om *OrderedMap[K, V]) MarshalYAML() (interface{}, error) { - if om == nil { - return []byte("null"), nil - } - - node := yaml.Node{ - Kind: yaml.MappingNode, - } - - for pair := om.Oldest(); pair != nil; pair = pair.Next() { - key, value := pair.Key, pair.Value - - keyNode := &yaml.Node{} - - // serialize key to yaml, then deserialize it back into the node - // this is a hack to get the correct tag for the key - if err := keyNode.Encode(key); err != nil { - return nil, err - } - - valueNode := &yaml.Node{} - if err := valueNode.Encode(value); err != nil { - return nil, err - } - - node.Content = append(node.Content, keyNode, valueNode) - } - - return &node, nil -} - -// UnmarshalYAML implements the yaml.Unmarshaler interface. -func (om *OrderedMap[K, V]) UnmarshalYAML(value *yaml.Node) error { - if value.Kind != yaml.MappingNode { - return fmt.Errorf("pipeline must contain YAML mapping, has %v", value.Kind) - } - - if om.list == nil { - om.initialize(0) - } - - for index := 0; index < len(value.Content); index += 2 { - var key K - var val V - - if err := value.Content[index].Decode(&key); err != nil { - return err - } - if err := value.Content[index+1].Decode(&val); err != nil { - return err - } - - om.Set(key, val) - } - - return nil -} |