1. update clientset, deepcopy using code-generator
2. add a dummy file tools.go to force "go mod vendor" to see code-generator as dependencies 3. add a script to update CRD 4. add a README to document CRD updating steps run go mod tidy update README
This commit is contained in:
xiangqian
9
vendor/gonum.org/v1/gonum/graph/iterator/doc.go
generated
vendored
Normal file
9
vendor/gonum.org/v1/gonum/graph/iterator/doc.go
generated
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
// Copyright ©2018 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
// Package iterator provides node, edge and line iterators.
|
||||
//
|
||||
// The iterators provided satisfy the graph.Nodes, graph.Edges and
|
||||
// graph.Lines interfaces.
|
||||
package iterator
|
||||
131
vendor/gonum.org/v1/gonum/graph/iterator/edges.go
generated
vendored
Normal file
131
vendor/gonum.org/v1/gonum/graph/iterator/edges.go
generated
vendored
Normal file
@@ -0,0 +1,131 @@
|
||||
// Copyright ©2018 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package iterator
|
||||
|
||||
import "gonum.org/v1/gonum/graph"
|
||||
|
||||
// OrderedEdges implements the graph.Edges and graph.EdgeSlicer interfaces.
|
||||
// The iteration order of OrderedEdges is the order of edges passed to
|
||||
// NewEdgeIterator.
|
||||
type OrderedEdges struct {
|
||||
idx int
|
||||
edges []graph.Edge
|
||||
}
|
||||
|
||||
// NewOrderedEdges returns an OrderedEdges initialized with the provided edges.
|
||||
func NewOrderedEdges(edges []graph.Edge) *OrderedEdges {
|
||||
return &OrderedEdges{idx: -1, edges: edges}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of edges to be iterated over.
|
||||
func (e *OrderedEdges) Len() int {
|
||||
if e.idx >= len(e.edges) {
|
||||
return 0
|
||||
}
|
||||
if e.idx <= 0 {
|
||||
return len(e.edges)
|
||||
}
|
||||
return len(e.edges[e.idx:])
|
||||
}
|
||||
|
||||
// Next returns whether the next call of Edge will return a valid edge.
|
||||
func (e *OrderedEdges) Next() bool {
|
||||
if uint(e.idx)+1 < uint(len(e.edges)) {
|
||||
e.idx++
|
||||
return true
|
||||
}
|
||||
e.idx = len(e.edges)
|
||||
return false
|
||||
}
|
||||
|
||||
// Edge returns the current edge of the iterator. Next must have been
|
||||
// called prior to a call to Edge.
|
||||
func (e *OrderedEdges) Edge() graph.Edge {
|
||||
if e.idx >= len(e.edges) || e.idx < 0 {
|
||||
return nil
|
||||
}
|
||||
return e.edges[e.idx]
|
||||
}
|
||||
|
||||
// EdgeSlice returns all the remaining edges in the iterator and advances
|
||||
// the iterator.
|
||||
func (e *OrderedEdges) EdgeSlice() []graph.Edge {
|
||||
if e.idx >= len(e.edges) {
|
||||
return nil
|
||||
}
|
||||
idx := e.idx
|
||||
if idx == -1 {
|
||||
idx = 0
|
||||
}
|
||||
e.idx = len(e.edges)
|
||||
return e.edges[idx:]
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (e *OrderedEdges) Reset() {
|
||||
e.idx = -1
|
||||
}
|
||||
|
||||
// OrderedWeightedEdges implements the graph.Edges and graph.EdgeSlicer interfaces.
|
||||
// The iteration order of OrderedWeightedEdges is the order of edges passed to
|
||||
// NewEdgeIterator.
|
||||
type OrderedWeightedEdges struct {
|
||||
idx int
|
||||
edges []graph.WeightedEdge
|
||||
}
|
||||
|
||||
// NewOrderedWeightedEdges returns an OrderedWeightedEdges initialized with the provided edges.
|
||||
func NewOrderedWeightedEdges(edges []graph.WeightedEdge) *OrderedWeightedEdges {
|
||||
return &OrderedWeightedEdges{idx: -1, edges: edges}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of edges to be iterated over.
|
||||
func (e *OrderedWeightedEdges) Len() int {
|
||||
if e.idx >= len(e.edges) {
|
||||
return 0
|
||||
}
|
||||
if e.idx <= 0 {
|
||||
return len(e.edges)
|
||||
}
|
||||
return len(e.edges[e.idx:])
|
||||
}
|
||||
|
||||
// Next returns whether the next call of WeightedEdge will return a valid edge.
|
||||
func (e *OrderedWeightedEdges) Next() bool {
|
||||
if uint(e.idx)+1 < uint(len(e.edges)) {
|
||||
e.idx++
|
||||
return true
|
||||
}
|
||||
e.idx = len(e.edges)
|
||||
return false
|
||||
}
|
||||
|
||||
// WeightedEdge returns the current edge of the iterator. Next must have been
|
||||
// called prior to a call to WeightedEdge.
|
||||
func (e *OrderedWeightedEdges) WeightedEdge() graph.WeightedEdge {
|
||||
if e.idx >= len(e.edges) || e.idx < 0 {
|
||||
return nil
|
||||
}
|
||||
return e.edges[e.idx]
|
||||
}
|
||||
|
||||
// WeightedEdgeSlice returns all the remaining edges in the iterator and advances
|
||||
// the iterator.
|
||||
func (e *OrderedWeightedEdges) WeightedEdgeSlice() []graph.WeightedEdge {
|
||||
if e.idx >= len(e.edges) {
|
||||
return nil
|
||||
}
|
||||
idx := e.idx
|
||||
if idx == -1 {
|
||||
idx = 0
|
||||
}
|
||||
e.idx = len(e.edges)
|
||||
return e.edges[idx:]
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (e *OrderedWeightedEdges) Reset() {
|
||||
e.idx = -1
|
||||
}
|
||||
131
vendor/gonum.org/v1/gonum/graph/iterator/lines.go
generated
vendored
Normal file
131
vendor/gonum.org/v1/gonum/graph/iterator/lines.go
generated
vendored
Normal file
@@ -0,0 +1,131 @@
|
||||
// Copyright ©2018 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package iterator
|
||||
|
||||
import "gonum.org/v1/gonum/graph"
|
||||
|
||||
// OrderedLines implements the graph.Lines and graph.LineSlicer interfaces.
|
||||
// The iteration order of OrderedLines is the order of lines passed to
|
||||
// NewLineIterator.
|
||||
type OrderedLines struct {
|
||||
idx int
|
||||
lines []graph.Line
|
||||
}
|
||||
|
||||
// NewOrderedLines returns an OrderedLines initialized with the provided lines.
|
||||
func NewOrderedLines(lines []graph.Line) *OrderedLines {
|
||||
return &OrderedLines{idx: -1, lines: lines}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of lines to be iterated over.
|
||||
func (e *OrderedLines) Len() int {
|
||||
if e.idx >= len(e.lines) {
|
||||
return 0
|
||||
}
|
||||
if e.idx <= 0 {
|
||||
return len(e.lines)
|
||||
}
|
||||
return len(e.lines[e.idx:])
|
||||
}
|
||||
|
||||
// Next returns whether the next call of Line will return a valid line.
|
||||
func (e *OrderedLines) Next() bool {
|
||||
if uint(e.idx)+1 < uint(len(e.lines)) {
|
||||
e.idx++
|
||||
return true
|
||||
}
|
||||
e.idx = len(e.lines)
|
||||
return false
|
||||
}
|
||||
|
||||
// Line returns the current line of the iterator. Next must have been
|
||||
// called prior to a call to Line.
|
||||
func (e *OrderedLines) Line() graph.Line {
|
||||
if e.idx >= len(e.lines) || e.idx < 0 {
|
||||
return nil
|
||||
}
|
||||
return e.lines[e.idx]
|
||||
}
|
||||
|
||||
// LineSlice returns all the remaining lines in the iterator and advances
|
||||
// the iterator.
|
||||
func (e *OrderedLines) LineSlice() []graph.Line {
|
||||
if e.idx >= len(e.lines) {
|
||||
return nil
|
||||
}
|
||||
idx := e.idx
|
||||
if idx == -1 {
|
||||
idx = 0
|
||||
}
|
||||
e.idx = len(e.lines)
|
||||
return e.lines[idx:]
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (e *OrderedLines) Reset() {
|
||||
e.idx = -1
|
||||
}
|
||||
|
||||
// OrderedWeightedLines implements the graph.Lines and graph.LineSlicer interfaces.
|
||||
// The iteration order of OrderedWeightedLines is the order of lines passed to
|
||||
// NewLineIterator.
|
||||
type OrderedWeightedLines struct {
|
||||
idx int
|
||||
lines []graph.WeightedLine
|
||||
}
|
||||
|
||||
// NewWeightedLineIterator returns an OrderedWeightedLines initialized with the provided lines.
|
||||
func NewOrderedWeightedLines(lines []graph.WeightedLine) *OrderedWeightedLines {
|
||||
return &OrderedWeightedLines{idx: -1, lines: lines}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of lines to be iterated over.
|
||||
func (e *OrderedWeightedLines) Len() int {
|
||||
if e.idx >= len(e.lines) {
|
||||
return 0
|
||||
}
|
||||
if e.idx <= 0 {
|
||||
return len(e.lines)
|
||||
}
|
||||
return len(e.lines[e.idx:])
|
||||
}
|
||||
|
||||
// Next returns whether the next call of WeightedLine will return a valid line.
|
||||
func (e *OrderedWeightedLines) Next() bool {
|
||||
if uint(e.idx)+1 < uint(len(e.lines)) {
|
||||
e.idx++
|
||||
return true
|
||||
}
|
||||
e.idx = len(e.lines)
|
||||
return false
|
||||
}
|
||||
|
||||
// WeightedLine returns the current line of the iterator. Next must have been
|
||||
// called prior to a call to WeightedLine.
|
||||
func (e *OrderedWeightedLines) WeightedLine() graph.WeightedLine {
|
||||
if e.idx >= len(e.lines) || e.idx < 0 {
|
||||
return nil
|
||||
}
|
||||
return e.lines[e.idx]
|
||||
}
|
||||
|
||||
// WeightedLineSlice returns all the remaining lines in the iterator and advances
|
||||
// the iterator.
|
||||
func (e *OrderedWeightedLines) WeightedLineSlice() []graph.WeightedLine {
|
||||
if e.idx >= len(e.lines) {
|
||||
return nil
|
||||
}
|
||||
idx := e.idx
|
||||
if idx == -1 {
|
||||
idx = 0
|
||||
}
|
||||
e.idx = len(e.lines)
|
||||
return e.lines[idx:]
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (e *OrderedWeightedLines) Reset() {
|
||||
e.idx = -1
|
||||
}
|
||||
125
vendor/gonum.org/v1/gonum/graph/iterator/nodes.go
generated
vendored
Normal file
125
vendor/gonum.org/v1/gonum/graph/iterator/nodes.go
generated
vendored
Normal file
@@ -0,0 +1,125 @@
|
||||
// Copyright ©2018 The Gonum Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style
|
||||
// license that can be found in the LICENSE file.
|
||||
|
||||
package iterator
|
||||
|
||||
import "gonum.org/v1/gonum/graph"
|
||||
|
||||
// OrderedNodes implements the graph.Nodes and graph.NodeSlicer interfaces.
|
||||
// The iteration order of OrderedNodes is the order of nodes passed to
|
||||
// NewNodeIterator.
|
||||
type OrderedNodes struct {
|
||||
idx int
|
||||
nodes []graph.Node
|
||||
}
|
||||
|
||||
// NewOrderedNodes returns a OrderedNodes initialized with the provided nodes.
|
||||
func NewOrderedNodes(nodes []graph.Node) *OrderedNodes {
|
||||
return &OrderedNodes{idx: -1, nodes: nodes}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of nodes to be iterated over.
|
||||
func (n *OrderedNodes) Len() int {
|
||||
if n.idx >= len(n.nodes) {
|
||||
return 0
|
||||
}
|
||||
if n.idx <= 0 {
|
||||
return len(n.nodes)
|
||||
}
|
||||
return len(n.nodes[n.idx:])
|
||||
}
|
||||
|
||||
// Next returns whether the next call of Node will return a valid node.
|
||||
func (n *OrderedNodes) Next() bool {
|
||||
if uint(n.idx)+1 < uint(len(n.nodes)) {
|
||||
n.idx++
|
||||
return true
|
||||
}
|
||||
n.idx = len(n.nodes)
|
||||
return false
|
||||
}
|
||||
|
||||
// Node returns the current node of the iterator. Next must have been
|
||||
// called prior to a call to Node.
|
||||
func (n *OrderedNodes) Node() graph.Node {
|
||||
if n.idx >= len(n.nodes) || n.idx < 0 {
|
||||
return nil
|
||||
}
|
||||
return n.nodes[n.idx]
|
||||
}
|
||||
|
||||
// NodeSlice returns all the remaining nodes in the iterator and advances
|
||||
// the iterator.
|
||||
func (n *OrderedNodes) NodeSlice() []graph.Node {
|
||||
if n.idx >= len(n.nodes) {
|
||||
return nil
|
||||
}
|
||||
idx := n.idx
|
||||
if idx == -1 {
|
||||
idx = 0
|
||||
}
|
||||
n.idx = len(n.nodes)
|
||||
return n.nodes[idx:]
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (n *OrderedNodes) Reset() {
|
||||
n.idx = -1
|
||||
}
|
||||
|
||||
// ImplicitNodes implements the graph.Nodes interface for a set of nodes over
|
||||
// a contiguous ID range.
|
||||
type ImplicitNodes struct {
|
||||
beg, end int
|
||||
curr int
|
||||
newNode func(id int) graph.Node
|
||||
}
|
||||
|
||||
// NewImplicitNodes returns a new implicit node iterator spanning nodes in [beg,end).
|
||||
// The provided new func maps the id to a graph.Node. NewImplicitNodes will panic
|
||||
// if beg is greater than end.
|
||||
func NewImplicitNodes(beg, end int, new func(id int) graph.Node) *ImplicitNodes {
|
||||
if beg > end {
|
||||
panic("iterator: invalid range")
|
||||
}
|
||||
return &ImplicitNodes{beg: beg, end: end, curr: beg - 1, newNode: new}
|
||||
}
|
||||
|
||||
// Len returns the remaining number of nodes to be iterated over.
|
||||
func (n *ImplicitNodes) Len() int {
|
||||
return n.end - n.curr - 1
|
||||
}
|
||||
|
||||
// Next returns whether the next call of Node will return a valid node.
|
||||
func (n *ImplicitNodes) Next() bool {
|
||||
if n.curr == n.end {
|
||||
return false
|
||||
}
|
||||
n.curr++
|
||||
return n.curr < n.end
|
||||
}
|
||||
|
||||
// Node returns the current node of the iterator. Next must have been
|
||||
// called prior to a call to Node.
|
||||
func (n *ImplicitNodes) Node() graph.Node {
|
||||
if n.Len() == -1 || n.curr < n.beg {
|
||||
return nil
|
||||
}
|
||||
return n.newNode(n.curr)
|
||||
}
|
||||
|
||||
// Reset returns the iterator to its initial state.
|
||||
func (n *ImplicitNodes) Reset() {
|
||||
n.curr = n.beg - 1
|
||||
}
|
||||
|
||||
// NodeSlice returns all the remaining nodes in the iterator and advances
|
||||
// the iterator.
|
||||
func (n *ImplicitNodes) NodeSlice() []graph.Node {
|
||||
nodes := make([]graph.Node, 0, n.Len())
|
||||
for n.curr++; n.curr < n.end; n.curr++ {
|
||||
nodes = append(nodes, n.newNode(n.curr))
|
||||
}
|
||||
return nodes
|
||||
}
|
||||
Reference in New Issue
Block a user