Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package kitty for openSUSE:Factory checked
in at 2024-09-08 11:59:48
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/kitty (Old)
and /work/SRC/openSUSE:Factory/.kitty.new.10096 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "kitty"
Sun Sep 8 11:59:48 2024 rev:37 rq:1199239 version:0.36.2
Changes:
--------
--- /work/SRC/openSUSE:Factory/kitty/kitty.changes 2024-08-26
22:13:24.257969528 +0200
+++ /work/SRC/openSUSE:Factory/.kitty.new.10096/kitty.changes 2024-09-08
12:01:24.546015671 +0200
@@ -1,0 +2,16 @@
+Fri Sep 6 14:11:41 UTC 2024 - Scott Bradnick <scott.bradn...@suse.com>
+
+- Update to 0.36.2:
+ * Linux: Fix a regression in 0.36.0 that caused font features defined via
+ fontconfig to be ignored (#7773)
+ * goto_tab: Allow numbers less than -1 to go to the Nth previously active tab
+ * Wayland: Fix for upcoming explicit sync changes in Wayland compositors
+ breaking kitty (#7767)
+ * Remote control: When listening on a UNIX domain socket only allow
+ connections from processes having the same user id (#7777)
+ * kitten @: Fix a regression connecting to TCP sockets using plain IP
+ addresses rather than hostnames (#7794)
+ * diff kitten: Fix a regression that broke diffing against remote
+ files (#7797)
+
+-------------------------------------------------------------------
Old:
----
kitty-0.36.1.tar.gz
New:
----
kitty-0.36.2.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ kitty.spec ++++++
--- /var/tmp/diff_new_pack.zD9CgQ/_old 2024-09-08 12:01:25.094038358 +0200
+++ /var/tmp/diff_new_pack.zD9CgQ/_new 2024-09-08 12:01:25.098038524 +0200
@@ -19,7 +19,7 @@
# sphinx_copybutton not in Factory
%bcond_with docs
Name: kitty
-Version: 0.36.1
+Version: 0.36.2
Release: 0
Summary: A GPU-based terminal emulator
License: GPL-3.0-only
@@ -35,7 +35,6 @@
BuildRequires: fontconfig-devel
BuildRequires: freetype2-devel
### Avoiding any 'have choice for go' issues ...
-#BuildRequires: go1.22
BuildRequires: go >= 1.23
#####
### Temporarily disabled until go1.23 is default
++++++ kitty-0.36.1.tar.gz -> kitty-0.36.2.tar.gz ++++++
/work/SRC/openSUSE:Factory/kitty/kitty-0.36.1.tar.gz
/work/SRC/openSUSE:Factory/.kitty.new.10096/kitty-0.36.2.tar.gz differ: char
12, line 1
++++++ vendor.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addr.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addr.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addr.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addr.go
2024-09-06 16:13:42.000000000 +0200
@@ -2015,11 +2015,6 @@
return addr
}
-// toAddressBase is needed for tries
-func (addr *Address) toAddressBase() *Address {
- return addr
-}
-
// ToIP converts to an IPAddress if this address or subnet originated as an
IPv4 or IPv6 address or subnet, or an implicitly zero-valued IP.
// If not, ToIP returns nil.
//
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrerr/err.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrerr/err.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrerr/err.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrerr/err.go
2024-09-06 16:13:42.000000000 +0200
@@ -1,5 +1,5 @@
//
-// Copyright 2020-2022 Sean C Foley
+// Copyright 2020-2024 Sean C Foley
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addriterator.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addriterator.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addriterator.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addriterator.go
2024-09-06 16:13:42.000000000 +0200
@@ -34,7 +34,6 @@
Remove() T
}
-//
type singleIterator[T any] struct {
empty bool
original T
@@ -52,7 +51,6 @@
return
}
-//
type multiAddrIterator struct {
Iterator[*AddressSection]
zone Zone
@@ -134,7 +132,6 @@
return iter.Iterator.Next().ToIP()
}
-//
type sliceIterator[T any] struct {
elements []T
}
@@ -151,7 +148,6 @@
return
}
-//
type ipv4AddressIterator struct {
Iterator[*Address]
}
@@ -160,7 +156,6 @@
return iter.Iterator.Next().ToIPv4()
}
-//
type ipv6AddressIterator struct {
Iterator[*Address]
}
@@ -169,7 +164,6 @@
return iter.Iterator.Next().ToIPv6()
}
-//
type macAddressIterator struct {
Iterator[*Address]
}
@@ -178,7 +172,6 @@
return iter.Iterator.Next().ToMAC()
}
-//
type addressSeriesIterator struct {
Iterator[*Address]
}
@@ -190,7 +183,6 @@
return wrapAddress(iter.Iterator.Next())
}
-//
type ipaddressSeriesIterator struct {
Iterator[*IPAddress]
}
@@ -202,7 +194,6 @@
return iter.Iterator.Next().Wrap()
}
-//
type sectionSeriesIterator struct {
Iterator[*AddressSection]
}
@@ -214,7 +205,6 @@
return wrapSection(iter.Iterator.Next())
}
-//
type ipSectionSeriesIterator struct {
Iterator[*IPAddressSection]
}
@@ -225,3 +215,139 @@
}
return wrapIPSection(iter.Iterator.Next())
}
+
+// StdPushIterator converts a "pull" iterator in this libary to a "push"
iterator assignable to the type iter.Seq in the standard library.
+//
+// The returned iterator is a single-use iterator.
+//
+// This function does not return iter.Seq directly, instead it returns a
func(yield func(V) bool) assignable to a variable of type iter.Seq[V].
+// This avoids adding a dependency of this libary on Go version 1.23 while
still integrating with the iter package introduced with Go 1.23.
+//
+// To convert an instance of IteratorWithRemove, wrap it by calling
NewPointIteratorWithRemove first, then pass the returned iterator this function.
+// To convert an instance of CachingTrieIterator, wrap it by calling
NewPointCachingTrieIterator first, then pass the returned iterator this
function.
+//
+// You should avoid doing a double conversion on an iterator from this library,
+// first to a "push" iterator with StdPushIterator and then to a "pull"
iterator using iter.Pull in the standard libary.
+// The result is an iterator less efficient than the original that also
requires a call to the "stop" function to release resources.
+// Instead, use StdPullIterator to get a pull iterator with an API similar to
that provided by iter.Pull.
+func StdPushIterator[V any](iterator Iterator[V]) func(yield func(V) bool) {
+ return func(yield func(V) bool) {
+ for iterator.HasNext() && yield(iterator.Next()) {
+ }
+ }
+}
+
+// StdPullIterator converts a "pull" iterator from this library to a standard
library "pull" iterator
+// consisting of a single function for iterating, and a second function for
stopping.
+//
+// Note that the stop function is a no-op for all iterators in this library.
+// It does nothing, and can be ignored. It is provided only to match the
returned values of iter.Pull.
+// To convert an instance of IteratorWithRemove, wrap it by calling
NewPointIteratorWithRemove first, then pass the returned iterator this function.
+// To convert an instance of CachingTrieIterator, wrap it by calling
NewPointCachingTrieIterator first, then pass the returned iterator this
function.
+//
+// This function produces an iterator equivalent to the original. It is a
single-use iterator, like the original.
+//
+// Use this function rather than a double conversion: firstly to a "push"
iterator with StdPushIterator,
+// and secondly to a "pull" iterator using iter.Pull from the standard libary.
+// The double-conversion produces a final iterator less efficient than the
original.
+func StdPullIterator[V any](iterator Iterator[V]) (next func() (V, bool), stop
func()) {
+ stop, next = func() {}, func() (V, bool) {
+ hasNext := iterator.HasNext()
+ return iterator.Next(), hasNext
+ }
+ return
+}
+
+// NewPointIteratorWithRemove can be used to convert an IteratorWithRemove to
standard libary iterators.
+// Call this function, and then pass the returned iterator to either
StdPushIterator or StdPullIterator.
+// This preserves access to the removal operation of the original iterator,
now available through each element, IteratorWithRemovePosition.
+func NewPointIteratorWithRemove[V any](iterator IteratorWithRemove[V])
Iterator[IteratorWithRemovePosition[V]] {
+ wrappedIter := pointIteratorWithRemove[V]{IteratorWithRemove: iterator}
+ castIter := Iterator[IteratorWithRemovePosition[V]](&wrappedIter)
+ return castIter
+}
+
+type pointIteratorWithRemove[V any] struct {
+ IteratorWithRemove[V]
+}
+
+func (iter pointIteratorWithRemove[V]) Next() IteratorWithRemovePosition[V] {
+ return IteratorWithRemovePosition[V]{
+ v: iter.IteratorWithRemove.Next(),
+ iter: iter.IteratorWithRemove,
+ }
+}
+
+func (iter pointIteratorWithRemove[V]) HasNext() bool {
+ return iter.IteratorWithRemove.HasNext()
+}
+
+// IteratorWithRemovePosition is an element returned from a
PointIteratorWithRemove.
+type IteratorWithRemovePosition[V any] struct {
+ v V
+ iter IteratorWithRemove[V]
+}
+
+// Value returns the iterator value associated with this iterator position.
+func (iterPosition IteratorWithRemovePosition[V]) Value() V {
+ return iterPosition.v
+}
+
+// Remove removes the current iterated value from the underlying data
structure or collection, and returns that element.
+// If there is no such element, because it has been removed already or there
are no more iterated elements, it returns the zero value for T.
+func (iterPosition IteratorWithRemovePosition[V]) Remove() V {
+ return iterPosition.iter.Remove()
+}
+
+// NewPointCachingTrieIterator can be used to convert a CachingTrieIterator to
standard libary iterators.
+// Call this function, and then pass the returned iterator to either
StdPushIterator or StdPullIterator.
+// This preserves access to the removal and caching operations of the original
iterator, now available through each element of type
CachingTrieIteratorPosition.
+func NewPointCachingTrieIterator[V any](iterator CachingTrieIterator[V])
Iterator[CachingTrieIteratorPosition[V]] {
+ wrappedIter := pointCachingTrieIterator[V]{CachingTrieIterator:
iterator}
+ castIter := Iterator[CachingTrieIteratorPosition[V]](&wrappedIter)
+ return castIter
+}
+
+type pointCachingTrieIterator[V any] struct {
+ CachingTrieIterator[V]
+}
+
+func (iter pointCachingTrieIterator[V]) Next() CachingTrieIteratorPosition[V] {
+ return CachingTrieIteratorPosition[V]{
+ v: iter.CachingTrieIterator.Next(),
+ iter: iter.CachingTrieIterator,
+ }
+}
+
+func (iter pointCachingTrieIterator[V]) HasNext() bool {
+ return iter.CachingTrieIterator.HasNext()
+}
+
+// CachingTrieIteratorPosition is an element returned from an iterator created
with NewPointCachingTrieIterator.
+type CachingTrieIteratorPosition[V any] struct {
+ v V
+ iter CachingTrieIterator[V]
+}
+
+// Value returns the iterator value associated with this iterator position.
+func (iterPosition CachingTrieIteratorPosition[V]) Value() V {
+ return iterPosition.v
+}
+
+// Remove removes the current iterated value from the underlying data
structure or collection, and returns that element.
+// If there is no such element, because it has been removed already or there
are no more iterated elements, it returns the zero value for T.
+func (iterPosition CachingTrieIteratorPosition[V]) Remove() V {
+ return iterPosition.iter.Remove()
+}
+
+func (iterPosition CachingTrieIteratorPosition[V]) GetCached() Cached {
+ return iterPosition.iter.GetCached()
+}
+
+func (iterPosition CachingTrieIteratorPosition[V])
CacheWithLowerSubNode(cached Cached) bool {
+ return iterPosition.iter.CacheWithLowerSubNode(cached)
+}
+
+func (iterPosition CachingTrieIteratorPosition[V])
CacheWithUpperSubNode(cached Cached) bool {
+ return iterPosition.iter.CacheWithUpperSubNode(cached)
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrie.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrie.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrie.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrie.go
2024-09-06 16:13:42.000000000 +0200
@@ -168,7 +168,7 @@
}
// Iterates all nodes, ordered by keys from largest prefix blocks to smallest,
and then to individual addresses.
-func (trie *trieBase[T, V]) containingFirstIterator(forwardSubNodeOrder bool)
tree.CachingTrieNodeIterator[trieKey[T], V] {
+func (trie *trieBase[T, V]) containingFirstIterator(forwardSubNodeOrder bool)
tree.TrieNodeIteratorRem[trieKey[T], V] {
return trie.toTrie().ContainingFirstIterator(forwardSubNodeOrder)
}
@@ -323,13 +323,17 @@
//
// The unique and pre-defined structure for a trie means that different means
of traversing the trie can be more meaningful.
// This trie implementation provides 8 different ways of iterating through the
trie:
-// - 1, 2: the natural sorted trie order, forward and reverse (spliterating
is also an option for these two orders). Use the methods NodeIterator,
Iterator or DescendingIterator. Functions for incrementing and decrementing
keys, or comparing keys, is also provided for this order.
-// - 3, 4: pre-order tree traversal, in which parent node is visited before
sub-nodes, with sub-nodes visited in forward or reverse order
-// - 5, 6: post-order tree traversal, in which sub-nodes are visited before
parent nodes, with sub-nodes visited in forward or reverse order
-// - 7, 8: prefix-block order, in which larger prefix blocks are visited
before smaller, and blocks of equal size are visited in forward or reverse
sorted order
+// - 1, 2: the natural sorted trie order, forward and reverse (spliterating
is also an option for these two orders). Use the methods Iterator,
DescendingIterator, NodeIterator, or AllNodeIterator. Functions for
incrementing and decrementing keys, or comparing keys, are also provided for
this ordering of addresses.
+// - 3, 4: pre-order tree traversal, in which parent node is visited before
sub-nodes, with sub-nodes visited in forward or reverse order. Use the methods
ContainingFirstIterator or ContainingFirstAllNodeIterator.
+// - 5, 6: post-order tree traversal, in which sub-nodes are visited before
parent nodes, with sub-nodes visited in forward or reverse order. Use the
methods ContainedFirstIterator or ContainedFirstAllNodeIterator.
+// - 7, 8: prefix-block order, in which larger prefix blocks are visited
before smaller, and blocks of equal size are visited in forward or reverse
sorted order. Use the methods BlockSizeNodeIterator, BlockSizeAllNodeIterator,
or BlockSizeCachingAllNodeIterator.
//
// All of these orderings are useful in specific contexts.
//
+// The pre-order tree traversal and prefix-block orders visit parent nodes
before their respective sub-nodes,
+// and thus provide iterators that allow you to cache data with each sub-node
when visiting the parent,
+// providing more efficient iteration when you need information about the path
to the node when visiting each node.
+//
// If you create an iterator, then that iterator can no longer be advanced
following any further modification to the trie.
// Any call to Next or Remove will panic if the trie was changed following
creation of the iterator.
//
@@ -610,6 +614,9 @@
}
// BlockSizeCachingAllNodeIterator returns an iterator that iterates all
nodes, ordered by keys from largest prefix blocks to smallest, and then to
individual addresses.
+// The returned iterator of type CachingTrieIterator allows you to cache an
object with the lower or upper sub-node of the currently visited node.
+// Each cached object can be retrieved later when iterating the sub-nodes.
That allows you to provide iteration context from a parent to its sub-nodes
when iterating.
+// If the caching functionality is not needed, use BlockSizeAllNodeIterator.
func (trie *Trie[T]) BlockSizeCachingAllNodeIterator()
CachingTrieIterator[*TrieNode[T]] {
return cachingAddressTrieNodeIterator[T,
emptyValue]{trie.toBase().blockSizeCachingAllNodeIterator()}
}
@@ -617,19 +624,8 @@
// ContainingFirstIterator returns an iterator that does a pre-order binary
tree traversal of the added nodes.
// All added nodes will be visited before their added sub-nodes.
// For an address trie this means added containing subnet blocks will be
visited before their added contained addresses and subnet blocks.
-//
-// Once a given node is visited, the iterator allows you to cache an object
corresponding to the
-// lower or upper sub-node that can be retrieved when you later visit that
sub-node.
-//
-// Objects are cached only with nodes to be visited.
-// So for this iterator that means an object will be cached with the first
added lower or upper sub-node,
-// the next lower or upper sub-node to be visited,
-// which is not necessarily the direct lower or upper sub-node of a given node.
-//
-// The caching allows you to provide iteration context from a parent to its
sub-nodes when iterating.
-// The caching and retrieval is done in constant-time.
-func (trie *Trie[T]) ContainingFirstIterator(forwardSubNodeOrder bool)
CachingTrieIterator[*TrieNode[T]] {
- return cachingAddressTrieNodeIterator[T,
emptyValue]{trie.toBase().containingFirstIterator(forwardSubNodeOrder)}
+func (trie *Trie[T]) ContainingFirstIterator(forwardSubNodeOrder bool)
IteratorWithRemove[*TrieNode[T]] {
+ return addrTrieNodeIteratorRem[T,
emptyValue]{trie.toBase().containingFirstIterator(forwardSubNodeOrder)}
}
// ContainingFirstAllNodeIterator returns an iterator that does a pre-order
binary tree traversal.
@@ -1033,26 +1029,18 @@
}
// BlockSizeCachingAllNodeIterator returns an iterator that iterates all
nodes, ordered by keys from largest prefix blocks to smallest, and then to
individual addresses.
+// The returned iterator of type CachingTrieIterator allows you to cache an
object with the lower or upper sub-node of the currently visited node.
+// Each cached object can be retrieved later when iterating the sub-nodes.
That allows you to provide iteration context from a parent to its sub-nodes
when iterating.
+// If the caching functionality is not needed, use BlockSizeAllNodeIterator.
func (trie *AssociativeTrie[T, V]) BlockSizeCachingAllNodeIterator()
CachingTrieIterator[*AssociativeTrieNode[T, V]] {
- return cachingAssociativeAddressTrieNodeIteratorX[T,
V]{trie.toBase().blockSizeCachingAllNodeIterator()}
+ return cachingAssociativeAddressTrieNodeIterator[T,
V]{trie.toBase().blockSizeCachingAllNodeIterator()}
}
// ContainingFirstIterator returns an iterator that does a pre-order binary
trie traversal of the added nodes.
// All added nodes will be visited before their added sub-nodes.
// For an address trie this means added containing subnet blocks will be
visited before their added contained addresses and subnet blocks.
-//
-// Once a given node is visited, the iterator allows you to cache an object
corresponding to the
-// lower or upper sub-node that can be retrieved when you later visit that
sub-node.
-//
-// Objects are cached only with nodes to be visited.
-// So for this iterator that means an object will be cached with the first
added lower or upper sub-node,
-// the next lower or upper sub-node to be visited,
-// which is not necessarily the direct lower or upper sub-node of a given node.
-//
-// The caching allows you to provide iteration context from a parent to its
sub-nodes when iterating.
-// The caching and retrieval is done in constant-time.
-func (trie *AssociativeTrie[T, V]) ContainingFirstIterator(forwardSubNodeOrder
bool) CachingTrieIterator[*AssociativeTrieNode[T, V]] {
- return cachingAssociativeAddressTrieNodeIteratorX[T,
V]{trie.toBase().containingFirstIterator(forwardSubNodeOrder)}
+func (trie *AssociativeTrie[T, V]) ContainingFirstIterator(forwardSubNodeOrder
bool) IteratorWithRemove[*AssociativeTrieNode[T, V]] {
+ return associativeAddressTrieNodeIteratorRem[T,
V]{trie.toBase().containingFirstIterator(forwardSubNodeOrder)}
}
// ContainingFirstAllNodeIterator returns an iterator that does a pre-order
binary trie traversal.
@@ -1064,7 +1052,7 @@
// That allows you to provide iteration context from a parent to its sub-nodes
when iterating.
// The caching and retrieval is done in constant-time.
func (trie *AssociativeTrie[T, V])
ContainingFirstAllNodeIterator(forwardSubNodeOrder bool)
CachingTrieIterator[*AssociativeTrieNode[T, V]] {
- return cachingAssociativeAddressTrieNodeIteratorX[T,
V]{trie.toBase().containingFirstAllNodeIterator(forwardSubNodeOrder)}
+ return cachingAssociativeAddressTrieNodeIterator[T,
V]{trie.toBase().containingFirstAllNodeIterator(forwardSubNodeOrder)}
}
// ContainedFirstIterator returns an iterator that does a post-order binary
trie traversal of the added nodes.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrieiterator.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrieiterator.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrieiterator.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrieiterator.go
2024-09-06 16:13:42.000000000 +0200
@@ -46,7 +46,7 @@
// be retrieved with GetCached when the lower sub-node is visited later.
//
// Returns false if it could not be cached, either because the node has
since been removed with a call to Remove,
- // because Next has not been called yet, or because there is no lower
sub node for the node previously returned by Next.
+ // because Next has not been called yet, or because there is no lower
sub node for the node previously returned by Next.
//
// The caching and retrieval is done in constant time.
CacheWithLowerSubNode(Cached) bool
@@ -153,15 +153,15 @@
//
-type cachingAssociativeAddressTrieNodeIteratorX[T TrieKeyConstraint[T], V any]
struct {
+type cachingAssociativeAddressTrieNodeIterator[T TrieKeyConstraint[T], V any]
struct {
tree.CachingTrieNodeIterator[trieKey[T], V]
}
-func (iter cachingAssociativeAddressTrieNodeIteratorX[T, V]) Next()
*AssociativeTrieNode[T, V] {
+func (iter cachingAssociativeAddressTrieNodeIterator[T, V]) Next()
*AssociativeTrieNode[T, V] {
return toAssociativeTrieNode[T, V](iter.CachingTrieNodeIterator.Next())
}
-func (iter cachingAssociativeAddressTrieNodeIteratorX[T, V]) Remove()
*AssociativeTrieNode[T, V] {
+func (iter cachingAssociativeAddressTrieNodeIterator[T, V]) Remove()
*AssociativeTrieNode[T, V] {
return toAssociativeTrieNode[T,
V](iter.CachingTrieNodeIterator.Remove())
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrienode.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrienode.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrienode.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtrienode.go
2024-09-06 16:13:42.000000000 +0200
@@ -35,8 +35,11 @@
IsOneBit(index BitCount) bool // AddressComponent
- toAddressBase() *Address // AddressType - used by MatchBits
+ ToAddressBase() *Address // used by MatchBits, and made public for
users who use TrieKeyConstraint in generic code.
+ // getPrefixLen is a performance enhancement.
+ // GetPrefixLen is also a part of this interface, through
PrefixedConstraint,
+ // but getPrefixLen avoids the copy required so that the cached prefix
len is not overwritten using the returned pointer.
getPrefixLen() PrefixLen
toMaxLower() T
@@ -61,7 +64,7 @@
func (a trieKey[T]) ToPrefixBlockLen(bitCount BitCount) trieKey[T] {
addr := a.address.ToPrefixBlockLen(bitCount)
if addr != a.address {
- addr.toAddressBase().assignTrieCache()
+ addr.ToAddressBase().assignTrieCache()
}
return trieKey[T]{address: addr}
}
@@ -110,11 +113,11 @@
// When comparing 0.0.0.0/0, which has no prefix, to other addresses, the
first bit in the other address determines the ordering.
// If 1 it is larger and if 0 it is smaller than 0.0.0.0/0.
func (a trieKey[T]) Compare(other trieKey[T]) int {
- return a.address.trieCompare(other.address.toAddressBase())
+ return a.address.trieCompare(other.address.ToAddressBase())
}
func (a trieKey[T]) GetTrieKeyData() *tree.TrieKeyData {
- return a.address.toAddressBase().getTrieCache()
+ return a.address.ToAddressBase().getTrieCache()
}
// Note: We could instead have implemented followingBitsFlag as a *uint64
returned from BitsMatchPartially.
@@ -124,7 +127,7 @@
// MatchBits returns false if we need to keep going and try to match sub-nodes.
// MatchBits returns true if the bits do not match, or the bits match to the
very end.
func (a trieKey[T]) MatchBits(key trieKey[T], bitIndex int, simpleSearch bool,
handleMatch tree.KeyCompareResult, newTrieCache *tree.TrieKeyData)
(continueToNext bool, followingBitsFlag uint64) {
- existingAddr := key.address.toAddressBase()
+ existingAddr := key.address.ToAddressBase()
if simpleSearch {
// this is the optimized path for the case where we do not need
to know how many of the initial bits match in a mismatch
@@ -318,7 +321,7 @@
}
}
- newAddr := a.address.toAddressBase()
+ newAddr := a.address.ToAddressBase()
bitsPerSegment := existingAddr.GetBitsPerSegment()
bytesPerSegment := existingAddr.GetBytesPerSegment()
segmentIndex := getHostSegmentIndex(bitIndex, bytesPerSegment,
bitsPerSegment)
@@ -526,7 +529,7 @@
return node.toBinTrieNode().BlockSizeCachingAllNodeIterator()
}
-func (node *trieNode[T, V]) containingFirstIterator(forwardSubNodeOrder bool)
tree.CachingTrieNodeIterator[trieKey[T], V] {
+func (node *trieNode[T, V]) containingFirstIterator(forwardSubNodeOrder bool)
tree.TrieNodeIteratorRem[trieKey[T], V] {
return node.toBinTrieNode().ContainingFirstIterator(forwardSubNodeOrder)
}
@@ -824,6 +827,10 @@
// BlockSizeCachingAllNodeIterator returns an iterator that iterates all
nodes, ordered by keys from largest prefix blocks to smallest and then to
individual addresses,
// in the sub-trie with this node as the root.
+//
+// The returned iterator of type CachingTrieIterator allows you to cache an
object with the lower or upper sub-node of the currently visited node.
+// Each cached object can be retrieved later when iterating the sub-nodes.
That allows you to provide iteration context from a parent to its sub-nodes
when iterating.
+// If the caching functionality is not needed, use BlockSizeAllNodeIterator.
func (node *TrieNode[T]) BlockSizeCachingAllNodeIterator()
CachingTrieIterator[*TrieNode[T]] {
return cachingAddressTrieNodeIterator[T,
emptyValue]{node.toBase().blockSizeCachingAllNodeIterator()}
}
@@ -833,19 +840,8 @@
//
// All added nodes will be visited before their added sub-nodes.
// For an address trie this means added containing subnet blocks will be
visited before their added contained addresses and subnet blocks.
-//
-// Once a given node is visited, the iterator allows you to cache an object
corresponding to the
-// lower or upper sub-node that can be retrieved when you later visit that
sub-node.
-//
-// Objects are cached only with nodes to be visited.
-// So for this iterator that means an object will be cached with the first
added lower or upper sub-node,
-// the next lower or upper sub-node to be visited,
-// which is not necessarily the direct lower or upper sub-node of a given node.
-//
-// The caching allows you to provide iteration context from a parent to its
sub-nodes when iterating.
-// The caching and retrieval is done in constant-time.
-func (node *TrieNode[T]) ContainingFirstIterator(forwardSubNodeOrder bool)
CachingTrieIterator[*TrieNode[T]] {
- return cachingAddressTrieNodeIterator[T,
emptyValue]{node.toBase().containingFirstIterator(forwardSubNodeOrder)}
+func (node *TrieNode[T]) ContainingFirstIterator(forwardSubNodeOrder bool)
IteratorWithRemove[*TrieNode[T]] {
+ return addrTrieNodeIteratorRem[T,
emptyValue]{node.toBase().containingFirstIterator(forwardSubNodeOrder)}
}
// ContainingFirstAllNodeIterator returns an iterator that does a pre-order
binary trie traversal of all the nodes
@@ -1347,8 +1343,12 @@
// BlockSizeCachingAllNodeIterator returns an iterator that iterates all
nodes, ordered by keys from largest prefix blocks to smallest and then to
individual addresses,
// in the sub-trie with this node as the root.
+//
+// The returned iterator of type CachingTrieIterator allows you to cache an
object with the lower or upper sub-node of the currently visited node.
+// Each cached object can be retrieved later when iterating the sub-nodes.
That allows you to provide iteration context from a parent to its sub-nodes
when iterating.
+// If the caching functionality is not needed, use BlockSizeAllNodeIterator.
func (node *AssociativeTrieNode[T, V]) BlockSizeCachingAllNodeIterator()
CachingTrieIterator[*AssociativeTrieNode[T, V]] {
- return cachingAssociativeAddressTrieNodeIteratorX[T,
V]{node.toBase().blockSizeCachingAllNodeIterator()}
+ return cachingAssociativeAddressTrieNodeIterator[T,
V]{node.toBase().blockSizeCachingAllNodeIterator()}
}
// ContainingFirstIterator returns an iterator that does a pre-order binary
trie traversal of the added nodes
@@ -1356,19 +1356,8 @@
//
// All added nodes will be visited before their added sub-nodes.
// For an address trie this means added containing subnet blocks will be
visited before their added contained addresses and subnet blocks.
-//
-// Once a given node is visited, the iterator allows you to cache an object
corresponding to the
-// lower or upper sub-node that can be retrieved when you later visit that
sub-node.
-//
-// Objects are cached only with nodes to be visited.
-// So for this iterator that means an object will be cached with the first
added lower or upper sub-node,
-// the next lower or upper sub-node to be visited,
-// which is not necessarily the direct lower or upper sub-node of a given node.
-//
-// The caching allows you to provide iteration context from a parent to its
sub-nodes when iterating.
-// The caching and retrieval is done in constant-time.
-func (node *AssociativeTrieNode[T, V])
ContainingFirstIterator(forwardSubNodeOrder bool)
CachingTrieIterator[*AssociativeTrieNode[T, V]] {
- return cachingAssociativeAddressTrieNodeIteratorX[T,
V]{node.toBase().containingFirstIterator(forwardSubNodeOrder)}
+func (node *AssociativeTrieNode[T, V])
ContainingFirstIterator(forwardSubNodeOrder bool)
IteratorWithRemove[*AssociativeTrieNode[T, V]] {
+ return associativeAddressTrieNodeIteratorRem[T,
V]{node.toBase().containingFirstIterator(forwardSubNodeOrder)}
}
// ContainingFirstAllNodeIterator returns an iterator that does a pre-order
binary trie traversal of all the nodes
@@ -1382,7 +1371,7 @@
// That allows you to provide iteration context from a parent to its sub-nodes
when iterating.
// The caching and retrieval is done in constant-time.
func (node *AssociativeTrieNode[T, V])
ContainingFirstAllNodeIterator(forwardSubNodeOrder bool)
CachingTrieIterator[*AssociativeTrieNode[T, V]] {
- return cachingAssociativeAddressTrieNodeIteratorX[T,
V]{node.toBase().containingFirstAllNodeIterator(forwardSubNodeOrder)}
+ return cachingAssociativeAddressTrieNodeIterator[T,
V]{node.toBase().containingFirstAllNodeIterator(forwardSubNodeOrder)}
}
// ContainedFirstIterator returns an iterator that does a post-order binary
trie traversal of the added nodes
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtype.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtype.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtype.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/addrtype.go
2024-09-06 16:13:42.000000000 +0200
@@ -20,7 +20,7 @@
type addrType byte
const (
- zeroType addrType = 0 // no segments
+ zeroType addrType = 0 // no segments, or non-version specific
segments
ipv4Type addrType = 1 // ipv4 segments
ipv6Type addrType = 2 // ipv6 segments
ipv6v4MixedType addrType = 3 // ipv6-v4 mixed segments
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/clonearrays.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/clonearrays.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/clonearrays.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/clonearrays.go
2024-09-06 16:13:42.000000000 +0200
@@ -1,5 +1,5 @@
//
-// Copyright 2020-2022 Sean C Foley
+// Copyright 2020-2024 Sean C Foley
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -51,20 +51,73 @@
return cloneToExtra(sect, orig, converter)
}
-func cloneTo[T any, U any](orig []T, conv func(T) U) []U {
- result := make([]U, len(orig))
- for i := range orig {
- result[i] = conv(orig[i])
+func cloneTo[T any, U any](orig []T, conv func(T) U) (result []U) {
+ result = make([]U, len(orig))
+ for i, v := range orig {
+ result[i] = conv(v)
}
- return result
+ return
}
-func cloneToExtra[T any, U any](sect T, orig []T, conv func(T) U) []U {
+func cloneToExtra[T any, U any](sect T, orig []T, conv func(T) U) (result []U)
{
origCount := len(orig)
- result := make([]U, origCount+1)
+ result = make([]U, origCount+1)
result[origCount] = conv(sect)
- for i := range orig {
- result[i] = conv(orig[i])
+ for i, v := range orig {
+ result[i] = conv(v)
}
- return result
+ return
+}
+
+// ToIPv4Slice converts a slice of subnets, addresses, or components thereof
into IPv4-specific components.
+// The original slice element type can be one of *Address, *IPAddress,
*AddressDivisionGrouping,
+// *AddressSection, *IPAddressSection, *AddressDivision, *AddressSegment,
*IPAddressSegment, *SequentialRange,
+// ExtendedIPSegmentSeries, WrappedIPAddress, WrappedIPAddressSection,
ExtendedSegmentSeries, WrappedAddress, or WrappedAddressSection.
+// Each slice element will be converted if the element originated as an IPv4
component, otherwise the element will be converted to nil in the returned slice.
+func ToIPv4Slice[T interface {
+ ToIPv4() IPv4Type
+}, IPv4Type any](orig []T) []IPv4Type {
+ return cloneTo(orig, func(a T) IPv4Type { return a.ToIPv4() })
+}
+
+// ToIPv6Slice converts a slice of subnets, addresses, or components thereof
into IPv6-specific components.
+// The original slice element type can be one of *Address, *IPAddress,
*AddressDivisionGrouping,
+// *AddressSection, *IPAddressSection, *AddressDivision, *AddressSegment,
*IPAddressSegment, *SequentialRange,
+// ExtendedIPSegmentSeries, WrappedIPAddress, WrappedIPAddressSection,
ExtendedSegmentSeries, WrappedAddress, or WrappedAddressSection.
+// Each slice element will be converted if the element originated as an IPv6
component, otherwise the element will be converted to nil in the returned slice.
+func ToIPv6Slice[T interface {
+ ToIPv6() IPv6Type
+}, IPv6Type any](orig []T) []IPv6Type {
+ return cloneTo(orig, func(a T) IPv6Type { return a.ToIPv6() })
+}
+
+// ToIPSlice converts a slice of subnets, addresses, or components thereof
into IP-specific components.
+// The original slice element type can be one of *Address, *IPv4Address,
*IPv6Address, *AddressDivisionGrouping,
+// *AddressSection, *IPv4AddressSection, *IPv6AddressSection,
*AddressDivision, *AddressSegment, *IPv4AddressSegment, *IPv6AddressSegment,
*IPAddressSegment,
+// *SequentialRange, ExtendedSegmentSeries, WrappedAddress,
WrappedAddressSection, WrappedIPAddress, IPAddressType, *SequentialRange, or
IPAddressSeqRangeType.
+// Each slice element will be converted if the element originated as an IPv6
component, otherwise the element will be converted to nil in the returned slice.
+func ToIPSlice[T interface {
+ ToIP() IPType
+}, IPType any](orig []T) []IPType {
+ return cloneTo(orig, func(a T) IPType { return a.ToIP() })
+}
+
+// ToAddressBaseSlice converts a slice of subnets or addresses into general
addresses or subnets not specific to a version or address type.
+// The original slice element type can be one of *Address, *IPv4Address,
*IPv6Address, *MACAddress, *IPAddress, or AddressType.
+// Each slice element will be converted if the element originated as an IPv6
component, otherwise the element will be converted to nil in the returned slice.
+func ToAddressBaseSlice[T interface {
+ ToAddressBase() AddrType
+}, AddrType any](orig []T) []AddrType {
+ return cloneTo(orig, func(a T) AddrType { return a.ToAddressBase() })
+}
+
+// ToMACSlice converts a slice of subnets, addresses, or components thereof
into MAC-specific components.
+// The original slice element type can be one of *Address,
*AddressDivisionGrouping,
+// *AddressSection, *AddressDivision, *AddressSegment,
+// ExtendedSegmentSeries, WrappedAddress, or WrappedAddressSection.
+// Each slice element will be converted if the element originated as a MAC
component, otherwise the element will be converted to nil in the returned slice.
+func ToMACSlice[T interface {
+ ToMAC() MACType
+}, MACType any](orig []T) []MACType {
+ return cloneTo(orig, func(a T) MACType { return a.ToMAC() })
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/cover.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/cover.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/cover.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/cover.go
2024-09-06 16:13:42.000000000 +0200
@@ -1,5 +1,5 @@
//
-// Copyright 2020-2022 Sean C Foley
+// Copyright 2020-2024 Sean C Foley
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/grouping.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/grouping.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/grouping.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/grouping.go
2024-09-06 16:13:42.000000000 +0200
@@ -1,5 +1,5 @@
//
-// Copyright 2020-2023 Sean C Foley
+// Copyright 2020-2024 Sean C Foley
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipaddr.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipaddr.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipaddr.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipaddr.go
2024-09-06 16:13:42.000000000 +0200
@@ -1579,11 +1579,6 @@
return (*Address)(unsafe.Pointer(addr))
}
-// toAddressBase is needed for tries, it skips the init() call
-func (addr *IPAddress) toAddressBase() *Address {
- return (*Address)(unsafe.Pointer(addr))
-}
-
// ToIP is an identity method.
//
// ToIP can be called with a nil receiver, enabling you to chain this method
with methods that might return a nil pointer.
@@ -1969,6 +1964,63 @@
return getMergedPrefixBlocks(filterSeries(addr, addrs))
}
+// MergeToPrefixBlocks merges the given set of IP addresses and subnets into a
minimal number of prefix blocks.
+//
+// This function complements the MergeToPrefixBlock methods of each IP address
type, whether IPv4Address, IPv6Address, or IPAddress.
+// Those methods ignore arguments that do not match the IP version of the
method receiver, while this function does not.
+// This function will only ignore an argument if it is nil, or it is the
zero-bit zero value of the type IPAddress.
+// All other arguments will have IP version IPv4 or IPv6, and will be merged
into one of the two returned slices.
+//
+// Use ToIPv4Slice or ToIPv6Slice if you wish to convert the returned slices
to the more specific types []*IPv4Address or []*IPv6Address.
+func MergeToPrefixBlocks(addrs ...*IPAddress) (ipv4Blocks, ipv6Blocks
[]*IPAddress) {
+ return mergeToBlocks((*IPAddress).MergeToPrefixBlocks, addrs)
+}
+
+// MergeToSequentialBlocks merges the given set of IP addresses and subnets
into a minimal number of sequential blocks.
+//
+// This function complements the MergeToSequentialBlocks methods of the IP
address types, whether IPv4Address, IPv6Address, or IPAddress.
+// Those methods ignore arguments that do not match the IP version of the
method receiver, while this function does not.
+// This function will only ignore an argument if it is the zero-bit zero value
of the type IPAddress.
+// All other arguments will have IP version IPv4 or IPv6, and will be merged
into one of the two returned slices.
+//
+// Use ToIPv4Slice or ToIPv6Slice if you wish to convert the returned slices
to the more specific types []*IPv4Address or []*IPv6Address.
+func MergeToSequentialBlocks(addrs ...*IPAddress) (ipv4Blocks, ipv6Blocks
[]*IPAddress) {
+ return mergeToBlocks((*IPAddress).MergeToSequentialBlocks, addrs)
+}
+
+func mergeToBlocks(
+ merge func(*IPAddress, ...*IPAddress) []*IPAddress,
+ addrs []*IPAddress) (
+ ipv4Blocks, ipv6Blocks []*IPAddress) {
+
+ var ipv4Addr, ipv6Addr *IPAddress
+ for _, addr := range addrs {
+ addrType := addr.getAddrType()
+ if addrType == ipv4Type {
+ if ipv4Addr == nil {
+ ipv4Addr = addr
+ }
+ if ipv6Addr != nil {
+ break
+ }
+ } else if addrType == ipv6Type {
+ if ipv6Addr == nil {
+ ipv6Addr = addr
+ }
+ if ipv4Addr != nil {
+ break
+ }
+ }
+ }
+ if ipv4Addr != nil {
+ ipv4Blocks = merge(ipv4Addr, addrs...)
+ }
+ if ipv6Addr != nil {
+ ipv6Blocks = merge(ipv6Addr, addrs...)
+ }
+ return
+}
+
// SpanWithPrefixBlocks returns an array of prefix blocks that cover the same
set of addresses as this subnet.
//
// Unlike SpanWithPrefixBlocksTo, the result only includes addresses that are
a part of this subnet.
@@ -2048,12 +2100,6 @@
return addr.SpanWithSequentialBlocks()
}
return getSpanningSequentialBlocks(addr, other)
- // return cloneToIPAddrs(
- // getSpanningSequentialBlocks(
- // addr.Wrap(),
- // other.Wrap(),
- // ),
- // )
}
// ReverseBytes returns a new address with the bytes reversed. Any prefix
length is dropped.
@@ -2097,7 +2143,7 @@
//and
https://standards.ieee.org/wp-content/uploads/import/documents/tutorials/macgrp.pdf
and https://en.wikipedia.org/wiki/MAC_address
//canonicalParams = new
MACStringOptions.Builder().setSeparator(MACAddress.DASH_SEGMENT_SEPARATOR).setUppercase(true).setExpandedSegments(true).setWildcards(new
Wildcards(MACAddress.DASHED_SEGMENT_RANGE_SEPARATOR_STR,
Address.SEGMENT_WILDCARD_STR, null)).toOptions();
// Search docs for: An example is "01-23-45-67-89-ab"
-// But ACTUALLY, in the ends I decided not to:
https://www.mef.net/wp-content/uploads/MEF-89.pdf
+// But ACTUALLY, in the end I decided not to:
https://www.mef.net/wp-content/uploads/MEF-89.pdf
// ToCanonicalString produces a canonical string for the address.
//
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipv4addr.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipv4addr.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipv4addr.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipv4addr.go
2024-09-06 16:13:42.000000000 +0200
@@ -1842,11 +1842,6 @@
return (*Address)(unsafe.Pointer(addr))
}
-// toAddressBase is needed for tries, it skips the init() call
-func (addr *IPv4Address) toAddressBase() *Address {
- return (*Address)(unsafe.Pointer(addr))
-}
-
// ToIP converts to an IPAddress, a polymorphic type usable with all IP
addresses and subnets.
// Afterwards, you can convert back with ToIPv4.
//
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipv6addr.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipv6addr.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipv6addr.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/ipv6addr.go
2024-09-06 16:13:42.000000000 +0200
@@ -2225,11 +2225,6 @@
return (*Address)(unsafe.Pointer(addr))
}
-// toAddressBase is needed for tries, it skips the init() call
-func (addr *IPv6Address) toAddressBase() *Address {
- return (*Address)(unsafe.Pointer(addr))
-}
-
// ToIP converts to an IPAddress, a polymorphic type usable with all IP
addresses and subnets.
//
// ToIP can be called with a nil receiver, enabling you to chain this method
with methods that might return a nil pointer.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/largegrouping.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/largegrouping.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/largegrouping.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/largegrouping.go
2024-09-06 16:13:42.000000000 +0200
@@ -1,5 +1,5 @@
//
-// Copyright 2022-2023 Sean C Foley
+// Copyright 2022-2024 Sean C Foley
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/macaddr.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/macaddr.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/macaddr.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/macaddr.go
2024-09-06 16:13:42.000000000 +0200
@@ -1257,11 +1257,6 @@
return (*Address)(addr)
}
-// toAddressBase is needed for tries, it skips the init() call
-func (addr *MACAddress) toAddressBase() *Address {
- return (*Address)(addr)
-}
-
// Wrap wraps this address, returning a WrappedAddress, an implementation of
ExtendedSegmentSeries,
// which can be used to write code that works with both addresses and address
sections.
func (addr *MACAddress) Wrap() WrappedAddress {
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/merge.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/merge.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/merge.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/merge.go
2024-09-06 16:13:42.000000000 +0200
@@ -1,5 +1,5 @@
//
-// Copyright 2020-2022 Sean C Foley
+// Copyright 2020-2024 Sean C Foley
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/sectiterator.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/sectiterator.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/sectiterator.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/sectiterator.go
2024-09-06 16:13:42.000000000 +0200
@@ -1,5 +1,5 @@
//
-// Copyright 2020-2022 Sean C Foley
+// Copyright 2020-2024 Sean C Foley
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/split.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/split.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/split.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/split.go
2024-09-06 16:13:42.000000000 +0200
@@ -1,5 +1,5 @@
//
-// Copyright 2020-2022 Sean C Foley
+// Copyright 2020-2024 Sean C Foley
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -23,12 +23,6 @@
"github.com/seancfoley/ipaddress-go/ipaddr/addrerr"
)
-// TODO LATER change to generics , this also allows us to possibly avoid the
slice copy with the return slice.
-// Here we would not be returning []ExtendedIPSegmentSeries, we'd be returning
[]T for the end-type T.
-// So, the idea I think, is that we can use the trick we used in tries, with
[T TrieConstraint[T]], allowing us to specify methods like ToPrefixBlock T
-// So, then we can return []T. Overall this is a bit of work.
-// In fact, when you think about it, generics can give you all the same things
as ExtendedIPSegmentSeries
-
type spannableType[S any, T any] interface {
*S
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/stringparams.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/stringparams.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/stringparams.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/stringparams.go
2024-09-06 16:13:42.000000000 +0200
@@ -1,5 +1,5 @@
//
-// Copyright 2020-2022 Sean C Foley
+// Copyright 2020-2024 Sean C Foley
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/utils.go
new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/utils.go
--- old/vendor/github.com/seancfoley/ipaddress-go/ipaddr/utils.go
2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/github.com/seancfoley/ipaddress-go/ipaddr/utils.go
2024-09-06 16:13:42.000000000 +0200
@@ -1,5 +1,5 @@
//
-// Copyright 2020-2022 Sean C Foley
+// Copyright 2020-2024 Sean C Foley
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/vendor/modules.txt new/vendor/modules.txt
--- old/vendor/modules.txt 2024-08-25 20:01:08.000000000 +0200
+++ new/vendor/modules.txt 2024-09-06 16:13:42.000000000 +0200
@@ -52,7 +52,7 @@
# github.com/seancfoley/bintree v1.3.1
## explicit; go 1.18
github.com/seancfoley/bintree/tree
-# github.com/seancfoley/ipaddress-go v1.6.0
+# github.com/seancfoley/ipaddress-go v1.7.0
## explicit; go 1.18
github.com/seancfoley/ipaddress-go/ipaddr
github.com/seancfoley/ipaddress-go/ipaddr/addrerr
