use istio client-go library instead of knative (#1661)
use istio client-go library instead of knative bump kubernetes dependency version change code coverage to codecov
This commit is contained in:
zryfish
361
vendor/sigs.k8s.io/structured-merge-diff/value/value.go
generated
vendored
Normal file
361
vendor/sigs.k8s.io/structured-merge-diff/value/value.go
generated
vendored
Normal file
@@ -0,0 +1,361 @@
|
||||
/*
|
||||
Copyright 2018 The Kubernetes Authors.
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
package value
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"sort"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// A Value is an object; it corresponds to an 'atom' in the schema.
|
||||
type Value struct {
|
||||
// Exactly one of the below must be set.
|
||||
FloatValue *Float
|
||||
IntValue *Int
|
||||
StringValue *String
|
||||
BooleanValue *Boolean
|
||||
ListValue *List
|
||||
MapValue *Map
|
||||
Null bool // represents an explicit `"foo" = null`
|
||||
}
|
||||
|
||||
// Equals returns true iff the two values are equal.
|
||||
func (v Value) Equals(rhs Value) bool {
|
||||
return !v.Less(rhs) && !rhs.Less(v)
|
||||
}
|
||||
|
||||
// Less provides a total ordering for Value (so that they can be sorted, even
|
||||
// if they are of different types).
|
||||
func (v Value) Less(rhs Value) bool {
|
||||
if v.FloatValue != nil {
|
||||
if rhs.FloatValue == nil {
|
||||
// Extra: compare floats and ints numerically.
|
||||
if rhs.IntValue != nil {
|
||||
return float64(*v.FloatValue) < float64(*rhs.IntValue)
|
||||
}
|
||||
return true
|
||||
}
|
||||
return *v.FloatValue < *rhs.FloatValue
|
||||
} else if rhs.FloatValue != nil {
|
||||
// Extra: compare floats and ints numerically.
|
||||
if v.IntValue != nil {
|
||||
return float64(*v.IntValue) < float64(*rhs.FloatValue)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
if v.IntValue != nil {
|
||||
if rhs.IntValue == nil {
|
||||
return true
|
||||
}
|
||||
return *v.IntValue < *rhs.IntValue
|
||||
} else if rhs.IntValue != nil {
|
||||
return false
|
||||
}
|
||||
|
||||
if v.StringValue != nil {
|
||||
if rhs.StringValue == nil {
|
||||
return true
|
||||
}
|
||||
return *v.StringValue < *rhs.StringValue
|
||||
} else if rhs.StringValue != nil {
|
||||
return false
|
||||
}
|
||||
|
||||
if v.BooleanValue != nil {
|
||||
if rhs.BooleanValue == nil {
|
||||
return true
|
||||
}
|
||||
if *v.BooleanValue == *rhs.BooleanValue {
|
||||
return false
|
||||
}
|
||||
return *v.BooleanValue == false
|
||||
} else if rhs.BooleanValue != nil {
|
||||
return false
|
||||
}
|
||||
|
||||
if v.ListValue != nil {
|
||||
if rhs.ListValue == nil {
|
||||
return true
|
||||
}
|
||||
return v.ListValue.Less(rhs.ListValue)
|
||||
} else if rhs.ListValue != nil {
|
||||
return false
|
||||
}
|
||||
if v.MapValue != nil {
|
||||
if rhs.MapValue == nil {
|
||||
return true
|
||||
}
|
||||
return v.MapValue.Less(rhs.MapValue)
|
||||
} else if rhs.MapValue != nil {
|
||||
return false
|
||||
}
|
||||
if v.Null {
|
||||
if !rhs.Null {
|
||||
return true
|
||||
}
|
||||
return false
|
||||
} else if rhs.Null {
|
||||
return false
|
||||
}
|
||||
|
||||
// Invalid Value-- nothing is set.
|
||||
return false
|
||||
}
|
||||
|
||||
type Int int64
|
||||
type Float float64
|
||||
type String string
|
||||
type Boolean bool
|
||||
|
||||
// Field is an individual key-value pair.
|
||||
type Field struct {
|
||||
Name string
|
||||
Value Value
|
||||
}
|
||||
|
||||
// List is a list of items.
|
||||
type List struct {
|
||||
Items []Value
|
||||
}
|
||||
|
||||
// Less compares two lists lexically.
|
||||
func (l *List) Less(rhs *List) bool {
|
||||
i := 0
|
||||
for {
|
||||
if i >= len(l.Items) && i >= len(rhs.Items) {
|
||||
// Lists are the same length and all items are equal.
|
||||
return false
|
||||
}
|
||||
if i >= len(l.Items) {
|
||||
// LHS is shorter.
|
||||
return true
|
||||
}
|
||||
if i >= len(rhs.Items) {
|
||||
// RHS is shorter.
|
||||
return false
|
||||
}
|
||||
if l.Items[i].Less(rhs.Items[i]) {
|
||||
// LHS is less; return
|
||||
return true
|
||||
}
|
||||
if rhs.Items[i].Less(l.Items[i]) {
|
||||
// RHS is less; return
|
||||
return false
|
||||
}
|
||||
// The items are equal; continue.
|
||||
i++
|
||||
}
|
||||
}
|
||||
|
||||
// Map is a map of key-value pairs. It represents both structs and maps. We use
|
||||
// a list and a go-language map to preserve order.
|
||||
//
|
||||
// Set and Get helpers are provided.
|
||||
type Map struct {
|
||||
Items []Field
|
||||
|
||||
// may be nil; lazily constructed.
|
||||
// TODO: Direct modifications to Items above will cause serious problems.
|
||||
index map[string]int
|
||||
// may be empty; lazily constructed.
|
||||
// TODO: Direct modifications to Items above will cause serious problems.
|
||||
order []int
|
||||
}
|
||||
|
||||
func (m *Map) computeOrder() []int {
|
||||
if len(m.order) != len(m.Items) {
|
||||
m.order = make([]int, len(m.Items))
|
||||
for i := range m.order {
|
||||
m.order[i] = i
|
||||
}
|
||||
sort.SliceStable(m.order, func(i, j int) bool {
|
||||
return m.Items[m.order[i]].Name < m.Items[m.order[j]].Name
|
||||
})
|
||||
}
|
||||
return m.order
|
||||
}
|
||||
|
||||
// Less compares two maps lexically.
|
||||
func (m *Map) Less(rhs *Map) bool {
|
||||
var noAllocL, noAllocR [2]int
|
||||
var morder, rorder []int
|
||||
|
||||
// For very short maps (<2 elements) this permits us to avoid
|
||||
// allocating the order array. We could make this accomodate larger
|
||||
// maps, but 2 items should be enough to cover most path element
|
||||
// comparisons, and at some point there will be diminishing returns.
|
||||
// This has a large effect on the path element deserialization test,
|
||||
// because everything is sorted / compared, but only once.
|
||||
switch len(m.Items) {
|
||||
case 0:
|
||||
morder = noAllocL[0:0]
|
||||
case 1:
|
||||
morder = noAllocL[0:1]
|
||||
case 2:
|
||||
morder = noAllocL[0:2]
|
||||
if m.Items[0].Name > m.Items[1].Name {
|
||||
morder[0] = 1
|
||||
} else {
|
||||
morder[1] = 1
|
||||
}
|
||||
default:
|
||||
morder = m.computeOrder()
|
||||
}
|
||||
|
||||
switch len(rhs.Items) {
|
||||
case 0:
|
||||
rorder = noAllocR[0:0]
|
||||
case 1:
|
||||
rorder = noAllocR[0:1]
|
||||
case 2:
|
||||
rorder = noAllocR[0:2]
|
||||
if rhs.Items[0].Name > rhs.Items[1].Name {
|
||||
rorder[0] = 1
|
||||
} else {
|
||||
rorder[1] = 1
|
||||
}
|
||||
default:
|
||||
rorder = rhs.computeOrder()
|
||||
}
|
||||
|
||||
i := 0
|
||||
for {
|
||||
if i >= len(morder) && i >= len(rorder) {
|
||||
// Maps are the same length and all items are equal.
|
||||
return false
|
||||
}
|
||||
if i >= len(morder) {
|
||||
// LHS is shorter.
|
||||
return true
|
||||
}
|
||||
if i >= len(rorder) {
|
||||
// RHS is shorter.
|
||||
return false
|
||||
}
|
||||
fa, fb := &m.Items[morder[i]], &rhs.Items[rorder[i]]
|
||||
if fa.Name != fb.Name {
|
||||
// the map having the field name that sorts lexically less is "less"
|
||||
return fa.Name < fb.Name
|
||||
}
|
||||
if fa.Value.Less(fb.Value) {
|
||||
// LHS is less; return
|
||||
return true
|
||||
}
|
||||
if fb.Value.Less(fa.Value) {
|
||||
// RHS is less; return
|
||||
return false
|
||||
}
|
||||
// The items are equal; continue.
|
||||
i++
|
||||
}
|
||||
}
|
||||
|
||||
// Get returns the (Field, true) or (nil, false) if it is not present
|
||||
func (m *Map) Get(key string) (*Field, bool) {
|
||||
if m.index == nil {
|
||||
m.index = map[string]int{}
|
||||
for i := range m.Items {
|
||||
m.index[m.Items[i].Name] = i
|
||||
}
|
||||
}
|
||||
f, ok := m.index[key]
|
||||
if !ok {
|
||||
return nil, false
|
||||
}
|
||||
return &m.Items[f], true
|
||||
}
|
||||
|
||||
// Set inserts or updates the given item.
|
||||
func (m *Map) Set(key string, value Value) {
|
||||
if f, ok := m.Get(key); ok {
|
||||
f.Value = value
|
||||
return
|
||||
}
|
||||
m.Items = append(m.Items, Field{Name: key, Value: value})
|
||||
i := len(m.Items) - 1
|
||||
m.index[key] = i
|
||||
m.order = nil
|
||||
}
|
||||
|
||||
// Delete removes the key from the set.
|
||||
func (m *Map) Delete(key string) {
|
||||
items := []Field{}
|
||||
for i := range m.Items {
|
||||
if m.Items[i].Name != key {
|
||||
items = append(items, m.Items[i])
|
||||
}
|
||||
}
|
||||
m.Items = items
|
||||
m.index = nil // Since the list has changed
|
||||
m.order = nil
|
||||
}
|
||||
|
||||
// StringValue returns s as a scalar string Value.
|
||||
func StringValue(s string) Value {
|
||||
s2 := String(s)
|
||||
return Value{StringValue: &s2}
|
||||
}
|
||||
|
||||
// IntValue returns i as a scalar numeric (integer) Value.
|
||||
func IntValue(i int) Value {
|
||||
i2 := Int(i)
|
||||
return Value{IntValue: &i2}
|
||||
}
|
||||
|
||||
// FloatValue returns f as a scalar numeric (float) Value.
|
||||
func FloatValue(f float64) Value {
|
||||
f2 := Float(f)
|
||||
return Value{FloatValue: &f2}
|
||||
}
|
||||
|
||||
// BooleanValue returns b as a scalar boolean Value.
|
||||
func BooleanValue(b bool) Value {
|
||||
b2 := Boolean(b)
|
||||
return Value{BooleanValue: &b2}
|
||||
}
|
||||
|
||||
// String returns a human-readable representation of the value.
|
||||
func (v Value) String() string {
|
||||
switch {
|
||||
case v.FloatValue != nil:
|
||||
return fmt.Sprintf("%v", *v.FloatValue)
|
||||
case v.IntValue != nil:
|
||||
return fmt.Sprintf("%v", *v.IntValue)
|
||||
case v.StringValue != nil:
|
||||
return fmt.Sprintf("%q", *v.StringValue)
|
||||
case v.BooleanValue != nil:
|
||||
return fmt.Sprintf("%v", *v.BooleanValue)
|
||||
case v.ListValue != nil:
|
||||
strs := []string{}
|
||||
for _, item := range v.ListValue.Items {
|
||||
strs = append(strs, item.String())
|
||||
}
|
||||
return "[" + strings.Join(strs, ",") + "]"
|
||||
case v.MapValue != nil:
|
||||
strs := []string{}
|
||||
for _, i := range v.MapValue.Items {
|
||||
strs = append(strs, fmt.Sprintf("%v=%v", i.Name, i.Value))
|
||||
}
|
||||
return "{" + strings.Join(strs, ";") + "}"
|
||||
default:
|
||||
fallthrough
|
||||
case v.Null == true:
|
||||
return "null"
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user