ipaddr

package

Go to main page

Versions in this module

v1

v1.6.0

May 19, 2024

Changes in this version

+ const MaxRadix

+ const MinRadix

type Address

+ func (addr *Address) Enumerate(other AddressType) *big.Int

+ func (addr *Address) Overlaps(other AddressType) bool

type AddressSection

+ func (section *AddressSection) Enumerate(other AddressSectionType) *big.Int

+ func (section *AddressSection) Overlaps(other AddressSectionType) bool

type AddressSectionType

+ Enumerate func(AddressSectionType) *big.Int

+ Overlaps func(AddressSectionType) bool

type AddressSegment

+ func (seg *AddressSegment) Overlaps(other AddressSegmentType) bool

type AddressSegmentType

+ Overlaps func(AddressSegmentType) bool

type AddressType

+ Enumerate func(AddressType) *big.Int

+ Overlaps func(AddressType) bool

type AssociativeTrie

+ func (trie *AssociativeTrie[T, V]) Ceiling(addr T) T

+ func (trie *AssociativeTrie[T, V]) Floor(addr T) T

+ func (trie *AssociativeTrie[T, V]) Higher(addr T) T

+ func (trie *AssociativeTrie[T, V]) Lower(addr T) T

+ func (trie *AssociativeTrie[T, V]) ShortestPrefixMatch(addr T) T

+ func (trie *AssociativeTrie[T, V]) ShortestPrefixMatchNode(addr T) *AssociativeTrieNode[T, V]

type AssociativeTrieNode

+ func AddAssociativeTrieToDual[R interface{ ... }, V, V2 any](tries *DualIPv4v6AssociativeTries[V], trie *AssociativeTrieNode[R, V2], ...) *AssociativeTrieNode[*IPAddress, V]

+ func (node *AssociativeTrieNode[T, V]) ShortestPrefixMatch(addr T) T

+ func (node *AssociativeTrieNode[T, V]) ShortestPrefixMatchNode(addr T) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrieNode[T, V]) Ceiling(addr T) T

+ func (trie *AssociativeTrieNode[T, V]) Floor(addr T) T

+ func (trie *AssociativeTrieNode[T, V]) Higher(addr T) T

+ func (trie *AssociativeTrieNode[T, V]) Lower(addr T) T

+ type DualIPv4v6AssociativeTries struct

+ func (tries *DualIPv4v6AssociativeTries) Add(addr *IPAddress) bool

+ func (tries *DualIPv4v6AssociativeTries) Ceiling(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6AssociativeTries) Clear()

+ func (tries *DualIPv4v6AssociativeTries) Contains(addr *IPAddress) bool

+ func (tries *DualIPv4v6AssociativeTries) DescendingIterator() IteratorWithRemove[*IPAddress]

+ func (tries *DualIPv4v6AssociativeTries) ElementContains(addr *IPAddress) bool

+ func (tries *DualIPv4v6AssociativeTries) Floor(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6AssociativeTries) Higher(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6AssociativeTries) IsEmpty() bool

+ func (tries *DualIPv4v6AssociativeTries) Iterator() IteratorWithRemove[*IPAddress]

+ func (tries *DualIPv4v6AssociativeTries) LongestPrefixMatch(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6AssociativeTries) Lower(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6AssociativeTries) Remove(addr *IPAddress) bool

+ func (tries *DualIPv4v6AssociativeTries) ShortestPrefixMatch(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6AssociativeTries) Size() int

+ func (tries *DualIPv4v6AssociativeTries[V]) AddIPv4Trie(trie *AssociativeTrieNode[*IPv4Address, V]) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) AddIPv6Trie(trie *AssociativeTrieNode[*IPv6Address, V]) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) AddNode(addr *IPAddress) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) AddTrie(trie *AssociativeTrieNode[*IPAddress, V]) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) AddedNodesTreeString() string

+ func (tries *DualIPv4v6AssociativeTries[V]) BlockSizeNodeIterator(lowerSubNodeFirst bool) IteratorWithRemove[*AssociativeTrieNode[*IPAddress, V]]

+ func (tries *DualIPv4v6AssociativeTries[V]) CeilingAddedNode(addr *IPAddress) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) Clone() *DualIPv4v6AssociativeTries[V]

+ func (tries *DualIPv4v6AssociativeTries[V]) ContainedFirstIterator(forwardSubNodeOrder bool) IteratorWithRemove[*AssociativeTrieNode[*IPAddress, V]]

+ func (tries *DualIPv4v6AssociativeTries[V]) ContainingFirstIterator(forwardSubNodeOrder bool) IteratorWithRemove[*AssociativeTrieNode[*IPAddress, V]]

+ func (tries *DualIPv4v6AssociativeTries[V]) DeepEqual(other *DualIPv4v6AssociativeTries[V]) bool

+ func (tries *DualIPv4v6AssociativeTries[V]) ElementsContainedBy(addr *IPAddress) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) ElementsContaining(addr *IPAddress) *ContainmentValuesPath[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) Equal(other *DualIPv4v6AssociativeTries[V]) bool

+ func (tries *DualIPv4v6AssociativeTries[V]) FloorAddedNode(addr *IPAddress) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) Get(addr *IPAddress) (V, bool)

+ func (tries *DualIPv4v6AssociativeTries[V]) GetAddedNode(addr *IPAddress) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) GetIPv4Trie() *AssociativeTrie[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) GetIPv6Trie() *AssociativeTrie[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) HigherAddedNode(addr *IPAddress) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) LongestPrefixMatchNode(addr *IPAddress) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) LowerAddedNode(addr *IPAddress) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) NodeIterator(forward bool) IteratorWithRemove[*AssociativeTrieNode[*IPAddress, V]]

+ func (tries *DualIPv4v6AssociativeTries[V]) Put(addr *IPAddress, value V) (V, bool)

+ func (tries *DualIPv4v6AssociativeTries[V]) PutIPv4Trie(trie *AssociativeTrieNode[*IPv4Address, V]) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) PutIPv6Trie(trie *AssociativeTrieNode[*IPv6Address, V]) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) PutNode(addr *IPAddress, value V) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) PutTrie(trie *AssociativeTrieNode[*IPAddress, V]) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) Remap(addr *IPAddress, ...) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) RemapIfAbsent(addr *IPAddress, supplier func() V) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) RemoveElementsContainedBy(addr *IPAddress) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) ShortestPrefixMatchNode(addr *IPAddress) *AssociativeTrieNode[*IPAddress, V]

+ func (tries *DualIPv4v6AssociativeTries[V]) String() string

+ func (tries *DualIPv4v6AssociativeTries[V]) TreeString(withNonAddedKeys bool) string

+ func (tries DualIPv4v6AssociativeTries) Format(state fmt.State, verb rune)

+ type DualIPv4v6Tries struct

+ func (tries *DualIPv4v6Tries) Add(addr *IPAddress) bool

+ func (tries *DualIPv4v6Tries) AddIPv4Trie(trie *TrieNode[*IPv4Address]) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) AddIPv6Trie(trie *TrieNode[*IPv6Address]) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) AddNode(addr *IPAddress) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) AddTrie(trie *TrieNode[*IPAddress]) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) AddedNodesTreeString() string

+ func (tries *DualIPv4v6Tries) BlockSizeNodeIterator(lowerSubNodeFirst bool) IteratorWithRemove[*TrieNode[*IPAddress]]

+ func (tries *DualIPv4v6Tries) Ceiling(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6Tries) CeilingAddedNode(addr *IPAddress) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) Clear()

+ func (tries *DualIPv4v6Tries) Clone() *DualIPv4v6Tries

+ func (tries *DualIPv4v6Tries) ContainedFirstIterator(forwardSubNodeOrder bool) IteratorWithRemove[*TrieNode[*IPAddress]]

+ func (tries *DualIPv4v6Tries) ContainingFirstIterator(forwardSubNodeOrder bool) IteratorWithRemove[*TrieNode[*IPAddress]]

+ func (tries *DualIPv4v6Tries) Contains(addr *IPAddress) bool

+ func (tries *DualIPv4v6Tries) DescendingIterator() IteratorWithRemove[*IPAddress]

+ func (tries *DualIPv4v6Tries) ElementContains(addr *IPAddress) bool

+ func (tries *DualIPv4v6Tries) ElementsContainedBy(addr *IPAddress) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) ElementsContaining(addr *IPAddress) *ContainmentPath[*IPAddress]

+ func (tries *DualIPv4v6Tries) Equal(other *DualIPv4v6Tries) bool

+ func (tries *DualIPv4v6Tries) Floor(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6Tries) FloorAddedNode(addr *IPAddress) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) GetAddedNode(addr *IPAddress) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) GetIPv4Trie() *Trie[*IPAddress]

+ func (tries *DualIPv4v6Tries) GetIPv6Trie() *Trie[*IPAddress]

+ func (tries *DualIPv4v6Tries) Higher(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6Tries) HigherAddedNode(addr *IPAddress) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) IsEmpty() bool

+ func (tries *DualIPv4v6Tries) Iterator() IteratorWithRemove[*IPAddress]

+ func (tries *DualIPv4v6Tries) LongestPrefixMatch(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6Tries) LongestPrefixMatchNode(addr *IPAddress) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) Lower(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6Tries) LowerAddedNode(addr *IPAddress) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) NodeIterator(forward bool) IteratorWithRemove[*TrieNode[*IPAddress]]

+ func (tries *DualIPv4v6Tries) Remove(addr *IPAddress) bool

+ func (tries *DualIPv4v6Tries) RemoveElementsContainedBy(addr *IPAddress) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) ShortestPrefixMatch(addr *IPAddress) *IPAddress

+ func (tries *DualIPv4v6Tries) ShortestPrefixMatchNode(addr *IPAddress) *TrieNode[*IPAddress]

+ func (tries *DualIPv4v6Tries) Size() int

+ func (tries *DualIPv4v6Tries) String() string

+ func (tries *DualIPv4v6Tries) TreeString(withNonAddedKeys bool) string

+ func (tries DualIPv4v6Tries) Format(state fmt.State, verb rune)

type ExtendedIPSegmentSeries

+ Enumerate func(ExtendedIPSegmentSeries) *big.Int

type ExtendedSegmentSeries

+ Enumerate func(ExtendedSegmentSeries) *big.Int

type IPAddress

+ func (addr *IPAddress) ContainsRange(other IPAddressSeqRangeType) bool

+ func (addr *IPAddress) Enumerate(other AddressType) *big.Int

+ func (addr *IPAddress) Overlaps(other AddressType) bool

+ func (addr *IPAddress) OverlapsRange(other IPAddressSeqRangeType) bool

type IPAddressSection

+ func (section *IPAddressSection) Enumerate(other AddressSectionType) *big.Int

+ func (section *IPAddressSection) Overlaps(other AddressSectionType) bool

type IPAddressSegment

+ func (seg *IPAddressSegment) Overlaps(other AddressSegmentType) bool

type IPAddressSeqRangeType

+ Enumerate func(IPAddressType) *big.Int

+ OverlapsAddress func(IPAddressType) bool

type IPAddressType

+ ContainsRange func(IPAddressSeqRangeType) bool

+ OverlapsRange func(IPAddressSeqRangeType) bool

type IPv4Address

+ func (addr *IPv4Address) ContainsRange(other IPAddressSeqRangeType) bool

+ func (addr *IPv4Address) Enumerate(other AddressType) *big.Int

+ func (addr *IPv4Address) EnumerateIPv4(other AddressType) (val int64, ok bool)

+ func (addr *IPv4Address) Overlaps(other AddressType) bool

+ func (addr *IPv4Address) OverlapsRange(other IPAddressSeqRangeType) bool

type IPv4AddressSection

+ func (section *IPv4AddressSection) Enumerate(other AddressSectionType) *big.Int

+ func (section *IPv4AddressSection) EnumerateIPv4(other AddressSectionType) (val int64, ok bool)

+ func (section *IPv4AddressSection) Overlaps(other AddressSectionType) bool

type IPv4AddressSegment

+ func (seg *IPv4AddressSegment) Overlaps(other AddressSegmentType) bool

type IPv6Address

+ func (addr *IPv6Address) ContainsRange(other IPAddressSeqRangeType) bool

+ func (addr *IPv6Address) Enumerate(other AddressType) *big.Int

+ func (addr *IPv6Address) IncrementBig(bigIncrement *big.Int) *IPv6Address

+ func (addr *IPv6Address) Overlaps(other AddressType) bool

+ func (addr *IPv6Address) OverlapsRange(other IPAddressSeqRangeType) bool

type IPv6AddressSection

+ func (section *IPv6AddressSection) Enumerate(other AddressSectionType) *big.Int

+ func (section *IPv6AddressSection) IncrementBig(bigIncrement *big.Int) *IPv6AddressSection

+ func (section *IPv6AddressSection) Overlaps(other AddressSectionType) bool

type IPv6AddressSegment

+ func (seg *IPv6AddressSegment) Overlaps(other AddressSegmentType) bool

type MACAddress

+ func (addr *MACAddress) Enumerate(other AddressType) *big.Int

+ func (addr *MACAddress) Overlaps(other AddressType) bool

type MACAddressSection

+ func (section *MACAddressSection) Enumerate(other AddressSectionType) *big.Int

+ func (section *MACAddressSection) Overlaps(other AddressSectionType) bool

type MACAddressSegment

+ func (seg *MACAddressSegment) Overlaps(other AddressSegmentType) bool

type SequentialRange

+ func (rng *SequentialRange[T]) Enumerate(other IPAddressType) *big.Int

+ func (rng *SequentialRange[T]) OverlapsAddress(other IPAddressType) bool

type Trie

+ func (trie *Trie[T]) Ceiling(addr T) T

+ func (trie *Trie[T]) Floor(addr T) T

+ func (trie *Trie[T]) Higher(addr T) T

+ func (trie *Trie[T]) Lower(addr T) T

type TrieNode

+ func (node *TrieNode[T]) ShortestPrefixMatch(addr T) T

+ func (node *TrieNode[T]) ShortestPrefixMatchNode(addr T) *TrieNode[T]

+ func (trie *TrieNode[T]) Ceiling(addr T) T

+ func (trie *TrieNode[T]) Floor(addr T) T

+ func (trie *TrieNode[T]) Higher(addr T) T

+ func (trie *TrieNode[T]) Lower(addr T) T

type WrappedAddress

+ func (addr WrappedAddress) Enumerate(other ExtendedSegmentSeries) *big.Int

type WrappedAddressSection

+ func (section WrappedAddressSection) Enumerate(other ExtendedSegmentSeries) *big.Int

type WrappedIPAddress

+ func (addr WrappedIPAddress) Enumerate(other ExtendedIPSegmentSeries) *big.Int

type WrappedIPAddressSection

+ func (section WrappedIPAddressSection) Enumerate(other ExtendedIPSegmentSeries) *big.Int

v1.5.5

Sep 22, 2023

Changes in this version

type IPv6Address

+ func (addr *IPv6Address) Uint64Values() (high, low uint64)

+ func (addr *IPv6Address) UpperUint64Values() (high, low uint64)

type IPv6AddressSection

+ func (section *IPv6AddressSection) Uint64Values() (high, low uint64)

+ func (section *IPv6AddressSection) UpperUint64Values() (high, low uint64)

type Trie

+ func (trie *Trie[T]) ShortestPrefixMatch(addr T) T

+ func (trie *Trie[T]) ShortestPrefixMatchNode(addr T) *TrieNode[T]

v1.5.4

Mar 10, 2023

Changes in this version

type HostName

+ func (addrStr HostName) Format(state fmt.State, verb rune)

type IPAddressLargeDivisionGrouping

+ func (grouping IPAddressLargeDivisionGrouping) Format(state fmt.State, verb rune)

type IPAddressString

+ func (addrStr IPAddressString) Format(state fmt.State, verb rune)

type IPv4AddressSegment

+ func (seg IPv4AddressSegment) Format(state fmt.State, verb rune)

type MACAddressString

+ func (addrStr MACAddressString) Format(state fmt.State, verb rune)

v1.5.3

Jan 3, 2023

Changes in this version

type AddedTreeNode

+ func (node AddedTreeNode[T]) IsAdded() bool

type AssociativeAddedTreeNode

+ func (node AssociativeAddedTreeNode[T, V]) IsAdded() bool

+ type BitItem interface

+ GetBitCount func() BitCount

+ GetByteCount func() int

+ type Prefixed interface

+ GetPrefixLen func() PrefixLen

+ IsPrefixBlock func() bool

+ IsPrefixed func() bool

+ IsSinglePrefixBlock func() bool

+ type PrefixedConstraint interface

+ SetPrefixLen func(BitCount) T

+ ToPrefixBlock func() T

+ ToPrefixBlockLen func(BitCount) T

+ WithoutPrefixLen func() T

type TrieKeyConstraint

+ IsOneBit func(index BitCount) bool

+ ToAddressBase func() *Address

v1.5.2

Nov 29, 2022

v1.5.1

Nov 28, 2022

Changes in this version

type Address

+ func (addr *Address) ToGenericKey() Key[*Address]

+ type GenericKeyConstraint interface

type IPAddress

+ func (addr *IPAddress) ToGenericKey() Key[*IPAddress]

type IPv4Address

+ func (addr *IPv4Address) ToGenericKey() Key[*IPv4Address]

type IPv6Address

+ func (addr *IPv6Address) ToGenericKey() Key[*IPv6Address]

+ type KeyGeneratorConstraint interface

+ ToGenericKey func() Key[T]

type MACAddress

+ func (addr *MACAddress) ToGenericKey() Key[*MACAddress]

v1.5.0

Nov 26, 2022

Changes in this version

+ func AssociativeTreesString(withNonAddedKeys bool, tries ...*AssociativeTrie[T, V]) string

+ type AddedTree struct

+ func (atree AddedTree[T]) GetRoot() AddedTreeNode[T]

+ func (atree AddedTree[T]) String() string

+ type AddedTreeNode struct

+ func (node AddedTreeNode[T]) GetKey() T

+ func (node AddedTreeNode[T]) GetSubNodes() []AddedTreeNode[T]

+ func (node AddedTreeNode[T]) String() string

+ func (node AddedTreeNode[T]) TreeString() string

type Address

+ func (addr *Address) ToNormalizedWildcardString() string

type AddressSection

+ func (section *AddressSection) ToNormalizedWildcardString() string

type AddressSegmentSeries

+ ToNormalizedWildcardString func() string

+ type AllocatedBlock struct

+ func (alloc AllocatedBlock[T]) GetAddress() T

+ func (alloc AllocatedBlock[T]) GetCount() *big.Int

+ func (alloc AllocatedBlock[T]) GetReservedCount() int

+ func (alloc AllocatedBlock[T]) GetSize() *big.Int

+ func (alloc AllocatedBlock[T]) String() string

+ type AssociativeAddedTree struct

+ func (atree AssociativeAddedTree[T, V]) GetRoot() AssociativeAddedTreeNode[T, V]

+ func (atree AssociativeAddedTree[T, V]) String() string

+ type AssociativeAddedTreeNode struct

+ func (node AssociativeAddedTreeNode[T, V]) GetKey() T

+ func (node AssociativeAddedTreeNode[T, V]) GetSubNodes() []AssociativeAddedTreeNode[T, V]

+ func (node AssociativeAddedTreeNode[T, V]) GetValue() V

+ func (node AssociativeAddedTreeNode[T, V]) String() string

+ func (node AssociativeAddedTreeNode[T, V]) TreeString() string

+ type AssociativeTrie struct

+ func NewAssociativeTrie() *AssociativeTrie[T, V]

+ func (trie *AssociativeTrie) Clear()

+ func (trie *AssociativeTrie[T, V]) Add(addr T) bool

+ func (trie *AssociativeTrie[T, V]) AddNode(addr T) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) AddTrie(added *AssociativeTrieNode[T, V]) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) AddedNodesTreeString() string

+ func (trie *AssociativeTrie[T, V]) AllNodeIterator(forward bool) IteratorWithRemove[*AssociativeTrieNode[T, V]]

+ func (trie *AssociativeTrie[T, V]) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IteratorWithRemove[*AssociativeTrieNode[T, V]]

+ func (trie *AssociativeTrie[T, V]) BlockSizeCachingAllNodeIterator() CachingTrieIterator[*AssociativeTrieNode[T, V]]

+ func (trie *AssociativeTrie[T, V]) BlockSizeNodeIterator(lowerSubNodeFirst bool) IteratorWithRemove[*AssociativeTrieNode[T, V]]

+ func (trie *AssociativeTrie[T, V]) CeilingAddedNode(addr T) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) Clone() *AssociativeTrie[T, V]

+ func (trie *AssociativeTrie[T, V]) ConstructAddedNodesTree() AssociativeAddedTree[T, V]

+ func (trie *AssociativeTrie[T, V]) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) Iterator[*AssociativeTrieNode[T, V]]

+ func (trie *AssociativeTrie[T, V]) ContainedFirstIterator(forwardSubNodeOrder bool) IteratorWithRemove[*AssociativeTrieNode[T, V]]

+ func (trie *AssociativeTrie[T, V]) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingTrieIterator[*AssociativeTrieNode[T, V]]

+ func (trie *AssociativeTrie[T, V]) ContainingFirstIterator(forwardSubNodeOrder bool) CachingTrieIterator[*AssociativeTrieNode[T, V]]

+ func (trie *AssociativeTrie[T, V]) Contains(addr T) bool

+ func (trie *AssociativeTrie[T, V]) DeepEqual(other *AssociativeTrie[T, V]) bool

+ func (trie *AssociativeTrie[T, V]) DescendingIterator() Iterator[T]

+ func (trie *AssociativeTrie[T, V]) ElementContains(addr T) bool

+ func (trie *AssociativeTrie[T, V]) ElementsContainedBy(addr T) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) ElementsContaining(addr T) *ContainmentValuesPath[T, V]

+ func (trie *AssociativeTrie[T, V]) Equal(other *AssociativeTrie[T, V]) bool

+ func (trie *AssociativeTrie[T, V]) FirstAddedNode() *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) FirstNode() *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) FloorAddedNode(addr T) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) Get(addr T) (V, bool)

+ func (trie *AssociativeTrie[T, V]) GetAddedNode(addr T) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) GetNode(addr T) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) GetRoot() *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) HigherAddedNode(addr T) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) IsEmpty() bool

+ func (trie *AssociativeTrie[T, V]) Iterator() Iterator[T]

+ func (trie *AssociativeTrie[T, V]) LastAddedNode() *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) LastNode() *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) LongestPrefixMatch(addr T) T

+ func (trie *AssociativeTrie[T, V]) LongestPrefixMatchNode(addr T) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) LowerAddedNode(addr T) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) NodeIterator(forward bool) IteratorWithRemove[*AssociativeTrieNode[T, V]]

+ func (trie *AssociativeTrie[T, V]) NodeSize() int

+ func (trie *AssociativeTrie[T, V]) Put(addr T, value V) (V, bool)

+ func (trie *AssociativeTrie[T, V]) PutNode(addr T, value V) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) PutTrie(added *AssociativeTrieNode[T, V]) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) Remap(addr T, remapper func(existingValue V, found bool) (mapped V, mapIt bool)) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) RemapIfAbsent(addr T, supplier func() V) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) Remove(addr T) bool

+ func (trie *AssociativeTrie[T, V]) RemoveElementsContainedBy(addr T) *AssociativeTrieNode[T, V]

+ func (trie *AssociativeTrie[T, V]) Size() int

+ func (trie *AssociativeTrie[T, V]) String() string

+ func (trie *AssociativeTrie[T, V]) TreeString(withNonAddedKeys bool) string

+ func (trie AssociativeTrie[T, V]) Format(state fmt.State, verb rune)

+ type AssociativeTrieNode struct

+ func (node *AssociativeTrieNode[T, V]) AllNodeIterator(forward bool) IteratorWithRemove[*AssociativeTrieNode[T, V]]

+ func (node *AssociativeTrieNode[T, V]) AsNewTrie() *AssociativeTrie[T, V]

+ func (node *AssociativeTrieNode[T, V]) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IteratorWithRemove[*AssociativeTrieNode[T, V]]

+ func (node *AssociativeTrieNode[T, V]) BlockSizeCachingAllNodeIterator() CachingTrieIterator[*AssociativeTrieNode[T, V]]

+ func (node *AssociativeTrieNode[T, V]) BlockSizeNodeIterator(lowerSubNodeFirst bool) IteratorWithRemove[*AssociativeTrieNode[T, V]]

+ func (node *AssociativeTrieNode[T, V]) CeilingAddedNode(addr T) *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) Clear()

+ func (node *AssociativeTrieNode[T, V]) ClearValue()

+ func (node *AssociativeTrieNode[T, V]) Clone() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) CloneTree() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) Compare(other *AssociativeTrieNode[T, V]) int

+ func (node *AssociativeTrieNode[T, V]) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) Iterator[*AssociativeTrieNode[T, V]]

+ func (node *AssociativeTrieNode[T, V]) ContainedFirstIterator(forwardSubNodeOrder bool) IteratorWithRemove[*AssociativeTrieNode[T, V]]

+ func (node *AssociativeTrieNode[T, V]) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingTrieIterator[*AssociativeTrieNode[T, V]]

+ func (node *AssociativeTrieNode[T, V]) ContainingFirstIterator(forwardSubNodeOrder bool) CachingTrieIterator[*AssociativeTrieNode[T, V]]

+ func (node *AssociativeTrieNode[T, V]) Contains(addr T) bool

+ func (node *AssociativeTrieNode[T, V]) DeepEqual(other *AssociativeTrieNode[T, V]) bool

+ func (node *AssociativeTrieNode[T, V]) DescendingIterator() Iterator[T]

+ func (node *AssociativeTrieNode[T, V]) ElementContains(addr T) bool

+ func (node *AssociativeTrieNode[T, V]) ElementsContainedBy(addr T) *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) ElementsContaining(addr T) *ContainmentValuesPath[T, V]

+ func (node *AssociativeTrieNode[T, V]) Equal(other *AssociativeTrieNode[T, V]) bool

+ func (node *AssociativeTrieNode[T, V]) FirstAddedNode() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) FirstNode() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) FloorAddedNode(addr T) *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) Get(addr T) (V, bool)

+ func (node *AssociativeTrieNode[T, V]) GetAddedNode(addr T) *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) GetKey() T

+ func (node *AssociativeTrieNode[T, V]) GetLowerSubNode() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) GetNode(addr T) *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) GetParent() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) GetUpperSubNode() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) GetValue() V

+ func (node *AssociativeTrieNode[T, V]) HigherAddedNode(addr T) *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) IsAdded() bool

+ func (node *AssociativeTrieNode[T, V]) IsEmpty() bool

+ func (node *AssociativeTrieNode[T, V]) IsLeaf() bool

+ func (node *AssociativeTrieNode[T, V]) IsRoot() bool

+ func (node *AssociativeTrieNode[T, V]) Iterator() Iterator[T]

+ func (node *AssociativeTrieNode[T, V]) LastAddedNode() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) LastNode() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) LongestPrefixMatch(addr T) T

+ func (node *AssociativeTrieNode[T, V]) LongestPrefixMatchNode(addr T) *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) LowerAddedNode(addr T) *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) NextAddedNode() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) NextNode() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) NodeIterator(forward bool) IteratorWithRemove[*AssociativeTrieNode[T, V]]

+ func (node *AssociativeTrieNode[T, V]) NodeSize() int

+ func (node *AssociativeTrieNode[T, V]) PreviousAddedNode() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) PreviousNode() *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) Remove()

+ func (node *AssociativeTrieNode[T, V]) RemoveElementsContainedBy(addr T) *AssociativeTrieNode[T, V]

+ func (node *AssociativeTrieNode[T, V]) RemoveNode(addr T) bool

+ func (node *AssociativeTrieNode[T, V]) SetAdded()

+ func (node *AssociativeTrieNode[T, V]) SetValue(val V)

+ func (node *AssociativeTrieNode[T, V]) Size() int

+ func (node *AssociativeTrieNode[T, V]) String() string

+ func (node *AssociativeTrieNode[T, V]) TreeDeepEqual(other *AssociativeTrieNode[T, V]) bool

+ func (node *AssociativeTrieNode[T, V]) TreeEqual(other *AssociativeTrieNode[T, V]) bool

+ func (node *AssociativeTrieNode[T, V]) TreeString(withNonAddedKeys, withSizes bool) string

+ func (node AssociativeTrieNode[T, V]) Format(state fmt.State, verb rune)

+ type Cached = tree.C

+ type CachingTrieIterator interface

+ CacheWithLowerSubNode func(Cached) bool

+ CacheWithUpperSubNode func(Cached) bool

+ GetCached func() Cached

+ type ContainmentValuesPath struct

+ func (path *ContainmentValuesPath) Count() int

+ func (path *ContainmentValuesPath) String() string

+ func (path *ContainmentValuesPath[T, V]) LongestPrefixMatch() *ContainmentValuesPathNode[T, V]

+ func (path *ContainmentValuesPath[T, V]) ShortestPrefixMatch() *ContainmentValuesPathNode[T, V]

+ type ContainmentValuesPathNode struct

+ func (node *ContainmentValuesPathNode) Count() int

+ func (node *ContainmentValuesPathNode) GetKey() T

+ func (node *ContainmentValuesPathNode) ListString() string

+ func (node *ContainmentValuesPathNode) String() string

+ func (node *ContainmentValuesPathNode[T, V]) GetValue() V

+ func (node *ContainmentValuesPathNode[T, V]) Next() *ContainmentValuesPathNode[T, V]

+ func (node *ContainmentValuesPathNode[T, V]) Previous() *ContainmentValuesPathNode[T, V]

+ type DelimitedAddressString string

+ func (str DelimitedAddressString) CountDelimitedAddresses() int

+ func (str DelimitedAddressString) ParseDelimitedIPAddrSegments() Iterator[*IPAddressString]

+ func (str DelimitedAddressString) ParseDelimitedSegments() Iterator[string]

+ type HostBitCount uint8

+ func (h *HostBitCount) BlockSize() *big.Int

+ func (h *HostBitCount) IsNil() bool

+ func (h *HostBitCount) Len() BitCount

+ func (h *HostBitCount) String() string

type HostName

+ func NewHostNameFromNetNetIPAddr(addr netip.Addr) *HostName

+ func NewHostNameFromNetNetIPAddrPort(addrPort netip.AddrPort) *HostName

+ func NewHostNameFromNetNetIPPrefix(addr netip.Prefix) (hostName *HostName, err addrerr.AddressValueError)

type IPAddress

+ func NewIPAddressFromNetNetIPAddr(addr netip.Addr) *IPAddress

+ func NewIPAddressFromNetNetIPPrefix(prefixedAddr netip.Prefix) (*IPAddress, addrerr.AddressError)

+ func (addr *IPAddress) GetNetNetIPAddr() netip.Addr

+ func (addr *IPAddress) GetUpperNetNetIPAddr() netip.Addr

type IPAddressRange

+ CopyNetIP func(bytes net.IP) net.IP

+ CopyUpperNetIP func(bytes net.IP) net.IP

+ GetIPVersion func() IPVersion

+ GetLowerIPAddress func() *IPAddress

+ GetNetIP func() net.IP

+ GetNetNetIPAddr func() netip.Addr

+ GetUpperIPAddress func() *IPAddress

+ GetUpperNetIP func() net.IP

+ GetUpperNetNetIPAddr func() netip.Addr

type IPv4Address

+ func (addr *IPv4Address) GetNetNetIPAddr() netip.Addr

+ func (addr *IPv4Address) GetUpperNetNetIPAddr() netip.Addr

type IPv4AddressKey

+ func IPv4KeyFromRangeKey(key RangeBoundaryKey[*IPv4Address]) IPv4AddressKey

type IPv4SegmentValueProvider

+ func WrapSegmentValueProviderForIPv4(f SegmentValueProvider) IPv4SegmentValueProvider

type IPv6Address

+ func (addr *IPv6Address) GetNetNetIPAddr() netip.Addr

+ func (addr *IPv6Address) GetUpperNetNetIPAddr() netip.Addr

type IPv6AddressKey

+ func IPv6KeyFromRangeKey(key RangeBoundaryKey[*IPv6Address]) IPv6AddressKey

type IPv6SegmentValueProvider

+ func WrapSegmentValueProviderForIPv6(f SegmentValueProvider) IPv6SegmentValueProvider

+ type IteratePartitionConstraint interface

+ AssignMinPrefixForBlock func() T

+ Iterator func() Iterator[T]

+ PrefixBlockIterator func() Iterator[T]

+ WithoutPrefixLen func() T

+ type Iterator interface

+ HasNext func() bool

+ Next func() T

+ type IteratorWithRemove interface

+ Remove func() T

+ type Key struct

+ func IPKeyFromRangeKey(key RangeBoundaryKey[*IPAddress]) Key[*IPAddress]

+ func (key Key[T]) String() string

+ func (key Key[T]) ToAddress() T

+ type KeyConstraint interface

type MACAddress

+ func (addr *MACAddress) ToNormalizedWildcardString() string

type MACAddressSection

+ func (addr *MACAddressSection) ToNormalizedWildcardString() string

type MACSegmentValueProvider

+ func WrapSegmentValueProviderForMAC(f SegmentValueProvider) MACSegmentValueProvider

+ type MappedPartition map[T]V

+ func ApplyForEach(p *Partition[T], action func(T) V) MappedPartition[T, V]

+ func ApplyForEachConditionally(p *Partition[T], action func(T) (V, bool)) MappedPartition[T, V]

type Partition

+ func PartitionWithSingleBlockSize(newAddr T) *Partition[T]

+ func PartitionWithSpanningBlocks(newAddr T) *Partition[T]

type PortNum

+ func (p *PortNum) Port() PortNum

+ type PrefixBlockAllocator struct

+ func (alloc *PrefixBlockAllocator[T]) AddAvailable(blocks ...T)

+ func (alloc *PrefixBlockAllocator[T]) AllocateBitLen(bitLength BitCount) T

+ func (alloc *PrefixBlockAllocator[T]) AllocateMultiBitLens(bitLengths ...BitCount) []AllocatedBlock[T]

+ func (alloc *PrefixBlockAllocator[T]) AllocateSize(sizeRequired uint64) T

+ func (alloc *PrefixBlockAllocator[T]) AllocateSizes(blockSizes ...uint64) []AllocatedBlock[T]

+ func (alloc *PrefixBlockAllocator[T]) GetAvailable() (blocks []T)

+ func (alloc *PrefixBlockAllocator[T]) GetBlockCount() int

+ func (alloc *PrefixBlockAllocator[T]) GetReserved() (reservedCount int)

+ func (alloc *PrefixBlockAllocator[T]) GetTotalCount() *big.Int

+ func (alloc *PrefixBlockAllocator[T]) GetVersion() IPVersion

+ func (alloc *PrefixBlockAllocator[T]) SetReserved(reservedCount int)

+ func (alloc PrefixBlockAllocator[T]) String() string

+ type PrefixBlockConstraint interface

+ MergeToPrefixBlocks func(...T) []T

+ PrefixBlockIterator func() Iterator[T]

+ SetPrefixLen func(BitCount) T

type PrefixKey

+ func PrefixKeyFrom(addr AddressType) PrefixKey

+ type RangeBoundaryKey interface

+ ToAddress func() T

type SegmentValueProvider

+ func WrapIPv4SegmentValueProvider(f IPv4SegmentValueProvider) SegmentValueProvider

+ func WrapIPv6SegmentValueProvider(f IPv6SegmentValueProvider) SegmentValueProvider

+ func WrapMACSegmentValueProvider(f MACSegmentValueProvider) SegmentValueProvider

+ type SequentialRange struct

+ func NewSequentialRange(lower, upper T) *SequentialRange[T]

+ func (rng *SequentialRange[T]) Bytes() []byte

+ func (rng *SequentialRange[T]) Compare(item AddressItem) int

+ func (rng *SequentialRange[T]) CompareSize(other AddressItem) int

+ func (rng *SequentialRange[T]) Contains(other IPAddressType) bool

+ func (rng *SequentialRange[T]) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (rng *SequentialRange[T]) ContainsRange(other IPAddressSeqRangeType) bool

+ func (rng *SequentialRange[T]) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (rng *SequentialRange[T]) CopyBytes(bytes []byte) []byte

+ func (rng *SequentialRange[T]) CopyNetIP(bytes net.IP) net.IP

+ func (rng *SequentialRange[T]) CopyUpperBytes(bytes []byte) []byte

+ func (rng *SequentialRange[T]) CopyUpperNetIP(bytes net.IP) net.IP

+ func (rng *SequentialRange[T]) CoverWithPrefixBlock() T

+ func (rng *SequentialRange[T]) Equal(other IPAddressSeqRangeType) bool

+ func (rng *SequentialRange[T]) Extend(other *SequentialRange[T]) *SequentialRange[T]

+ func (rng *SequentialRange[T]) GetBitCount() BitCount

+ func (rng *SequentialRange[T]) GetByteCount() int

+ func (rng *SequentialRange[T]) GetCount() *big.Int

+ func (rng *SequentialRange[T]) GetIPVersion() IPVersion

+ func (rng *SequentialRange[T]) GetLower() T

+ func (rng *SequentialRange[T]) GetLowerIPAddress() *IPAddress

+ func (rng *SequentialRange[T]) GetMinPrefixLenForBlock() BitCount

+ func (rng *SequentialRange[T]) GetNetIP() net.IP

+ func (rng *SequentialRange[T]) GetNetNetIPAddr() netip.Addr

+ func (rng *SequentialRange[T]) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (rng *SequentialRange[T]) GetPrefixLenForSingleBlock() PrefixLen

+ func (rng *SequentialRange[T]) GetUpper() T

+ func (rng *SequentialRange[T]) GetUpperIPAddress() *IPAddress

+ func (rng *SequentialRange[T]) GetUpperNetIP() net.IP

+ func (rng *SequentialRange[T]) GetUpperNetNetIPAddr() netip.Addr

+ func (rng *SequentialRange[T]) GetUpperValue() *big.Int

+ func (rng *SequentialRange[T]) GetValue() *big.Int

+ func (rng *SequentialRange[T]) IncludesMax() bool

+ func (rng *SequentialRange[T]) IncludesZero() bool

+ func (rng *SequentialRange[T]) Intersect(other *SequentialRange[T]) *SequentialRange[T]

+ func (rng *SequentialRange[T]) IsFullRange() bool

+ func (rng *SequentialRange[T]) IsIPv4() bool

+ func (rng *SequentialRange[T]) IsIPv6() bool

+ func (rng *SequentialRange[T]) IsMax() bool

+ func (rng *SequentialRange[T]) IsMultiple() bool

+ func (rng *SequentialRange[T]) IsSequential() bool

+ func (rng *SequentialRange[T]) IsZero() bool

+ func (rng *SequentialRange[T]) Iterator() Iterator[T]

+ func (rng *SequentialRange[T]) Join(ranges ...*SequentialRange[T]) []*SequentialRange[T]

+ func (rng *SequentialRange[T]) JoinTo(other *SequentialRange[T]) *SequentialRange[T]

+ func (rng *SequentialRange[T]) Overlaps(other *SequentialRange[T]) bool

+ func (rng *SequentialRange[T]) PrefixBlockIterator(prefLength BitCount) Iterator[T]

+ func (rng *SequentialRange[T]) PrefixIterator(prefLength BitCount) Iterator[*SequentialRange[T]]

+ func (rng *SequentialRange[T]) SpanWithPrefixBlocks() []T

+ func (rng *SequentialRange[T]) SpanWithSequentialBlocks() []T

+ func (rng *SequentialRange[T]) String() string

+ func (rng *SequentialRange[T]) Subtract(other *SequentialRange[T]) []*SequentialRange[T]

+ func (rng *SequentialRange[T]) ToCanonicalString() string

+ func (rng *SequentialRange[T]) ToIP() *SequentialRange[*IPAddress]

+ func (rng *SequentialRange[T]) ToIPv4() *SequentialRange[*IPv4Address]

+ func (rng *SequentialRange[T]) ToIPv6() *SequentialRange[*IPv6Address]

+ func (rng *SequentialRange[T]) ToKey() SequentialRangeKey[T]

+ func (rng *SequentialRange[T]) ToNormalizedString() string

+ func (rng *SequentialRange[T]) ToString(lowerStringer func(T) string, separator string, upperStringer func(T) string) string

+ func (rng *SequentialRange[T]) UpperBytes() []byte

+ func (rng SequentialRange[T]) Format(state fmt.State, verb rune)

+ type SequentialRangeConstraint interface

+ CoverWithPrefixBlockTo func(T) T

+ Format func(state fmt.State, verb rune)

+ GetLower func() T

+ GetUpper func() T

+ IncludesMaxHostLen func(BitCount) bool

+ IncludesZeroHostLen func(BitCount) bool

+ Increment func(int64) T

+ SpanWithPrefixBlocks func() []T

+ SpanWithPrefixBlocksTo func(T) []T

+ SpanWithSequentialBlocksTo func(T) []T

+ ToIP func() *IPAddress

+ ToPrefixBlockLen func(BitCount) T

+ WithoutPrefixLen func() T

+ type SequentialRangeKey struct

+ func (key SequentialRangeKey[T]) GetLowerKey() RangeBoundaryKey[T]

+ func (key SequentialRangeKey[T]) GetUpperKey() RangeBoundaryKey[T]

+ func (key SequentialRangeKey[T]) String() string

+ func (key SequentialRangeKey[T]) ToSeqRange() *SequentialRange[T]

+ type SpanPartitionConstraint interface

+ SpanWithPrefixBlocks func() []T

+ WithoutPrefixLen func() T

+ type Trie struct

+ func NewTrie() *Trie[T]

+ func (trie *Trie) Clear()

+ func (trie *Trie[T]) Add(addr T) bool

+ func (trie *Trie[T]) AddNode(addr T) *TrieNode[T]

+ func (trie *Trie[T]) AddTrie(added *TrieNode[T]) *TrieNode[T]

+ func (trie *Trie[T]) AddedNodesTreeString() string

+ func (trie *Trie[T]) AllNodeIterator(forward bool) IteratorWithRemove[*TrieNode[T]]

+ func (trie *Trie[T]) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IteratorWithRemove[*TrieNode[T]]

+ func (trie *Trie[T]) BlockSizeCachingAllNodeIterator() CachingTrieIterator[*TrieNode[T]]

+ func (trie *Trie[T]) BlockSizeNodeIterator(lowerSubNodeFirst bool) IteratorWithRemove[*TrieNode[T]]

+ func (trie *Trie[T]) CeilingAddedNode(addr T) *TrieNode[T]

+ func (trie *Trie[T]) Clone() *Trie[T]

+ func (trie *Trie[T]) ConstructAddedNodesTree() AddedTree[T]

+ func (trie *Trie[T]) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) Iterator[*TrieNode[T]]

+ func (trie *Trie[T]) ContainedFirstIterator(forwardSubNodeOrder bool) IteratorWithRemove[*TrieNode[T]]

+ func (trie *Trie[T]) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingTrieIterator[*TrieNode[T]]

+ func (trie *Trie[T]) ContainingFirstIterator(forwardSubNodeOrder bool) CachingTrieIterator[*TrieNode[T]]

+ func (trie *Trie[T]) Contains(addr T) bool

+ func (trie *Trie[T]) DescendingIterator() Iterator[T]

+ func (trie *Trie[T]) ElementContains(addr T) bool

+ func (trie *Trie[T]) ElementsContainedBy(addr T) *TrieNode[T]

+ func (trie *Trie[T]) ElementsContaining(addr T) *ContainmentPath[T]

+ func (trie *Trie[T]) Equal(other *Trie[T]) bool

+ func (trie *Trie[T]) FirstAddedNode() *TrieNode[T]

+ func (trie *Trie[T]) FirstNode() *TrieNode[T]

+ func (trie *Trie[T]) FloorAddedNode(addr T) *TrieNode[T]

+ func (trie *Trie[T]) GetAddedNode(addr T) *TrieNode[T]

+ func (trie *Trie[T]) GetNode(addr T) *TrieNode[T]

+ func (trie *Trie[T]) GetRoot() *TrieNode[T]

+ func (trie *Trie[T]) HigherAddedNode(addr T) *TrieNode[T]

+ func (trie *Trie[T]) IsEmpty() bool

+ func (trie *Trie[T]) Iterator() Iterator[T]

+ func (trie *Trie[T]) LastAddedNode() *TrieNode[T]

+ func (trie *Trie[T]) LastNode() *TrieNode[T]

+ func (trie *Trie[T]) LongestPrefixMatch(addr T) T

+ func (trie *Trie[T]) LongestPrefixMatchNode(addr T) *TrieNode[T]

+ func (trie *Trie[T]) LowerAddedNode(addr T) *TrieNode[T]

+ func (trie *Trie[T]) NodeIterator(forward bool) IteratorWithRemove[*TrieNode[T]]

+ func (trie *Trie[T]) NodeSize() int

+ func (trie *Trie[T]) Remove(addr T) bool

+ func (trie *Trie[T]) RemoveElementsContainedBy(addr T) *TrieNode[T]

+ func (trie *Trie[T]) Size() int

+ func (trie *Trie[T]) String() string

+ func (trie *Trie[T]) TreeString(withNonAddedKeys bool) string

+ func (trie Trie[T]) Format(state fmt.State, verb rune)

+ type TrieKeyConstraint interface

+ ToPrefixBlockLen func(prefLen BitCount) T

+ type TrieNode struct

+ func (node *TrieNode[T]) AllNodeIterator(forward bool) IteratorWithRemove[*TrieNode[T]]

+ func (node *TrieNode[T]) AsNewTrie() *Trie[T]

+ func (node *TrieNode[T]) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IteratorWithRemove[*TrieNode[T]]

+ func (node *TrieNode[T]) BlockSizeCachingAllNodeIterator() CachingTrieIterator[*TrieNode[T]]

+ func (node *TrieNode[T]) BlockSizeNodeIterator(lowerSubNodeFirst bool) IteratorWithRemove[*TrieNode[T]]

+ func (node *TrieNode[T]) CeilingAddedNode(addr T) *TrieNode[T]

+ func (node *TrieNode[T]) Clear()

+ func (node *TrieNode[T]) Clone() *TrieNode[T]

+ func (node *TrieNode[T]) CloneTree() *TrieNode[T]

+ func (node *TrieNode[T]) Compare(other *TrieNode[T]) int

+ func (node *TrieNode[T]) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) Iterator[*TrieNode[T]]

+ func (node *TrieNode[T]) ContainedFirstIterator(forwardSubNodeOrder bool) IteratorWithRemove[*TrieNode[T]]

+ func (node *TrieNode[T]) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingTrieIterator[*TrieNode[T]]

+ func (node *TrieNode[T]) ContainingFirstIterator(forwardSubNodeOrder bool) CachingTrieIterator[*TrieNode[T]]

+ func (node *TrieNode[T]) Contains(addr T) bool

+ func (node *TrieNode[T]) DescendingIterator() Iterator[T]

+ func (node *TrieNode[T]) ElementContains(addr T) bool

+ func (node *TrieNode[T]) ElementsContainedBy(addr T) *TrieNode[T]

+ func (node *TrieNode[T]) ElementsContaining(addr T) *ContainmentPath[T]

+ func (node *TrieNode[T]) Equal(other *TrieNode[T]) bool

+ func (node *TrieNode[T]) FirstAddedNode() *TrieNode[T]

+ func (node *TrieNode[T]) FirstNode() *TrieNode[T]

+ func (node *TrieNode[T]) FloorAddedNode(addr T) *TrieNode[T]

+ func (node *TrieNode[T]) GetAddedNode(addr T) *TrieNode[T]

+ func (node *TrieNode[T]) GetKey() T

+ func (node *TrieNode[T]) GetLowerSubNode() *TrieNode[T]

+ func (node *TrieNode[T]) GetNode(addr T) *TrieNode[T]

+ func (node *TrieNode[T]) GetParent() *TrieNode[T]

+ func (node *TrieNode[T]) GetUpperSubNode() *TrieNode[T]

+ func (node *TrieNode[T]) HigherAddedNode(addr T) *TrieNode[T]

+ func (node *TrieNode[T]) IsAdded() bool

+ func (node *TrieNode[T]) IsEmpty() bool

+ func (node *TrieNode[T]) IsLeaf() bool

+ func (node *TrieNode[T]) IsRoot() bool

+ func (node *TrieNode[T]) Iterator() Iterator[T]

+ func (node *TrieNode[T]) LastAddedNode() *TrieNode[T]

+ func (node *TrieNode[T]) LastNode() *TrieNode[T]

+ func (node *TrieNode[T]) LongestPrefixMatch(addr T) T

+ func (node *TrieNode[T]) LongestPrefixMatchNode(addr T) *TrieNode[T]

+ func (node *TrieNode[T]) LowerAddedNode(addr T) *TrieNode[T]

+ func (node *TrieNode[T]) NextAddedNode() *TrieNode[T]

+ func (node *TrieNode[T]) NextNode() *TrieNode[T]

+ func (node *TrieNode[T]) NodeIterator(forward bool) IteratorWithRemove[*TrieNode[T]]

+ func (node *TrieNode[T]) NodeSize() int

+ func (node *TrieNode[T]) PreviousAddedNode() *TrieNode[T]

+ func (node *TrieNode[T]) PreviousNode() *TrieNode[T]

+ func (node *TrieNode[T]) Remove()

+ func (node *TrieNode[T]) RemoveElementsContainedBy(addr T) *TrieNode[T]

+ func (node *TrieNode[T]) RemoveNode(addr T) bool

+ func (node *TrieNode[T]) SetAdded()

+ func (node *TrieNode[T]) Size() int

+ func (node *TrieNode[T]) String() string

+ func (node *TrieNode[T]) TreeEqual(other *TrieNode[T]) bool

+ func (node *TrieNode[T]) TreeString(withNonAddedKeys, withSizes bool) string

+ func (node TrieNode[T]) Format(state fmt.State, verb rune)

v1.4.1

Oct 21, 2022

v1.4.0

Oct 21, 2022

Changes in this version

+ func BitsForCount(count uint64) (result int)

+ func BlockSize(bits uint) *big.Int

type IPAddressSeqRange

+ func NewIPSeqRange(lower, upper *IPAddress) *IPAddressSeqRange

+ type IPAllocatedBlock struct

+ func (alloc IPAllocatedBlock) GetAddress() *IPAddress

+ func (alloc IPAllocatedBlock) GetCount() *big.Int

+ func (alloc IPAllocatedBlock) GetReservedCount() int

+ func (alloc IPAllocatedBlock) GetSize() *big.Int

+ func (alloc IPAllocatedBlock) String() string

+ type IPPrefixBlockAllocator struct

+ func (alloc *IPPrefixBlockAllocator) AddAvailable(blocks ...*IPAddress)

+ func (alloc *IPPrefixBlockAllocator) AllocateBitLen(bitLength BitCount) *IPAddress

+ func (alloc *IPPrefixBlockAllocator) AllocateMultiBitLens(bitLengths ...BitCount) []IPAllocatedBlock

+ func (alloc *IPPrefixBlockAllocator) AllocateSize(sizeRequired uint64) *IPAddress

+ func (alloc *IPPrefixBlockAllocator) AllocateSizes(blockSizes ...uint64) []IPAllocatedBlock

+ func (alloc *IPPrefixBlockAllocator) GetAvailable() (blocks []*IPAddress)

+ func (alloc *IPPrefixBlockAllocator) GetBlockCount() int

+ func (alloc *IPPrefixBlockAllocator) GetReserved() (reservedCount int)

+ func (alloc *IPPrefixBlockAllocator) GetTotalCount() *big.Int

+ func (alloc *IPPrefixBlockAllocator) GetVersion() IPVersion

+ func (alloc *IPPrefixBlockAllocator) SetReserved(reservedCount int)

+ func (alloc *IPPrefixBlockAllocator) ToIPv4() *IPv4PrefixBlockAllocator

+ func (alloc *IPPrefixBlockAllocator) ToIPv6() *IPv6PrefixBlockAllocator

+ func (alloc IPPrefixBlockAllocator) String() string

type IPVersion

+ func (version IPVersion) GetNetwork() (network IPAddressNetwork)

+ type IPv4AllocatedBlock struct

+ func (alloc IPv4AllocatedBlock) GetAddress() *IPv4Address

+ func (alloc IPv4AllocatedBlock) GetCount() *big.Int

+ func (alloc IPv4AllocatedBlock) GetReservedCount() int

+ func (alloc IPv4AllocatedBlock) GetSize() *big.Int

+ func (alloc IPv4AllocatedBlock) String() string

+ type IPv4PrefixBlockAllocator struct

+ func (alloc *IPv4PrefixBlockAllocator) AddAvailable(blocks ...*IPv4Address)

+ func (alloc *IPv4PrefixBlockAllocator) AllocateBitLen(bitLength BitCount) *IPv4Address

+ func (alloc *IPv4PrefixBlockAllocator) AllocateMultiBitLens(bitLengths ...BitCount) []IPv4AllocatedBlock

+ func (alloc *IPv4PrefixBlockAllocator) AllocateSize(sizeRequired uint64) *IPv4Address

+ func (alloc *IPv4PrefixBlockAllocator) AllocateSizes(blockSizes ...uint64) []IPv4AllocatedBlock

+ func (alloc *IPv4PrefixBlockAllocator) GetAvailable() (blocks []*IPv4Address)

+ func (alloc *IPv4PrefixBlockAllocator) GetBlockCount() int

+ func (alloc *IPv4PrefixBlockAllocator) GetReserved() (reservedCount int)

+ func (alloc *IPv4PrefixBlockAllocator) GetTotalCount() *big.Int

+ func (alloc *IPv4PrefixBlockAllocator) GetVersion() IPVersion

+ func (alloc *IPv4PrefixBlockAllocator) SetReserved(reservedCount int)

+ func (alloc IPv4PrefixBlockAllocator) String() string

+ type IPv6AllocatedBlock struct

+ func (alloc IPv6AllocatedBlock) GetAddress() *IPv6Address

+ func (alloc IPv6AllocatedBlock) GetCount() *big.Int

+ func (alloc IPv6AllocatedBlock) GetReservedCount() int

+ func (alloc IPv6AllocatedBlock) GetSize() *big.Int

+ func (alloc IPv6AllocatedBlock) String() string

+ type IPv6PrefixBlockAllocator struct

+ func (alloc *IPv6PrefixBlockAllocator) AddAvailable(blocks ...*IPv6Address)

+ func (alloc *IPv6PrefixBlockAllocator) AllocateBitLen(bitLength BitCount) *IPv6Address

+ func (alloc *IPv6PrefixBlockAllocator) AllocateMultiBitLens(bitLengths ...BitCount) []IPv6AllocatedBlock

+ func (alloc *IPv6PrefixBlockAllocator) AllocateSize(sizeRequired uint64) *IPv6Address

+ func (alloc *IPv6PrefixBlockAllocator) AllocateSizes(blockSizes ...uint64) []IPv6AllocatedBlock

+ func (alloc *IPv6PrefixBlockAllocator) GetAvailable() (blocks []*IPv6Address)

+ func (alloc *IPv6PrefixBlockAllocator) GetBlockCount() int

+ func (alloc *IPv6PrefixBlockAllocator) GetReserved() (reservedCount int)

+ func (alloc *IPv6PrefixBlockAllocator) GetTotalCount() *big.Int

+ func (alloc *IPv6PrefixBlockAllocator) GetVersion() IPVersion

+ func (alloc *IPv6PrefixBlockAllocator) SetReserved(reservedCount int)

+ func (alloc IPv6PrefixBlockAllocator) String() string

v1.3.0

Oct 10, 2022

Changes in this version

+ const AnyScheme

+ const IPv6SegmentSeparatorStr

+ const IPv6UncSegmentSeparatorStr

+ const IPv6UncZoneSeparatorStr

type AddressDivision

+ func (div *AddressDivision) CompareSize(other AddressItem) int

type AddressItem

+ CompareSize func(AddressItem) int

type AddressSegment

+ func (seg *AddressSegment) CompareSize(other AddressItem) int

type ExtendedMasker

+ func MaskExtendedRange(value, extendedValue, upperValue, extendedUpperValue, maskValue, ... uint64) ExtendedMasker

type HostName

+ func (host *HostName) IsReverseDNS() bool

+ func (host *HostName) IsUncIPv6Literal() bool

type IPAddress

+ func (addr *IPAddress) ToUNCHostName() string

+ type IPAddressLargeDivision struct

+ func NewIPAddressLargeDivision(val []byte, bitCount BitCount, defaultRadix int) *IPAddressLargeDivision

+ func NewIPAddressLargePrefixDivision(val []byte, prefixLen PrefixLen, bitCount BitCount, defaultRadix int) *IPAddressLargeDivision

+ func NewIPAddressLargeRangeDivision(val, upperVal []byte, bitCount BitCount, defaultRadix int) *IPAddressLargeDivision

+ func NewIPAddressLargeRangePrefixDivision(val, upperVal []byte, prefixLen PrefixLen, bitCount BitCount, defaultRadix int) *IPAddressLargeDivision

+ func (div *IPAddressLargeDivision) Compare(item AddressItem) int

+ func (div *IPAddressLargeDivision) CompareSize(other AddressItem) int

+ func (div *IPAddressLargeDivision) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (div *IPAddressLargeDivision) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (div *IPAddressLargeDivision) GetCount() *big.Int

+ func (div *IPAddressLargeDivision) GetDivisionPrefixLen() PrefixLen

+ func (div *IPAddressLargeDivision) GetMinPrefixLenForBlock() BitCount

+ func (div *IPAddressLargeDivision) GetPrefixLen() PrefixLen

+ func (div *IPAddressLargeDivision) GetPrefixLenForSingleBlock() PrefixLen

+ func (div *IPAddressLargeDivision) GetString() string

+ func (div *IPAddressLargeDivision) GetUpperValue() *BigDivInt

+ func (div *IPAddressLargeDivision) GetValue() *BigDivInt

+ func (div *IPAddressLargeDivision) GetWildcardString() string

+ func (div *IPAddressLargeDivision) IsMultiple() bool

+ func (div *IPAddressLargeDivision) IsPrefixBlock() bool

+ func (div *IPAddressLargeDivision) IsPrefixed() bool

+ func (div *IPAddressLargeDivision) IsSinglePrefix(divisionPrefixLen BitCount) bool

+ func (div *IPAddressLargeDivision) IsSinglePrefixBlock() bool

+ func (div *IPAddressLargeDivision) String() string

+ func (div IPAddressLargeDivision) Format(state fmt.State, verb rune)

+ type IPAddressLargeDivisionGrouping struct

+ func NewIPAddressLargeDivGrouping(divs []*IPAddressLargeDivision) *IPAddressLargeDivisionGrouping

+ func (grouping *IPAddressLargeDivisionGrouping) Bytes() []byte

+ func (grouping *IPAddressLargeDivisionGrouping) Compare(item AddressItem) int

+ func (grouping *IPAddressLargeDivisionGrouping) CompareSize(other AddressItem) int

+ func (grouping *IPAddressLargeDivisionGrouping) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (grouping *IPAddressLargeDivisionGrouping) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (grouping *IPAddressLargeDivisionGrouping) CopyBytes(bytes []byte) []byte

+ func (grouping *IPAddressLargeDivisionGrouping) CopyDivisions(divs []*IPAddressLargeDivision) (count int)

+ func (grouping *IPAddressLargeDivisionGrouping) CopySubDivisions(start, end int, divs []*IPAddressLargeDivision) (count int)

+ func (grouping *IPAddressLargeDivisionGrouping) CopyUpperBytes(bytes []byte) []byte

+ func (grouping *IPAddressLargeDivisionGrouping) ForEachDivision(consumer func(divisionIndex int, division *IPAddressLargeDivision) (stop bool)) int

+ func (grouping *IPAddressLargeDivisionGrouping) GetCount() *big.Int

+ func (grouping *IPAddressLargeDivisionGrouping) GetDivision(index int) *IPAddressLargeDivision

+ func (grouping *IPAddressLargeDivisionGrouping) GetMinPrefixLenForBlock() BitCount

+ func (grouping *IPAddressLargeDivisionGrouping) GetPrefixLenForSingleBlock() PrefixLen

+ func (grouping *IPAddressLargeDivisionGrouping) GetUpperValue() *big.Int

+ func (grouping *IPAddressLargeDivisionGrouping) GetValue() *big.Int

+ func (grouping *IPAddressLargeDivisionGrouping) IsMultiple() bool

+ func (grouping *IPAddressLargeDivisionGrouping) IsPrefixBlock() bool

+ func (grouping *IPAddressLargeDivisionGrouping) IsPrefixed() bool

+ func (grouping *IPAddressLargeDivisionGrouping) IsSinglePrefixBlock() bool

+ func (grouping *IPAddressLargeDivisionGrouping) String() string

+ func (grouping *IPAddressLargeDivisionGrouping) UpperBytes() []byte

type IPAddressSegment

+ func (seg *IPAddressSegment) CompareSize(other AddressItem) int

type IPAddressString

+ func (addrStr *IPAddressString) IsBase85IPv6() bool

+ func (addrStr *IPAddressString) IsIPv4Mapped() bool

type IPv4Address

+ func (addr *IPv4Address) ToUNCHostName() string

type IPv4AddressSegment

+ func (seg *IPv4AddressSegment) CompareSize(other AddressItem) int

type IPv6Address

+ func (addr *IPv6Address) ToBase85String() (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToUNCHostName() string

type IPv6AddressSection

+ func (section *IPv6AddressSection) ToBase85String() (string, addrerr.IncompatibleAddressError)

type IPv6AddressSegment

+ func (seg *IPv6AddressSegment) CompareSize(other AddressItem) int

type MACAddressSegment

+ func (seg *MACAddressSegment) CompareSize(other AddressItem) int

v1.2.1

Jun 1, 2022

v1.2.0

May 28, 2022

Changes in this version

type Address

+ func (addr *Address) ForEachSegment(consumer func(segmentIndex int, segment *AddressSegment) (stop bool)) int

type AddressDivisionGrouping

+ func (grouping *AddressDivisionGrouping) ForEachDivision(consumer func(divisionIndex int, division *AddressDivision) (stop bool)) int

type AddressSection

+ func (section *AddressSection) ForEachSegment(consumer func(segmentIndex int, segment *AddressSegment) (stop bool)) int

type AddressSectionType

+ PrefixContains func(AddressSectionType) bool

+ PrefixEqual func(AddressSectionType) bool

+ type ContainmentPath struct

+ func (path *ContainmentPath) Count() int

+ func (path *ContainmentPath) LongestPrefixMatch() *ContainmentPathNode

+ func (path *ContainmentPath) ShortestPrefixMatch() *ContainmentPathNode

+ func (path *ContainmentPath) String() string

+ type ContainmentPathNode struct

+ func (node *ContainmentPathNode) Count() int

+ func (node *ContainmentPathNode) GetKey() *Address

+ func (node *ContainmentPathNode) GetValue() NodeValue

+ func (node *ContainmentPathNode) ListString() string

+ func (node *ContainmentPathNode) Next() *ContainmentPathNode

+ func (node *ContainmentPathNode) Previous() *ContainmentPathNode

+ func (node *ContainmentPathNode) String() string

type ExtendedSegmentSeries

+ ToPrefixBlockLen func(prefLen BitCount) ExtendedSegmentSeries

type HostIdentifierString

+ Wrap func() ExtendedIdentifierString

type IPAddress

+ func NewIPAddressFromBytes(ip net.IP) (*IPAddress, addrerr.AddressValueError)

+ func NewIPAddressFromSegs(segments []*IPAddressSegment) (res *IPAddress, err addrerr.AddressValueError)

+ func (addr *IPAddress) ForEachSegment(consumer func(segmentIndex int, segment *IPAddressSegment) (stop bool)) int

+ func (addr *IPAddress) GetUpperNetIPAddr() *net.IPAddr

+ func (addr *IPAddress) WrapAddress() WrappedAddress

type IPAddressActionAdapter

+ func (a IPAddressActionAdapter) IPAction(addr *IPAddress)

+ func (a IPAddressActionAdapter) IPv4Action(addr *IPv4Address)

+ func (a IPAddressActionAdapter) IPv6Action(addr *IPv6Address)

type IPAddressCreator

+ func (creator IPAddressCreator) NewIPSectionFromSegmentedBytes(bytes []byte, segmentCount int) (*IPAddressSection, addrerr.AddressValueError)

type IPAddressSection

+ func (section *IPAddressSection) ForEachSegment(consumer func(segmentIndex int, segment *IPAddressSegment) (stop bool)) int

+ func (section *IPAddressSection) WrapSection() WrappedAddressSection

type IPAddressSeqRangeType

+ Equal func(IPAddressSeqRangeType) bool

+ ToCanonicalString func() string

+ ToNormalizedString func() string

type IPv4Address

+ func (addr *IPv4Address) ForEachSegment(consumer func(segmentIndex int, segment *IPv4AddressSegment) (stop bool)) int

+ func (addr *IPv4Address) GetIPv4BlockCount(segmentCount int) uint64

+ func (addr *IPv4Address) GetIPv4Count() uint64

+ func (addr *IPv4Address) GetIPv4PrefixCount() uint64

+ func (addr *IPv4Address) GetIPv4PrefixCountLen(prefixLength BitCount) uint64

+ func (addr *IPv4Address) GetNetIPAddr() *net.IPAddr

+ func (addr *IPv4Address) GetUpperNetIPAddr() *net.IPAddr

+ func (addr *IPv4Address) IsFullRange() bool

+ func (addr *IPv4Address) WrapAddress() WrappedAddress

type IPv4AddressSection

+ func (section *IPv4AddressSection) ForEachSegment(consumer func(segmentIndex int, segment *IPv4AddressSegment) (stop bool)) int

+ func (section *IPv4AddressSection) WrapSection() WrappedAddressSection

type IPv6Address

+ func NewIPv6AddressFromZonedMACSection(prefix *IPv6AddressSection, suffix *MACAddressSection, zone string) (*IPv6Address, addrerr.AddressError)

+ func (addr *IPv6Address) ForEachSegment(consumer func(segmentIndex int, segment *IPv6AddressSegment) (stop bool)) int

+ func (addr *IPv6Address) GetUpperNetIPAddr() *net.IPAddr

+ func (addr *IPv6Address) IsFullRange() bool

+ func (addr *IPv6Address) WrapAddress() WrappedAddress

type IPv6AddressSection

+ func NewIPv6SectionFromPrefixedRange(vals, upperVals IPv6SegmentValueProvider, segmentCount int, ...) (res *IPv6AddressSection)

+ func NewIPv6SectionFromRange(vals, upperVals IPv6SegmentValueProvider, segmentCount int) (res *IPv6AddressSection)

+ func (section *IPv6AddressSection) ForEachSegment(consumer func(segmentIndex int, segment *IPv6AddressSegment) (stop bool)) int

+ func (section *IPv6AddressSection) WrapSection() WrappedAddressSection

type MACAddress

+ func NewMACAddressFromSegs(segments []*MACAddressSegment) (*MACAddress, addrerr.AddressValueError)

+ func (addr *MACAddress) ForEachSegment(consumer func(segmentIndex int, segment *MACAddressSegment) (stop bool)) int

+ func (addr *MACAddress) ToPrefixBlockLen(prefLen BitCount) *MACAddress

type MACAddressSection

+ func (section *MACAddressSection) ForEachSegment(consumer func(segmentIndex int, segment *MACAddressSegment) (stop bool)) int

+ type SegmentSequence struct

+ type SegmentSequenceList struct

type WrappedAddress

+ func (addr WrappedAddress) ToPrefixBlockLen(prefLen BitCount) ExtendedSegmentSeries

type WrappedAddressSection

+ func (section WrappedAddressSection) ForEachSegment(consumer func(segmentIndex int, segment *AddressSegment) (stop bool)) int

+ func (section WrappedAddressSection) ToPrefixBlockLen(prefLen BitCount) ExtendedSegmentSeries

+ type WrappedIPAddressIterator struct

+ func (iter WrappedIPAddressIterator) Next() *Address

type WrappedIPAddressSection

+ func (section WrappedIPAddressSection) ForEachSegment(consumer func(segmentIndex int, segment *IPAddressSegment) (stop bool)) int

+ func (section WrappedIPAddressSection) WrapSection() WrappedAddressSection

v1.1.2

Feb 28, 2022

v1.1.1

Feb 28, 2022

Changes in this version

+ const EUIScheme

+ const IPv4Scheme

+ const IPv6Scheme

type AddressKey

+ Scheme AddressScheme

+ func (key *AddressKey) String() string

+ func (key *AddressKey) ToAddress() *Address

+ type AddressScheme string

+ type IPAddressKey struct

+ func (key *IPAddressKey) ToIP() *IPAddress

type IPAddressSeqRangeKey

+ func (key *IPAddressSeqRangeKey) String() string

+ func (key *IPAddressSeqRangeKey) ToSeqRange() *IPAddressSeqRange

type IPv4AddressKey

+ func (key *IPv4AddressKey) String() string

+ func (key *IPv4AddressKey) ToIPKey() *IPAddressKey

type IPv4AddressSeqRangeKey

+ func (key *IPv4AddressSeqRangeKey) String() string

type IPv6AddressKey

+ func (key *IPv6AddressKey) String() string

+ func (key *IPv6AddressKey) ToIPKey() *IPAddressKey

type IPv6AddressSeqRangeKey

+ func (key *IPv6AddressSeqRangeKey) String() string

type MACAddressKey

+ func (key *MACAddressKey) String() string

v1.1.0

Feb 26, 2022

Changes in this version

+ const MaxSegmentCount

+ func CompareSegInt(one, two SegInt) int

+ func TreesString(withNonAddedKeys bool, tries ...*AddressTrie) string

type Address

+ func (addr *Address) GetLeadingBitCount(ones bool) BitCount

+ func (addr *Address) GetTrailingBitCount(ones bool) BitCount

+ func (addr *Address) ToKey() *AddressKey

+ func (addr *Address) ToPrefixBlockLen(prefLen BitCount) *Address

+ func (addr *Address) ToSinglePrefixBlockOrAddress() *Address

+ func (addr *Address) TrieCompare(other *Address) (int, addrerr.IncompatibleAddressError)

+ func (addr *Address) TrieDecrement() *Address

+ func (addr *Address) TrieIncrement() *Address

+ type AddressKey struct

+ Prefix PrefixKey

+ SegmentCount uint8

+ Values [MaxSegmentCount]struct{ ... }

+ Zone Zone

type AddressSection

+ func (section *AddressSection) GetLeadingBitCount(ones bool) BitCount

+ func (section *AddressSection) GetTrailingBitCount(ones bool) BitCount

type AddressSegment

+ func (seg *AddressSegment) GetLeadingBitCount(ones bool) BitCount

+ func (seg *AddressSegment) GetSegmentHostMask(networkBits BitCount) SegInt

+ func (seg *AddressSegment) GetSegmentNetworkMask(networkBits BitCount) SegInt

+ func (seg *AddressSegment) GetTrailingBitCount(ones bool) BitCount

+ type AddressTrie struct

+ func (trie *AddressTrie) Add(addr *Address) bool

+ func (trie *AddressTrie) AddNode(addr *Address) *AddressTrieNode

+ func (trie *AddressTrie) AddTrie(added *AddressTrieNode) *AddressTrieNode

+ func (trie *AddressTrie) AddedNodesTreeString() string

+ func (trie *AddressTrie) AllNodeIterator(forward bool) AddressTrieNodeIteratorRem

+ func (trie *AddressTrie) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) AddressTrieNodeIteratorRem

+ func (trie *AddressTrie) BlockSizeCachingAllNodeIterator() CachingAddressTrieNodeIterator

+ func (trie *AddressTrie) BlockSizeNodeIterator(lowerSubNodeFirst bool) AddressTrieNodeIteratorRem

+ func (trie *AddressTrie) CeilingAddedNode(addr *Address) *AddressTrieNode

+ func (trie *AddressTrie) Clear()

+ func (trie *AddressTrie) Clone() *AddressTrie

+ func (trie *AddressTrie) ConstructAddedNodesTree() *AddressTrie

+ func (trie *AddressTrie) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) AddressTrieNodeIterator

+ func (trie *AddressTrie) ContainedFirstIterator(forwardSubNodeOrder bool) AddressTrieNodeIteratorRem

+ func (trie *AddressTrie) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingAddressTrieNodeIterator

+ func (trie *AddressTrie) ContainingFirstIterator(forwardSubNodeOrder bool) CachingAddressTrieNodeIterator

+ func (trie *AddressTrie) Contains(addr *Address) bool

+ func (trie *AddressTrie) DescendingIterator() AddressIterator

+ func (trie *AddressTrie) ElementContains(addr *Address) bool

+ func (trie *AddressTrie) ElementsContainedBy(addr *Address) *AddressTrieNode

+ func (trie *AddressTrie) ElementsContaining(addr *Address) *AddressTrieNode

+ func (trie *AddressTrie) Equal(other *AddressTrie) bool

+ func (trie *AddressTrie) FirstAddedNode() *AddressTrieNode

+ func (trie *AddressTrie) FirstNode() *AddressTrieNode

+ func (trie *AddressTrie) FloorAddedNode(addr *Address) *AddressTrieNode

+ func (trie *AddressTrie) GetAddedNode(addr *Address) *AddressTrieNode

+ func (trie *AddressTrie) GetNode(addr *Address) *AddressTrieNode

+ func (trie *AddressTrie) GetRoot() *AddressTrieNode

+ func (trie *AddressTrie) HigherAddedNode(addr *Address) *AddressTrieNode

+ func (trie *AddressTrie) IsEmpty() bool

+ func (trie *AddressTrie) Iterator() AddressIterator

+ func (trie *AddressTrie) LastAddedNode() *AddressTrieNode

+ func (trie *AddressTrie) LastNode() *AddressTrieNode

+ func (trie *AddressTrie) LongestPrefixMatch(addr *Address) *Address

+ func (trie *AddressTrie) LongestPrefixMatchNode(addr *Address) *AddressTrieNode

+ func (trie *AddressTrie) LowerAddedNode(addr *Address) *AddressTrieNode

+ func (trie *AddressTrie) NodeIterator(forward bool) AddressTrieNodeIteratorRem

+ func (trie *AddressTrie) NodeSize() int

+ func (trie *AddressTrie) Remove(addr *Address) bool

+ func (trie *AddressTrie) RemoveElementsContainedBy(addr *Address) *AddressTrieNode

+ func (trie *AddressTrie) Size() int

+ func (trie *AddressTrie) String() string

+ func (trie *AddressTrie) ToAssociative() *AssociativeAddressTrie

+ func (trie *AddressTrie) ToIPv4() *IPv4AddressTrie

+ func (trie *AddressTrie) ToIPv4Associative() *IPv4AddressAssociativeTrie

+ func (trie *AddressTrie) ToIPv6() *IPv6AddressTrie

+ func (trie *AddressTrie) ToIPv6Associative() *IPv6AddressAssociativeTrie

+ func (trie *AddressTrie) ToMAC() *MACAddressTrie

+ func (trie *AddressTrie) ToMACAssociative() *MACAddressAssociativeTrie

+ func (trie *AddressTrie) TreeString(withNonAddedKeys bool) string

+ func (trie AddressTrie) Format(state fmt.State, verb rune)

+ type AddressTrieNode struct

+ func (node *AddressTrieNode) AllNodeIterator(forward bool) AddressTrieNodeIteratorRem

+ func (node *AddressTrieNode) AsNewTrie() *AddressTrie

+ func (node *AddressTrieNode) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) AddressTrieNodeIteratorRem

+ func (node *AddressTrieNode) BlockSizeCachingAllNodeIterator() CachingAddressTrieNodeIterator

+ func (node *AddressTrieNode) BlockSizeNodeIterator(lowerSubNodeFirst bool) AddressTrieNodeIteratorRem

+ func (node *AddressTrieNode) CeilingAddedNode(addr *Address) *AddressTrieNode

+ func (node *AddressTrieNode) Clear()

+ func (node *AddressTrieNode) Clone() *AddressTrieNode

+ func (node *AddressTrieNode) CloneTree() *AddressTrieNode

+ func (node *AddressTrieNode) Compare(other *AddressTrieNode) int

+ func (node *AddressTrieNode) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) AddressTrieNodeIterator

+ func (node *AddressTrieNode) ContainedFirstIterator(forwardSubNodeOrder bool) AddressTrieNodeIteratorRem

+ func (node *AddressTrieNode) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingAddressTrieNodeIterator

+ func (node *AddressTrieNode) ContainingFirstIterator(forwardSubNodeOrder bool) CachingAddressTrieNodeIterator

+ func (node *AddressTrieNode) Contains(addr *Address) bool

+ func (node *AddressTrieNode) DescendingIterator() AddressIterator

+ func (node *AddressTrieNode) ElementContains(addr *Address) bool

+ func (node *AddressTrieNode) ElementsContainedBy(addr *Address) *AddressTrieNode

+ func (node *AddressTrieNode) ElementsContaining(addr *Address) *AddressTrieNode

+ func (node *AddressTrieNode) Equal(other *AddressTrieNode) bool

+ func (node *AddressTrieNode) FirstAddedNode() *AddressTrieNode

+ func (node *AddressTrieNode) FirstNode() *AddressTrieNode

+ func (node *AddressTrieNode) FloorAddedNode(addr *Address) *AddressTrieNode

+ func (node *AddressTrieNode) GetAddedNode(addr *Address) *AddressTrieNode

+ func (node *AddressTrieNode) GetKey() *Address

+ func (node *AddressTrieNode) GetLowerSubNode() *AddressTrieNode

+ func (node *AddressTrieNode) GetNode(addr *Address) *AddressTrieNode

+ func (node *AddressTrieNode) GetParent() *AddressTrieNode

+ func (node *AddressTrieNode) GetUpperSubNode() *AddressTrieNode

+ func (node *AddressTrieNode) HigherAddedNode(addr *Address) *AddressTrieNode

+ func (node *AddressTrieNode) IsAdded() bool

+ func (node *AddressTrieNode) IsEmpty() bool

+ func (node *AddressTrieNode) IsLeaf() bool

+ func (node *AddressTrieNode) IsRoot() bool

+ func (node *AddressTrieNode) Iterator() AddressIterator

+ func (node *AddressTrieNode) LastAddedNode() *AddressTrieNode

+ func (node *AddressTrieNode) LastNode() *AddressTrieNode

+ func (node *AddressTrieNode) LongestPrefixMatch(addr *Address) *Address

+ func (node *AddressTrieNode) LongestPrefixMatchNode(addr *Address) *AddressTrieNode

+ func (node *AddressTrieNode) LowerAddedNode(addr *Address) *AddressTrieNode

+ func (node *AddressTrieNode) NextAddedNode() *AddressTrieNode

+ func (node *AddressTrieNode) NextNode() *AddressTrieNode

+ func (node *AddressTrieNode) NodeIterator(forward bool) AddressTrieNodeIteratorRem

+ func (node *AddressTrieNode) NodeSize() int

+ func (node *AddressTrieNode) PreviousAddedNode() *AddressTrieNode

+ func (node *AddressTrieNode) PreviousNode() *AddressTrieNode

+ func (node *AddressTrieNode) Remove()

+ func (node *AddressTrieNode) RemoveElementsContainedBy(addr *Address) *AddressTrieNode

+ func (node *AddressTrieNode) RemoveNode(addr *Address) bool

+ func (node *AddressTrieNode) SetAdded()

+ func (node *AddressTrieNode) Size() int

+ func (node *AddressTrieNode) String() string

+ func (node *AddressTrieNode) ToAssociative() *AssociativeAddressTrieNode

+ func (node *AddressTrieNode) ToIPv4() *IPv4AddressTrieNode

+ func (node *AddressTrieNode) ToIPv4Associative() *IPv4AddressAssociativeTrieNode

+ func (node *AddressTrieNode) ToIPv6() *IPv6AddressTrieNode

+ func (node *AddressTrieNode) ToIPv6Associative() *IPv6AddressAssociativeTrieNode

+ func (node *AddressTrieNode) ToMAC() *MACAddressTrieNode

+ func (node *AddressTrieNode) ToMACAssociative() *MACAddressAssociativeTrieNode

+ func (node *AddressTrieNode) TreeEqual(other *AddressTrieNode) bool

+ func (node *AddressTrieNode) TreeString(withNonAddedKeys, withSizes bool) string

+ func (node AddressTrieNode) Format(state fmt.State, verb rune)

+ type AddressTrieNodeIterator interface

+ Next func() *AddressTrieNode

+ type AddressTrieNodeIteratorRem interface

+ Remove func() *AddressTrieNode

+ type AssociativeAddressTrie struct

+ func (trie *AssociativeAddressTrie) Add(addr *Address) bool

+ func (trie *AssociativeAddressTrie) AddNode(addr *Address) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) AddTrie(added *AssociativeAddressTrieNode) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) AddedNodesTreeString() string

+ func (trie *AssociativeAddressTrie) AllNodeIterator(forward bool) AssociativeAddressTrieNodeIteratorRem

+ func (trie *AssociativeAddressTrie) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) AssociativeAddressTrieNodeIteratorRem

+ func (trie *AssociativeAddressTrie) BlockSizeCachingAllNodeIterator() CachingAssociativeAddressTrieNodeIterator

+ func (trie *AssociativeAddressTrie) BlockSizeNodeIterator(lowerSubNodeFirst bool) AssociativeAddressTrieNodeIteratorRem

+ func (trie *AssociativeAddressTrie) CeilingAddedNode(addr *Address) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) Clone() *AssociativeAddressTrie

+ func (trie *AssociativeAddressTrie) ConstructAddedNodesTree() *AssociativeAddressTrie

+ func (trie *AssociativeAddressTrie) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) AssociativeAddressTrieNodeIterator

+ func (trie *AssociativeAddressTrie) ContainedFirstIterator(forwardSubNodeOrder bool) AssociativeAddressTrieNodeIteratorRem

+ func (trie *AssociativeAddressTrie) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingAssociativeAddressTrieNodeIterator

+ func (trie *AssociativeAddressTrie) ContainingFirstIterator(forwardSubNodeOrder bool) CachingAssociativeAddressTrieNodeIterator

+ func (trie *AssociativeAddressTrie) Contains(addr *Address) bool

+ func (trie *AssociativeAddressTrie) DeepEqual(other *AssociativeAddressTrie) bool

+ func (trie *AssociativeAddressTrie) DescendingIterator() AddressIterator

+ func (trie *AssociativeAddressTrie) ElementContains(addr *Address) bool

+ func (trie *AssociativeAddressTrie) ElementsContainedBy(addr *Address) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) ElementsContaining(addr *Address) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) Equal(other *AssociativeAddressTrie) bool

+ func (trie *AssociativeAddressTrie) FirstAddedNode() *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) FirstNode() *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) FloorAddedNode(addr *Address) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) Get(addr *Address) NodeValue

+ func (trie *AssociativeAddressTrie) GetAddedNode(addr *Address) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) GetNode(addr *Address) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) GetRoot() *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) HigherAddedNode(addr *Address) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) IsEmpty() bool

+ func (trie *AssociativeAddressTrie) Iterator() AddressIterator

+ func (trie *AssociativeAddressTrie) LastAddedNode() *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) LastNode() *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) LongestPrefixMatch(addr *Address) *Address

+ func (trie *AssociativeAddressTrie) LongestPrefixMatchNode(addr *Address) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) LowerAddedNode(addr *Address) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) NodeIterator(forward bool) AssociativeAddressTrieNodeIteratorRem

+ func (trie *AssociativeAddressTrie) NodeSize() int

+ func (trie *AssociativeAddressTrie) Put(addr *Address, value NodeValue) (bool, NodeValue)

+ func (trie *AssociativeAddressTrie) PutNode(addr *Address, value NodeValue) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) PutTrie(added *AssociativeAddressTrieNode) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) Remap(addr *Address, remapper func(NodeValue) NodeValue) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) RemapIfAbsent(addr *Address, supplier func() NodeValue, insertNil bool) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) Remove(addr *Address) bool

+ func (trie *AssociativeAddressTrie) RemoveElementsContainedBy(addr *Address) *AssociativeAddressTrieNode

+ func (trie *AssociativeAddressTrie) Size() int

+ func (trie *AssociativeAddressTrie) String() string

+ func (trie *AssociativeAddressTrie) ToBase() *AddressTrie

+ func (trie *AssociativeAddressTrie) ToIPv4() *IPv4AddressAssociativeTrie

+ func (trie *AssociativeAddressTrie) TreeString(withNonAddedKeys bool) string

+ func (trie AssociativeAddressTrie) Format(state fmt.State, verb rune)

+ type AssociativeAddressTrieNode struct

+ func (node *AssociativeAddressTrieNode) AllNodeIterator(forward bool) AssociativeAddressTrieNodeIteratorRem

+ func (node *AssociativeAddressTrieNode) AsNewTrie() *AssociativeAddressTrie

+ func (node *AssociativeAddressTrieNode) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) AssociativeAddressTrieNodeIteratorRem

+ func (node *AssociativeAddressTrieNode) BlockSizeCachingAllNodeIterator() CachingAssociativeAddressTrieNodeIterator

+ func (node *AssociativeAddressTrieNode) BlockSizeNodeIterator(lowerSubNodeFirst bool) AssociativeAddressTrieNodeIteratorRem

+ func (node *AssociativeAddressTrieNode) CeilingAddedNode(addr *Address) *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) Clear()

+ func (node *AssociativeAddressTrieNode) ClearValue()

+ func (node *AssociativeAddressTrieNode) Clone() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) CloneTree() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) Compare(other *AssociativeAddressTrieNode) int

+ func (node *AssociativeAddressTrieNode) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) AssociativeAddressTrieNodeIterator

+ func (node *AssociativeAddressTrieNode) ContainedFirstIterator(forwardSubNodeOrder bool) AssociativeAddressTrieNodeIteratorRem

+ func (node *AssociativeAddressTrieNode) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingAssociativeAddressTrieNodeIterator

+ func (node *AssociativeAddressTrieNode) ContainingFirstIterator(forwardSubNodeOrder bool) CachingAssociativeAddressTrieNodeIterator

+ func (node *AssociativeAddressTrieNode) Contains(addr *Address) bool

+ func (node *AssociativeAddressTrieNode) DeepEqual(other *AssociativeAddressTrieNode) bool

+ func (node *AssociativeAddressTrieNode) DescendingIterator() AddressIterator

+ func (node *AssociativeAddressTrieNode) ElementContains(addr *Address) bool

+ func (node *AssociativeAddressTrieNode) ElementsContainedBy(addr *Address) *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) ElementsContaining(addr *Address) *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) Equal(other *AssociativeAddressTrieNode) bool

+ func (node *AssociativeAddressTrieNode) FirstAddedNode() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) FirstNode() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) FloorAddedNode(addr *Address) *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) Get(addr *Address) NodeValue

+ func (node *AssociativeAddressTrieNode) GetAddedNode(addr *Address) *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) GetKey() *Address

+ func (node *AssociativeAddressTrieNode) GetLowerSubNode() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) GetNode(addr *Address) *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) GetParent() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) GetUpperSubNode() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) GetValue() NodeValue

+ func (node *AssociativeAddressTrieNode) HigherAddedNode(addr *Address) *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) IsAdded() bool

+ func (node *AssociativeAddressTrieNode) IsEmpty() bool

+ func (node *AssociativeAddressTrieNode) IsLeaf() bool

+ func (node *AssociativeAddressTrieNode) IsRoot() bool

+ func (node *AssociativeAddressTrieNode) Iterator() AddressIterator

+ func (node *AssociativeAddressTrieNode) LastAddedNode() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) LastNode() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) LongestPrefixMatch(addr *Address) *Address

+ func (node *AssociativeAddressTrieNode) LongestPrefixMatchNode(addr *Address) *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) LowerAddedNode(addr *Address) *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) NextAddedNode() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) NextNode() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) NodeIterator(forward bool) AssociativeAddressTrieNodeIteratorRem

+ func (node *AssociativeAddressTrieNode) NodeSize() int

+ func (node *AssociativeAddressTrieNode) PreviousAddedNode() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) PreviousNode() *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) Remove()

+ func (node *AssociativeAddressTrieNode) RemoveElementsContainedBy(addr *Address) *AssociativeAddressTrieNode

+ func (node *AssociativeAddressTrieNode) RemoveNode(addr *Address) bool

+ func (node *AssociativeAddressTrieNode) SetAdded()

+ func (node *AssociativeAddressTrieNode) SetValue(val NodeValue)

+ func (node *AssociativeAddressTrieNode) Size() int

+ func (node *AssociativeAddressTrieNode) String() string

+ func (node *AssociativeAddressTrieNode) ToBase() *AddressTrieNode

+ func (node *AssociativeAddressTrieNode) ToIPv4() *IPv4AddressAssociativeTrieNode

+ func (node *AssociativeAddressTrieNode) ToIPv6() *IPv6AddressAssociativeTrieNode

+ func (node *AssociativeAddressTrieNode) ToMAC() *MACAddressAssociativeTrieNode

+ func (node *AssociativeAddressTrieNode) TreeDeepEqual(other *AssociativeAddressTrieNode) bool

+ func (node *AssociativeAddressTrieNode) TreeEqual(other *AssociativeAddressTrieNode) bool

+ func (node *AssociativeAddressTrieNode) TreeString(withNonAddedKeys, withSizes bool) string

+ func (node AssociativeAddressTrieNode) Format(state fmt.State, verb rune)

+ type AssociativeAddressTrieNodeIterator interface

+ Next func() *AssociativeAddressTrieNode

+ type AssociativeAddressTrieNodeIteratorRem interface

+ Remove func() *AssociativeAddressTrieNode

+ type CachingAddressTrieNodeIterator interface

+ type CachingAssociativeAddressTrieNodeIterator interface

+ type CachingIPv4AssociativeTrieNodeIterator interface

+ type CachingIPv4TrieNodeIterator interface

+ type CachingIPv6AssociativeTrieNodeIterator interface

+ type CachingIPv6TrieNodeIterator interface

+ type CachingMACAssociativeTrieNodeIterator interface

+ type CachingMACTrieNodeIterator interface

type IPAddress

+ func (addr *IPAddress) ToKey() *AddressKey

+ func (addr *IPAddress) ToSinglePrefixBlockOrAddress() *IPAddress

+ func (addr *IPAddress) TrieCompare(other *IPAddress) (int, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) TrieDecrement() *IPAddress

+ func (addr *IPAddress) TrieIncrement() *IPAddress

+ type IPAddressActionAdapter struct

+ Adapted func(*Address)

+ func (a IPAddressActionAdapter) IPPredicate(addr *IPAddress)

+ func (a IPAddressActionAdapter) IPv4Predicate(addr *IPv4Address)

+ func (a IPAddressActionAdapter) IPv6Predicate(addr *IPv6Address)

+ type IPAddressPredicateAdapter struct

+ Adapted func(*Address) bool

+ func (a IPAddressPredicateAdapter) IPPredicate(addr *IPAddress) bool

+ func (a IPAddressPredicateAdapter) IPv4Predicate(addr *IPv4Address) bool

+ func (a IPAddressPredicateAdapter) IPv6Predicate(addr *IPv6Address) bool

type IPAddressSeqRange

+ func (rng *IPAddressSeqRange) ToKey() *IPAddressSeqRangeKey

+ type IPAddressSeqRangeKey struct

type IPv4Address

+ func (addr *IPv4Address) ToKey() *IPv4AddressKey

+ func (addr *IPv4Address) ToSinglePrefixBlockOrAddress() *IPv4Address

+ func (addr *IPv4Address) TrieCompare(other *IPv4Address) int

+ func (addr *IPv4Address) TrieDecrement() *IPv4Address

+ func (addr *IPv4Address) TrieIncrement() *IPv4Address

+ type IPv4AddressAssociativeTrie struct

+ func NewIPv4AddressAssociativeTrie() *IPv4AddressAssociativeTrie

+ func (trie *IPv4AddressAssociativeTrie) Add(addr *IPv4Address) bool

+ func (trie *IPv4AddressAssociativeTrie) AddNode(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) AddTrie(added *IPv4AddressAssociativeTrieNode) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) AddedNodesTreeString() string

+ func (trie *IPv4AddressAssociativeTrie) AllNodeIterator(forward bool) IPv4AssociativeTrieNodeIteratorRem

+ func (trie *IPv4AddressAssociativeTrie) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IPv4AssociativeTrieNodeIteratorRem

+ func (trie *IPv4AddressAssociativeTrie) BlockSizeCachingAllNodeIterator() CachingIPv4AssociativeTrieNodeIterator

+ func (trie *IPv4AddressAssociativeTrie) BlockSizeNodeIterator(lowerSubNodeFirst bool) IPv4AssociativeTrieNodeIteratorRem

+ func (trie *IPv4AddressAssociativeTrie) CeilingAddedNode(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) Clone() *IPv4AddressAssociativeTrie

+ func (trie *IPv4AddressAssociativeTrie) ConstructAddedNodesTree() *IPv4AddressAssociativeTrie

+ func (trie *IPv4AddressAssociativeTrie) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) IPv4AssociativeTrieNodeIterator

+ func (trie *IPv4AddressAssociativeTrie) ContainedFirstIterator(forwardSubNodeOrder bool) IPv4AssociativeTrieNodeIteratorRem

+ func (trie *IPv4AddressAssociativeTrie) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingIPv4AssociativeTrieNodeIterator

+ func (trie *IPv4AddressAssociativeTrie) ContainingFirstIterator(forwardSubNodeOrder bool) CachingIPv4AssociativeTrieNodeIterator

+ func (trie *IPv4AddressAssociativeTrie) Contains(addr *IPv4Address) bool

+ func (trie *IPv4AddressAssociativeTrie) DeepEqual(other *IPv4AddressAssociativeTrie) bool

+ func (trie *IPv4AddressAssociativeTrie) DescendingIterator() IPv4AddressIterator

+ func (trie *IPv4AddressAssociativeTrie) ElementContains(addr *IPv4Address) bool

+ func (trie *IPv4AddressAssociativeTrie) ElementsContainedBy(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) ElementsContaining(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) Equal(other *IPv4AddressAssociativeTrie) bool

+ func (trie *IPv4AddressAssociativeTrie) FirstAddedNode() *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) FirstNode() *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) FloorAddedNode(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) Get(addr *IPv4Address) NodeValue

+ func (trie *IPv4AddressAssociativeTrie) GetAddedNode(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) GetNode(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) GetRoot() *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) HigherAddedNode(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) IsEmpty() bool

+ func (trie *IPv4AddressAssociativeTrie) Iterator() IPv4AddressIterator

+ func (trie *IPv4AddressAssociativeTrie) LastAddedNode() *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) LastNode() *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) LongestPrefixMatch(addr *IPv4Address) *IPv4Address

+ func (trie *IPv4AddressAssociativeTrie) LongestPrefixMatchNode(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) LowerAddedNode(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) NodeIterator(forward bool) IPv4AssociativeTrieNodeIteratorRem

+ func (trie *IPv4AddressAssociativeTrie) NodeSize() int

+ func (trie *IPv4AddressAssociativeTrie) Put(addr *IPv4Address, value NodeValue) (bool, NodeValue)

+ func (trie *IPv4AddressAssociativeTrie) PutNode(addr *IPv4Address, value NodeValue) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) PutTrie(added *IPv4AddressAssociativeTrieNode) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) Remap(addr *IPv4Address, remapper func(NodeValue) NodeValue) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) RemapIfAbsent(addr *IPv4Address, supplier func() NodeValue, insertNil bool) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) Remove(addr *IPv4Address) bool

+ func (trie *IPv4AddressAssociativeTrie) RemoveElementsContainedBy(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (trie *IPv4AddressAssociativeTrie) Size() int

+ func (trie *IPv4AddressAssociativeTrie) String() string

+ func (trie *IPv4AddressAssociativeTrie) ToAssociativeBase() *AssociativeAddressTrie

+ func (trie *IPv4AddressAssociativeTrie) ToBase() *AddressTrie

+ func (trie *IPv4AddressAssociativeTrie) ToIPv4Base() *IPv4AddressTrie

+ func (trie *IPv4AddressAssociativeTrie) TreeString(withNonAddedKeys bool) string

+ func (trie IPv4AddressAssociativeTrie) Format(state fmt.State, verb rune)

+ type IPv4AddressAssociativeTrieNode struct

+ func (node *IPv4AddressAssociativeTrieNode) AllNodeIterator(forward bool) IPv4AssociativeTrieNodeIteratorRem

+ func (node *IPv4AddressAssociativeTrieNode) AsNewTrie() *IPv4AddressAssociativeTrie

+ func (node *IPv4AddressAssociativeTrieNode) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IPv4AssociativeTrieNodeIteratorRem

+ func (node *IPv4AddressAssociativeTrieNode) BlockSizeCachingAllNodeIterator() CachingIPv4AssociativeTrieNodeIterator

+ func (node *IPv4AddressAssociativeTrieNode) BlockSizeNodeIterator(lowerSubNodeFirst bool) IPv4AssociativeTrieNodeIteratorRem

+ func (node *IPv4AddressAssociativeTrieNode) CeilingAddedNode(addr *Address) *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) Clear()

+ func (node *IPv4AddressAssociativeTrieNode) ClearValue()

+ func (node *IPv4AddressAssociativeTrieNode) Clone() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) CloneTree() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) Compare(other *IPv4AddressAssociativeTrieNode) int

+ func (node *IPv4AddressAssociativeTrieNode) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) IPv4AssociativeTrieNodeIterator

+ func (node *IPv4AddressAssociativeTrieNode) ContainedFirstIterator(forwardSubNodeOrder bool) IPv4AssociativeTrieNodeIteratorRem

+ func (node *IPv4AddressAssociativeTrieNode) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingIPv4AssociativeTrieNodeIterator

+ func (node *IPv4AddressAssociativeTrieNode) ContainingFirstIterator(forwardSubNodeOrder bool) CachingIPv4AssociativeTrieNodeIterator

+ func (node *IPv4AddressAssociativeTrieNode) Contains(addr *IPv4Address) bool

+ func (node *IPv4AddressAssociativeTrieNode) DeepEqual(other *IPv4AddressAssociativeTrieNode) bool

+ func (node *IPv4AddressAssociativeTrieNode) DescendingIterator() IPv4AddressIterator

+ func (node *IPv4AddressAssociativeTrieNode) ElementContains(addr *IPv4Address) bool

+ func (node *IPv4AddressAssociativeTrieNode) ElementsContainedBy(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) ElementsContaining(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) Equal(other *IPv4AddressAssociativeTrieNode) bool

+ func (node *IPv4AddressAssociativeTrieNode) FirstAddedNode() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) FirstNode() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) FloorAddedNode(addr *Address) *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) Get(addr *IPv4Address) NodeValue

+ func (node *IPv4AddressAssociativeTrieNode) GetAddedNode(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) GetKey() *IPv4Address

+ func (node *IPv4AddressAssociativeTrieNode) GetLowerSubNode() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) GetNode(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) GetParent() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) GetUpperSubNode() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) GetValue() NodeValue

+ func (node *IPv4AddressAssociativeTrieNode) HigherAddedNode(addr *Address) *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) IsAdded() bool

+ func (node *IPv4AddressAssociativeTrieNode) IsEmpty() bool

+ func (node *IPv4AddressAssociativeTrieNode) IsLeaf() bool

+ func (node *IPv4AddressAssociativeTrieNode) IsRoot() bool

+ func (node *IPv4AddressAssociativeTrieNode) Iterator() IPv4AddressIterator

+ func (node *IPv4AddressAssociativeTrieNode) LastAddedNode() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) LastNode() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) LongestPrefixMatch(addr *IPv4Address) *Address

+ func (node *IPv4AddressAssociativeTrieNode) LongestPrefixMatchNode(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) LowerAddedNode(addr *Address) *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) NextAddedNode() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) NextNode() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) NodeIterator(forward bool) IPv4AssociativeTrieNodeIteratorRem

+ func (node *IPv4AddressAssociativeTrieNode) NodeSize() int

+ func (node *IPv4AddressAssociativeTrieNode) PreviousAddedNode() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) PreviousNode() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) Remove()

+ func (node *IPv4AddressAssociativeTrieNode) RemoveElementsContainedBy(addr *IPv4Address) *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) RemoveNode(addr *IPv4Address) bool

+ func (node *IPv4AddressAssociativeTrieNode) SetAdded()

+ func (node *IPv4AddressAssociativeTrieNode) SetValue(val NodeValue)

+ func (node *IPv4AddressAssociativeTrieNode) Size() int

+ func (node *IPv4AddressAssociativeTrieNode) String() string

+ func (node *IPv4AddressAssociativeTrieNode) ToAssociativeBase() *AssociativeAddressTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) ToBase() *AddressTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) ToIPv4Base() *IPv4AddressTrieNode

+ func (node *IPv4AddressAssociativeTrieNode) TreeDeepEqual(other *IPv4AddressAssociativeTrieNode) bool

+ func (node *IPv4AddressAssociativeTrieNode) TreeEqual(other *IPv4AddressAssociativeTrieNode) bool

+ func (node *IPv4AddressAssociativeTrieNode) TreeString(withNonAddedKeys, withSizes bool) string

+ func (node IPv4AddressAssociativeTrieNode) Format(state fmt.State, verb rune)

+ type IPv4AddressKey struct

+ Prefix PrefixKey

+ Values [IPv4SegmentCount]struct{ ... }

+ func (key *IPv4AddressKey) Normalize()

+ func (key *IPv4AddressKey) ToAddress() *IPv4Address

+ func (key *IPv4AddressKey) ToBaseKey() *AddressKey

+ func (key *IPv4AddressKey) UpperVal(segmentIndex int) IPv4SegInt

+ func (key *IPv4AddressKey) Val(segmentIndex int) IPv4SegInt

type IPv4AddressSeqRange

+ func (rng *IPv4AddressSeqRange) ToKey() *IPv4AddressSeqRangeKey

+ type IPv4AddressSeqRangeKey struct

+ func (key *IPv4AddressSeqRangeKey) ToSeqRange() *IPv4AddressSeqRange

+ type IPv4AddressTrie struct

+ func NewIPv4AddressTrie() *IPv4AddressTrie

+ func (trie *IPv4AddressTrie) Add(addr *IPv4Address) bool

+ func (trie *IPv4AddressTrie) AddNode(addr *IPv4Address) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) AddTrie(added *IPv4AddressTrieNode) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) AddedNodesTreeString() string

+ func (trie *IPv4AddressTrie) AllNodeIterator(forward bool) IPv4TrieNodeIteratorRem

+ func (trie *IPv4AddressTrie) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IPv4TrieNodeIteratorRem

+ func (trie *IPv4AddressTrie) BlockSizeCachingAllNodeIterator() CachingIPv4TrieNodeIterator

+ func (trie *IPv4AddressTrie) BlockSizeNodeIterator(lowerSubNodeFirst bool) IPv4TrieNodeIteratorRem

+ func (trie *IPv4AddressTrie) CeilingAddedNode(addr *IPv4Address) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) Clear()

+ func (trie *IPv4AddressTrie) Clone() *IPv4AddressTrie

+ func (trie *IPv4AddressTrie) ConstructAddedNodesTree() *IPv4AddressTrie

+ func (trie *IPv4AddressTrie) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) IPv4TrieNodeIterator

+ func (trie *IPv4AddressTrie) ContainedFirstIterator(forwardSubNodeOrder bool) IPv4TrieNodeIteratorRem

+ func (trie *IPv4AddressTrie) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingIPv4TrieNodeIterator

+ func (trie *IPv4AddressTrie) ContainingFirstIterator(forwardSubNodeOrder bool) CachingIPv4TrieNodeIterator

+ func (trie *IPv4AddressTrie) Contains(addr *IPv4Address) bool

+ func (trie *IPv4AddressTrie) DescendingIterator() IPv4AddressIterator

+ func (trie *IPv4AddressTrie) ElementContains(addr *IPv4Address) bool

+ func (trie *IPv4AddressTrie) ElementsContainedBy(addr *IPv4Address) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) ElementsContaining(addr *IPv4Address) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) Equal(other *IPv4AddressTrie) bool

+ func (trie *IPv4AddressTrie) FirstAddedNode() *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) FirstNode() *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) FloorAddedNode(addr *IPv4Address) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) GetAddedNode(addr *IPv4Address) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) GetNode(addr *IPv4Address) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) GetRoot() *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) HigherAddedNode(addr *IPv4Address) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) IsEmpty() bool

+ func (trie *IPv4AddressTrie) Iterator() IPv4AddressIterator

+ func (trie *IPv4AddressTrie) LastAddedNode() *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) LastNode() *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) LongestPrefixMatch(addr *IPv4Address) *IPv4Address

+ func (trie *IPv4AddressTrie) LongestPrefixMatchNode(addr *IPv4Address) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) LowerAddedNode(addr *IPv4Address) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) NodeIterator(forward bool) IPv4TrieNodeIteratorRem

+ func (trie *IPv4AddressTrie) NodeSize() int

+ func (trie *IPv4AddressTrie) Remove(addr *IPv4Address) bool

+ func (trie *IPv4AddressTrie) RemoveElementsContainedBy(addr *IPv4Address) *IPv4AddressTrieNode

+ func (trie *IPv4AddressTrie) Size() int

+ func (trie *IPv4AddressTrie) String() string

+ func (trie *IPv4AddressTrie) ToAssociative() *IPv4AddressAssociativeTrie

+ func (trie *IPv4AddressTrie) ToBase() *AddressTrie

+ func (trie *IPv4AddressTrie) TreeString(withNonAddedKeys bool) string

+ func (trie IPv4AddressTrie) Format(state fmt.State, verb rune)

+ type IPv4AddressTrieNode struct

+ func (node *IPv4AddressTrieNode) AllNodeIterator(forward bool) IPv4TrieNodeIteratorRem

+ func (node *IPv4AddressTrieNode) AsNewTrie() *IPv4AddressTrie

+ func (node *IPv4AddressTrieNode) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IPv4TrieNodeIteratorRem

+ func (node *IPv4AddressTrieNode) BlockSizeCachingAllNodeIterator() CachingIPv4TrieNodeIterator

+ func (node *IPv4AddressTrieNode) BlockSizeNodeIterator(lowerSubNodeFirst bool) IPv4TrieNodeIteratorRem

+ func (node *IPv4AddressTrieNode) CeilingAddedNode(addr *Address) *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) Clear()

+ func (node *IPv4AddressTrieNode) Clone() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) CloneTree() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) Compare(other *IPv4AddressTrieNode) int

+ func (node *IPv4AddressTrieNode) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) IPv4TrieNodeIterator

+ func (node *IPv4AddressTrieNode) ContainedFirstIterator(forwardSubNodeOrder bool) IPv4TrieNodeIteratorRem

+ func (node *IPv4AddressTrieNode) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingIPv4TrieNodeIterator

+ func (node *IPv4AddressTrieNode) ContainingFirstIterator(forwardSubNodeOrder bool) CachingIPv4TrieNodeIterator

+ func (node *IPv4AddressTrieNode) Contains(addr *IPv4Address) bool

+ func (node *IPv4AddressTrieNode) DescendingIterator() IPv4AddressIterator

+ func (node *IPv4AddressTrieNode) ElementContains(addr *IPv4Address) bool

+ func (node *IPv4AddressTrieNode) ElementsContainedBy(addr *IPv4Address) *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) ElementsContaining(addr *IPv4Address) *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) Equal(other *IPv4AddressTrieNode) bool

+ func (node *IPv4AddressTrieNode) FirstAddedNode() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) FirstNode() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) FloorAddedNode(addr *Address) *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) GetAddedNode(addr *IPv4Address) *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) GetKey() *IPv4Address

+ func (node *IPv4AddressTrieNode) GetLowerSubNode() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) GetNode(addr *IPv4Address) *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) GetParent() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) GetUpperSubNode() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) HigherAddedNode(addr *Address) *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) IsAdded() bool

+ func (node *IPv4AddressTrieNode) IsEmpty() bool

+ func (node *IPv4AddressTrieNode) IsLeaf() bool

+ func (node *IPv4AddressTrieNode) IsRoot() bool

+ func (node *IPv4AddressTrieNode) Iterator() IPv4AddressIterator

+ func (node *IPv4AddressTrieNode) LastAddedNode() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) LastNode() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) LongestPrefixMatch(addr *IPv4Address) *Address

+ func (node *IPv4AddressTrieNode) LongestPrefixMatchNode(addr *IPv4Address) *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) LowerAddedNode(addr *Address) *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) NextAddedNode() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) NextNode() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) NodeIterator(forward bool) IPv4TrieNodeIteratorRem

+ func (node *IPv4AddressTrieNode) NodeSize() int

+ func (node *IPv4AddressTrieNode) PreviousAddedNode() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) PreviousNode() *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) Remove()

+ func (node *IPv4AddressTrieNode) RemoveElementsContainedBy(addr *IPv4Address) *IPv4AddressTrieNode

+ func (node *IPv4AddressTrieNode) RemoveNode(addr *IPv4Address) bool

+ func (node *IPv4AddressTrieNode) SetAdded()

+ func (node *IPv4AddressTrieNode) Size() int

+ func (node *IPv4AddressTrieNode) String() string

+ func (node *IPv4AddressTrieNode) ToAssociative() *IPv4AddressAssociativeTrieNode

+ func (node *IPv4AddressTrieNode) ToBase() *AddressTrieNode

+ func (node *IPv4AddressTrieNode) TreeEqual(other *IPv4AddressTrieNode) bool

+ func (node *IPv4AddressTrieNode) TreeString(withNonAddedKeys, withSizes bool) string

+ func (node IPv4AddressTrieNode) Format(state fmt.State, verb rune)

+ type IPv4AssociativeTrieNodeIterator interface

+ Next func() *IPv4AddressAssociativeTrieNode

+ type IPv4AssociativeTrieNodeIteratorRem interface

+ Remove func() *IPv4AddressAssociativeTrieNode

+ type IPv4TrieNodeIterator interface

+ Next func() *IPv4AddressTrieNode

+ type IPv4TrieNodeIteratorRem interface

+ Remove func() *IPv4AddressTrieNode

type IPv6Address

+ func (addr *IPv6Address) ToKey() *IPv6AddressKey

+ func (addr *IPv6Address) ToSinglePrefixBlockOrAddress() *IPv6Address

+ func (addr *IPv6Address) TrieCompare(other *IPv6Address) int

+ func (addr *IPv6Address) TrieDecrement() *IPv6Address

+ func (addr *IPv6Address) TrieIncrement() *IPv6Address

+ type IPv6AddressAssociativeTrie struct

+ func NewIPv6AddressAssociativeTrie() *IPv6AddressAssociativeTrie

+ func (trie *IPv6AddressAssociativeTrie) Add(addr *IPv6Address) bool

+ func (trie *IPv6AddressAssociativeTrie) AddNode(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) AddTrie(added *IPv6AddressAssociativeTrieNode) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) AddedNodesTreeString() string

+ func (trie *IPv6AddressAssociativeTrie) AllNodeIterator(forward bool) IPv6AssociativeTrieNodeIteratorRem

+ func (trie *IPv6AddressAssociativeTrie) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IPv6AssociativeTrieNodeIteratorRem

+ func (trie *IPv6AddressAssociativeTrie) BlockSizeCachingAllNodeIterator() CachingIPv6AssociativeTrieNodeIterator

+ func (trie *IPv6AddressAssociativeTrie) BlockSizeNodeIterator(lowerSubNodeFirst bool) IPv6AssociativeTrieNodeIteratorRem

+ func (trie *IPv6AddressAssociativeTrie) CeilingAddedNode(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) Clone() *IPv6AddressAssociativeTrie

+ func (trie *IPv6AddressAssociativeTrie) ConstructAddedNodesTree() *IPv6AddressAssociativeTrie

+ func (trie *IPv6AddressAssociativeTrie) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) IPv6AssociativeTrieNodeIterator

+ func (trie *IPv6AddressAssociativeTrie) ContainedFirstIterator(forwardSubNodeOrder bool) IPv6AssociativeTrieNodeIteratorRem

+ func (trie *IPv6AddressAssociativeTrie) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingIPv6AssociativeTrieNodeIterator

+ func (trie *IPv6AddressAssociativeTrie) ContainingFirstIterator(forwardSubNodeOrder bool) CachingIPv6AssociativeTrieNodeIterator

+ func (trie *IPv6AddressAssociativeTrie) Contains(addr *IPv6Address) bool

+ func (trie *IPv6AddressAssociativeTrie) DeepEqual(other *IPv6AddressAssociativeTrie) bool

+ func (trie *IPv6AddressAssociativeTrie) DescendingIterator() IPv6AddressIterator

+ func (trie *IPv6AddressAssociativeTrie) ElementContains(addr *IPv6Address) bool

+ func (trie *IPv6AddressAssociativeTrie) ElementsContainedBy(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) ElementsContaining(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) Equal(other *IPv6AddressAssociativeTrie) bool

+ func (trie *IPv6AddressAssociativeTrie) FirstAddedNode() *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) FirstNode() *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) FloorAddedNode(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) Get(addr *IPv6Address) NodeValue

+ func (trie *IPv6AddressAssociativeTrie) GetAddedNode(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) GetNode(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) GetRoot() *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) HigherAddedNode(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) IsEmpty() bool

+ func (trie *IPv6AddressAssociativeTrie) Iterator() IPv6AddressIterator

+ func (trie *IPv6AddressAssociativeTrie) LastAddedNode() *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) LastNode() *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) LongestPrefixMatch(addr *IPv6Address) *IPv6Address

+ func (trie *IPv6AddressAssociativeTrie) LongestPrefixMatchNode(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) LowerAddedNode(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) NodeIterator(forward bool) IPv6AssociativeTrieNodeIteratorRem

+ func (trie *IPv6AddressAssociativeTrie) NodeSize() int

+ func (trie *IPv6AddressAssociativeTrie) Put(addr *IPv6Address, value NodeValue) (bool, NodeValue)

+ func (trie *IPv6AddressAssociativeTrie) PutNode(addr *IPv6Address, value NodeValue) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) PutTrie(added *IPv6AddressAssociativeTrieNode) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) Remap(addr *IPv6Address, remapper func(NodeValue) NodeValue) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) RemapIfAbsent(addr *IPv6Address, supplier func() NodeValue, insertNil bool) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) Remove(addr *IPv6Address) bool

+ func (trie *IPv6AddressAssociativeTrie) RemoveElementsContainedBy(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (trie *IPv6AddressAssociativeTrie) Size() int

+ func (trie *IPv6AddressAssociativeTrie) String() string

+ func (trie *IPv6AddressAssociativeTrie) ToAssociativeBase() *AssociativeAddressTrie

+ func (trie *IPv6AddressAssociativeTrie) ToBase() *AddressTrie

+ func (trie *IPv6AddressAssociativeTrie) ToIPv6Base() *IPv6AddressTrie

+ func (trie *IPv6AddressAssociativeTrie) TreeString(withNonAddedKeys bool) string

+ func (trie IPv6AddressAssociativeTrie) Format(state fmt.State, verb rune)

+ type IPv6AddressAssociativeTrieNode struct

+ func (node *IPv6AddressAssociativeTrieNode) AllNodeIterator(forward bool) IPv6AssociativeTrieNodeIteratorRem

+ func (node *IPv6AddressAssociativeTrieNode) AsNewTrie() *IPv6AddressAssociativeTrie

+ func (node *IPv6AddressAssociativeTrieNode) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IPv6AssociativeTrieNodeIteratorRem

+ func (node *IPv6AddressAssociativeTrieNode) BlockSizeCachingAllNodeIterator() CachingIPv6AssociativeTrieNodeIterator

+ func (node *IPv6AddressAssociativeTrieNode) BlockSizeNodeIterator(lowerSubNodeFirst bool) IPv6AssociativeTrieNodeIteratorRem

+ func (node *IPv6AddressAssociativeTrieNode) CeilingAddedNode(addr *Address) *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) Clear()

+ func (node *IPv6AddressAssociativeTrieNode) ClearValue()

+ func (node *IPv6AddressAssociativeTrieNode) Clone() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) CloneTree() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) Compare(other *IPv6AddressAssociativeTrieNode) int

+ func (node *IPv6AddressAssociativeTrieNode) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) IPv6AssociativeTrieNodeIterator

+ func (node *IPv6AddressAssociativeTrieNode) ContainedFirstIterator(forwardSubNodeOrder bool) IPv6AssociativeTrieNodeIteratorRem

+ func (node *IPv6AddressAssociativeTrieNode) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingIPv6AssociativeTrieNodeIterator

+ func (node *IPv6AddressAssociativeTrieNode) ContainingFirstIterator(forwardSubNodeOrder bool) CachingIPv6AssociativeTrieNodeIterator

+ func (node *IPv6AddressAssociativeTrieNode) Contains(addr *IPv6Address) bool

+ func (node *IPv6AddressAssociativeTrieNode) DeepEqual(other *IPv6AddressAssociativeTrieNode) bool

+ func (node *IPv6AddressAssociativeTrieNode) DescendingIterator() IPv6AddressIterator

+ func (node *IPv6AddressAssociativeTrieNode) ElementContains(addr *IPv6Address) bool

+ func (node *IPv6AddressAssociativeTrieNode) ElementsContainedBy(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) ElementsContaining(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) Equal(other *IPv6AddressAssociativeTrieNode) bool

+ func (node *IPv6AddressAssociativeTrieNode) FirstAddedNode() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) FirstNode() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) FloorAddedNode(addr *Address) *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) Get(addr *IPv6Address) NodeValue

+ func (node *IPv6AddressAssociativeTrieNode) GetAddedNode(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) GetKey() *IPv6Address

+ func (node *IPv6AddressAssociativeTrieNode) GetLowerSubNode() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) GetNode(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) GetParent() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) GetUpperSubNode() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) GetValue() NodeValue

+ func (node *IPv6AddressAssociativeTrieNode) HigherAddedNode(addr *Address) *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) IsAdded() bool

+ func (node *IPv6AddressAssociativeTrieNode) IsEmpty() bool

+ func (node *IPv6AddressAssociativeTrieNode) IsLeaf() bool

+ func (node *IPv6AddressAssociativeTrieNode) IsRoot() bool

+ func (node *IPv6AddressAssociativeTrieNode) Iterator() IPv6AddressIterator

+ func (node *IPv6AddressAssociativeTrieNode) LastAddedNode() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) LastNode() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) LongestPrefixMatch(addr *IPv6Address) *Address

+ func (node *IPv6AddressAssociativeTrieNode) LongestPrefixMatchNode(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) LowerAddedNode(addr *Address) *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) NextAddedNode() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) NextNode() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) NodeIterator(forward bool) IPv6AssociativeTrieNodeIteratorRem

+ func (node *IPv6AddressAssociativeTrieNode) NodeSize() int

+ func (node *IPv6AddressAssociativeTrieNode) PreviousAddedNode() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) PreviousNode() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) Remove()

+ func (node *IPv6AddressAssociativeTrieNode) RemoveElementsContainedBy(addr *IPv6Address) *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) RemoveNode(addr *IPv6Address) bool

+ func (node *IPv6AddressAssociativeTrieNode) SetAdded()

+ func (node *IPv6AddressAssociativeTrieNode) SetValue(val NodeValue)

+ func (node *IPv6AddressAssociativeTrieNode) Size() int

+ func (node *IPv6AddressAssociativeTrieNode) String() string

+ func (node *IPv6AddressAssociativeTrieNode) ToAssociativeBase() *AssociativeAddressTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) ToBase() *AddressTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) ToIPv6Base() *IPv6AddressTrieNode

+ func (node *IPv6AddressAssociativeTrieNode) TreeDeepEqual(other *IPv6AddressAssociativeTrieNode) bool

+ func (node *IPv6AddressAssociativeTrieNode) TreeEqual(other *IPv6AddressAssociativeTrieNode) bool

+ func (node *IPv6AddressAssociativeTrieNode) TreeString(withNonAddedKeys, withSizes bool) string

+ func (node IPv6AddressAssociativeTrieNode) Format(state fmt.State, verb rune)

+ type IPv6AddressKey struct

+ Prefix PrefixKey

+ Values [IPv6SegmentCount]struct{ ... }

+ Zone Zone

+ func (key *IPv6AddressKey) Normalize()

+ func (key *IPv6AddressKey) ToAddress() *IPv6Address

+ func (key *IPv6AddressKey) ToBaseKey() *AddressKey

+ func (key *IPv6AddressKey) UpperVal(segmentIndex int) IPv6SegInt

+ func (key *IPv6AddressKey) Val(segmentIndex int) IPv6SegInt

type IPv6AddressSeqRange

+ func (rng *IPv6AddressSeqRange) ToKey() *IPv6AddressSeqRangeKey

+ type IPv6AddressSeqRangeKey struct

+ func (key *IPv6AddressSeqRangeKey) ToSeqRange() *IPv6AddressSeqRange

+ type IPv6AddressTrie struct

+ func NewIPv6AddressTrie() *IPv6AddressTrie

+ func (trie *IPv6AddressTrie) Add(addr *IPv6Address) bool

+ func (trie *IPv6AddressTrie) AddNode(addr *IPv6Address) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) AddTrie(added *IPv6AddressTrieNode) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) AddedNodesTreeString() string

+ func (trie *IPv6AddressTrie) AllNodeIterator(forward bool) IPv6TrieNodeIteratorRem

+ func (trie *IPv6AddressTrie) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IPv6TrieNodeIteratorRem

+ func (trie *IPv6AddressTrie) BlockSizeCachingAllNodeIterator() CachingIPv6TrieNodeIterator

+ func (trie *IPv6AddressTrie) BlockSizeNodeIterator(lowerSubNodeFirst bool) IPv6TrieNodeIteratorRem

+ func (trie *IPv6AddressTrie) CeilingAddedNode(addr *IPv6Address) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) Clear()

+ func (trie *IPv6AddressTrie) Clone() *IPv6AddressTrie

+ func (trie *IPv6AddressTrie) ConstructAddedNodesTree() *IPv6AddressTrie

+ func (trie *IPv6AddressTrie) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) IPv6TrieNodeIterator

+ func (trie *IPv6AddressTrie) ContainedFirstIterator(forwardSubNodeOrder bool) IPv6TrieNodeIteratorRem

+ func (trie *IPv6AddressTrie) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingIPv6TrieNodeIterator

+ func (trie *IPv6AddressTrie) ContainingFirstIterator(forwardSubNodeOrder bool) CachingIPv6TrieNodeIterator

+ func (trie *IPv6AddressTrie) Contains(addr *IPv6Address) bool

+ func (trie *IPv6AddressTrie) DescendingIterator() IPv6AddressIterator

+ func (trie *IPv6AddressTrie) ElementContains(addr *IPv6Address) bool

+ func (trie *IPv6AddressTrie) ElementsContainedBy(addr *IPv6Address) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) ElementsContaining(addr *IPv6Address) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) Equal(other *IPv6AddressTrie) bool

+ func (trie *IPv6AddressTrie) FirstAddedNode() *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) FirstNode() *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) FloorAddedNode(addr *IPv6Address) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) GetAddedNode(addr *IPv6Address) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) GetNode(addr *IPv6Address) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) GetRoot() *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) HigherAddedNode(addr *IPv6Address) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) IsEmpty() bool

+ func (trie *IPv6AddressTrie) Iterator() IPv6AddressIterator

+ func (trie *IPv6AddressTrie) LastAddedNode() *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) LastNode() *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) LongestPrefixMatch(addr *IPv6Address) *IPv6Address

+ func (trie *IPv6AddressTrie) LongestPrefixMatchNode(addr *IPv6Address) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) LowerAddedNode(addr *IPv6Address) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) NodeIterator(forward bool) IPv6TrieNodeIteratorRem

+ func (trie *IPv6AddressTrie) NodeSize() int

+ func (trie *IPv6AddressTrie) Remove(addr *IPv6Address) bool

+ func (trie *IPv6AddressTrie) RemoveElementsContainedBy(addr *IPv6Address) *IPv6AddressTrieNode

+ func (trie *IPv6AddressTrie) Size() int

+ func (trie *IPv6AddressTrie) String() string

+ func (trie *IPv6AddressTrie) ToAssociative() *IPv6AddressAssociativeTrie

+ func (trie *IPv6AddressTrie) ToBase() *AddressTrie

+ func (trie *IPv6AddressTrie) TreeString(withNonAddedKeys bool) string

+ func (trie IPv6AddressTrie) Format(state fmt.State, verb rune)

+ type IPv6AddressTrieNode struct

+ func (node *IPv6AddressTrieNode) AllNodeIterator(forward bool) IPv6TrieNodeIteratorRem

+ func (node *IPv6AddressTrieNode) AsNewTrie() *IPv6AddressTrie

+ func (node *IPv6AddressTrieNode) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) IPv6TrieNodeIteratorRem

+ func (node *IPv6AddressTrieNode) BlockSizeCachingAllNodeIterator() CachingIPv6TrieNodeIterator

+ func (node *IPv6AddressTrieNode) BlockSizeNodeIterator(lowerSubNodeFirst bool) IPv6TrieNodeIteratorRem

+ func (node *IPv6AddressTrieNode) CeilingAddedNode(addr *Address) *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) Clear()

+ func (node *IPv6AddressTrieNode) Clone() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) CloneTree() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) Compare(other *IPv6AddressTrieNode) int

+ func (node *IPv6AddressTrieNode) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) IPv6TrieNodeIterator

+ func (node *IPv6AddressTrieNode) ContainedFirstIterator(forwardSubNodeOrder bool) IPv6TrieNodeIteratorRem

+ func (node *IPv6AddressTrieNode) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingIPv6TrieNodeIterator

+ func (node *IPv6AddressTrieNode) ContainingFirstIterator(forwardSubNodeOrder bool) CachingIPv6TrieNodeIterator

+ func (node *IPv6AddressTrieNode) Contains(addr *IPv6Address) bool

+ func (node *IPv6AddressTrieNode) DescendingIterator() IPv6AddressIterator

+ func (node *IPv6AddressTrieNode) ElementContains(addr *IPv6Address) bool

+ func (node *IPv6AddressTrieNode) ElementsContainedBy(addr *IPv6Address) *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) ElementsContaining(addr *IPv6Address) *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) Equal(other *IPv6AddressTrieNode) bool

+ func (node *IPv6AddressTrieNode) FirstAddedNode() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) FirstNode() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) FloorAddedNode(addr *Address) *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) GetAddedNode(addr *IPv6Address) *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) GetKey() *IPv6Address

+ func (node *IPv6AddressTrieNode) GetLowerSubNode() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) GetNode(addr *IPv6Address) *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) GetParent() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) GetUpperSubNode() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) HigherAddedNode(addr *Address) *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) IsAdded() bool

+ func (node *IPv6AddressTrieNode) IsEmpty() bool

+ func (node *IPv6AddressTrieNode) IsLeaf() bool

+ func (node *IPv6AddressTrieNode) IsRoot() bool

+ func (node *IPv6AddressTrieNode) Iterator() IPv6AddressIterator

+ func (node *IPv6AddressTrieNode) LastAddedNode() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) LastNode() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) LongestPrefixMatch(addr *IPv6Address) *Address

+ func (node *IPv6AddressTrieNode) LongestPrefixMatchNode(addr *IPv6Address) *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) LowerAddedNode(addr *Address) *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) NextAddedNode() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) NextNode() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) NodeIterator(forward bool) IPv6TrieNodeIteratorRem

+ func (node *IPv6AddressTrieNode) NodeSize() int

+ func (node *IPv6AddressTrieNode) PreviousAddedNode() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) PreviousNode() *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) Remove()

+ func (node *IPv6AddressTrieNode) RemoveElementsContainedBy(addr *IPv6Address) *IPv6AddressTrieNode

+ func (node *IPv6AddressTrieNode) RemoveNode(addr *IPv6Address) bool

+ func (node *IPv6AddressTrieNode) SetAdded()

+ func (node *IPv6AddressTrieNode) Size() int

+ func (node *IPv6AddressTrieNode) String() string

+ func (node *IPv6AddressTrieNode) ToAssociative() *IPv6AddressAssociativeTrieNode

+ func (node *IPv6AddressTrieNode) ToBase() *AddressTrieNode

+ func (node *IPv6AddressTrieNode) TreeEqual(other *IPv6AddressTrieNode) bool

+ func (node *IPv6AddressTrieNode) TreeString(withNonAddedKeys, withSizes bool) string

+ func (node IPv6AddressTrieNode) Format(state fmt.State, verb rune)

+ type IPv6AssociativeTrieNodeIterator interface

+ Next func() *IPv6AddressAssociativeTrieNode

+ type IPv6AssociativeTrieNodeIteratorRem interface

+ Remove func() *IPv6AddressAssociativeTrieNode

+ type IPv6TrieNodeIterator interface

+ Next func() *IPv6AddressTrieNode

+ type IPv6TrieNodeIteratorRem interface

+ Remove func() *IPv6AddressTrieNode

type MACAddress

+ func (addr *MACAddress) ToKey() *MACAddressKey

+ func (addr *MACAddress) ToSinglePrefixBlockOrAddress() *MACAddress

+ func (addr *MACAddress) TrieCompare(other *MACAddress) (int, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) TrieDecrement() *MACAddress

+ func (addr *MACAddress) TrieIncrement() *MACAddress

+ type MACAddressAssociativeTrie struct

+ func NewMACAddressAssociativeTrie(extended bool) *MACAddressAssociativeTrie

+ func (trie *MACAddressAssociativeTrie) Add(addr *MACAddress) bool

+ func (trie *MACAddressAssociativeTrie) AddNode(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) AddTrie(added *MACAddressAssociativeTrieNode) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) AddedNodesTreeString() string

+ func (trie *MACAddressAssociativeTrie) AllNodeIterator(forward bool) MACAssociativeTrieNodeIteratorRem

+ func (trie *MACAddressAssociativeTrie) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) MACAssociativeTrieNodeIteratorRem

+ func (trie *MACAddressAssociativeTrie) BlockSizeCachingAllNodeIterator() CachingMACAssociativeTrieNodeIterator

+ func (trie *MACAddressAssociativeTrie) BlockSizeNodeIterator(lowerSubNodeFirst bool) MACAssociativeTrieNodeIteratorRem

+ func (trie *MACAddressAssociativeTrie) CeilingAddedNode(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) Clone() *MACAddressAssociativeTrie

+ func (trie *MACAddressAssociativeTrie) ConstructAddedNodesTree() *MACAddressAssociativeTrie

+ func (trie *MACAddressAssociativeTrie) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) MACAssociativeTrieNodeIterator

+ func (trie *MACAddressAssociativeTrie) ContainedFirstIterator(forwardSubNodeOrder bool) MACAssociativeTrieNodeIteratorRem

+ func (trie *MACAddressAssociativeTrie) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingMACAssociativeTrieNodeIterator

+ func (trie *MACAddressAssociativeTrie) ContainingFirstIterator(forwardSubNodeOrder bool) CachingMACAssociativeTrieNodeIterator

+ func (trie *MACAddressAssociativeTrie) Contains(addr *MACAddress) bool

+ func (trie *MACAddressAssociativeTrie) DeepEqual(other *MACAddressAssociativeTrie) bool

+ func (trie *MACAddressAssociativeTrie) DescendingIterator() MACAddressIterator

+ func (trie *MACAddressAssociativeTrie) ElementContains(addr *MACAddress) bool

+ func (trie *MACAddressAssociativeTrie) ElementsContainedBy(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) ElementsContaining(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) Equal(other *MACAddressAssociativeTrie) bool

+ func (trie *MACAddressAssociativeTrie) FirstAddedNode() *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) FirstNode() *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) FloorAddedNode(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) Get(addr *MACAddress) NodeValue

+ func (trie *MACAddressAssociativeTrie) GetAddedNode(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) GetNode(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) GetRoot() *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) HigherAddedNode(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) IsEmpty() bool

+ func (trie *MACAddressAssociativeTrie) Iterator() MACAddressIterator

+ func (trie *MACAddressAssociativeTrie) LastAddedNode() *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) LastNode() *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) LongestPrefixMatch(addr *MACAddress) *MACAddress

+ func (trie *MACAddressAssociativeTrie) LongestPrefixMatchNode(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) LowerAddedNode(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) NodeIterator(forward bool) MACAssociativeTrieNodeIteratorRem

+ func (trie *MACAddressAssociativeTrie) NodeSize() int

+ func (trie *MACAddressAssociativeTrie) Put(addr *MACAddress, value NodeValue) (bool, NodeValue)

+ func (trie *MACAddressAssociativeTrie) PutNode(addr *MACAddress, value NodeValue) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) PutTrie(added *MACAddressAssociativeTrieNode) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) Remap(addr *MACAddress, remapper func(NodeValue) NodeValue) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) RemapIfAbsent(addr *MACAddress, supplier func() NodeValue, insertNil bool) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) Remove(addr *MACAddress) bool

+ func (trie *MACAddressAssociativeTrie) RemoveElementsContainedBy(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (trie *MACAddressAssociativeTrie) Size() int

+ func (trie *MACAddressAssociativeTrie) String() string

+ func (trie *MACAddressAssociativeTrie) ToAssociativeBase() *AssociativeAddressTrie

+ func (trie *MACAddressAssociativeTrie) ToBase() *AddressTrie

+ func (trie *MACAddressAssociativeTrie) ToMACBase() *MACAddressTrie

+ func (trie *MACAddressAssociativeTrie) TreeString(withNonAddedKeys bool) string

+ func (trie MACAddressAssociativeTrie) Format(state fmt.State, verb rune)

+ type MACAddressAssociativeTrieNode struct

+ func (node *MACAddressAssociativeTrieNode) AllNodeIterator(forward bool) MACAssociativeTrieNodeIteratorRem

+ func (node *MACAddressAssociativeTrieNode) AsNewTrie() *MACAddressAssociativeTrie

+ func (node *MACAddressAssociativeTrieNode) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) MACAssociativeTrieNodeIteratorRem

+ func (node *MACAddressAssociativeTrieNode) BlockSizeCachingAllNodeIterator() CachingMACAssociativeTrieNodeIterator

+ func (node *MACAddressAssociativeTrieNode) BlockSizeNodeIterator(lowerSubNodeFirst bool) MACAssociativeTrieNodeIteratorRem

+ func (node *MACAddressAssociativeTrieNode) CeilingAddedNode(addr *Address) *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) Clear()

+ func (node *MACAddressAssociativeTrieNode) ClearValue()

+ func (node *MACAddressAssociativeTrieNode) Clone() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) CloneTree() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) Compare(other *MACAddressAssociativeTrieNode) int

+ func (node *MACAddressAssociativeTrieNode) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) MACAssociativeTrieNodeIterator

+ func (node *MACAddressAssociativeTrieNode) ContainedFirstIterator(forwardSubNodeOrder bool) MACAssociativeTrieNodeIteratorRem

+ func (node *MACAddressAssociativeTrieNode) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingMACAssociativeTrieNodeIterator

+ func (node *MACAddressAssociativeTrieNode) ContainingFirstIterator(forwardSubNodeOrder bool) CachingMACAssociativeTrieNodeIterator

+ func (node *MACAddressAssociativeTrieNode) Contains(addr *MACAddress) bool

+ func (node *MACAddressAssociativeTrieNode) DeepEqual(other *MACAddressAssociativeTrieNode) bool

+ func (node *MACAddressAssociativeTrieNode) DescendingIterator() MACAddressIterator

+ func (node *MACAddressAssociativeTrieNode) ElementContains(addr *MACAddress) bool

+ func (node *MACAddressAssociativeTrieNode) ElementsContainedBy(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) ElementsContaining(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) Equal(other *MACAddressAssociativeTrieNode) bool

+ func (node *MACAddressAssociativeTrieNode) FirstAddedNode() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) FirstNode() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) FloorAddedNode(addr *Address) *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) Get(addr *MACAddress) NodeValue

+ func (node *MACAddressAssociativeTrieNode) GetAddedNode(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) GetKey() *MACAddress

+ func (node *MACAddressAssociativeTrieNode) GetLowerSubNode() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) GetNode(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) GetParent() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) GetUpperSubNode() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) GetValue() NodeValue

+ func (node *MACAddressAssociativeTrieNode) HigherAddedNode(addr *Address) *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) IsAdded() bool

+ func (node *MACAddressAssociativeTrieNode) IsEmpty() bool

+ func (node *MACAddressAssociativeTrieNode) IsLeaf() bool

+ func (node *MACAddressAssociativeTrieNode) IsRoot() bool

+ func (node *MACAddressAssociativeTrieNode) Iterator() MACAddressIterator

+ func (node *MACAddressAssociativeTrieNode) LastAddedNode() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) LastNode() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) LongestPrefixMatch(addr *MACAddress) *Address

+ func (node *MACAddressAssociativeTrieNode) LongestPrefixMatchNode(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) LowerAddedNode(addr *Address) *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) NextAddedNode() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) NextNode() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) NodeIterator(forward bool) MACAssociativeTrieNodeIteratorRem

+ func (node *MACAddressAssociativeTrieNode) NodeSize() int

+ func (node *MACAddressAssociativeTrieNode) PreviousAddedNode() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) PreviousNode() *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) Remove()

+ func (node *MACAddressAssociativeTrieNode) RemoveElementsContainedBy(addr *MACAddress) *MACAddressAssociativeTrieNode

+ func (node *MACAddressAssociativeTrieNode) RemoveNode(addr *MACAddress) bool

+ func (node *MACAddressAssociativeTrieNode) SetAdded()

+ func (node *MACAddressAssociativeTrieNode) SetValue(val NodeValue)

+ func (node *MACAddressAssociativeTrieNode) Size() int

+ func (node *MACAddressAssociativeTrieNode) String() string

+ func (node *MACAddressAssociativeTrieNode) ToAssociativeBase() *AssociativeAddressTrieNode

+ func (node *MACAddressAssociativeTrieNode) ToBase() *AddressTrieNode

+ func (node *MACAddressAssociativeTrieNode) ToMACBase() *MACAddressTrieNode

+ func (node *MACAddressAssociativeTrieNode) TreeDeepEqual(other *MACAddressAssociativeTrieNode) bool

+ func (node *MACAddressAssociativeTrieNode) TreeEqual(other *MACAddressAssociativeTrieNode) bool

+ func (node *MACAddressAssociativeTrieNode) TreeString(withNonAddedKeys, withSizes bool) string

+ func (node MACAddressAssociativeTrieNode) Format(state fmt.State, verb rune)

+ type MACAddressKey struct

+ Prefix PrefixKey

+ SegmentCount uint8

+ Values [ExtendedUniqueIdentifier64SegmentCount]struct{ ... }

+ func (key *MACAddressKey) ToAddress() *MACAddress

+ func (key *MACAddressKey) ToBaseKey() *AddressKey

+ func (key *MACAddressKey) UpperVal(segmentIndex int) IPv4SegInt

+ func (key *MACAddressKey) Val(segmentIndex int) IPv4SegInt

type MACAddressSection

+ func (section *MACAddressSection) GetLeadingBitCount(ones bool) BitCount

+ func (section *MACAddressSection) GetTrailingBitCount(ones bool) BitCount

type MACAddressSegment

+ func (seg *MACAddressSegment) GetLeadingBitCount(ones bool) BitCount

+ func (seg *MACAddressSegment) GetSegmentHostMask(networkBits BitCount) SegInt

+ func (seg *MACAddressSegment) GetSegmentNetworkMask(networkBits BitCount) SegInt

+ func (seg *MACAddressSegment) GetTrailingBitCount(ones bool) BitCount

+ type MACAddressTrie struct

+ func NewMACAddressTrie(extended bool) *MACAddressTrie

+ func (trie *MACAddressTrie) Add(addr *MACAddress) bool

+ func (trie *MACAddressTrie) AddNode(addr *MACAddress) *MACAddressTrieNode

+ func (trie *MACAddressTrie) AddTrie(added *MACAddressTrieNode) *MACAddressTrieNode

+ func (trie *MACAddressTrie) AddedNodesTreeString() string

+ func (trie *MACAddressTrie) AllNodeIterator(forward bool) MACTrieNodeIteratorRem

+ func (trie *MACAddressTrie) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) MACTrieNodeIteratorRem

+ func (trie *MACAddressTrie) BlockSizeCachingAllNodeIterator() CachingMACTrieNodeIterator

+ func (trie *MACAddressTrie) BlockSizeNodeIterator(lowerSubNodeFirst bool) MACTrieNodeIteratorRem

+ func (trie *MACAddressTrie) CeilingAddedNode(addr *MACAddress) *MACAddressTrieNode

+ func (trie *MACAddressTrie) Clear()

+ func (trie *MACAddressTrie) Clone() *MACAddressTrie

+ func (trie *MACAddressTrie) ConstructAddedNodesTree() *MACAddressTrie

+ func (trie *MACAddressTrie) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) MACTrieNodeIterator

+ func (trie *MACAddressTrie) ContainedFirstIterator(forwardSubNodeOrder bool) MACTrieNodeIteratorRem

+ func (trie *MACAddressTrie) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingMACTrieNodeIterator

+ func (trie *MACAddressTrie) ContainingFirstIterator(forwardSubNodeOrder bool) CachingMACTrieNodeIterator

+ func (trie *MACAddressTrie) Contains(addr *MACAddress) bool

+ func (trie *MACAddressTrie) DescendingIterator() MACAddressIterator

+ func (trie *MACAddressTrie) ElementContains(addr *MACAddress) bool

+ func (trie *MACAddressTrie) ElementsContainedBy(addr *MACAddress) *MACAddressTrieNode

+ func (trie *MACAddressTrie) ElementsContaining(addr *MACAddress) *MACAddressTrieNode

+ func (trie *MACAddressTrie) Equal(other *MACAddressTrie) bool

+ func (trie *MACAddressTrie) FirstAddedNode() *MACAddressTrieNode

+ func (trie *MACAddressTrie) FirstNode() *MACAddressTrieNode

+ func (trie *MACAddressTrie) FloorAddedNode(addr *MACAddress) *MACAddressTrieNode

+ func (trie *MACAddressTrie) GetAddedNode(addr *MACAddress) *MACAddressTrieNode

+ func (trie *MACAddressTrie) GetNode(addr *MACAddress) *MACAddressTrieNode

+ func (trie *MACAddressTrie) GetRoot() *MACAddressTrieNode

+ func (trie *MACAddressTrie) HigherAddedNode(addr *MACAddress) *MACAddressTrieNode

+ func (trie *MACAddressTrie) IsEmpty() bool

+ func (trie *MACAddressTrie) Iterator() MACAddressIterator

+ func (trie *MACAddressTrie) LastAddedNode() *MACAddressTrieNode

+ func (trie *MACAddressTrie) LastNode() *MACAddressTrieNode

+ func (trie *MACAddressTrie) LongestPrefixMatch(addr *MACAddress) *MACAddress

+ func (trie *MACAddressTrie) LongestPrefixMatchNode(addr *MACAddress) *MACAddressTrieNode

+ func (trie *MACAddressTrie) LowerAddedNode(addr *MACAddress) *MACAddressTrieNode

+ func (trie *MACAddressTrie) NodeIterator(forward bool) MACTrieNodeIteratorRem

+ func (trie *MACAddressTrie) NodeSize() int

+ func (trie *MACAddressTrie) Remove(addr *MACAddress) bool

+ func (trie *MACAddressTrie) RemoveElementsContainedBy(addr *MACAddress) *MACAddressTrieNode

+ func (trie *MACAddressTrie) Size() int

+ func (trie *MACAddressTrie) String() string

+ func (trie *MACAddressTrie) ToAssociative() *MACAddressAssociativeTrie

+ func (trie *MACAddressTrie) ToBase() *AddressTrie

+ func (trie *MACAddressTrie) TreeString(withNonAddedKeys bool) string

+ func (trie MACAddressTrie) Format(state fmt.State, verb rune)

+ type MACAddressTrieNode struct

+ func (node *MACAddressTrieNode) AllNodeIterator(forward bool) MACTrieNodeIteratorRem

+ func (node *MACAddressTrieNode) AsNewTrie() *MACAddressTrie

+ func (node *MACAddressTrieNode) BlockSizeAllNodeIterator(lowerSubNodeFirst bool) MACTrieNodeIteratorRem

+ func (node *MACAddressTrieNode) BlockSizeCachingAllNodeIterator() CachingMACTrieNodeIterator

+ func (node *MACAddressTrieNode) BlockSizeNodeIterator(lowerSubNodeFirst bool) MACTrieNodeIteratorRem

+ func (node *MACAddressTrieNode) CeilingAddedNode(addr *Address) *MACAddressTrieNode

+ func (node *MACAddressTrieNode) Clear()

+ func (node *MACAddressTrieNode) Clone() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) CloneTree() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) Compare(other *MACAddressTrieNode) int

+ func (node *MACAddressTrieNode) ContainedFirstAllNodeIterator(forwardSubNodeOrder bool) MACTrieNodeIterator

+ func (node *MACAddressTrieNode) ContainedFirstIterator(forwardSubNodeOrder bool) MACTrieNodeIteratorRem

+ func (node *MACAddressTrieNode) ContainingFirstAllNodeIterator(forwardSubNodeOrder bool) CachingMACTrieNodeIterator

+ func (node *MACAddressTrieNode) ContainingFirstIterator(forwardSubNodeOrder bool) CachingMACTrieNodeIterator

+ func (node *MACAddressTrieNode) Contains(addr *MACAddress) bool

+ func (node *MACAddressTrieNode) DescendingIterator() MACAddressIterator

+ func (node *MACAddressTrieNode) ElementContains(addr *MACAddress) bool

+ func (node *MACAddressTrieNode) ElementsContainedBy(addr *MACAddress) *MACAddressTrieNode

+ func (node *MACAddressTrieNode) ElementsContaining(addr *MACAddress) *MACAddressTrieNode

+ func (node *MACAddressTrieNode) Equal(other *MACAddressTrieNode) bool

+ func (node *MACAddressTrieNode) FirstAddedNode() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) FirstNode() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) FloorAddedNode(addr *Address) *MACAddressTrieNode

+ func (node *MACAddressTrieNode) GetAddedNode(addr *MACAddress) *MACAddressTrieNode

+ func (node *MACAddressTrieNode) GetKey() *MACAddress

+ func (node *MACAddressTrieNode) GetLowerSubNode() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) GetNode(addr *MACAddress) *MACAddressTrieNode

+ func (node *MACAddressTrieNode) GetParent() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) GetUpperSubNode() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) HigherAddedNode(addr *Address) *MACAddressTrieNode

+ func (node *MACAddressTrieNode) IsAdded() bool

+ func (node *MACAddressTrieNode) IsEmpty() bool

+ func (node *MACAddressTrieNode) IsLeaf() bool

+ func (node *MACAddressTrieNode) IsRoot() bool

+ func (node *MACAddressTrieNode) Iterator() MACAddressIterator

+ func (node *MACAddressTrieNode) LastAddedNode() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) LastNode() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) LongestPrefixMatch(addr *MACAddress) *Address

+ func (node *MACAddressTrieNode) LongestPrefixMatchNode(addr *MACAddress) *MACAddressTrieNode

+ func (node *MACAddressTrieNode) LowerAddedNode(addr *Address) *MACAddressTrieNode

+ func (node *MACAddressTrieNode) NextAddedNode() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) NextNode() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) NodeIterator(forward bool) MACTrieNodeIteratorRem

+ func (node *MACAddressTrieNode) NodeSize() int

+ func (node *MACAddressTrieNode) PreviousAddedNode() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) PreviousNode() *MACAddressTrieNode

+ func (node *MACAddressTrieNode) Remove()

+ func (node *MACAddressTrieNode) RemoveElementsContainedBy(addr *MACAddress) *MACAddressTrieNode

+ func (node *MACAddressTrieNode) RemoveNode(addr *MACAddress) bool

+ func (node *MACAddressTrieNode) SetAdded()

+ func (node *MACAddressTrieNode) Size() int

+ func (node *MACAddressTrieNode) String() string

+ func (node *MACAddressTrieNode) ToAssociative() *MACAddressAssociativeTrieNode

+ func (node *MACAddressTrieNode) ToBase() *AddressTrieNode

+ func (node *MACAddressTrieNode) TreeEqual(other *MACAddressTrieNode) bool

+ func (node *MACAddressTrieNode) TreeString(withNonAddedKeys, withSizes bool) string

+ func (node MACAddressTrieNode) Format(state fmt.State, verb rune)

+ type MACAssociativeTrieNodeIterator interface

+ Next func() *MACAddressAssociativeTrieNode

+ type MACAssociativeTrieNodeIteratorRem interface

+ Remove func() *MACAddressAssociativeTrieNode

+ type MACTrieNodeIterator interface

+ Next func() *MACAddressTrieNode

+ type MACTrieNodeIteratorRem interface

+ Remove func() *MACAddressTrieNode

+ type NodeValue = tree.V

type Partition

+ func PartitionIPWithSingleBlockSize(newAddr *IPAddress) *Partition

+ func PartitionIPWithSpanningBlocks(newAddr *IPAddress) *Partition

+ type PrefixKey struct

+ IsPrefixed bool

+ PrefixLen PrefixBitCount

+ func (pref *PrefixKey) Normalize()

+ func (pref *PrefixKey) ToPrefixLen() PrefixLen

type PrefixLen

+ func ToPrefixLen(i int) PrefixLen

type WrappedAddressSection

+ func (section WrappedAddressSection) GetLeadingBitCount(ones bool) BitCount

+ func (section WrappedAddressSection) GetTrailingBitCount(ones bool) BitCount

v1.0.2

Jan 15, 2022

v1.0.1

Jan 15, 2022

Changes in this version

+ const AlternativeRangeSeparator

+ const AlternativeRangeSeparatorStr

+ const BinaryPrefix

+ const DefaultSeqRangeSeparator

+ const DivIntSize

+ const ExtendedDigitsRangeSeparatorStr

+ const ExtendedUniqueIdentifier48SegmentCount

+ const ExtendedUniqueIdentifier64SegmentCount

+ const HexPrefix

+ const IPv4BitCount

+ const IPv4BitsPerSegment

+ const IPv4ByteCount

+ const IPv4BytesPerSegment

+ const IPv4DefaultTextualRadix

+ const IPv4MaxValue

+ const IPv4MaxValuePerSegment

+ const IPv4ReverseDnsSuffix

+ const IPv4SegmentCount

+ const IPv4SegmentMaxChars

+ const IPv4SegmentSeparator

+ const IPv4SegmentSeparatorStr

+ const IPv6AlternativeRangeSeparatorStr

+ const IPv6AlternativeZoneSeparator

+ const IPv6AlternativeZoneSeparatorStr

+ const IPv6BitCount

+ const IPv6BitsPerSegment

+ const IPv6ByteCount

+ const IPv6BytesPerSegment

+ const IPv6DefaultTextualRadix

+ const IPv6EndBracket

+ const IPv6MaxValuePerSegment

+ const IPv6MixedOriginalByteCount

+ const IPv6MixedOriginalSegmentCount

+ const IPv6MixedReplacedSegmentCount

+ const IPv6ReverseDnsSuffix

+ const IPv6ReverseDnsSuffixDeprecated

+ const IPv6SegmentCount

+ const IPv6SegmentMaxChars

+ const IPv6SegmentSeparator

+ const IPv6StartBracket

+ const IPv6UncRangeSeparator

+ const IPv6UncRangeSeparatorStr

+ const IPv6UncSegmentSeparator

+ const IPv6UncSuffix

+ const IPv6UncZoneSeparator

+ const IPv6ZoneSeparator

+ const IPv6ZoneSeparatorStr

+ const IPvFuture

+ const LabelSeparator

+ const MACBitsPerSegment

+ const MACBytesPerSegment

+ const MACColonSegmentSeparator

+ const MACDashSegmentSeparator

+ const MACDefaultTextualRadix

+ const MACMaxValuePerDottedSegment

+ const MACMaxValuePerSegment

+ const MACOrganizationalUniqueIdentifierSegmentCount

+ const MACSegmentMaxChars

+ const MacDashedSegmentRangeSeparator

+ const MacDashedSegmentRangeSeparatorStr

+ const MacDottedSegmentSeparator

+ const MacSpaceSegmentSeparator

+ const MediaAccessControlDotted64SegmentCount

+ const MediaAccessControlDottedSegmentCount

+ const MediaAccessControlSegmentCount

+ const NoZone

+ const OctalPrefix

+ const PortSeparator

+ const PrefixLenSeparator

+ const PrefixLenSeparatorStr

+ const RangeSeparator

+ const RangeSeparatorStr

+ const SegIntSize

+ const SegmentSqlSingleWildcard

+ const SegmentSqlSingleWildcardStr

+ const SegmentSqlWildcard

+ const SegmentSqlWildcardStr

+ const SegmentValueDelimiter

+ const SegmentWildcard

+ const SegmentWildcardStr

+ const SmtpIPv6Identifier

+ var CountComparator = AddressComparator

+ var HighValueComparator = AddressComparator

+ var IPv4Network = &IPv4AddressNetwork

+ var IPv6LinkLocalPrefix = createLinkLocalPrefix()

+ var IPv6Network = &IPv6AddressNetwork

+ var LowValueComparator = AddressComparator

+ var ReverseHighValueComparator = AddressComparator

+ var ReverseLowValueComparator = AddressComparator

+ func AddrsMatchOrdered(addrs1, addrs2 []*IPAddress) (result bool)

+ func AddrsMatchUnordered(addrs1, addrs2 []*IPAddress) (result bool)

+ func CountDelimitedAddresses(str string) int

+ type Address struct

+ func (addr *Address) AdjustPrefixLen(prefixLen BitCount) *Address

+ func (addr *Address) AdjustPrefixLenZeroed(prefixLen BitCount) (*Address, addrerr.IncompatibleAddressError)

+ func (addr *Address) AssignMinPrefixForBlock() *Address

+ func (addr *Address) AssignPrefixForSingleBlock() *Address

+ func (addr *Address) BlockIterator(segmentCount int) AddressIterator

+ func (addr *Address) Bytes() []byte

+ func (addr *Address) Compare(item AddressItem) int

+ func (addr *Address) CompareSize(other AddressType) int

+ func (addr *Address) Contains(other AddressType) bool

+ func (addr *Address) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (addr *Address) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (addr *Address) CopyBytes(bytes []byte) []byte

+ func (addr *Address) CopySegments(segs []*AddressSegment) (count int)

+ func (addr *Address) CopySubSegments(start, end int, segs []*AddressSegment) (count int)

+ func (addr *Address) CopyUpperBytes(bytes []byte) []byte

+ func (addr *Address) Equal(other AddressType) bool

+ func (addr *Address) GetBitCount() BitCount

+ func (addr *Address) GetBitsPerSegment() BitCount

+ func (addr *Address) GetBlockCount(segmentCount int) *big.Int

+ func (addr *Address) GetByteCount() int

+ func (addr *Address) GetBytesPerSegment() int

+ func (addr *Address) GetCount() *big.Int

+ func (addr *Address) GetDivisionCount() int

+ func (addr *Address) GetGenericDivision(index int) DivisionType

+ func (addr *Address) GetGenericSegment(index int) AddressSegmentType

+ func (addr *Address) GetLower() *Address

+ func (addr *Address) GetMaxSegmentValue() SegInt

+ func (addr *Address) GetMinPrefixLenForBlock() BitCount

+ func (addr *Address) GetPrefixCount() *big.Int

+ func (addr *Address) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (addr *Address) GetPrefixLen() PrefixLen

+ func (addr *Address) GetPrefixLenForSingleBlock() PrefixLen

+ func (addr *Address) GetSection() *AddressSection

+ func (addr *Address) GetSegment(index int) *AddressSegment

+ func (addr *Address) GetSegmentCount() int

+ func (addr *Address) GetSegmentStrings() []string

+ func (addr *Address) GetSegments() []*AddressSegment

+ func (addr *Address) GetSequentialBlockCount() *big.Int

+ func (addr *Address) GetSequentialBlockIndex() int

+ func (addr *Address) GetSubSection(index, endIndex int) *AddressSection

+ func (addr *Address) GetTrailingSection(index int) *AddressSection

+ func (addr *Address) GetUpper() *Address

+ func (addr *Address) GetUpperValue() *big.Int

+ func (addr *Address) GetValue() *big.Int

+ func (addr *Address) IncludesMax() bool

+ func (addr *Address) IncludesZero() bool

+ func (addr *Address) Increment(increment int64) *Address

+ func (addr *Address) IncrementBoundary(increment int64) *Address

+ func (addr *Address) IsFullRange() bool

+ func (addr *Address) IsIP() bool

+ func (addr *Address) IsIPv4() bool

+ func (addr *Address) IsIPv6() bool

+ func (addr *Address) IsLocal() bool

+ func (addr *Address) IsMAC() bool

+ func (addr *Address) IsMax() bool

+ func (addr *Address) IsMulticast() bool

+ func (addr *Address) IsMultiple() bool

+ func (addr *Address) IsOneBit(bitIndex BitCount) bool

+ func (addr *Address) IsPrefixBlock() bool

+ func (addr *Address) IsPrefixed() bool

+ func (addr *Address) IsSequential() bool

+ func (addr *Address) IsSinglePrefixBlock() bool

+ func (addr *Address) IsZero() bool

+ func (addr *Address) Iterator() AddressIterator

+ func (addr *Address) PrefixBlockIterator() AddressIterator

+ func (addr *Address) PrefixContains(other AddressType) bool

+ func (addr *Address) PrefixEqual(other AddressType) bool

+ func (addr *Address) PrefixIterator() AddressIterator

+ func (addr *Address) ReverseBits(perByte bool) (*Address, addrerr.IncompatibleAddressError)

+ func (addr *Address) ReverseBytes() (*Address, addrerr.IncompatibleAddressError)

+ func (addr *Address) ReverseSegments() *Address

+ func (addr *Address) SequentialBlockIterator() AddressIterator

+ func (addr *Address) SetPrefixLen(prefixLen BitCount) *Address

+ func (addr *Address) SetPrefixLenZeroed(prefixLen BitCount) (*Address, addrerr.IncompatibleAddressError)

+ func (addr *Address) String() string

+ func (addr *Address) TestBit(n BitCount) bool

+ func (addr *Address) ToAddressBase() *Address

+ func (addr *Address) ToAddressString() HostIdentifierString

+ func (addr *Address) ToBinaryString(with0bPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *Address) ToBlock(segmentIndex int, lower, upper SegInt) *Address

+ func (addr *Address) ToCanonicalString() string

+ func (addr *Address) ToCompressedString() string

+ func (addr *Address) ToCustomString(stringOptions addrstr.StringOptions) string

+ func (addr *Address) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *Address) ToIP() *IPAddress

+ func (addr *Address) ToIPv4() *IPv4Address

+ func (addr *Address) ToIPv6() *IPv6Address

+ func (addr *Address) ToMAC() *MACAddress

+ func (addr *Address) ToNormalizedString() string

+ func (addr *Address) ToOctalString(with0Prefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *Address) ToPrefixBlock() *Address

+ func (addr *Address) UpperBytes() []byte

+ func (addr *Address) WithoutPrefixLen() *Address

+ func (addr *Address) Wrap() WrappedAddress

+ func (addr Address) Format(state fmt.State, verb rune)

+ type AddressComparator struct

+ func (comp AddressComparator) Compare(one, two AddressItem) int

+ func (comp AddressComparator) CompareAddressSections(one, two AddressSectionType) int

+ func (comp AddressComparator) CompareAddresses(one, two AddressType) int

+ func (comp AddressComparator) CompareDivisions(one, two DivisionType) int

+ func (comp AddressComparator) CompareRanges(one, two IPAddressSeqRangeType) int

+ func (comp AddressComparator) CompareSegments(one, two AddressSegmentType) int

+ func (comp AddressComparator) CompareSeries(one, two AddressDivisionSeries) int

+ type AddressComponent interface

+ IsOneBit func(BitCount) bool

+ TestBit func(BitCount) bool

+ ToHexString func(bool) (string, addrerr.IncompatibleAddressError)

+ ToNormalizedString func() string

+ type AddressDivision struct

+ func NewDivision(val DivInt, bitCount BitCount) *AddressDivision

+ func NewPrefixDivision(val DivInt, prefixLen PrefixLen, bitCount BitCount) *AddressDivision

+ func NewRangeDivision(val, upperVal DivInt, bitCount BitCount) *AddressDivision

+ func NewRangePrefixDivision(val, upperVal DivInt, prefixLen PrefixLen, bitCount BitCount) *AddressDivision

+ func (div *AddressDivision) Bytes() []byte

+ func (div *AddressDivision) Compare(item AddressItem) int

+ func (div *AddressDivision) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (div *AddressDivision) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (div *AddressDivision) CopyBytes(bytes []byte) []byte

+ func (div *AddressDivision) CopyUpperBytes(bytes []byte) []byte

+ func (div *AddressDivision) GetBitCount() BitCount

+ func (div *AddressDivision) GetByteCount() int

+ func (div *AddressDivision) GetCount() *big.Int

+ func (div *AddressDivision) GetDivisionValue() DivInt

+ func (div *AddressDivision) GetMaxValue() DivInt

+ func (div *AddressDivision) GetMinPrefixLenForBlock() BitCount

+ func (div *AddressDivision) GetPrefixCountLen(divisionPrefixLength BitCount) *big.Int

+ func (div *AddressDivision) GetPrefixLenForSingleBlock() PrefixLen

+ func (div *AddressDivision) GetString() string

+ func (div *AddressDivision) GetUpperDivisionValue() DivInt

+ func (div *AddressDivision) GetUpperValue() *BigDivInt

+ func (div *AddressDivision) GetValue() *BigDivInt

+ func (div *AddressDivision) GetWildcardString() string

+ func (div *AddressDivision) IncludesMax() bool

+ func (div *AddressDivision) IncludesZero() bool

+ func (div *AddressDivision) IsFullRange() bool

+ func (div *AddressDivision) IsIP() bool

+ func (div *AddressDivision) IsIPv4() bool

+ func (div *AddressDivision) IsIPv6() bool

+ func (div *AddressDivision) IsMAC() bool

+ func (div *AddressDivision) IsMax() bool

+ func (div *AddressDivision) IsMultiple() bool

+ func (div *AddressDivision) IsSegmentBase() bool

+ func (div *AddressDivision) IsSinglePrefix(divisionPrefixLength BitCount) bool

+ func (div *AddressDivision) IsZero() bool

+ func (div *AddressDivision) Matches(value DivInt) bool

+ func (div *AddressDivision) MatchesValsWithMask(lowerValue, upperValue, mask DivInt) bool

+ func (div *AddressDivision) MatchesWithMask(value, mask DivInt) bool

+ func (div *AddressDivision) String() string

+ func (div *AddressDivision) ToDiv() *AddressDivision

+ func (div *AddressDivision) ToIP() *IPAddressSegment

+ func (div *AddressDivision) ToIPv4() *IPv4AddressSegment

+ func (div *AddressDivision) ToIPv6() *IPv6AddressSegment

+ func (div *AddressDivision) ToMAC() *MACAddressSegment

+ func (div *AddressDivision) ToSegmentBase() *AddressSegment

+ func (div *AddressDivision) UpperBytes() []byte

+ func (div AddressDivision) Format(state fmt.State, verb rune)

+ type AddressDivisionGrouping struct

+ func NewDivisionGrouping(divs []*AddressDivision, prefixLength PrefixLen) *AddressDivisionGrouping

+ func (grouping *AddressDivisionGrouping) Bytes() []byte

+ func (grouping *AddressDivisionGrouping) Compare(item AddressItem) int

+ func (grouping *AddressDivisionGrouping) CompareSize(other StandardDivGroupingType) int

+ func (grouping *AddressDivisionGrouping) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (grouping *AddressDivisionGrouping) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (grouping *AddressDivisionGrouping) CopyBytes(bytes []byte) []byte

+ func (grouping *AddressDivisionGrouping) CopyDivisions(divs []*AddressDivision) (count int)

+ func (grouping *AddressDivisionGrouping) CopySubDivisions(start, end int, divs []*AddressDivision) (count int)

+ func (grouping *AddressDivisionGrouping) CopyUpperBytes(bytes []byte) []byte

+ func (grouping *AddressDivisionGrouping) GetBlockCount(divisionCount int) *big.Int

+ func (grouping *AddressDivisionGrouping) GetCount() *big.Int

+ func (grouping *AddressDivisionGrouping) GetDivision(index int) *AddressDivision

+ func (grouping *AddressDivisionGrouping) GetDivisionCount() int

+ func (grouping *AddressDivisionGrouping) GetDivisionStrings() []string

+ func (grouping *AddressDivisionGrouping) GetGenericDivision(index int) DivisionType

+ func (grouping *AddressDivisionGrouping) GetMinPrefixLenForBlock() BitCount

+ func (grouping *AddressDivisionGrouping) GetPrefixCount() *big.Int

+ func (grouping *AddressDivisionGrouping) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (grouping *AddressDivisionGrouping) GetPrefixLen() PrefixLen

+ func (grouping *AddressDivisionGrouping) GetPrefixLenForSingleBlock() PrefixLen

+ func (grouping *AddressDivisionGrouping) GetSequentialBlockCount() *big.Int

+ func (grouping *AddressDivisionGrouping) GetSequentialBlockIndex() int

+ func (grouping *AddressDivisionGrouping) GetUpperValue() *big.Int

+ func (grouping *AddressDivisionGrouping) GetValue() *big.Int

+ func (grouping *AddressDivisionGrouping) IncludesMax() bool

+ func (grouping *AddressDivisionGrouping) IncludesZero() bool

+ func (grouping *AddressDivisionGrouping) IsAdaptiveZero() bool

+ func (grouping *AddressDivisionGrouping) IsFullRange() bool

+ func (grouping *AddressDivisionGrouping) IsIP() bool

+ func (grouping *AddressDivisionGrouping) IsIPv4() bool

+ func (grouping *AddressDivisionGrouping) IsIPv6() bool

+ func (grouping *AddressDivisionGrouping) IsMAC() bool

+ func (grouping *AddressDivisionGrouping) IsMax() bool

+ func (grouping *AddressDivisionGrouping) IsMixedIPv6v4() bool

+ func (grouping *AddressDivisionGrouping) IsMultiple() bool

+ func (grouping *AddressDivisionGrouping) IsPrefixBlock() bool

+ func (grouping *AddressDivisionGrouping) IsPrefixed() bool

+ func (grouping *AddressDivisionGrouping) IsSectionBase() bool

+ func (grouping *AddressDivisionGrouping) IsSequential() bool

+ func (grouping *AddressDivisionGrouping) IsSinglePrefixBlock() bool

+ func (grouping *AddressDivisionGrouping) IsZero() bool

+ func (grouping *AddressDivisionGrouping) String() string

+ func (grouping *AddressDivisionGrouping) ToDivGrouping() *AddressDivisionGrouping

+ func (grouping *AddressDivisionGrouping) ToIP() *IPAddressSection

+ func (grouping *AddressDivisionGrouping) ToIPv4() *IPv4AddressSection

+ func (grouping *AddressDivisionGrouping) ToIPv6() *IPv6AddressSection

+ func (grouping *AddressDivisionGrouping) ToMAC() *MACAddressSection

+ func (grouping *AddressDivisionGrouping) ToMixedIPv6v4() *IPv6v4MixedAddressGrouping

+ func (grouping *AddressDivisionGrouping) ToSectionBase() *AddressSection

+ func (grouping *AddressDivisionGrouping) UpperBytes() []byte

+ func (grouping AddressDivisionGrouping) Format(state fmt.State, verb rune)

+ func (grouping AddressDivisionGrouping) GetBitCount() BitCount

+ func (grouping AddressDivisionGrouping) GetByteCount() int

+ type AddressDivisionSeries interface

+ GetBlockCount func(divisionCount int) *big.Int

+ GetDivisionCount func() int

+ GetGenericDivision func(index int) DivisionType

+ GetPrefixCount func() *big.Int

+ GetPrefixLen func() PrefixLen

+ GetSequentialBlockCount func() *big.Int

+ GetSequentialBlockIndex func() int

+ IsPrefixBlock func() bool

+ IsPrefixed func() bool

+ IsSequential func() bool

+ IsSinglePrefixBlock func() bool

+ type AddressItem interface

+ Bytes func() []byte

+ Compare func(item AddressItem) int

+ ContainsPrefixBlock func(BitCount) bool

+ ContainsSinglePrefixBlock func(BitCount) bool

+ CopyBytes func(bytes []byte) []byte

+ CopyUpperBytes func(bytes []byte) []byte

+ GetBitCount func() BitCount

+ GetByteCount func() int

+ GetCount func() *big.Int

+ GetMinPrefixLenForBlock func() BitCount

+ GetPrefixCountLen func(BitCount) *big.Int

+ GetPrefixLenForSingleBlock func() PrefixLen

+ GetUpperValue func() *big.Int

+ GetValue func() *big.Int

+ IncludesMax func() bool

+ IncludesZero func() bool

+ IsFullRange func() bool

+ IsMax func() bool

+ IsMultiple func() bool

+ IsZero func() bool

+ UpperBytes func() []byte

+ type AddressIterator interface

+ Next func() *Address

+ func NewFilteredAddrIterator(iter AddressIterator, skip func(*Address) bool) AddressIterator

+ type AddressSection struct

+ func (section *AddressSection) AdjustPrefixLen(prefixLen BitCount) *AddressSection

+ func (section *AddressSection) AdjustPrefixLenZeroed(prefixLen BitCount) (*AddressSection, addrerr.IncompatibleAddressError)

+ func (section *AddressSection) AssignMinPrefixForBlock() *AddressSection

+ func (section *AddressSection) AssignPrefixForSingleBlock() *AddressSection

+ func (section *AddressSection) Bytes() []byte

+ func (section *AddressSection) Compare(item AddressItem) int

+ func (section *AddressSection) CompareSize(other StandardDivGroupingType) int

+ func (section *AddressSection) Contains(other AddressSectionType) bool

+ func (section *AddressSection) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (section *AddressSection) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (section *AddressSection) CopyBytes(bytes []byte) []byte

+ func (section *AddressSection) CopySegments(segs []*AddressSegment) (count int)

+ func (section *AddressSection) CopySubSegments(start, end int, segs []*AddressSegment) (count int)

+ func (section *AddressSection) CopyUpperBytes(bytes []byte) []byte

+ func (section *AddressSection) Equal(other AddressSectionType) bool

+ func (section *AddressSection) GetBitCount() BitCount

+ func (section *AddressSection) GetBitsPerSegment() BitCount

+ func (section *AddressSection) GetBlockCount(segmentCount int) *big.Int

+ func (section *AddressSection) GetByteCount() int

+ func (section *AddressSection) GetBytesPerSegment() int

+ func (section *AddressSection) GetCount() *big.Int

+ func (section *AddressSection) GetGenericSegment(index int) AddressSegmentType

+ func (section *AddressSection) GetLower() *AddressSection

+ func (section *AddressSection) GetMaxSegmentValue() SegInt

+ func (section *AddressSection) GetMinPrefixLenForBlock() BitCount

+ func (section *AddressSection) GetPrefixCount() *big.Int

+ func (section *AddressSection) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (section *AddressSection) GetPrefixLen() PrefixLen

+ func (section *AddressSection) GetPrefixLenForSingleBlock() PrefixLen

+ func (section *AddressSection) GetSegment(index int) *AddressSegment

+ func (section *AddressSection) GetSegmentCount() int

+ func (section *AddressSection) GetSegmentStrings() []string

+ func (section *AddressSection) GetSegments() (res []*AddressSegment)

+ func (section *AddressSection) GetSequentialBlockCount() *big.Int

+ func (section *AddressSection) GetSequentialBlockIndex() int

+ func (section *AddressSection) GetSubSection(index, endIndex int) *AddressSection

+ func (section *AddressSection) GetTrailingSection(index int) *AddressSection

+ func (section *AddressSection) GetUpper() *AddressSection

+ func (section *AddressSection) GetUpperValue() *big.Int

+ func (section *AddressSection) GetValue() *big.Int

+ func (section *AddressSection) IncludesMax() bool

+ func (section *AddressSection) IncludesZero() bool

+ func (section *AddressSection) Increment(increment int64) *AddressSection

+ func (section *AddressSection) IncrementBoundary(increment int64) *AddressSection

+ func (section *AddressSection) IsAdaptiveZero() bool

+ func (section *AddressSection) IsFullRange() bool

+ func (section *AddressSection) IsIP() bool

+ func (section *AddressSection) IsIPv4() bool

+ func (section *AddressSection) IsIPv6() bool

+ func (section *AddressSection) IsMAC() bool

+ func (section *AddressSection) IsMax() bool

+ func (section *AddressSection) IsMultiple() bool

+ func (section *AddressSection) IsOneBit(prefixBitIndex BitCount) bool

+ func (section *AddressSection) IsPrefixBlock() bool

+ func (section *AddressSection) IsPrefixed() bool

+ func (section *AddressSection) IsSequential() bool

+ func (section *AddressSection) IsSinglePrefixBlock() bool

+ func (section *AddressSection) IsZero() bool

+ func (section *AddressSection) Iterator() SectionIterator

+ func (section *AddressSection) PrefixBlockIterator() SectionIterator

+ func (section *AddressSection) PrefixContains(other AddressSectionType) (res bool)

+ func (section *AddressSection) PrefixEqual(other AddressSectionType) (res bool)

+ func (section *AddressSection) PrefixIterator() SectionIterator

+ func (section *AddressSection) ReverseBits(perByte bool) (*AddressSection, addrerr.IncompatibleAddressError)

+ func (section *AddressSection) ReverseBytes() (*AddressSection, addrerr.IncompatibleAddressError)

+ func (section *AddressSection) ReverseSegments() *AddressSection

+ func (section *AddressSection) SetPrefixLen(prefixLen BitCount) *AddressSection

+ func (section *AddressSection) SetPrefixLenZeroed(prefixLen BitCount) (*AddressSection, addrerr.IncompatibleAddressError)

+ func (section *AddressSection) String() string

+ func (section *AddressSection) TestBit(n BitCount) bool

+ func (section *AddressSection) ToBinaryString(with0bPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *AddressSection) ToBlock(segmentIndex int, lower, upper SegInt) *AddressSection

+ func (section *AddressSection) ToCanonicalString() string

+ func (section *AddressSection) ToCompressedString() string

+ func (section *AddressSection) ToCustomString(stringOptions addrstr.StringOptions) string

+ func (section *AddressSection) ToDivGrouping() *AddressDivisionGrouping

+ func (section *AddressSection) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *AddressSection) ToIP() *IPAddressSection

+ func (section *AddressSection) ToIPv4() *IPv4AddressSection

+ func (section *AddressSection) ToIPv6() *IPv6AddressSection

+ func (section *AddressSection) ToMAC() *MACAddressSection

+ func (section *AddressSection) ToNormalizedString() string

+ func (section *AddressSection) ToOctalString(with0Prefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *AddressSection) ToPrefixBlock() *AddressSection

+ func (section *AddressSection) ToPrefixBlockLen(prefLen BitCount) *AddressSection

+ func (section *AddressSection) ToSectionBase() *AddressSection

+ func (section *AddressSection) UpperBytes() []byte

+ func (section *AddressSection) WithoutPrefixLen() *AddressSection

+ func (section *AddressSection) Wrap() WrappedAddressSection

+ func (section AddressSection) Format(state fmt.State, verb rune)

+ type AddressSectionType interface

+ Contains func(AddressSectionType) bool

+ Equal func(AddressSectionType) bool

+ ToSectionBase func() *AddressSection

+ type AddressSegment struct

+ func (seg *AddressSegment) Bytes() []byte

+ func (seg *AddressSegment) Compare(item AddressItem) int

+ func (seg *AddressSegment) Contains(other AddressSegmentType) bool

+ func (seg *AddressSegment) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (seg *AddressSegment) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (seg *AddressSegment) CopyBytes(bytes []byte) []byte

+ func (seg *AddressSegment) CopyUpperBytes(bytes []byte) []byte

+ func (seg *AddressSegment) Equal(other AddressSegmentType) bool

+ func (seg *AddressSegment) GetBitCount() BitCount

+ func (seg *AddressSegment) GetByteCount() int

+ func (seg *AddressSegment) GetCount() *big.Int

+ func (seg *AddressSegment) GetLower() *AddressSegment

+ func (seg *AddressSegment) GetMaxValue() SegInt

+ func (seg *AddressSegment) GetMinPrefixLenForBlock() BitCount

+ func (seg *AddressSegment) GetPrefixCountLen(segmentPrefixLength BitCount) *big.Int

+ func (seg *AddressSegment) GetPrefixLenForSingleBlock() PrefixLen

+ func (seg *AddressSegment) GetPrefixValueCountLen(segmentPrefixLength BitCount) SegIntCount

+ func (seg *AddressSegment) GetSegmentValue() SegInt

+ func (seg *AddressSegment) GetString() string

+ func (seg *AddressSegment) GetUpper() *AddressSegment

+ func (seg *AddressSegment) GetUpperSegmentValue() SegInt

+ func (seg *AddressSegment) GetUpperValue() *BigDivInt

+ func (seg *AddressSegment) GetValue() *BigDivInt

+ func (seg *AddressSegment) GetValueCount() SegIntCount

+ func (seg *AddressSegment) GetWildcardString() string

+ func (seg *AddressSegment) IncludesMax() bool

+ func (seg *AddressSegment) IncludesZero() bool

+ func (seg *AddressSegment) IsFullRange() bool

+ func (seg *AddressSegment) IsIP() bool

+ func (seg *AddressSegment) IsIPv4() bool

+ func (seg *AddressSegment) IsIPv6() bool

+ func (seg *AddressSegment) IsMAC() bool

+ func (seg *AddressSegment) IsMax() bool

+ func (seg *AddressSegment) IsMultiple() bool

+ func (seg *AddressSegment) IsOneBit(segmentBitIndex BitCount) bool

+ func (seg *AddressSegment) IsSinglePrefix(divisionPrefixLength BitCount) bool

+ func (seg *AddressSegment) IsZero() bool

+ func (seg *AddressSegment) Iterator() SegmentIterator

+ func (seg *AddressSegment) Matches(value SegInt) bool

+ func (seg *AddressSegment) MatchesValsWithMask(lowerValue, upperValue, mask SegInt) bool

+ func (seg *AddressSegment) MatchesWithMask(value, mask SegInt) bool

+ func (seg *AddressSegment) PrefixContains(other AddressSegmentType, prefixLength BitCount) bool

+ func (seg *AddressSegment) PrefixEqual(other AddressSegmentType, prefixLength BitCount) bool

+ func (seg *AddressSegment) ReverseBits(perByte bool) (res *AddressSegment, err addrerr.IncompatibleAddressError)

+ func (seg *AddressSegment) ReverseBytes() (res *AddressSegment, err addrerr.IncompatibleAddressError)

+ func (seg *AddressSegment) String() string

+ func (seg *AddressSegment) TestBit(n BitCount) bool

+ func (seg *AddressSegment) ToDiv() *AddressDivision

+ func (seg *AddressSegment) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (seg *AddressSegment) ToIP() *IPAddressSegment

+ func (seg *AddressSegment) ToIPv4() *IPv4AddressSegment

+ func (seg *AddressSegment) ToIPv6() *IPv6AddressSegment

+ func (seg *AddressSegment) ToMAC() *MACAddressSegment

+ func (seg *AddressSegment) ToNormalizedString() string

+ func (seg *AddressSegment) ToSegmentBase() *AddressSegment

+ func (seg *AddressSegment) UpperBytes() []byte

+ type AddressSegmentSeries interface

+ GetBitsPerSegment func() BitCount

+ GetBytesPerSegment func() int

+ GetGenericSegment func(index int) AddressSegmentType

+ GetMaxSegmentValue func() SegInt

+ GetSegmentCount func() int

+ GetSegmentStrings func() []string

+ ToBinaryString func(with0bPrefix bool) (string, addrerr.IncompatibleAddressError)

+ ToCanonicalString func() string

+ ToCompressedString func() string

+ ToOctalString func(withPrefix bool) (string, addrerr.IncompatibleAddressError)

+ type AddressSegmentType interface

+ Contains func(AddressSegmentType) bool

+ Equal func(AddressSegmentType) bool

+ GetSegmentValue func() SegInt

+ GetUpperSegmentValue func() SegInt

+ ToSegmentBase func() *AddressSegment

+ type AddressType interface

+ CompareSize func(AddressType) int

+ Contains func(AddressType) bool

+ Equal func(AddressType) bool

+ PrefixContains func(AddressType) bool

+ PrefixEqual func(AddressType) bool

+ ToAddressBase func() *Address

+ type AddressValueProvider interface

+ GetSegmentCount func() int

+ GetUpperValues func() SegmentValueProvider

+ GetValues func() SegmentValueProvider

+ type BigDivInt = big.Int

+ type BitCount = int

+ func BitsPerSegment(version IPVersion) BitCount

+ func GetMinPrefixLenForBlock(lower, upper DivInt, bitCount BitCount) BitCount

+ type BitwiseOrer interface

+ GetOredLower func(value, maskValue uint64) uint64

+ GetOredUpper func(upperValue, maskValue uint64) uint64

+ IsSequential func() bool

+ type DefaultAddressConverter struct

+ func (DefaultAddressConverter) IsIPv4Convertible(address *IPAddress) bool

+ func (DefaultAddressConverter) IsIPv6Convertible(address *IPAddress) bool

+ func (DefaultAddressConverter) ToIPv6(address *IPAddress) *IPv6Address

+ func (converter DefaultAddressConverter) ToIPv4(address *IPAddress) *IPv4Address

+ type DivInt = uint64

+ type DivisionType interface

+ GetString func() string

+ GetWildcardString func() string

+ IsSinglePrefix func(BitCount) bool

+ type EmbeddedIPv6AddressSection struct

+ func (section *EmbeddedIPv6AddressSection) IsPrefixBlock() bool

+ type ExtendedIPSegmentSeries interface

+ AdjustPrefixLen func(BitCount) ExtendedIPSegmentSeries

+ AdjustPrefixLenZeroed func(BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ AssignMinPrefixForBlock func() ExtendedIPSegmentSeries

+ AssignPrefixForSingleBlock func() ExtendedIPSegmentSeries

+ BlockIterator func(segmentCount int) ExtendedIPSegmentSeriesIterator

+ CompareSize func(ExtendedIPSegmentSeries) int

+ Contains func(ExtendedIPSegmentSeries) bool

+ CopySegments func(segs []*IPAddressSegment) (count int)

+ CopySubSegments func(start, end int, segs []*IPAddressSegment) (count int)

+ CoverWithPrefixBlock func() ExtendedIPSegmentSeries

+ Equal func(ExtendedIPSegmentSeries) bool

+ GetHostMask func() ExtendedIPSegmentSeries

+ GetHostSection func() *IPAddressSection

+ GetHostSectionLen func(BitCount) *IPAddressSection

+ GetLower func() ExtendedIPSegmentSeries

+ GetNetworkMask func() ExtendedIPSegmentSeries

+ GetNetworkSection func() *IPAddressSection

+ GetNetworkSectionLen func(BitCount) *IPAddressSection

+ GetSection func() *IPAddressSection

+ GetSegment func(index int) *IPAddressSegment

+ GetSegments func() []*IPAddressSegment

+ GetSubSection func(index, endIndex int) *IPAddressSection

+ GetTrailingSection func(index int) *IPAddressSection

+ GetUpper func() ExtendedIPSegmentSeries

+ Increment func(int64) ExtendedIPSegmentSeries

+ IncrementBoundary func(int64) ExtendedIPSegmentSeries

+ IsIPv4 func() bool

+ IsIPv6 func() bool

+ Iterator func() ExtendedIPSegmentSeriesIterator

+ PrefixBlockIterator func() ExtendedIPSegmentSeriesIterator

+ PrefixIterator func() ExtendedIPSegmentSeriesIterator

+ ReverseBits func(perByte bool) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ ReverseBytes func() (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ ReverseSegments func() ExtendedIPSegmentSeries

+ SequentialBlockIterator func() ExtendedIPSegmentSeriesIterator

+ SetPrefixLen func(BitCount) ExtendedIPSegmentSeries

+ SetPrefixLenZeroed func(BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ SpanWithPrefixBlocks func() []ExtendedIPSegmentSeries

+ SpanWithSequentialBlocks func() []ExtendedIPSegmentSeries

+ ToBlock func(segmentIndex int, lower, upper SegInt) ExtendedIPSegmentSeries

+ ToCustomString func(stringOptions addrstr.IPStringOptions) string

+ ToIPv4 func() IPv4AddressSegmentSeries

+ ToIPv6 func() IPv6AddressSegmentSeries

+ ToMaxHost func() (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ ToMaxHostLen func(BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ ToPrefixBlock func() ExtendedIPSegmentSeries

+ ToPrefixBlockLen func(BitCount) ExtendedIPSegmentSeries

+ ToZeroHost func() (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ ToZeroHostLen func(BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ ToZeroNetwork func() ExtendedIPSegmentSeries

+ Unwrap func() IPAddressSegmentSeries

+ WithoutPrefixLen func() ExtendedIPSegmentSeries

+ type ExtendedIPSegmentSeriesIterator interface

+ Next func() ExtendedIPSegmentSeries

+ type ExtendedIdentifierString interface

+ GetAddress func() AddressType

+ ToAddress func() (AddressType, error)

+ Unwrap func() HostIdentifierString

+ type ExtendedMasker interface

+ GetExtendedMaskedLower func(extendedValue, extendedMaskValue uint64) uint64

+ GetExtendedMaskedUpper func(extendedUpperValue, extendedMaskValue uint64) uint64

+ type ExtendedSegmentSeries interface

+ AdjustPrefixLen func(BitCount) ExtendedSegmentSeries

+ AdjustPrefixLenZeroed func(BitCount) (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ AssignMinPrefixForBlock func() ExtendedSegmentSeries

+ AssignPrefixForSingleBlock func() ExtendedSegmentSeries

+ CompareSize func(ExtendedSegmentSeries) int

+ Contains func(ExtendedSegmentSeries) bool

+ CopySegments func(segs []*AddressSegment) (count int)

+ CopySubSegments func(start, end int, segs []*AddressSegment) (count int)

+ Equal func(ExtendedSegmentSeries) bool

+ GetLower func() ExtendedSegmentSeries

+ GetSection func() *AddressSection

+ GetSegment func(index int) *AddressSegment

+ GetSegments func() []*AddressSegment

+ GetSubSection func(index, endIndex int) *AddressSection

+ GetTrailingSection func(index int) *AddressSection

+ GetUpper func() ExtendedSegmentSeries

+ Increment func(int64) ExtendedSegmentSeries

+ IncrementBoundary func(int64) ExtendedSegmentSeries

+ IsIP func() bool

+ IsIPv4 func() bool

+ IsIPv6 func() bool

+ IsMAC func() bool

+ Iterator func() ExtendedSegmentSeriesIterator

+ PrefixBlockIterator func() ExtendedSegmentSeriesIterator

+ PrefixIterator func() ExtendedSegmentSeriesIterator

+ ReverseBits func(perByte bool) (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ ReverseBytes func() (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ ReverseSegments func() ExtendedSegmentSeries

+ SetPrefixLen func(BitCount) ExtendedSegmentSeries

+ SetPrefixLenZeroed func(BitCount) (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ ToBlock func(segmentIndex int, lower, upper SegInt) ExtendedSegmentSeries

+ ToCustomString func(stringOptions addrstr.StringOptions) string

+ ToIP func() IPAddressSegmentSeries

+ ToIPv4 func() IPv4AddressSegmentSeries

+ ToIPv6 func() IPv6AddressSegmentSeries

+ ToMAC func() MACAddressSegmentSeries

+ ToPrefixBlock func() ExtendedSegmentSeries

+ Unwrap func() AddressSegmentSeries

+ WithoutPrefixLen func() ExtendedSegmentSeries

+ type ExtendedSegmentSeriesIterator interface

+ Next func() ExtendedSegmentSeries

+ type HasNext interface

+ HasNext func() bool

+ type HostIdentifierString interface

+ IsValid func() bool

+ ToNormalizedString func() string

+ type HostIdentifierStringValidator interface

+ type HostName struct

+ func NewHostName(str string) *HostName

+ func NewHostNameFromAddr(addr *IPAddress) *HostName

+ func NewHostNameFromAddrPort(addr *IPAddress, port int) *HostName

+ func NewHostNameFromNetIP(bytes net.IP) (hostName *HostName, err addrerr.AddressValueError)

+ func NewHostNameFromNetIPAddr(addr *net.IPAddr) (hostName *HostName, err addrerr.AddressValueError)

+ func NewHostNameFromNetTCPAddr(addr *net.TCPAddr) (*HostName, addrerr.AddressValueError)

+ func NewHostNameFromNetUDPAddr(addr *net.UDPAddr) (*HostName, addrerr.AddressValueError)

+ func NewHostNameFromPrefixedNetIP(bytes net.IP, prefixLen PrefixLen) (hostName *HostName, err addrerr.AddressValueError)

+ func NewHostNameFromPrefixedNetIPAddr(addr *net.IPAddr, prefixLen PrefixLen) (hostName *HostName, err addrerr.AddressValueError)

+ func NewHostNameParams(str string, params addrstrparam.HostNameParams) *HostName

+ func (host *HostName) AsAddress() *IPAddress

+ func (host *HostName) AsAddressString() *IPAddressString

+ func (host *HostName) Compare(other *HostName) int

+ func (host *HostName) Equal(other *HostName) bool

+ func (host *HostName) GetAddress() *IPAddress

+ func (host *HostName) GetHost() string

+ func (host *HostName) GetMask() *IPAddress

+ func (host *HostName) GetNetworkPrefixLen() PrefixLen

+ func (host *HostName) GetNormalizedLabels() []string

+ func (host *HostName) GetPort() Port

+ func (host *HostName) GetService() string

+ func (host *HostName) GetValidationOptions() addrstrparam.HostNameParams

+ func (host *HostName) IsAddress() bool

+ func (host *HostName) IsAddressString() bool

+ func (host *HostName) IsAllAddresses() bool

+ func (host *HostName) IsEmpty() bool

+ func (host *HostName) IsLocalHost() bool

+ func (host *HostName) IsLoopback() bool

+ func (host *HostName) IsSelf() bool

+ func (host *HostName) IsValid() bool

+ func (host *HostName) ResolvesToSelf() bool

+ func (host *HostName) String() string

+ func (host *HostName) ToAddress() (addr *IPAddress, err addrerr.AddressError)

+ func (host *HostName) ToAddresses() (addrs []*IPAddress, err addrerr.AddressError)

+ func (host *HostName) ToNetIP() net.IP

+ func (host *HostName) ToNetIPAddr() *net.IPAddr

+ func (host *HostName) ToNetTCPAddr() *net.TCPAddr

+ func (host *HostName) ToNetTCPAddrService(serviceMapper func(string) Port) *net.TCPAddr

+ func (host *HostName) ToNetUDPAddr(serviceMapper func(string) Port) *net.UDPAddr

+ func (host *HostName) ToNetUDPAddrService(serviceMapper func(string) Port) *net.UDPAddr

+ func (host *HostName) ToNormalizedString() string

+ func (host *HostName) ToNormalizedWildcardString() string

+ func (host *HostName) ToQualifiedString() string

+ func (host *HostName) Validate() addrerr.HostNameError

+ func (host *HostName) Wrap() ExtendedIdentifierString

+ type IPAddress struct

+ func CheckBlockOrAddress(addr *IPAddress) *IPAddress

+ func NewIPAddressFromNetIP(ip net.IP) (*IPAddress, addrerr.AddressValueError)

+ func NewIPAddressFromNetIPAddr(addr *net.IPAddr) (*IPAddress, addrerr.AddressValueError)

+ func NewIPAddressFromNetIPMask(ip net.IPMask) (*IPAddress, addrerr.AddressValueError)

+ func NewIPAddressFromNetIPNet(ipnet net.IPNet) (*IPAddress, addrerr.AddressError)

+ func NewIPAddressFromPrefixedNetIP(ip net.IP, prefixLength PrefixLen) (*IPAddress, addrerr.AddressValueError)

+ func NewIPAddressFromPrefixedNetIPAddr(addr *net.IPAddr, prefixLength PrefixLen) (*IPAddress, addrerr.AddressValueError)

+ func NewIPAddressFromPrefixedSegments(segs []*IPAddressSegment, prefixLength PrefixLen) (res *IPAddress, err addrerr.AddressValueError)

+ func NewIPAddressFromPrefixedVals(version IPVersion, lowerValueProvider, upperValueProvider SegmentValueProvider, ...) *IPAddress

+ func NewIPAddressFromPrefixedZonedVals(version IPVersion, lowerValueProvider, upperValueProvider SegmentValueProvider, ...) *IPAddress

+ func NewIPAddressFromSegments(segments []*IPAddressSegment) (res *IPAddress, err addrerr.AddressValueError)

+ func NewIPAddressFromVals(version IPVersion, lowerValueProvider SegmentValueProvider) *IPAddress

+ func NewIPAddressFromValueProvider(valueProvider IPAddressValueProvider) *IPAddress

+ func (addr *IPAddress) AdjustPrefixLen(prefixLen BitCount) *IPAddress

+ func (addr *IPAddress) AdjustPrefixLenZeroed(prefixLen BitCount) (*IPAddress, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) AssignMinPrefixForBlock() *IPAddress

+ func (addr *IPAddress) AssignPrefixForSingleBlock() *IPAddress

+ func (addr *IPAddress) BitwiseOr(other *IPAddress) (masked *IPAddress, err addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) BlockIterator(segmentCount int) IPAddressIterator

+ func (addr *IPAddress) Bytes() []byte

+ func (addr *IPAddress) Compare(item AddressItem) int

+ func (addr *IPAddress) CompareSize(other AddressType) int

+ func (addr *IPAddress) Contains(other AddressType) bool

+ func (addr *IPAddress) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (addr *IPAddress) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (addr *IPAddress) CopyBytes(bytes []byte) []byte

+ func (addr *IPAddress) CopyNetIP(ip net.IP) net.IP

+ func (addr *IPAddress) CopySegments(segs []*IPAddressSegment) (count int)

+ func (addr *IPAddress) CopySubSegments(start, end int, segs []*IPAddressSegment) (count int)

+ func (addr *IPAddress) CopyUpperBytes(bytes []byte) []byte

+ func (addr *IPAddress) CopyUpperNetIP(ip net.IP) net.IP

+ func (addr *IPAddress) CoverWithPrefixBlock() *IPAddress

+ func (addr *IPAddress) CoverWithPrefixBlockTo(other *IPAddress) *IPAddress

+ func (addr *IPAddress) Equal(other AddressType) bool

+ func (addr *IPAddress) GetBitCount() BitCount

+ func (addr *IPAddress) GetBlockCount(segmentCount int) *big.Int

+ func (addr *IPAddress) GetBlockMaskPrefixLen(network bool) PrefixLen

+ func (addr *IPAddress) GetByteCount() int

+ func (addr *IPAddress) GetCount() *big.Int

+ func (addr *IPAddress) GetDivisionCount() int

+ func (addr *IPAddress) GetGenericDivision(index int) DivisionType

+ func (addr *IPAddress) GetGenericSegment(index int) AddressSegmentType

+ func (addr *IPAddress) GetHostMask() *IPAddress

+ func (addr *IPAddress) GetHostSection() *IPAddressSection

+ func (addr *IPAddress) GetHostSectionLen(prefLen BitCount) *IPAddressSection

+ func (addr *IPAddress) GetIPVersion() IPVersion

+ func (addr *IPAddress) GetLeadingBitCount(ones bool) BitCount

+ func (addr *IPAddress) GetLower() *IPAddress

+ func (addr *IPAddress) GetLowerIPAddress() *IPAddress

+ func (addr *IPAddress) GetMaxSegmentValue() SegInt

+ func (addr *IPAddress) GetMinPrefixLenForBlock() BitCount

+ func (addr *IPAddress) GetNetIP() net.IP

+ func (addr *IPAddress) GetNetIPAddr() net.IPAddr

+ func (addr *IPAddress) GetNetwork() IPAddressNetwork

+ func (addr *IPAddress) GetNetworkMask() *IPAddress

+ func (addr *IPAddress) GetNetworkPrefixLen() PrefixLen

+ func (addr *IPAddress) GetNetworkSection() *IPAddressSection

+ func (addr *IPAddress) GetNetworkSectionLen(prefLen BitCount) *IPAddressSection

+ func (addr *IPAddress) GetPrefixCount() *big.Int

+ func (addr *IPAddress) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (addr *IPAddress) GetPrefixLen() PrefixLen

+ func (addr *IPAddress) GetPrefixLenForSingleBlock() PrefixLen

+ func (addr *IPAddress) GetSection() *IPAddressSection

+ func (addr *IPAddress) GetSegment(index int) *IPAddressSegment

+ func (addr *IPAddress) GetSegmentCount() int

+ func (addr *IPAddress) GetSegmentStrings() []string

+ func (addr *IPAddress) GetSegments() []*IPAddressSegment

+ func (addr *IPAddress) GetSequentialBlockCount() *big.Int

+ func (addr *IPAddress) GetSequentialBlockIndex() int

+ func (addr *IPAddress) GetSubSection(index, endIndex int) *IPAddressSection

+ func (addr *IPAddress) GetTrailingBitCount(ones bool) BitCount

+ func (addr *IPAddress) GetTrailingSection(index int) *IPAddressSection

+ func (addr *IPAddress) GetUpper() *IPAddress

+ func (addr *IPAddress) GetUpperIPAddress() *IPAddress

+ func (addr *IPAddress) GetUpperNetIP() net.IP

+ func (addr *IPAddress) GetUpperValue() *big.Int

+ func (addr *IPAddress) GetValue() *big.Int

+ func (addr *IPAddress) IncludesMax() bool

+ func (addr *IPAddress) IncludesMaxHost() bool

+ func (addr *IPAddress) IncludesMaxHostLen(networkPrefixLength BitCount) bool

+ func (addr *IPAddress) IncludesZeroHost() bool

+ func (addr *IPAddress) IncludesZeroHostLen(networkPrefixLength BitCount) bool

+ func (addr *IPAddress) Increment(increment int64) *IPAddress

+ func (addr *IPAddress) IncrementBoundary(increment int64) *IPAddress

+ func (addr *IPAddress) Intersect(other *IPAddress) *IPAddress

+ func (addr *IPAddress) IsAnyLocal() bool

+ func (addr *IPAddress) IsIPv4() bool

+ func (addr *IPAddress) IsIPv6() bool

+ func (addr *IPAddress) IsLinkLocal() bool

+ func (addr *IPAddress) IsLocal() bool

+ func (addr *IPAddress) IsLoopback() bool

+ func (addr *IPAddress) IsMax() bool

+ func (addr *IPAddress) IsMaxHost() bool

+ func (addr *IPAddress) IsMaxHostLen(prefLen BitCount) bool

+ func (addr *IPAddress) IsMulticast() bool

+ func (addr *IPAddress) IsMultiple() bool

+ func (addr *IPAddress) IsOneBit(bitIndex BitCount) bool

+ func (addr *IPAddress) IsPrefixBlock() bool

+ func (addr *IPAddress) IsPrefixed() bool

+ func (addr *IPAddress) IsSingleNetwork() bool

+ func (addr *IPAddress) IsSinglePrefixBlock() bool

+ func (addr *IPAddress) IsUnspecified() bool

+ func (addr *IPAddress) IsZeroHost() bool

+ func (addr *IPAddress) IsZeroHostLen(prefLen BitCount) bool

+ func (addr *IPAddress) Iterator() IPAddressIterator

+ func (addr *IPAddress) Mask(other *IPAddress) (masked *IPAddress, err addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) MatchesWithMask(other *IPAddress, mask *IPAddress) bool

+ func (addr *IPAddress) MergeToPrefixBlocks(addrs ...*IPAddress) []*IPAddress

+ func (addr *IPAddress) MergeToSequentialBlocks(addrs ...*IPAddress) []*IPAddress

+ func (addr *IPAddress) PrefixBlockIterator() IPAddressIterator

+ func (addr *IPAddress) PrefixContains(other AddressType) bool

+ func (addr *IPAddress) PrefixEqual(other AddressType) bool

+ func (addr *IPAddress) PrefixIterator() IPAddressIterator

+ func (addr *IPAddress) ReverseBits(perByte bool) (*IPAddress, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) ReverseBytes() (*IPAddress, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) ReverseSegments() *IPAddress

+ func (addr *IPAddress) SequentialBlockIterator() IPAddressIterator

+ func (addr *IPAddress) SetPrefixLen(prefixLen BitCount) *IPAddress

+ func (addr *IPAddress) SetPrefixLenZeroed(prefixLen BitCount) (*IPAddress, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) SpanWithPrefixBlocks() []*IPAddress

+ func (addr *IPAddress) SpanWithPrefixBlocksTo(other *IPAddress) []*IPAddress

+ func (addr *IPAddress) SpanWithRange(other *IPAddress) *IPAddressSeqRange

+ func (addr *IPAddress) SpanWithSequentialBlocks() []*IPAddress

+ func (addr *IPAddress) SpanWithSequentialBlocksTo(other *IPAddress) []*IPAddress

+ func (addr *IPAddress) String() string

+ func (addr *IPAddress) Subtract(other *IPAddress) []*IPAddress

+ func (addr *IPAddress) TestBit(n BitCount) bool

+ func (addr *IPAddress) ToAddressBase() *Address

+ func (addr *IPAddress) ToAddressString() *IPAddressString

+ func (addr *IPAddress) ToBinaryString(with0bPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) ToBlock(segmentIndex int, lower, upper SegInt) *IPAddress

+ func (addr *IPAddress) ToCanonicalHostName() (*HostName, error)

+ func (addr *IPAddress) ToCanonicalString() string

+ func (addr *IPAddress) ToCanonicalWildcardString() string

+ func (addr *IPAddress) ToCompressedString() string

+ func (addr *IPAddress) ToCompressedWildcardString() string

+ func (addr *IPAddress) ToCustomString(stringOptions addrstr.IPStringOptions) string

+ func (addr *IPAddress) ToFullString() string

+ func (addr *IPAddress) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) ToHostName() *HostName

+ func (addr *IPAddress) ToIP() *IPAddress

+ func (addr *IPAddress) ToIPv4() *IPv4Address

+ func (addr *IPAddress) ToIPv6() *IPv6Address

+ func (addr *IPAddress) ToMaxHost() (*IPAddress, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) ToMaxHostLen(prefixLength BitCount) (*IPAddress, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) ToNormalizedString() string

+ func (addr *IPAddress) ToNormalizedWildcardString() string

+ func (addr *IPAddress) ToOctalString(with0Prefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) ToPrefixBlock() *IPAddress

+ func (addr *IPAddress) ToPrefixBlockLen(prefLen BitCount) *IPAddress

+ func (addr *IPAddress) ToPrefixLenString() string

+ func (addr *IPAddress) ToReverseDNSString() (string, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) ToSQLWildcardString() string

+ func (addr *IPAddress) ToSegmentedBinaryString() string

+ func (addr *IPAddress) ToSequentialRange() *IPAddressSeqRange

+ func (addr *IPAddress) ToSubnetString() string

+ func (addr *IPAddress) ToZeroHost() (*IPAddress, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) ToZeroHostLen(prefixLength BitCount) (*IPAddress, addrerr.IncompatibleAddressError)

+ func (addr *IPAddress) ToZeroNetwork() *IPAddress

+ func (addr *IPAddress) UpperBytes() []byte

+ func (addr *IPAddress) WithoutPrefixLen() *IPAddress

+ func (addr *IPAddress) Wrap() WrappedIPAddress

+ func (addr IPAddress) Format(state fmt.State, verb rune)

+ type IPAddressConverter interface

+ IsIPv4Convertible func(address *IPAddress) bool

+ IsIPv6Convertible func(address *IPAddress) bool

+ type IPAddressCreator struct

+ func (creator IPAddressCreator) CreatePrefixSegment(value SegInt, segmentPrefixLength PrefixLen) *IPAddressSegment

+ func (creator IPAddressCreator) CreateRangeSegment(lower, upper SegInt) *IPAddressSegment

+ func (creator IPAddressCreator) CreateSegment(lower, upper SegInt, segmentPrefixLength PrefixLen) *IPAddressSegment

+ func (creator IPAddressCreator) NewIPAddressFromPrefixedVals(lowerValueProvider, upperValueProvider SegmentValueProvider, ...) *IPAddress

+ func (creator IPAddressCreator) NewIPAddressFromPrefixedZonedVals(lowerValueProvider, upperValueProvider SegmentValueProvider, ...) *IPAddress

+ func (creator IPAddressCreator) NewIPAddressFromVals(lowerValueProvider SegmentValueProvider) *IPAddress

+ func (creator IPAddressCreator) NewIPSectionFromBytes(bytes []byte) (*IPAddressSection, addrerr.AddressValueError)

+ func (creator IPAddressCreator) NewIPSectionFromPrefixedBytes(bytes []byte, segmentCount int, prefLen PrefixLen) (*IPAddressSection, addrerr.AddressValueError)

+ func (creator IPAddressCreator) NewIPSectionFromSegmentBytes(bytes []byte, segmentCount int) (*IPAddressSection, addrerr.AddressValueError)

+ type IPAddressIterator interface

+ Next func() *IPAddress

+ func NewFilteredIPAddrIterator(iter IPAddressIterator, skip func(*IPAddress) bool) IPAddressIterator

+ type IPAddressNetwork interface

+ GetHostMask func(prefixLength BitCount) *IPAddress

+ GetLoopback func() *IPAddress

+ GetNetworkMask func(prefixLength BitCount) *IPAddress

+ GetPrefixedHostMask func(prefixLength BitCount) *IPAddress

+ GetPrefixedNetworkMask func(prefixLength BitCount) *IPAddress

+ type IPAddressRange interface

+ IsSequential func() bool

+ type IPAddressSection struct

+ func (section *IPAddressSection) AdjustPrefixLen(prefixLen BitCount) *IPAddressSection

+ func (section *IPAddressSection) AdjustPrefixLenZeroed(prefixLen BitCount) (*IPAddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) AssignMinPrefixForBlock() *IPAddressSection

+ func (section *IPAddressSection) AssignPrefixForSingleBlock() *IPAddressSection

+ func (section *IPAddressSection) BlockIterator(segmentCount int) IPSectionIterator

+ func (section *IPAddressSection) Bytes() []byte

+ func (section *IPAddressSection) Compare(item AddressItem) int

+ func (section *IPAddressSection) CompareSize(other StandardDivGroupingType) int

+ func (section *IPAddressSection) Contains(other AddressSectionType) bool

+ func (section *IPAddressSection) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (section *IPAddressSection) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (section *IPAddressSection) CopyBytes(bytes []byte) []byte

+ func (section *IPAddressSection) CopySegments(segs []*IPAddressSegment) (count int)

+ func (section *IPAddressSection) CopySubSegments(start, end int, segs []*IPAddressSegment) (count int)

+ func (section *IPAddressSection) CopyUpperBytes(bytes []byte) []byte

+ func (section *IPAddressSection) CoverWithPrefixBlock() *IPAddressSection

+ func (section *IPAddressSection) Equal(other AddressSectionType) bool

+ func (section *IPAddressSection) GetBitCount() BitCount

+ func (section *IPAddressSection) GetBitsPerSegment() BitCount

+ func (section *IPAddressSection) GetBlockCount(segmentCount int) *big.Int

+ func (section *IPAddressSection) GetBlockMaskPrefixLen(network bool) PrefixLen

+ func (section *IPAddressSection) GetByteCount() int

+ func (section *IPAddressSection) GetBytesPerSegment() int

+ func (section *IPAddressSection) GetCount() *big.Int

+ func (section *IPAddressSection) GetGenericSegment(index int) AddressSegmentType

+ func (section *IPAddressSection) GetHostMask() *IPAddressSection

+ func (section *IPAddressSection) GetHostSection() *IPAddressSection

+ func (section *IPAddressSection) GetHostSectionLen(prefLen BitCount) *IPAddressSection

+ func (section *IPAddressSection) GetIPVersion() IPVersion

+ func (section *IPAddressSection) GetLeadingBitCount(ones bool) BitCount

+ func (section *IPAddressSection) GetLower() *IPAddressSection

+ func (section *IPAddressSection) GetMaxSegmentValue() SegInt

+ func (section *IPAddressSection) GetMinPrefixLenForBlock() BitCount

+ func (section *IPAddressSection) GetNetworkMask() *IPAddressSection

+ func (section *IPAddressSection) GetNetworkPrefixLen() PrefixLen

+ func (section *IPAddressSection) GetNetworkSection() *IPAddressSection

+ func (section *IPAddressSection) GetNetworkSectionLen(prefLen BitCount) *IPAddressSection

+ func (section *IPAddressSection) GetPrefixCount() *big.Int

+ func (section *IPAddressSection) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (section *IPAddressSection) GetPrefixLenForSingleBlock() PrefixLen

+ func (section *IPAddressSection) GetSegment(index int) *IPAddressSegment

+ func (section *IPAddressSection) GetSegmentCount() int

+ func (section *IPAddressSection) GetSegmentStrings() []string

+ func (section *IPAddressSection) GetSegments() (res []*IPAddressSegment)

+ func (section *IPAddressSection) GetSequentialBlockCount() *big.Int

+ func (section *IPAddressSection) GetSequentialBlockIndex() int

+ func (section *IPAddressSection) GetSubSection(index, endIndex int) *IPAddressSection

+ func (section *IPAddressSection) GetTrailingBitCount(ones bool) BitCount

+ func (section *IPAddressSection) GetTrailingSection(index int) *IPAddressSection

+ func (section *IPAddressSection) GetUpper() *IPAddressSection

+ func (section *IPAddressSection) GetUpperValue() *big.Int

+ func (section *IPAddressSection) GetValue() *big.Int

+ func (section *IPAddressSection) IncludesMax() bool

+ func (section *IPAddressSection) IncludesMaxHost() bool

+ func (section *IPAddressSection) IncludesMaxHostLen(networkPrefixLength BitCount) bool

+ func (section *IPAddressSection) IncludesZero() bool

+ func (section *IPAddressSection) IncludesZeroHost() bool

+ func (section *IPAddressSection) IncludesZeroHostLen(networkPrefixLength BitCount) bool

+ func (section *IPAddressSection) Increment(increment int64) *IPAddressSection

+ func (section *IPAddressSection) IncrementBoundary(increment int64) *IPAddressSection

+ func (section *IPAddressSection) IsAdaptiveZero() bool

+ func (section *IPAddressSection) IsFullRange() bool

+ func (section *IPAddressSection) IsIPv4() bool

+ func (section *IPAddressSection) IsIPv6() bool

+ func (section *IPAddressSection) IsMax() bool

+ func (section *IPAddressSection) IsMaxHost() bool

+ func (section *IPAddressSection) IsMaxHostLen(prefLen BitCount) bool

+ func (section *IPAddressSection) IsMultiple() bool

+ func (section *IPAddressSection) IsOneBit(prefixBitIndex BitCount) bool

+ func (section *IPAddressSection) IsPrefixBlock() bool

+ func (section *IPAddressSection) IsPrefixed() bool

+ func (section *IPAddressSection) IsSequential() bool

+ func (section *IPAddressSection) IsSingleNetwork() bool

+ func (section *IPAddressSection) IsSinglePrefixBlock() bool

+ func (section *IPAddressSection) IsZero() bool

+ func (section *IPAddressSection) IsZeroHost() bool

+ func (section *IPAddressSection) IsZeroHostLen(prefLen BitCount) bool

+ func (section *IPAddressSection) Iterator() IPSectionIterator

+ func (section *IPAddressSection) PrefixBlockIterator() IPSectionIterator

+ func (section *IPAddressSection) PrefixContains(other AddressSectionType) bool

+ func (section *IPAddressSection) PrefixEqual(other AddressSectionType) bool

+ func (section *IPAddressSection) PrefixIterator() IPSectionIterator

+ func (section *IPAddressSection) ReverseBits(perByte bool) (*IPAddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) ReverseBytes() (*IPAddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) ReverseSegments() *IPAddressSection

+ func (section *IPAddressSection) SequentialBlockIterator() IPSectionIterator

+ func (section *IPAddressSection) SetPrefixLen(prefixLen BitCount) *IPAddressSection

+ func (section *IPAddressSection) SetPrefixLenZeroed(prefixLen BitCount) (*IPAddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) SpanWithPrefixBlocks() []*IPAddressSection

+ func (section *IPAddressSection) SpanWithSequentialBlocks() []*IPAddressSection

+ func (section *IPAddressSection) String() string

+ func (section *IPAddressSection) TestBit(n BitCount) bool

+ func (section *IPAddressSection) ToBinaryString(with0bPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) ToBlock(segmentIndex int, lower, upper SegInt) *IPAddressSection

+ func (section *IPAddressSection) ToCanonicalString() string

+ func (section *IPAddressSection) ToCanonicalWildcardString() string

+ func (section *IPAddressSection) ToCompressedString() string

+ func (section *IPAddressSection) ToCompressedWildcardString() string

+ func (section *IPAddressSection) ToCustomString(stringOptions addrstr.IPStringOptions) string

+ func (section *IPAddressSection) ToDivGrouping() *AddressDivisionGrouping

+ func (section *IPAddressSection) ToFullString() string

+ func (section *IPAddressSection) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) ToIPv4() *IPv4AddressSection

+ func (section *IPAddressSection) ToIPv6() *IPv6AddressSection

+ func (section *IPAddressSection) ToMaxHost() (res *IPAddressSection, err addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) ToMaxHostLen(prefixLength BitCount) (*IPAddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) ToNormalizedString() string

+ func (section *IPAddressSection) ToNormalizedWildcardString() string

+ func (section *IPAddressSection) ToOctalString(with0Prefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) ToPrefixBlock() *IPAddressSection

+ func (section *IPAddressSection) ToPrefixBlockLen(prefLen BitCount) *IPAddressSection

+ func (section *IPAddressSection) ToPrefixLenString() string

+ func (section *IPAddressSection) ToReverseDNSString() (string, addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) ToSQLWildcardString() string

+ func (section *IPAddressSection) ToSectionBase() *AddressSection

+ func (section *IPAddressSection) ToSegmentedBinaryString() string

+ func (section *IPAddressSection) ToSubnetString() string

+ func (section *IPAddressSection) ToZeroHost() (res *IPAddressSection, err addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) ToZeroHostLen(prefixLength BitCount) (*IPAddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPAddressSection) ToZeroNetwork() *IPAddressSection

+ func (section *IPAddressSection) UpperBytes() []byte

+ func (section *IPAddressSection) WithoutPrefixLen() *IPAddressSection

+ func (section *IPAddressSection) Wrap() WrappedIPAddressSection

+ type IPAddressSegment struct

+ func (seg *IPAddressSegment) Bytes() []byte

+ func (seg *IPAddressSegment) Compare(item AddressItem) int

+ func (seg *IPAddressSegment) Contains(other AddressSegmentType) bool

+ func (seg *IPAddressSegment) ContainsPrefixBlock(divisionPrefixLen BitCount) bool

+ func (seg *IPAddressSegment) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (seg *IPAddressSegment) CopyBytes(bytes []byte) []byte

+ func (seg *IPAddressSegment) CopyUpperBytes(bytes []byte) []byte

+ func (seg *IPAddressSegment) Equal(other AddressSegmentType) bool

+ func (seg *IPAddressSegment) GetBitCount() BitCount

+ func (seg *IPAddressSegment) GetBlockMaskPrefixLen(network bool) PrefixLen

+ func (seg *IPAddressSegment) GetByteCount() int

+ func (seg *IPAddressSegment) GetCount() *big.Int

+ func (seg *IPAddressSegment) GetLeadingBitCount(ones bool) BitCount

+ func (seg *IPAddressSegment) GetLower() *IPAddressSegment

+ func (seg *IPAddressSegment) GetMaxValue() SegInt

+ func (seg *IPAddressSegment) GetMinPrefixLenForBlock() BitCount

+ func (seg *IPAddressSegment) GetPrefixCountLen(segmentPrefixLength BitCount) *big.Int

+ func (seg *IPAddressSegment) GetPrefixLenForSingleBlock() PrefixLen

+ func (seg *IPAddressSegment) GetPrefixValueCount() SegIntCount

+ func (seg *IPAddressSegment) GetPrefixValueCountLen(segmentPrefixLength BitCount) SegIntCount

+ func (seg *IPAddressSegment) GetSegmentHostMask(networkBits BitCount) SegInt

+ func (seg *IPAddressSegment) GetSegmentNetworkMask(networkBits BitCount) SegInt

+ func (seg *IPAddressSegment) GetSegmentPrefixLen() PrefixLen

+ func (seg *IPAddressSegment) GetSegmentValue() SegInt

+ func (seg *IPAddressSegment) GetString() string

+ func (seg *IPAddressSegment) GetTrailingBitCount(ones bool) BitCount

+ func (seg *IPAddressSegment) GetUpper() *IPAddressSegment

+ func (seg *IPAddressSegment) GetUpperSegmentValue() SegInt

+ func (seg *IPAddressSegment) GetUpperValue() *BigDivInt

+ func (seg *IPAddressSegment) GetValue() *BigDivInt

+ func (seg *IPAddressSegment) GetValueCount() SegIntCount

+ func (seg *IPAddressSegment) GetWildcardString() string

+ func (seg *IPAddressSegment) IncludesMax() bool

+ func (seg *IPAddressSegment) IncludesZero() bool

+ func (seg *IPAddressSegment) IsFullRange() bool

+ func (seg *IPAddressSegment) IsIPv4() bool

+ func (seg *IPAddressSegment) IsIPv6() bool

+ func (seg *IPAddressSegment) IsMax() bool

+ func (seg *IPAddressSegment) IsMultiple() bool

+ func (seg *IPAddressSegment) IsOneBit(segmentBitIndex BitCount) bool

+ func (seg *IPAddressSegment) IsPrefixBlock() bool

+ func (seg *IPAddressSegment) IsPrefixed() bool

+ func (seg *IPAddressSegment) IsSinglePrefix(divisionPrefixLength BitCount) bool

+ func (seg *IPAddressSegment) IsSinglePrefixBlock() bool

+ func (seg *IPAddressSegment) IsZero() bool

+ func (seg *IPAddressSegment) Iterator() IPSegmentIterator

+ func (seg *IPAddressSegment) Matches(value SegInt) bool

+ func (seg *IPAddressSegment) MatchesValsWithMask(lowerValue, upperValue, mask SegInt) bool

+ func (seg *IPAddressSegment) MatchesWithMask(value, mask SegInt) bool

+ func (seg *IPAddressSegment) MatchesWithPrefixMask(value SegInt, networkBits BitCount) bool

+ func (seg *IPAddressSegment) PrefixBlockIterator() IPSegmentIterator

+ func (seg *IPAddressSegment) PrefixContains(other AddressSegmentType, prefixLength BitCount) bool

+ func (seg *IPAddressSegment) PrefixEqual(other AddressSegmentType, prefixLength BitCount) bool

+ func (seg *IPAddressSegment) PrefixIterator() IPSegmentIterator

+ func (seg *IPAddressSegment) PrefixedBlockIterator(segmentPrefixLen BitCount) IPSegmentIterator

+ func (seg *IPAddressSegment) ReverseBits(perByte bool) (res *AddressSegment, err addrerr.IncompatibleAddressError)

+ func (seg *IPAddressSegment) ReverseBytes() (res *AddressSegment, err addrerr.IncompatibleAddressError)

+ func (seg *IPAddressSegment) String() string

+ func (seg *IPAddressSegment) TestBit(n BitCount) bool

+ func (seg *IPAddressSegment) ToDiv() *AddressDivision

+ func (seg *IPAddressSegment) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (seg *IPAddressSegment) ToHostSegment(segmentPrefixLength PrefixLen) *IPAddressSegment

+ func (seg *IPAddressSegment) ToIPv4() *IPv4AddressSegment

+ func (seg *IPAddressSegment) ToIPv6() *IPv6AddressSegment

+ func (seg *IPAddressSegment) ToNetworkSegment(segmentPrefixLength PrefixLen) *IPAddressSegment

+ func (seg *IPAddressSegment) ToNormalizedString() string

+ func (seg *IPAddressSegment) ToPrefixedHostSegment(segmentPrefixLength PrefixLen) *IPAddressSegment

+ func (seg *IPAddressSegment) ToPrefixedNetworkSegment(segmentPrefixLength PrefixLen) *IPAddressSegment

+ func (seg *IPAddressSegment) ToSegmentBase() *AddressSegment

+ func (seg *IPAddressSegment) UpperBytes() []byte

+ func (seg *IPAddressSegment) WithoutPrefixLen() *IPAddressSegment

+ type IPAddressSegmentSeries interface

+ GetBlockMaskPrefixLen func(network bool) PrefixLen

+ GetIPVersion func() IPVersion

+ GetLeadingBitCount func(ones bool) BitCount

+ GetTrailingBitCount func(ones bool) BitCount

+ IncludesMaxHost func() bool

+ IncludesMaxHostLen func(prefLen BitCount) bool

+ IncludesZeroHost func() bool

+ IncludesZeroHostLen func(prefLen BitCount) bool

+ IsMaxHost func() bool

+ IsMaxHostLen func(BitCount) bool

+ IsSingleNetwork func() bool

+ IsZeroHost func() bool

+ IsZeroHostLen func(BitCount) bool

+ ToCanonicalWildcardString func() string

+ ToCompressedWildcardString func() string

+ ToFullString func() string

+ ToNormalizedWildcardString func() string

+ ToPrefixLenString func() string

+ ToReverseDNSString func() (string, addrerr.IncompatibleAddressError)

+ ToSQLWildcardString func() string

+ ToSegmentedBinaryString func() string

+ ToSubnetString func() string

+ type IPAddressSeqRange struct

+ func (rng *IPAddressSeqRange) Bytes() []byte

+ func (rng *IPAddressSeqRange) Compare(item AddressItem) int

+ func (rng *IPAddressSeqRange) CompareSize(other IPAddressSeqRangeType) int

+ func (rng *IPAddressSeqRange) Contains(other IPAddressType) bool

+ func (rng *IPAddressSeqRange) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (rng *IPAddressSeqRange) ContainsRange(other IPAddressSeqRangeType) bool

+ func (rng *IPAddressSeqRange) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (rng *IPAddressSeqRange) CopyBytes(bytes []byte) []byte

+ func (rng *IPAddressSeqRange) CopyNetIP(bytes net.IP) net.IP

+ func (rng *IPAddressSeqRange) CopyUpperBytes(bytes []byte) []byte

+ func (rng *IPAddressSeqRange) CopyUpperNetIP(bytes net.IP) net.IP

+ func (rng *IPAddressSeqRange) CoverWithPrefixBlock() *IPAddress

+ func (rng *IPAddressSeqRange) Equal(other IPAddressSeqRangeType) bool

+ func (rng *IPAddressSeqRange) Extend(other *IPAddressSeqRange) *IPAddressSeqRange

+ func (rng *IPAddressSeqRange) GetBitCount() BitCount

+ func (rng *IPAddressSeqRange) GetByteCount() int

+ func (rng *IPAddressSeqRange) GetCount() *big.Int

+ func (rng *IPAddressSeqRange) GetLower() *IPAddress

+ func (rng *IPAddressSeqRange) GetLowerIPAddress() *IPAddress

+ func (rng *IPAddressSeqRange) GetMinPrefixLenForBlock() BitCount

+ func (rng *IPAddressSeqRange) GetNetIP() net.IP

+ func (rng *IPAddressSeqRange) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (rng *IPAddressSeqRange) GetPrefixLenForSingleBlock() PrefixLen

+ func (rng *IPAddressSeqRange) GetUpper() *IPAddress

+ func (rng *IPAddressSeqRange) GetUpperIPAddress() *IPAddress

+ func (rng *IPAddressSeqRange) GetUpperNetIP() net.IP

+ func (rng *IPAddressSeqRange) GetUpperValue() *big.Int

+ func (rng *IPAddressSeqRange) GetValue() *big.Int

+ func (rng *IPAddressSeqRange) IncludesMax() bool

+ func (rng *IPAddressSeqRange) IncludesZero() bool

+ func (rng *IPAddressSeqRange) Intersect(other *IPAddressSeqRange) *IPAddressSeqRange

+ func (rng *IPAddressSeqRange) IsFullRange() bool

+ func (rng *IPAddressSeqRange) IsIPv4() bool

+ func (rng *IPAddressSeqRange) IsIPv6() bool

+ func (rng *IPAddressSeqRange) IsMax() bool

+ func (rng *IPAddressSeqRange) IsMultiple() bool

+ func (rng *IPAddressSeqRange) IsSequential() bool

+ func (rng *IPAddressSeqRange) IsZero() bool

+ func (rng *IPAddressSeqRange) Iterator() IPAddressIterator

+ func (rng *IPAddressSeqRange) Join(ranges ...*IPAddressSeqRange) []*IPAddressSeqRange

+ func (rng *IPAddressSeqRange) JoinTo(other *IPAddressSeqRange) *IPAddressSeqRange

+ func (rng *IPAddressSeqRange) Overlaps(other *IPAddressSeqRange) bool

+ func (rng *IPAddressSeqRange) PrefixBlockIterator(prefLength BitCount) IPAddressIterator

+ func (rng *IPAddressSeqRange) PrefixIterator(prefLength BitCount) IPAddressSeqRangeIterator

+ func (rng *IPAddressSeqRange) SpanWithPrefixBlocks() []*IPAddress

+ func (rng *IPAddressSeqRange) SpanWithSequentialBlocks() []*IPAddress

+ func (rng *IPAddressSeqRange) String() string

+ func (rng *IPAddressSeqRange) Subtract(other *IPAddressSeqRange) []*IPAddressSeqRange

+ func (rng *IPAddressSeqRange) ToCanonicalString() string

+ func (rng *IPAddressSeqRange) ToIP() *IPAddressSeqRange

+ func (rng *IPAddressSeqRange) ToIPv4() *IPv4AddressSeqRange

+ func (rng *IPAddressSeqRange) ToIPv6() *IPv6AddressSeqRange

+ func (rng *IPAddressSeqRange) ToNormalizedString() string

+ func (rng *IPAddressSeqRange) ToString(lowerStringer func(*IPAddress) string, separator string, ...) string

+ func (rng *IPAddressSeqRange) UpperBytes() []byte

+ func (rng IPAddressSeqRange) Format(state fmt.State, verb rune)

+ type IPAddressSeqRangeIterator interface

+ Next func() *IPAddressSeqRange

+ type IPAddressSeqRangeType interface

+ CompareSize func(IPAddressSeqRangeType) int

+ Contains func(IPAddressType) bool

+ ContainsRange func(IPAddressSeqRangeType) bool

+ ToIP func() *IPAddressSeqRange

+ type IPAddressString struct

+ func NewIPAddressString(str string) *IPAddressString

+ func NewIPAddressStringParams(str string, params addrstrparam.IPAddressStringParams) *IPAddressString

+ func (addrStr *IPAddressString) AdjustPrefixLen(adjustment BitCount) (*IPAddressString, addrerr.IncompatibleAddressError)

+ func (addrStr *IPAddressString) Compare(other *IPAddressString) int

+ func (addrStr *IPAddressString) Contains(other *IPAddressString) bool

+ func (addrStr *IPAddressString) Equal(other *IPAddressString) bool

+ func (addrStr *IPAddressString) GetAddress() *IPAddress

+ func (addrStr *IPAddressString) GetHostAddress() *IPAddress

+ func (addrStr *IPAddressString) GetIPVersion() IPVersion

+ func (addrStr *IPAddressString) GetMask() *IPAddress

+ func (addrStr *IPAddressString) GetNetworkPrefixLen() PrefixLen

+ func (addrStr *IPAddressString) GetSequentialRange() (res *IPAddressSeqRange)

+ func (addrStr *IPAddressString) GetValidationOptions() addrstrparam.IPAddressStringParams

+ func (addrStr *IPAddressString) GetVersionedAddress(version IPVersion) *IPAddress

+ func (addrStr *IPAddressString) IsAllAddresses() bool

+ func (addrStr *IPAddressString) IsEmpty() bool

+ func (addrStr *IPAddressString) IsIPv4() bool

+ func (addrStr *IPAddressString) IsIPv6() bool

+ func (addrStr *IPAddressString) IsLoopback() bool

+ func (addrStr *IPAddressString) IsMixedIPv6() bool

+ func (addrStr *IPAddressString) IsPrefixed() bool

+ func (addrStr *IPAddressString) IsValid() bool

+ func (addrStr *IPAddressString) IsZero() bool

+ func (addrStr *IPAddressString) PrefixContains(other *IPAddressString) bool

+ func (addrStr *IPAddressString) PrefixEqual(other *IPAddressString) bool

+ func (addrStr *IPAddressString) String() string

+ func (addrStr *IPAddressString) ToAddress() (*IPAddress, addrerr.AddressError)

+ func (addrStr *IPAddressString) ToHostAddress() (*IPAddress, addrerr.AddressError)

+ func (addrStr *IPAddressString) ToNormalizedString() string

+ func (addrStr *IPAddressString) ToSequentialRange() (res *IPAddressSeqRange, err addrerr.AddressStringError)

+ func (addrStr *IPAddressString) ToVersionedAddress(version IPVersion) (*IPAddress, addrerr.AddressError)

+ func (addrStr *IPAddressString) Validate() addrerr.AddressStringError

+ func (addrStr *IPAddressString) ValidateIPv4() addrerr.AddressStringError

+ func (addrStr *IPAddressString) ValidateIPv6() addrerr.AddressStringError

+ func (addrStr *IPAddressString) ValidateVersion(version IPVersion) addrerr.AddressStringError

+ func (addrStr *IPAddressString) Wrap() ExtendedIdentifierString

+ type IPAddressType interface

+ ToAddressString func() *IPAddressString

+ ToIP func() *IPAddress

+ Wrap func() WrappedIPAddress

+ type IPAddressValueProvider interface

+ GetIPVersion func() IPVersion

+ GetPrefixLen func() PrefixLen

+ GetZone func() string

+ type IPSectionIterator interface

+ Next func() *IPAddressSection

+ type IPSegmentIterator interface

+ Next func() *IPAddressSegment

+ type IPVersion string

+ const IPv4

+ const IPv6

+ const IndeterminateIPVersion

+ func (version IPVersion) Equal(other IPVersion) bool

+ func (version IPVersion) GetBitCount() BitCount

+ func (version IPVersion) GetBitsPerSegment() BitCount

+ func (version IPVersion) GetByteCount() int

+ func (version IPVersion) GetBytesPerSegment() int

+ func (version IPVersion) GetMaxSegmentValue() SegInt

+ func (version IPVersion) GetSegmentCount() int

+ func (version IPVersion) IsIPv4() bool

+ func (version IPVersion) IsIPv6() bool

+ func (version IPVersion) IsIndeterminate() bool

+ func (version IPVersion) String() string

+ type IPv4Address struct

+ func NewIPv4Address(section *IPv4AddressSection) (*IPv4Address, addrerr.AddressValueError)

+ func NewIPv4AddressFromBytes(bytes []byte) (addr *IPv4Address, err addrerr.AddressValueError)

+ func NewIPv4AddressFromPrefixedBytes(bytes []byte, prefixLength PrefixLen) (addr *IPv4Address, err addrerr.AddressValueError)

+ func NewIPv4AddressFromPrefixedRange(vals, upperVals IPv4SegmentValueProvider, prefixLength PrefixLen) *IPv4Address

+ func NewIPv4AddressFromPrefixedSegs(segments []*IPv4AddressSegment, prefixLength PrefixLen) (*IPv4Address, addrerr.AddressValueError)

+ func NewIPv4AddressFromPrefixedUint32(val uint32, prefixLength PrefixLen) *IPv4Address

+ func NewIPv4AddressFromPrefixedVals(vals IPv4SegmentValueProvider, prefixLength PrefixLen) *IPv4Address

+ func NewIPv4AddressFromRange(vals, upperVals IPv4SegmentValueProvider) *IPv4Address

+ func NewIPv4AddressFromSegs(segments []*IPv4AddressSegment) (*IPv4Address, addrerr.AddressValueError)

+ func NewIPv4AddressFromUint32(val uint32) *IPv4Address

+ func NewIPv4AddressFromVals(vals IPv4SegmentValueProvider) *IPv4Address

+ func (addr *IPv4Address) AdjustPrefixLen(prefixLen BitCount) *IPv4Address

+ func (addr *IPv4Address) AdjustPrefixLenZeroed(prefixLen BitCount) (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) AssignMinPrefixForBlock() *IPv4Address

+ func (addr *IPv4Address) AssignPrefixForSingleBlock() *IPv4Address

+ func (addr *IPv4Address) BitwiseOr(other *IPv4Address) (masked *IPv4Address, err addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) BlockIterator(segmentCount int) IPv4AddressIterator

+ func (addr *IPv4Address) Bytes() []byte

+ func (addr *IPv4Address) Compare(item AddressItem) int

+ func (addr *IPv4Address) CompareSize(other AddressType) int

+ func (addr *IPv4Address) Contains(other AddressType) bool

+ func (addr *IPv4Address) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (addr *IPv4Address) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (addr *IPv4Address) CopyBytes(bytes []byte) []byte

+ func (addr *IPv4Address) CopyNetIP(ip net.IP) net.IP

+ func (addr *IPv4Address) CopySegments(segs []*IPv4AddressSegment) (count int)

+ func (addr *IPv4Address) CopySubSegments(start, end int, segs []*IPv4AddressSegment) (count int)

+ func (addr *IPv4Address) CopyUpperBytes(bytes []byte) []byte

+ func (addr *IPv4Address) CopyUpperNetIP(ip net.IP) net.IP

+ func (addr *IPv4Address) CoverWithPrefixBlock() *IPv4Address

+ func (addr *IPv4Address) CoverWithPrefixBlockTo(other *IPv4Address) *IPv4Address

+ func (addr *IPv4Address) Equal(other AddressType) bool

+ func (addr *IPv4Address) GetBitCount() BitCount

+ func (addr *IPv4Address) GetBitsPerSegment() BitCount

+ func (addr *IPv4Address) GetBlockCount(segmentCount int) *big.Int

+ func (addr *IPv4Address) GetBlockMaskPrefixLen(network bool) PrefixLen

+ func (addr *IPv4Address) GetByteCount() int

+ func (addr *IPv4Address) GetBytesPerSegment() int

+ func (addr *IPv4Address) GetCount() *big.Int

+ func (addr *IPv4Address) GetDivisionCount() int

+ func (addr *IPv4Address) GetGenericDivision(index int) DivisionType

+ func (addr *IPv4Address) GetGenericSegment(index int) AddressSegmentType

+ func (addr *IPv4Address) GetHostMask() *IPv4Address

+ func (addr *IPv4Address) GetHostSection() *IPv4AddressSection

+ func (addr *IPv4Address) GetHostSectionLen(prefLen BitCount) *IPv4AddressSection

+ func (addr *IPv4Address) GetIPVersion() IPVersion

+ func (addr *IPv4Address) GetIPv4MappedAddress() (*IPv6Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) GetIPv6Address(section *IPv6AddressSection) (*IPv6Address, addrerr.AddressError)

+ func (addr *IPv4Address) GetLeadingBitCount(ones bool) BitCount

+ func (addr *IPv4Address) GetLower() *IPv4Address

+ func (addr *IPv4Address) GetLowerIPAddress() *IPAddress

+ func (addr *IPv4Address) GetMaxSegmentValue() SegInt

+ func (addr *IPv4Address) GetMinPrefixLenForBlock() BitCount

+ func (addr *IPv4Address) GetNetIP() net.IP

+ func (addr *IPv4Address) GetNetwork() IPAddressNetwork

+ func (addr *IPv4Address) GetNetworkMask() *IPv4Address

+ func (addr *IPv4Address) GetNetworkPrefixLen() PrefixLen

+ func (addr *IPv4Address) GetNetworkSection() *IPv4AddressSection

+ func (addr *IPv4Address) GetNetworkSectionLen(prefLen BitCount) *IPv4AddressSection

+ func (addr *IPv4Address) GetPrefixCount() *big.Int

+ func (addr *IPv4Address) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (addr *IPv4Address) GetPrefixLen() PrefixLen

+ func (addr *IPv4Address) GetPrefixLenForSingleBlock() PrefixLen

+ func (addr *IPv4Address) GetSection() *IPv4AddressSection

+ func (addr *IPv4Address) GetSegment(index int) *IPv4AddressSegment

+ func (addr *IPv4Address) GetSegmentCount() int

+ func (addr *IPv4Address) GetSegmentStrings() []string

+ func (addr *IPv4Address) GetSegments() []*IPv4AddressSegment

+ func (addr *IPv4Address) GetSequentialBlockCount() *big.Int

+ func (addr *IPv4Address) GetSequentialBlockIndex() int

+ func (addr *IPv4Address) GetSubSection(index, endIndex int) *IPv4AddressSection

+ func (addr *IPv4Address) GetTrailingBitCount(ones bool) BitCount

+ func (addr *IPv4Address) GetTrailingSection(index int) *IPv4AddressSection

+ func (addr *IPv4Address) GetUpper() *IPv4Address

+ func (addr *IPv4Address) GetUpperIPAddress() *IPAddress

+ func (addr *IPv4Address) GetUpperNetIP() net.IP

+ func (addr *IPv4Address) GetUpperValue() *big.Int

+ func (addr *IPv4Address) GetValue() *big.Int

+ func (addr *IPv4Address) IncludesMax() bool

+ func (addr *IPv4Address) IncludesMaxHost() bool

+ func (addr *IPv4Address) IncludesMaxHostLen(networkPrefixLength BitCount) bool

+ func (addr *IPv4Address) IncludesZeroHost() bool

+ func (addr *IPv4Address) IncludesZeroHostLen(networkPrefixLength BitCount) bool

+ func (addr *IPv4Address) Increment(increment int64) *IPv4Address

+ func (addr *IPv4Address) IncrementBoundary(increment int64) *IPv4Address

+ func (addr *IPv4Address) Intersect(other *IPv4Address) *IPv4Address

+ func (addr *IPv4Address) IsAnyLocal() bool

+ func (addr *IPv4Address) IsLinkLocal() bool

+ func (addr *IPv4Address) IsLocal() bool

+ func (addr *IPv4Address) IsLoopback() bool

+ func (addr *IPv4Address) IsMax() bool

+ func (addr *IPv4Address) IsMaxHost() bool

+ func (addr *IPv4Address) IsMaxHostLen(prefLen BitCount) bool

+ func (addr *IPv4Address) IsMulticast() bool

+ func (addr *IPv4Address) IsMultiple() bool

+ func (addr *IPv4Address) IsOneBit(bitIndex BitCount) bool

+ func (addr *IPv4Address) IsPrefixBlock() bool

+ func (addr *IPv4Address) IsPrefixed() bool

+ func (addr *IPv4Address) IsPrivate() bool

+ func (addr *IPv4Address) IsSingleNetwork() bool

+ func (addr *IPv4Address) IsSinglePrefixBlock() bool

+ func (addr *IPv4Address) IsUnspecified() bool

+ func (addr *IPv4Address) IsZeroHost() bool

+ func (addr *IPv4Address) IsZeroHostLen(prefLen BitCount) bool

+ func (addr *IPv4Address) Iterator() IPv4AddressIterator

+ func (addr *IPv4Address) Mask(other *IPv4Address) (masked *IPv4Address, err addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) MatchesWithMask(other *IPv4Address, mask *IPv4Address) bool

+ func (addr *IPv4Address) MergeToPrefixBlocks(addrs ...*IPv4Address) []*IPv4Address

+ func (addr *IPv4Address) MergeToSequentialBlocks(addrs ...*IPv4Address) []*IPv4Address

+ func (addr *IPv4Address) PrefixBlockIterator() IPv4AddressIterator

+ func (addr *IPv4Address) PrefixContains(other AddressType) bool

+ func (addr *IPv4Address) PrefixEqual(other AddressType) bool

+ func (addr *IPv4Address) PrefixIterator() IPv4AddressIterator

+ func (addr *IPv4Address) Replace(startIndex int, replacement *IPv4AddressSection) *IPv4Address

+ func (addr *IPv4Address) ReplaceLen(startIndex, endIndex int, replacement *IPv4Address, replacementIndex int) *IPv4Address

+ func (addr *IPv4Address) ReverseBits(perByte bool) (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ReverseBytes() *IPv4Address

+ func (addr *IPv4Address) ReverseSegments() *IPv4Address

+ func (addr *IPv4Address) SequentialBlockIterator() IPv4AddressIterator

+ func (addr *IPv4Address) SetPrefixLen(prefixLen BitCount) *IPv4Address

+ func (addr *IPv4Address) SetPrefixLenZeroed(prefixLen BitCount) (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) SpanWithPrefixBlocks() []*IPv4Address

+ func (addr *IPv4Address) SpanWithPrefixBlocksTo(other *IPv4Address) []*IPv4Address

+ func (addr *IPv4Address) SpanWithRange(other *IPv4Address) *IPv4AddressSeqRange

+ func (addr *IPv4Address) SpanWithSequentialBlocks() []*IPv4Address

+ func (addr *IPv4Address) SpanWithSequentialBlocksTo(other *IPv4Address) []*IPv4Address

+ func (addr *IPv4Address) String() string

+ func (addr *IPv4Address) Subtract(other *IPv4Address) []*IPv4Address

+ func (addr *IPv4Address) TestBit(n BitCount) bool

+ func (addr *IPv4Address) ToAddressBase() *Address

+ func (addr *IPv4Address) ToAddressString() *IPAddressString

+ func (addr *IPv4Address) ToBinaryString(with0bPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ToBlock(segmentIndex int, lower, upper SegInt) *IPv4Address

+ func (addr *IPv4Address) ToBroadcastAddress() (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ToCanonicalString() string

+ func (addr *IPv4Address) ToCanonicalWildcardString() string

+ func (addr *IPv4Address) ToCompressedString() string

+ func (addr *IPv4Address) ToCompressedWildcardString() string

+ func (addr *IPv4Address) ToCustomString(stringOptions addrstr.IPStringOptions) string

+ func (addr *IPv4Address) ToFullString() string

+ func (addr *IPv4Address) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ToIP() *IPAddress

+ func (addr *IPv4Address) ToInetAtonJoinedString(radix Inet_aton_radix, joinedCount int) (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ToInetAtonString(radix Inet_aton_radix) string

+ func (addr *IPv4Address) ToMaxHost() (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ToMaxHostLen(prefixLength BitCount) (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ToNetworkAddress() (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ToNormalizedString() string

+ func (addr *IPv4Address) ToNormalizedWildcardString() string

+ func (addr *IPv4Address) ToOctalString(with0Prefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ToPrefixBlock() *IPv4Address

+ func (addr *IPv4Address) ToPrefixBlockLen(prefLen BitCount) *IPv4Address

+ func (addr *IPv4Address) ToPrefixLenString() string

+ func (addr *IPv4Address) ToReverseDNSString() (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ToSQLWildcardString() string

+ func (addr *IPv4Address) ToSegmentedBinaryString() string

+ func (addr *IPv4Address) ToSequentialRange() *IPv4AddressSeqRange

+ func (addr *IPv4Address) ToSubnetString() string

+ func (addr *IPv4Address) ToZeroHost() (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ToZeroHostLen(prefixLength BitCount) (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv4Address) ToZeroNetwork() *IPv4Address

+ func (addr *IPv4Address) Uint32Value() uint32

+ func (addr *IPv4Address) UpperBytes() []byte

+ func (addr *IPv4Address) UpperUint32Value() uint32

+ func (addr *IPv4Address) WithoutPrefixLen() *IPv4Address

+ func (addr *IPv4Address) Wrap() WrappedIPAddress

+ func (addr IPv4Address) Format(state fmt.State, verb rune)

+ type IPv4AddressConverter interface

+ ToIPv4 func(address *IPAddress) *IPv4Address

+ type IPv4AddressIterator interface

+ Next func() *IPv4Address

+ type IPv4AddressNetwork struct

+ func (network IPv4AddressNetwork) GetHostMask(prefLen BitCount) *IPv4Address

+ func (network IPv4AddressNetwork) GetLoopback() *IPv4Address

+ func (network IPv4AddressNetwork) GetNetworkMask(prefLen BitCount) *IPv4Address

+ func (network IPv4AddressNetwork) GetPrefixedHostMask(prefLen BitCount) *IPv4Address

+ func (network IPv4AddressNetwork) GetPrefixedNetworkMask(prefLen BitCount) *IPv4Address

+ type IPv4AddressSection struct

+ func NewIPv4PrefixedSection(segments []*IPv4AddressSegment, prefixLen PrefixLen) *IPv4AddressSection

+ func NewIPv4Section(segments []*IPv4AddressSegment) *IPv4AddressSection

+ func NewIPv4SectionFromBytes(bytes []byte) (res *IPv4AddressSection, err addrerr.AddressValueError)

+ func NewIPv4SectionFromPrefixedBytes(bytes []byte, segmentCount int, prefixLength PrefixLen) (res *IPv4AddressSection, err addrerr.AddressValueError)

+ func NewIPv4SectionFromPrefixedRange(vals, upperVals IPv4SegmentValueProvider, segmentCount int, ...) (res *IPv4AddressSection)

+ func NewIPv4SectionFromPrefixedUint32(bytes uint32, segmentCount int, prefixLength PrefixLen) (res *IPv4AddressSection)

+ func NewIPv4SectionFromPrefixedVals(vals IPv4SegmentValueProvider, segmentCount int, prefixLength PrefixLen) (res *IPv4AddressSection)

+ func NewIPv4SectionFromRange(vals, upperVals IPv4SegmentValueProvider, segmentCount int) (res *IPv4AddressSection)

+ func NewIPv4SectionFromSegmentedBytes(bytes []byte, segmentCount int) (res *IPv4AddressSection, err addrerr.AddressValueError)

+ func NewIPv4SectionFromUint32(bytes uint32, segmentCount int) (res *IPv4AddressSection)

+ func NewIPv4SectionFromVals(vals IPv4SegmentValueProvider, segmentCount int) (res *IPv4AddressSection)

+ func (section *IPv4AddressSection) AdjustPrefixLen(prefixLen BitCount) *IPv4AddressSection

+ func (section *IPv4AddressSection) AdjustPrefixLenZeroed(prefixLen BitCount) (*IPv4AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) Append(other *IPv4AddressSection) *IPv4AddressSection

+ func (section *IPv4AddressSection) AssignMinPrefixForBlock() *IPv4AddressSection

+ func (section *IPv4AddressSection) AssignPrefixForSingleBlock() *IPv4AddressSection

+ func (section *IPv4AddressSection) BitwiseOr(other *IPv4AddressSection) (res *IPv4AddressSection, err addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) BlockIterator(segmentCount int) IPv4SectionIterator

+ func (section *IPv4AddressSection) Bytes() []byte

+ func (section *IPv4AddressSection) Compare(item AddressItem) int

+ func (section *IPv4AddressSection) CompareSize(other StandardDivGroupingType) int

+ func (section *IPv4AddressSection) Contains(other AddressSectionType) bool

+ func (section *IPv4AddressSection) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (section *IPv4AddressSection) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (section *IPv4AddressSection) CopyBytes(bytes []byte) []byte

+ func (section *IPv4AddressSection) CopySegments(segs []*IPv4AddressSegment) (count int)

+ func (section *IPv4AddressSection) CopySubSegments(start, end int, segs []*IPv4AddressSegment) (count int)

+ func (section *IPv4AddressSection) CopyUpperBytes(bytes []byte) []byte

+ func (section *IPv4AddressSection) CoverWithPrefixBlock() *IPv4AddressSection

+ func (section *IPv4AddressSection) CoverWithPrefixBlockTo(other *IPv4AddressSection) (*IPv4AddressSection, addrerr.SizeMismatchError)

+ func (section *IPv4AddressSection) Equal(other AddressSectionType) bool

+ func (section *IPv4AddressSection) GetBitCount() BitCount

+ func (section *IPv4AddressSection) GetBitsPerSegment() BitCount

+ func (section *IPv4AddressSection) GetBlockCount(segmentCount int) *big.Int

+ func (section *IPv4AddressSection) GetBlockMaskPrefixLen(network bool) PrefixLen

+ func (section *IPv4AddressSection) GetByteCount() int

+ func (section *IPv4AddressSection) GetBytesPerSegment() int

+ func (section *IPv4AddressSection) GetCount() *big.Int

+ func (section *IPv4AddressSection) GetGenericSegment(index int) AddressSegmentType

+ func (section *IPv4AddressSection) GetHostMask() *IPv4AddressSection

+ func (section *IPv4AddressSection) GetHostSection() *IPv4AddressSection

+ func (section *IPv4AddressSection) GetHostSectionLen(prefLen BitCount) *IPv4AddressSection

+ func (section *IPv4AddressSection) GetIPVersion() IPVersion

+ func (section *IPv4AddressSection) GetIPv4BlockCount(segmentCount int) uint64

+ func (section *IPv4AddressSection) GetIPv4Count() uint64

+ func (section *IPv4AddressSection) GetIPv4PrefixCount() uint64

+ func (section *IPv4AddressSection) GetIPv4PrefixCountLen(prefixLength BitCount) uint64

+ func (section *IPv4AddressSection) GetLeadingBitCount(ones bool) BitCount

+ func (section *IPv4AddressSection) GetLower() *IPv4AddressSection

+ func (section *IPv4AddressSection) GetMaxSegmentValue() SegInt

+ func (section *IPv4AddressSection) GetMinPrefixLenForBlock() BitCount

+ func (section *IPv4AddressSection) GetNetworkMask() *IPv4AddressSection

+ func (section *IPv4AddressSection) GetNetworkPrefixLen() PrefixLen

+ func (section *IPv4AddressSection) GetNetworkSection() *IPv4AddressSection

+ func (section *IPv4AddressSection) GetNetworkSectionLen(prefLen BitCount) *IPv4AddressSection

+ func (section *IPv4AddressSection) GetPrefixCount() *big.Int

+ func (section *IPv4AddressSection) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (section *IPv4AddressSection) GetPrefixLenForSingleBlock() PrefixLen

+ func (section *IPv4AddressSection) GetSegment(index int) *IPv4AddressSegment

+ func (section *IPv4AddressSection) GetSegmentCount() int

+ func (section *IPv4AddressSection) GetSegmentStrings() []string

+ func (section *IPv4AddressSection) GetSegments() (res []*IPv4AddressSegment)

+ func (section *IPv4AddressSection) GetSequentialBlockCount() *big.Int

+ func (section *IPv4AddressSection) GetSequentialBlockIndex() int

+ func (section *IPv4AddressSection) GetSubSection(index, endIndex int) *IPv4AddressSection

+ func (section *IPv4AddressSection) GetTrailingBitCount(ones bool) BitCount

+ func (section *IPv4AddressSection) GetTrailingSection(index int) *IPv4AddressSection

+ func (section *IPv4AddressSection) GetUpper() *IPv4AddressSection

+ func (section *IPv4AddressSection) GetUpperValue() *big.Int

+ func (section *IPv4AddressSection) GetValue() *big.Int

+ func (section *IPv4AddressSection) IncludesMax() bool

+ func (section *IPv4AddressSection) IncludesMaxHost() bool

+ func (section *IPv4AddressSection) IncludesMaxHostLen(networkPrefixLength BitCount) bool

+ func (section *IPv4AddressSection) IncludesZero() bool

+ func (section *IPv4AddressSection) IncludesZeroHost() bool

+ func (section *IPv4AddressSection) IncludesZeroHostLen(networkPrefixLength BitCount) bool

+ func (section *IPv4AddressSection) Increment(inc int64) *IPv4AddressSection

+ func (section *IPv4AddressSection) IncrementBoundary(increment int64) *IPv4AddressSection

+ func (section *IPv4AddressSection) Insert(index int, other *IPv4AddressSection) *IPv4AddressSection

+ func (section *IPv4AddressSection) Intersect(other *IPv4AddressSection) (res *IPv4AddressSection, err addrerr.SizeMismatchError)

+ func (section *IPv4AddressSection) IsAdaptiveZero() bool

+ func (section *IPv4AddressSection) IsFullRange() bool

+ func (section *IPv4AddressSection) IsMax() bool

+ func (section *IPv4AddressSection) IsMaxHost() bool

+ func (section *IPv4AddressSection) IsMaxHostLen(prefLen BitCount) bool

+ func (section *IPv4AddressSection) IsMultiple() bool

+ func (section *IPv4AddressSection) IsOneBit(prefixBitIndex BitCount) bool

+ func (section *IPv4AddressSection) IsPrefixBlock() bool

+ func (section *IPv4AddressSection) IsPrefixed() bool

+ func (section *IPv4AddressSection) IsSequential() bool

+ func (section *IPv4AddressSection) IsSingleNetwork() bool

+ func (section *IPv4AddressSection) IsSinglePrefixBlock() bool

+ func (section *IPv4AddressSection) IsZero() bool

+ func (section *IPv4AddressSection) IsZeroHost() bool

+ func (section *IPv4AddressSection) IsZeroHostLen(prefLen BitCount) bool

+ func (section *IPv4AddressSection) Iterator() IPv4SectionIterator

+ func (section *IPv4AddressSection) Mask(other *IPv4AddressSection) (res *IPv4AddressSection, err addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) MatchesWithMask(other *IPv4AddressSection, mask *IPv4AddressSection) bool

+ func (section *IPv4AddressSection) MergeToPrefixBlocks(sections ...*IPv4AddressSection) ([]*IPv4AddressSection, addrerr.SizeMismatchError)

+ func (section *IPv4AddressSection) MergeToSequentialBlocks(sections ...*IPv4AddressSection) ([]*IPv4AddressSection, addrerr.SizeMismatchError)

+ func (section *IPv4AddressSection) PrefixBlockIterator() IPv4SectionIterator

+ func (section *IPv4AddressSection) PrefixContains(other AddressSectionType) bool

+ func (section *IPv4AddressSection) PrefixEqual(other AddressSectionType) bool

+ func (section *IPv4AddressSection) PrefixIterator() IPv4SectionIterator

+ func (section *IPv4AddressSection) Replace(index int, replacement *IPv4AddressSection) *IPv4AddressSection

+ func (section *IPv4AddressSection) ReplaceLen(startIndex, endIndex int, replacement *IPv4AddressSection, ...) *IPv4AddressSection

+ func (section *IPv4AddressSection) ReverseBits(perByte bool) (*IPv4AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ReverseBytes() *IPv4AddressSection

+ func (section *IPv4AddressSection) ReverseSegments() *IPv4AddressSection

+ func (section *IPv4AddressSection) SequentialBlockIterator() IPv4SectionIterator

+ func (section *IPv4AddressSection) SetPrefixLen(prefixLen BitCount) *IPv4AddressSection

+ func (section *IPv4AddressSection) SetPrefixLenZeroed(prefixLen BitCount) (*IPv4AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) SpanWithPrefixBlocks() []*IPv4AddressSection

+ func (section *IPv4AddressSection) SpanWithPrefixBlocksTo(other *IPv4AddressSection) ([]*IPv4AddressSection, addrerr.SizeMismatchError)

+ func (section *IPv4AddressSection) SpanWithSequentialBlocks() []*IPv4AddressSection

+ func (section *IPv4AddressSection) SpanWithSequentialBlocksTo(other *IPv4AddressSection) ([]*IPv4AddressSection, addrerr.SizeMismatchError)

+ func (section *IPv4AddressSection) String() string

+ func (section *IPv4AddressSection) Subtract(other *IPv4AddressSection) (res []*IPv4AddressSection, err addrerr.SizeMismatchError)

+ func (section *IPv4AddressSection) TestBit(n BitCount) bool

+ func (section *IPv4AddressSection) ToBinaryString(with0bPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ToBlock(segmentIndex int, lower, upper SegInt) *IPv4AddressSection

+ func (section *IPv4AddressSection) ToCanonicalString() string

+ func (section *IPv4AddressSection) ToCanonicalWildcardString() string

+ func (section *IPv4AddressSection) ToCompressedString() string

+ func (section *IPv4AddressSection) ToCompressedWildcardString() string

+ func (section *IPv4AddressSection) ToDivGrouping() *AddressDivisionGrouping

+ func (section *IPv4AddressSection) ToFullString() string

+ func (section *IPv4AddressSection) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ToIP() *IPAddressSection

+ func (section *IPv4AddressSection) ToInetAtonJoinedString(radix Inet_aton_radix, joinedCount int) (string, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ToInetAtonString(radix Inet_aton_radix) string

+ func (section *IPv4AddressSection) ToJoinedSegments(joinCount int) (AddressDivisionSeries, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ToMaxHost() (*IPv4AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ToMaxHostLen(prefixLength BitCount) (*IPv4AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ToNormalizedJoinedString(stringParams addrstr.IPStringOptions, joinedCount int) (string, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ToNormalizedString() string

+ func (section *IPv4AddressSection) ToNormalizedWildcardString() string

+ func (section *IPv4AddressSection) ToOctalString(with0Prefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ToPrefixBlock() *IPv4AddressSection

+ func (section *IPv4AddressSection) ToPrefixBlockLen(prefLen BitCount) *IPv4AddressSection

+ func (section *IPv4AddressSection) ToPrefixLenString() string

+ func (section *IPv4AddressSection) ToReverseDNSString() (string, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ToSQLWildcardString() string

+ func (section *IPv4AddressSection) ToSectionBase() *AddressSection

+ func (section *IPv4AddressSection) ToSegmentedBinaryString() string

+ func (section *IPv4AddressSection) ToSubnetString() string

+ func (section *IPv4AddressSection) ToZeroHost() (*IPv4AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ToZeroHostLen(prefixLength BitCount) (*IPv4AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv4AddressSection) ToZeroNetwork() *IPv4AddressSection

+ func (section *IPv4AddressSection) Uint32Value() uint32

+ func (section *IPv4AddressSection) UpperBytes() []byte

+ func (section *IPv4AddressSection) UpperUint32Value() uint32

+ func (section *IPv4AddressSection) WithoutPrefixLen() *IPv4AddressSection

+ func (section *IPv4AddressSection) Wrap() WrappedIPAddressSection

+ type IPv4AddressSegment struct

+ func NewIPv4PrefixedSegment(val IPv4SegInt, prefixLen PrefixLen) *IPv4AddressSegment

+ func NewIPv4RangePrefixedSegment(val, upperVal IPv4SegInt, prefixLen PrefixLen) *IPv4AddressSegment

+ func NewIPv4RangeSegment(val, upperVal IPv4SegInt) *IPv4AddressSegment

+ func NewIPv4Segment(val IPv4SegInt) *IPv4AddressSegment

+ func (seg *IPv4AddressSegment) Bytes() []byte

+ func (seg *IPv4AddressSegment) Compare(item AddressItem) int

+ func (seg *IPv4AddressSegment) Contains(other AddressSegmentType) bool

+ func (seg *IPv4AddressSegment) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (seg *IPv4AddressSegment) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (seg *IPv4AddressSegment) CopyBytes(bytes []byte) []byte

+ func (seg *IPv4AddressSegment) CopyUpperBytes(bytes []byte) []byte

+ func (seg *IPv4AddressSegment) Equal(other AddressSegmentType) bool

+ func (seg *IPv4AddressSegment) GetBitCount() BitCount

+ func (seg *IPv4AddressSegment) GetBlockMaskPrefixLen(network bool) PrefixLen

+ func (seg *IPv4AddressSegment) GetByteCount() int

+ func (seg *IPv4AddressSegment) GetCount() *big.Int

+ func (seg *IPv4AddressSegment) GetIPv4SegmentValue() IPv4SegInt

+ func (seg *IPv4AddressSegment) GetIPv4UpperSegmentValue() IPv4SegInt

+ func (seg *IPv4AddressSegment) GetLeadingBitCount(ones bool) BitCount

+ func (seg *IPv4AddressSegment) GetLower() *IPv4AddressSegment

+ func (seg *IPv4AddressSegment) GetMaxValue() IPv4SegInt

+ func (seg *IPv4AddressSegment) GetMinPrefixLenForBlock() BitCount

+ func (seg *IPv4AddressSegment) GetPrefixCountLen(segmentPrefixLength BitCount) *big.Int

+ func (seg *IPv4AddressSegment) GetPrefixLenForSingleBlock() PrefixLen

+ func (seg *IPv4AddressSegment) GetPrefixValueCount() SegIntCount

+ func (seg *IPv4AddressSegment) GetPrefixValueCountLen(segmentPrefixLength BitCount) SegIntCount

+ func (seg *IPv4AddressSegment) GetSegmentHostMask(networkBits BitCount) SegInt

+ func (seg *IPv4AddressSegment) GetSegmentNetworkMask(networkBits BitCount) SegInt

+ func (seg *IPv4AddressSegment) GetSegmentPrefixLen() PrefixLen

+ func (seg *IPv4AddressSegment) GetSegmentValue() SegInt

+ func (seg *IPv4AddressSegment) GetString() string

+ func (seg *IPv4AddressSegment) GetTrailingBitCount(ones bool) BitCount

+ func (seg *IPv4AddressSegment) GetUpper() *IPv4AddressSegment

+ func (seg *IPv4AddressSegment) GetUpperSegmentValue() SegInt

+ func (seg *IPv4AddressSegment) GetUpperValue() *BigDivInt

+ func (seg *IPv4AddressSegment) GetValue() *BigDivInt

+ func (seg *IPv4AddressSegment) GetValueCount() SegIntCount

+ func (seg *IPv4AddressSegment) GetWildcardString() string

+ func (seg *IPv4AddressSegment) IncludesMax() bool

+ func (seg *IPv4AddressSegment) IncludesZero() bool

+ func (seg *IPv4AddressSegment) IsFullRange() bool

+ func (seg *IPv4AddressSegment) IsMax() bool

+ func (seg *IPv4AddressSegment) IsMultiple() bool

+ func (seg *IPv4AddressSegment) IsOneBit(segmentBitIndex BitCount) bool

+ func (seg *IPv4AddressSegment) IsPrefixBlock() bool

+ func (seg *IPv4AddressSegment) IsPrefixed() bool

+ func (seg *IPv4AddressSegment) IsSinglePrefix(divisionPrefixLength BitCount) bool

+ func (seg *IPv4AddressSegment) IsSinglePrefixBlock() bool

+ func (seg *IPv4AddressSegment) IsZero() bool

+ func (seg *IPv4AddressSegment) Iterator() IPv4SegmentIterator

+ func (seg *IPv4AddressSegment) Join(low *IPv4AddressSegment) (*IPv6AddressSegment, addrerr.IncompatibleAddressError)

+ func (seg *IPv4AddressSegment) Matches(value SegInt) bool

+ func (seg *IPv4AddressSegment) MatchesValsWithMask(lowerValue, upperValue, mask SegInt) bool

+ func (seg *IPv4AddressSegment) MatchesWithMask(value, mask SegInt) bool

+ func (seg *IPv4AddressSegment) MatchesWithPrefixMask(value IPv4SegInt, networkBits BitCount) bool

+ func (seg *IPv4AddressSegment) PrefixBlockIterator() IPv4SegmentIterator

+ func (seg *IPv4AddressSegment) PrefixContains(other AddressSegmentType, prefixLength BitCount) bool

+ func (seg *IPv4AddressSegment) PrefixEqual(other AddressSegmentType, prefixLength BitCount) bool

+ func (seg *IPv4AddressSegment) PrefixIterator() IPv4SegmentIterator

+ func (seg *IPv4AddressSegment) PrefixedBlockIterator(segmentPrefixLen BitCount) IPv4SegmentIterator

+ func (seg *IPv4AddressSegment) ReverseBits(_ bool) (res *IPv4AddressSegment, err addrerr.IncompatibleAddressError)

+ func (seg *IPv4AddressSegment) ReverseBytes() (*IPv4AddressSegment, addrerr.IncompatibleAddressError)

+ func (seg *IPv4AddressSegment) String() string

+ func (seg *IPv4AddressSegment) TestBit(n BitCount) bool

+ func (seg *IPv4AddressSegment) ToDiv() *AddressDivision

+ func (seg *IPv4AddressSegment) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (seg *IPv4AddressSegment) ToHostSegment(segmentPrefixLength PrefixLen) *IPv4AddressSegment

+ func (seg *IPv4AddressSegment) ToIP() *IPAddressSegment

+ func (seg *IPv4AddressSegment) ToNetworkSegment(segmentPrefixLength PrefixLen) *IPv4AddressSegment

+ func (seg *IPv4AddressSegment) ToNormalizedString() string

+ func (seg *IPv4AddressSegment) ToPrefixedHostSegment(segmentPrefixLength PrefixLen) *IPv4AddressSegment

+ func (seg *IPv4AddressSegment) ToPrefixedNetworkSegment(segmentPrefixLength PrefixLen) *IPv4AddressSegment

+ func (seg *IPv4AddressSegment) ToSegmentBase() *AddressSegment

+ func (seg *IPv4AddressSegment) UpperBytes() []byte

+ func (seg *IPv4AddressSegment) WithoutPrefixLen() *IPv4AddressSegment

+ type IPv4AddressSegmentSeries interface

+ CopySegments func(segs []*IPv4AddressSegment) (count int)

+ CopySubSegments func(start, end int, segs []*IPv4AddressSegment) (count int)

+ GetHostSection func() *IPv4AddressSection

+ GetHostSectionLen func(BitCount) *IPv4AddressSection

+ GetNetworkSection func() *IPv4AddressSection

+ GetNetworkSectionLen func(BitCount) *IPv4AddressSection

+ GetSegment func(index int) *IPv4AddressSegment

+ GetSegments func() []*IPv4AddressSegment

+ GetSubSection func(index, endIndex int) *IPv4AddressSection

+ GetTrailingSection func(index int) *IPv4AddressSection

+ type IPv4AddressSeqRange struct

+ func NewIPv4SeqRange(one, two *IPv4Address) *IPv4AddressSeqRange

+ func (rng *IPv4AddressSeqRange) Bytes() []byte

+ func (rng *IPv4AddressSeqRange) Compare(item AddressItem) int

+ func (rng *IPv4AddressSeqRange) CompareSize(other IPAddressSeqRangeType) int

+ func (rng *IPv4AddressSeqRange) Contains(other IPAddressType) bool

+ func (rng *IPv4AddressSeqRange) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (rng *IPv4AddressSeqRange) ContainsRange(other IPAddressSeqRangeType) bool

+ func (rng *IPv4AddressSeqRange) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (rng *IPv4AddressSeqRange) CopyBytes(bytes []byte) []byte

+ func (rng *IPv4AddressSeqRange) CopyNetIP(bytes net.IP) net.IP

+ func (rng *IPv4AddressSeqRange) CopyUpperBytes(bytes []byte) []byte

+ func (rng *IPv4AddressSeqRange) CopyUpperNetIP(bytes net.IP) net.IP

+ func (rng *IPv4AddressSeqRange) CoverWithPrefixBlock() *IPv4Address

+ func (rng *IPv4AddressSeqRange) Equal(other IPAddressSeqRangeType) bool

+ func (rng *IPv4AddressSeqRange) Extend(other *IPv4AddressSeqRange) *IPv4AddressSeqRange

+ func (rng *IPv4AddressSeqRange) GetBitCount() BitCount

+ func (rng *IPv4AddressSeqRange) GetByteCount() int

+ func (rng *IPv4AddressSeqRange) GetCount() *big.Int

+ func (rng *IPv4AddressSeqRange) GetIPv4Count() uint64

+ func (rng *IPv4AddressSeqRange) GetIPv4PrefixCount(prefixLength BitCount) uint64

+ func (rng *IPv4AddressSeqRange) GetLower() *IPv4Address

+ func (rng *IPv4AddressSeqRange) GetLowerIPAddress() *IPAddress

+ func (rng *IPv4AddressSeqRange) GetMinPrefixLenForBlock() BitCount

+ func (rng *IPv4AddressSeqRange) GetNetIP() net.IP

+ func (rng *IPv4AddressSeqRange) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (rng *IPv4AddressSeqRange) GetPrefixLenForSingleBlock() PrefixLen

+ func (rng *IPv4AddressSeqRange) GetUpper() *IPv4Address

+ func (rng *IPv4AddressSeqRange) GetUpperIPAddress() *IPAddress

+ func (rng *IPv4AddressSeqRange) GetUpperNetIP() net.IP

+ func (rng *IPv4AddressSeqRange) GetUpperValue() *big.Int

+ func (rng *IPv4AddressSeqRange) GetValue() *big.Int

+ func (rng *IPv4AddressSeqRange) IncludesMax() bool

+ func (rng *IPv4AddressSeqRange) IncludesZero() bool

+ func (rng *IPv4AddressSeqRange) Intersect(other *IPv4AddressSeqRange) *IPAddressSeqRange

+ func (rng *IPv4AddressSeqRange) IsFullRange() bool

+ func (rng *IPv4AddressSeqRange) IsMax() bool

+ func (rng *IPv4AddressSeqRange) IsMultiple() bool

+ func (rng *IPv4AddressSeqRange) IsSequential() bool

+ func (rng *IPv4AddressSeqRange) IsZero() bool

+ func (rng *IPv4AddressSeqRange) Iterator() IPv4AddressIterator

+ func (rng *IPv4AddressSeqRange) Join(ranges ...*IPv4AddressSeqRange) []*IPv4AddressSeqRange

+ func (rng *IPv4AddressSeqRange) JoinTo(other *IPv4AddressSeqRange) *IPv4AddressSeqRange

+ func (rng *IPv4AddressSeqRange) Overlaps(other *IPv4AddressSeqRange) bool

+ func (rng *IPv4AddressSeqRange) PrefixBlockIterator(prefLength BitCount) IPv4AddressIterator

+ func (rng *IPv4AddressSeqRange) PrefixIterator(prefLength BitCount) IPv4AddressSeqRangeIterator

+ func (rng *IPv4AddressSeqRange) SpanWithPrefixBlocks() []*IPv4Address

+ func (rng *IPv4AddressSeqRange) SpanWithSequentialBlocks() []*IPv4Address

+ func (rng *IPv4AddressSeqRange) String() string

+ func (rng *IPv4AddressSeqRange) Subtract(other *IPv4AddressSeqRange) []*IPv4AddressSeqRange

+ func (rng *IPv4AddressSeqRange) ToCanonicalString() string

+ func (rng *IPv4AddressSeqRange) ToIP() *IPAddressSeqRange

+ func (rng *IPv4AddressSeqRange) ToNormalizedString() string

+ func (rng *IPv4AddressSeqRange) ToString(lowerStringer func(*IPv4Address) string, separator string, ...) string

+ func (rng *IPv4AddressSeqRange) UpperBytes() []byte

+ func (rng IPv4AddressSeqRange) Format(state fmt.State, verb rune)

+ type IPv4AddressSeqRangeIterator interface

+ Next func() *IPv4AddressSeqRange

+ type IPv4Partition struct

+ func PartitionIPv4WithSingleBlockSize(newAddr *IPv4Address) IPv4Partition

+ func PartitionIpv4WithSpanningBlocks(newAddr *IPv4Address) IPv4Partition

+ func (p IPv4Partition) ForEach(action func(*IPv4Address))

+ func (p IPv4Partition) Iterator() IPv4AddressIterator

+ func (p IPv4Partition) PredicateForAny(predicate func(*IPv4Address) bool) bool

+ func (p IPv4Partition) PredicateForAnyEarly(predicate func(*IPv4Address) bool) bool

+ func (p IPv4Partition) PredicateForEach(predicate func(*IPv4Address) bool) bool

+ func (p IPv4Partition) PredicateForEachEarly(predicate func(*IPv4Address) bool) bool

+ type IPv4SectionIterator interface

+ Next func() *IPv4AddressSection

+ type IPv4SegInt = uint8

+ type IPv4SegmentIterator interface

+ Next func() *IPv4AddressSegment

+ type IPv4SegmentValueProvider func(segmentIndex int) IPv4SegInt

+ func WrappedSegmentValueProviderForIPv4(f SegmentValueProvider) IPv4SegmentValueProvider

+ type IPv6Address struct

+ func NewIPv6Address(section *IPv6AddressSection) (*IPv6Address, addrerr.AddressValueError)

+ func NewIPv6AddressFromBytes(bytes []byte) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromInt(val *big.Int) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromMAC(prefix *IPv6Address, suffix *MACAddress) (*IPv6Address, addrerr.IncompatibleAddressError)

+ func NewIPv6AddressFromMACSection(prefix *IPv6AddressSection, suffix *MACAddressSection) (*IPv6Address, addrerr.AddressError)

+ func NewIPv6AddressFromPrefixedBytes(bytes []byte, prefixLength PrefixLen) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromPrefixedInt(val *big.Int, prefixLength PrefixLen) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromPrefixedRange(vals, upperVals IPv6SegmentValueProvider, prefixLength PrefixLen) *IPv6Address

+ func NewIPv6AddressFromPrefixedSegs(segments []*IPv6AddressSegment, prefixLength PrefixLen) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromPrefixedUint64(highBytes, lowBytes uint64, prefixLength PrefixLen) *IPv6Address

+ func NewIPv6AddressFromPrefixedVals(vals IPv6SegmentValueProvider, prefixLength PrefixLen) *IPv6Address

+ func NewIPv6AddressFromPrefixedZonedBytes(bytes []byte, prefixLength PrefixLen, zone string) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromPrefixedZonedInt(val *big.Int, prefixLength PrefixLen, zone string) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromPrefixedZonedRange(vals, upperVals IPv6SegmentValueProvider, prefixLength PrefixLen, zone string) *IPv6Address

+ func NewIPv6AddressFromPrefixedZonedSegs(segments []*IPv6AddressSegment, prefixLength PrefixLen, zone string) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromPrefixedZonedUint64(highBytes, lowBytes uint64, prefixLength PrefixLen, zone string) *IPv6Address

+ func NewIPv6AddressFromRange(vals, upperVals IPv6SegmentValueProvider) *IPv6Address

+ func NewIPv6AddressFromSegs(segments []*IPv6AddressSegment) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromUint64(highBytes, lowBytes uint64) *IPv6Address

+ func NewIPv6AddressFromVals(vals IPv6SegmentValueProvider) *IPv6Address

+ func NewIPv6AddressFromZonedBytes(bytes []byte, zone string) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromZonedInt(val *big.Int, zone string) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromZonedMAC(prefix *IPv6AddressSection, suffix *MACAddressSection, zone string) (*IPv6Address, addrerr.AddressError)

+ func NewIPv6AddressFromZonedRange(vals, upperVals IPv6SegmentValueProvider, zone string) *IPv6Address

+ func NewIPv6AddressFromZonedSegs(segments []*IPv6AddressSegment, zone string) (addr *IPv6Address, err addrerr.AddressValueError)

+ func NewIPv6AddressFromZonedUint64(highBytes, lowBytes uint64, zone string) *IPv6Address

+ func NewIPv6AddressZoned(section *IPv6AddressSection, zone string) (*IPv6Address, addrerr.AddressValueError)

+ func (addr *IPv6Address) AdjustPrefixLen(prefixLen BitCount) *IPv6Address

+ func (addr *IPv6Address) AdjustPrefixLenZeroed(prefixLen BitCount) (*IPv6Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) AssignMinPrefixForBlock() *IPv6Address

+ func (addr *IPv6Address) AssignPrefixForSingleBlock() *IPv6Address

+ func (addr *IPv6Address) BitwiseOr(other *IPv6Address) (masked *IPv6Address, err addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) BlockIterator(segmentCount int) IPv6AddressIterator

+ func (addr *IPv6Address) Bytes() []byte

+ func (addr *IPv6Address) Compare(item AddressItem) int

+ func (addr *IPv6Address) CompareSize(other AddressType) int

+ func (addr *IPv6Address) Contains(other AddressType) bool

+ func (addr *IPv6Address) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (addr *IPv6Address) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (addr *IPv6Address) CopyBytes(bytes []byte) []byte

+ func (addr *IPv6Address) CopyNetIP(bytes net.IP) net.IP

+ func (addr *IPv6Address) CopySegments(segs []*IPv6AddressSegment) (count int)

+ func (addr *IPv6Address) CopySubSegments(start, end int, segs []*IPv6AddressSegment) (count int)

+ func (addr *IPv6Address) CopyUpperBytes(bytes []byte) []byte

+ func (addr *IPv6Address) CopyUpperNetIP(bytes net.IP) net.IP

+ func (addr *IPv6Address) CoverWithPrefixBlock() *IPv6Address

+ func (addr *IPv6Address) CoverWithPrefixBlockTo(other *IPv6Address) *IPv6Address

+ func (addr *IPv6Address) Equal(other AddressType) bool

+ func (addr *IPv6Address) Get6To4IPv4Address() (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) GetBitCount() BitCount

+ func (addr *IPv6Address) GetBitsPerSegment() BitCount

+ func (addr *IPv6Address) GetBlockCount(segmentCount int) *big.Int

+ func (addr *IPv6Address) GetBlockMaskPrefixLen(network bool) PrefixLen

+ func (addr *IPv6Address) GetByteCount() int

+ func (addr *IPv6Address) GetBytesPerSegment() int

+ func (addr *IPv6Address) GetCount() *big.Int

+ func (addr *IPv6Address) GetDivisionCount() int

+ func (addr *IPv6Address) GetEmbeddedIPv4Address() (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) GetEmbeddedIPv4AddressAt(byteIndex int) (*IPv4Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) GetEmbeddedIPv4AddressSection() (*IPv4AddressSection, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) GetGenericDivision(index int) DivisionType

+ func (addr *IPv6Address) GetGenericSegment(index int) AddressSegmentType

+ func (addr *IPv6Address) GetHostMask() *IPv6Address

+ func (addr *IPv6Address) GetHostSection() *IPv6AddressSection

+ func (addr *IPv6Address) GetHostSectionLen(prefLen BitCount) *IPv6AddressSection

+ func (addr *IPv6Address) GetIPVersion() IPVersion

+ func (addr *IPv6Address) GetIPv4AddressSection(startIndex, endIndex int) (*IPv4AddressSection, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) GetIPv6Address(embedded IPv4Address) (*IPv6Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) GetLeadingBitCount(ones bool) BitCount

+ func (addr *IPv6Address) GetLower() *IPv6Address

+ func (addr *IPv6Address) GetLowerIPAddress() *IPAddress

+ func (addr *IPv6Address) GetMaxSegmentValue() SegInt

+ func (addr *IPv6Address) GetMinPrefixLenForBlock() BitCount

+ func (addr *IPv6Address) GetMixedAddressGrouping() (*IPv6v4MixedAddressGrouping, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) GetNetIP() net.IP

+ func (addr *IPv6Address) GetNetIPAddr() net.IPAddr

+ func (addr *IPv6Address) GetNetwork() IPAddressNetwork

+ func (addr *IPv6Address) GetNetworkMask() *IPv6Address

+ func (addr *IPv6Address) GetNetworkPrefixLen() PrefixLen

+ func (addr *IPv6Address) GetNetworkSection() *IPv6AddressSection

+ func (addr *IPv6Address) GetNetworkSectionLen(prefLen BitCount) *IPv6AddressSection

+ func (addr *IPv6Address) GetPrefixCount() *big.Int

+ func (addr *IPv6Address) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (addr *IPv6Address) GetPrefixLen() PrefixLen

+ func (addr *IPv6Address) GetPrefixLenForSingleBlock() PrefixLen

+ func (addr *IPv6Address) GetSection() *IPv6AddressSection

+ func (addr *IPv6Address) GetSegment(index int) *IPv6AddressSegment

+ func (addr *IPv6Address) GetSegmentCount() int

+ func (addr *IPv6Address) GetSegmentStrings() []string

+ func (addr *IPv6Address) GetSegments() []*IPv6AddressSegment

+ func (addr *IPv6Address) GetSequentialBlockCount() *big.Int

+ func (addr *IPv6Address) GetSequentialBlockIndex() int

+ func (addr *IPv6Address) GetSubSection(index, endIndex int) *IPv6AddressSection

+ func (addr *IPv6Address) GetTrailingBitCount(ones bool) BitCount

+ func (addr *IPv6Address) GetTrailingSection(index int) *IPv6AddressSection

+ func (addr *IPv6Address) GetUpper() *IPv6Address

+ func (addr *IPv6Address) GetUpperIPAddress() *IPAddress

+ func (addr *IPv6Address) GetUpperNetIP() net.IP

+ func (addr *IPv6Address) GetUpperValue() *big.Int

+ func (addr *IPv6Address) GetValue() *big.Int

+ func (addr *IPv6Address) GetZone() Zone

+ func (addr *IPv6Address) HasZone() bool

+ func (addr *IPv6Address) IncludesMax() bool

+ func (addr *IPv6Address) IncludesMaxHost() bool

+ func (addr *IPv6Address) IncludesMaxHostLen(networkPrefixLength BitCount) bool

+ func (addr *IPv6Address) IncludesZeroHost() bool

+ func (addr *IPv6Address) IncludesZeroHostLen(networkPrefixLength BitCount) bool

+ func (addr *IPv6Address) Increment(increment int64) *IPv6Address

+ func (addr *IPv6Address) IncrementBoundary(increment int64) *IPv6Address

+ func (addr *IPv6Address) Intersect(other *IPv6Address) *IPv6Address

+ func (addr *IPv6Address) Is6Over4() bool

+ func (addr *IPv6Address) Is6To4() bool

+ func (addr *IPv6Address) IsAnyLocal() bool

+ func (addr *IPv6Address) IsEUI64() bool

+ func (addr *IPv6Address) IsIPv4Compatible() bool

+ func (addr *IPv6Address) IsIPv4Mapped() bool

+ func (addr *IPv6Address) IsIPv4Translatable() bool

+ func (addr *IPv6Address) IsIsatap() bool

+ func (addr *IPv6Address) IsLinkLocal() bool

+ func (addr *IPv6Address) IsLocal() bool

+ func (addr *IPv6Address) IsLoopback() bool

+ func (addr *IPv6Address) IsMax() bool

+ func (addr *IPv6Address) IsMaxHost() bool

+ func (addr *IPv6Address) IsMaxHostLen(prefLen BitCount) bool

+ func (addr *IPv6Address) IsMulticast() bool

+ func (addr *IPv6Address) IsMultiple() bool

+ func (addr *IPv6Address) IsOneBit(bitIndex BitCount) bool

+ func (addr *IPv6Address) IsPrefixBlock() bool

+ func (addr *IPv6Address) IsPrefixed() bool

+ func (addr *IPv6Address) IsSingleNetwork() bool

+ func (addr *IPv6Address) IsSinglePrefixBlock() bool

+ func (addr *IPv6Address) IsSiteLocal() bool

+ func (addr *IPv6Address) IsTeredo() bool

+ func (addr *IPv6Address) IsUniqueLocal() bool

+ func (addr *IPv6Address) IsUnspecified() bool

+ func (addr *IPv6Address) IsWellKnownIPv4Translatable() bool

+ func (addr *IPv6Address) IsZeroHost() bool

+ func (addr *IPv6Address) IsZeroHostLen(prefLen BitCount) bool

+ func (addr *IPv6Address) Iterator() IPv6AddressIterator

+ func (addr *IPv6Address) Mask(other *IPv6Address) (masked *IPv6Address, err addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) MatchesWithMask(other *IPv6Address, mask *IPv6Address) bool

+ func (addr *IPv6Address) MergeToPrefixBlocks(addrs ...*IPv6Address) []*IPv6Address

+ func (addr *IPv6Address) MergeToSequentialBlocks(addrs ...*IPv6Address) []*IPv6Address

+ func (addr *IPv6Address) PrefixBlockIterator() IPv6AddressIterator

+ func (addr *IPv6Address) PrefixContains(other AddressType) bool

+ func (addr *IPv6Address) PrefixEqual(other AddressType) bool

+ func (addr *IPv6Address) PrefixIterator() IPv6AddressIterator

+ func (addr *IPv6Address) Replace(startIndex int, replacement *IPv6AddressSection) *IPv6Address

+ func (addr *IPv6Address) ReplaceLen(startIndex, endIndex int, replacement *IPv6Address, replacementIndex int) *IPv6Address

+ func (addr *IPv6Address) ReverseBits(perByte bool) (*IPv6Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ReverseBytes() (*IPv6Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ReverseSegments() *IPv6Address

+ func (addr *IPv6Address) SequentialBlockIterator() IPv6AddressIterator

+ func (addr *IPv6Address) SetPrefixLen(prefixLen BitCount) *IPv6Address

+ func (addr *IPv6Address) SetPrefixLenZeroed(prefixLen BitCount) (*IPv6Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) SetZone(zone string) *IPv6Address

+ func (addr *IPv6Address) SpanWithPrefixBlocks() []*IPv6Address

+ func (addr *IPv6Address) SpanWithPrefixBlocksTo(other *IPv6Address) []*IPv6Address

+ func (addr *IPv6Address) SpanWithRange(other *IPv6Address) *IPv6AddressSeqRange

+ func (addr *IPv6Address) SpanWithSequentialBlocks() []*IPv6Address

+ func (addr *IPv6Address) SpanWithSequentialBlocksTo(other *IPv6Address) []*IPv6Address

+ func (addr *IPv6Address) String() string

+ func (addr *IPv6Address) Subtract(other *IPv6Address) []*IPv6Address

+ func (addr *IPv6Address) TestBit(n BitCount) bool

+ func (addr *IPv6Address) ToAddressBase() *Address

+ func (addr *IPv6Address) ToAddressString() *IPAddressString

+ func (addr *IPv6Address) ToBinaryString(with0bPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToBlock(segmentIndex int, lower, upper SegInt) *IPv6Address

+ func (addr *IPv6Address) ToCanonicalString() string

+ func (addr *IPv6Address) ToCanonicalWildcardString() string

+ func (addr *IPv6Address) ToCompressedString() string

+ func (addr *IPv6Address) ToCompressedWildcardString() string

+ func (addr *IPv6Address) ToCustomString(stringOptions addrstr.IPv6StringOptions) (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToEUI(extended bool) (*MACAddress, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToFullString() string

+ func (addr *IPv6Address) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToIP() *IPAddress

+ func (addr *IPv6Address) ToMaxHost() (*IPv6Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToMaxHostLen(prefixLength BitCount) (*IPv6Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToMixedString() (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToNormalizedString() string

+ func (addr *IPv6Address) ToNormalizedWildcardString() string

+ func (addr *IPv6Address) ToOctalString(with0Prefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToPrefixBlock() *IPv6Address

+ func (addr *IPv6Address) ToPrefixBlockLen(prefLen BitCount) *IPv6Address

+ func (addr *IPv6Address) ToPrefixLenString() string

+ func (addr *IPv6Address) ToReverseDNSString() (string, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToSQLWildcardString() string

+ func (addr *IPv6Address) ToSegmentedBinaryString() string

+ func (addr *IPv6Address) ToSequentialRange() *IPv6AddressSeqRange

+ func (addr *IPv6Address) ToSubnetString() string

+ func (addr *IPv6Address) ToZeroHost() (*IPv6Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToZeroHostLen(prefixLength BitCount) (*IPv6Address, addrerr.IncompatibleAddressError)

+ func (addr *IPv6Address) ToZeroNetwork() *IPv6Address

+ func (addr *IPv6Address) UpperBytes() []byte

+ func (addr *IPv6Address) WithoutPrefixLen() *IPv6Address

+ func (addr *IPv6Address) WithoutZone() *IPv6Address

+ func (addr *IPv6Address) Wrap() WrappedIPAddress

+ func (addr IPv6Address) Format(state fmt.State, verb rune)

+ type IPv6AddressConverter interface

+ ToIPv6 func(address *IPAddress) *IPv6Address

+ type IPv6AddressIterator interface

+ Next func() *IPv6Address

+ type IPv6AddressNetwork struct

+ func (network IPv6AddressNetwork) GetHostMask(prefLen BitCount) *IPv6Address

+ func (network IPv6AddressNetwork) GetLoopback() *IPv6Address

+ func (network IPv6AddressNetwork) GetNetworkMask(prefLen BitCount) *IPv6Address

+ func (network IPv6AddressNetwork) GetPrefixedHostMask(prefLen BitCount) *IPv6Address

+ func (network IPv6AddressNetwork) GetPrefixedNetworkMask(prefLen BitCount) *IPv6Address

+ type IPv6AddressSection struct

+ func NewIPv6PrefixedSection(segments []*IPv6AddressSegment, prefixLen PrefixLen) *IPv6AddressSection

+ func NewIPv6Section(segments []*IPv6AddressSegment) *IPv6AddressSection

+ func NewIPv6SectionFromBigInt(val *big.Int, segmentCount int) (res *IPv6AddressSection, err addrerr.AddressValueError)

+ func NewIPv6SectionFromBytes(bytes []byte) (res *IPv6AddressSection, err addrerr.AddressValueError)

+ func NewIPv6SectionFromMAC(eui *MACAddress) (res *IPv6AddressSection, err addrerr.IncompatibleAddressError)

+ func NewIPv6SectionFromPrefixedBigInt(val *big.Int, segmentCount int, prefixLen PrefixLen) (res *IPv6AddressSection, err addrerr.AddressValueError)

+ func NewIPv6SectionFromPrefixedBytes(bytes []byte, segmentCount int, prefixLength PrefixLen) (res *IPv6AddressSection, err addrerr.AddressValueError)

+ func NewIPv6SectionFromPrefixedRangeVals(vals, upperVals IPv6SegmentValueProvider, segmentCount int, ...) (res *IPv6AddressSection)

+ func NewIPv6SectionFromPrefixedUint64(highBytes, lowBytes uint64, segmentCount int, prefixLength PrefixLen) (res *IPv6AddressSection)

+ func NewIPv6SectionFromPrefixedVals(vals IPv6SegmentValueProvider, segmentCount int, prefixLength PrefixLen) (res *IPv6AddressSection)

+ func NewIPv6SectionFromRangeVals(vals, upperVals IPv6SegmentValueProvider, segmentCount int) (res *IPv6AddressSection)

+ func NewIPv6SectionFromSegmentedBytes(bytes []byte, segmentCount int) (res *IPv6AddressSection, err addrerr.AddressValueError)

+ func NewIPv6SectionFromUint64(highBytes, lowBytes uint64, segmentCount int) (res *IPv6AddressSection)

+ func NewIPv6SectionFromVals(vals IPv6SegmentValueProvider, segmentCount int) (res *IPv6AddressSection)

+ func (section *IPv6AddressSection) AdjustPrefixLen(prefixLen BitCount) *IPv6AddressSection

+ func (section *IPv6AddressSection) AdjustPrefixLenZeroed(prefixLen BitCount) (*IPv6AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) Append(other *IPv6AddressSection) *IPv6AddressSection

+ func (section *IPv6AddressSection) AssignMinPrefixForBlock() *IPv6AddressSection

+ func (section *IPv6AddressSection) AssignPrefixForSingleBlock() *IPv6AddressSection

+ func (section *IPv6AddressSection) BitwiseOr(other *IPv6AddressSection) (res *IPv6AddressSection, err addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) BlockIterator(segmentCount int) IPv6SectionIterator

+ func (section *IPv6AddressSection) Bytes() []byte

+ func (section *IPv6AddressSection) Compare(item AddressItem) int

+ func (section *IPv6AddressSection) CompareSize(other StandardDivGroupingType) int

+ func (section *IPv6AddressSection) Contains(other AddressSectionType) bool

+ func (section *IPv6AddressSection) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (section *IPv6AddressSection) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (section *IPv6AddressSection) CopyBytes(bytes []byte) []byte

+ func (section *IPv6AddressSection) CopySegments(segs []*IPv6AddressSegment) (count int)

+ func (section *IPv6AddressSection) CopySubSegments(start, end int, segs []*IPv6AddressSegment) (count int)

+ func (section *IPv6AddressSection) CopyUpperBytes(bytes []byte) []byte

+ func (section *IPv6AddressSection) CoverWithPrefixBlock() *IPv6AddressSection

+ func (section *IPv6AddressSection) CoverWithPrefixBlockTo(other *IPv6AddressSection) (*IPv6AddressSection, addrerr.SizeMismatchError)

+ func (section *IPv6AddressSection) Equal(other AddressSectionType) bool

+ func (section *IPv6AddressSection) GetBitCount() BitCount

+ func (section *IPv6AddressSection) GetBitsPerSegment() BitCount

+ func (section *IPv6AddressSection) GetBlockCount(segmentCount int) *big.Int

+ func (section *IPv6AddressSection) GetBlockMaskPrefixLen(network bool) PrefixLen

+ func (section *IPv6AddressSection) GetByteCount() int

+ func (section *IPv6AddressSection) GetBytesPerSegment() int

+ func (section *IPv6AddressSection) GetCount() *big.Int

+ func (section *IPv6AddressSection) GetGenericSegment(index int) AddressSegmentType

+ func (section *IPv6AddressSection) GetHostMask() *IPv6AddressSection

+ func (section *IPv6AddressSection) GetHostSection() *IPv6AddressSection

+ func (section *IPv6AddressSection) GetHostSectionLen(prefLen BitCount) *IPv6AddressSection

+ func (section *IPv6AddressSection) GetIPVersion() IPVersion

+ func (section *IPv6AddressSection) GetIPv4AddressSection(startByteIndex, endByteIndex int) (*IPv4AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) GetLeadingBitCount(ones bool) BitCount

+ func (section *IPv6AddressSection) GetLower() *IPv6AddressSection

+ func (section *IPv6AddressSection) GetMaxSegmentValue() SegInt

+ func (section *IPv6AddressSection) GetMinPrefixLenForBlock() BitCount

+ func (section *IPv6AddressSection) GetNetworkMask() *IPv6AddressSection

+ func (section *IPv6AddressSection) GetNetworkPrefixLen() PrefixLen

+ func (section *IPv6AddressSection) GetNetworkSection() *IPv6AddressSection

+ func (section *IPv6AddressSection) GetNetworkSectionLen(prefLen BitCount) *IPv6AddressSection

+ func (section *IPv6AddressSection) GetPrefixCount() *big.Int

+ func (section *IPv6AddressSection) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (section *IPv6AddressSection) GetPrefixLenForSingleBlock() PrefixLen

+ func (section *IPv6AddressSection) GetSegment(index int) *IPv6AddressSegment

+ func (section *IPv6AddressSection) GetSegmentCount() int

+ func (section *IPv6AddressSection) GetSegmentStrings() []string

+ func (section *IPv6AddressSection) GetSegments() (res []*IPv6AddressSegment)

+ func (section *IPv6AddressSection) GetSequentialBlockCount() *big.Int

+ func (section *IPv6AddressSection) GetSequentialBlockIndex() int

+ func (section *IPv6AddressSection) GetSubSection(index, endIndex int) *IPv6AddressSection

+ func (section *IPv6AddressSection) GetTrailingBitCount(ones bool) BitCount

+ func (section *IPv6AddressSection) GetTrailingSection(index int) *IPv6AddressSection

+ func (section *IPv6AddressSection) GetUpper() *IPv6AddressSection

+ func (section *IPv6AddressSection) GetUpperValue() *big.Int

+ func (section *IPv6AddressSection) GetValue() *big.Int

+ func (section *IPv6AddressSection) GetZeroRangeSegments() RangeList

+ func (section *IPv6AddressSection) GetZeroSegments() RangeList

+ func (section *IPv6AddressSection) IncludesMax() bool

+ func (section *IPv6AddressSection) IncludesMaxHost() bool

+ func (section *IPv6AddressSection) IncludesMaxHostLen(networkPrefixLength BitCount) bool

+ func (section *IPv6AddressSection) IncludesZero() bool

+ func (section *IPv6AddressSection) IncludesZeroHost() bool

+ func (section *IPv6AddressSection) IncludesZeroHostLen(networkPrefixLength BitCount) bool

+ func (section *IPv6AddressSection) Increment(increment int64) *IPv6AddressSection

+ func (section *IPv6AddressSection) IncrementBoundary(increment int64) *IPv6AddressSection

+ func (section *IPv6AddressSection) Insert(index int, other *IPv6AddressSection) *IPv6AddressSection

+ func (section *IPv6AddressSection) Intersect(other *IPv6AddressSection) (res *IPv6AddressSection, err addrerr.SizeMismatchError)

+ func (section *IPv6AddressSection) IsAdaptiveZero() bool

+ func (section *IPv6AddressSection) IsFullRange() bool

+ func (section *IPv6AddressSection) IsMax() bool

+ func (section *IPv6AddressSection) IsMaxHost() bool

+ func (section *IPv6AddressSection) IsMaxHostLen(prefLen BitCount) bool

+ func (section *IPv6AddressSection) IsMultiple() bool

+ func (section *IPv6AddressSection) IsOneBit(prefixBitIndex BitCount) bool

+ func (section *IPv6AddressSection) IsPrefixBlock() bool

+ func (section *IPv6AddressSection) IsPrefixed() bool

+ func (section *IPv6AddressSection) IsSequential() bool

+ func (section *IPv6AddressSection) IsSingleNetwork() bool

+ func (section *IPv6AddressSection) IsSinglePrefixBlock() bool

+ func (section *IPv6AddressSection) IsZero() bool

+ func (section *IPv6AddressSection) IsZeroHost() bool

+ func (section *IPv6AddressSection) IsZeroHostLen(prefLen BitCount) bool

+ func (section *IPv6AddressSection) Iterator() IPv6SectionIterator

+ func (section *IPv6AddressSection) Mask(other *IPv6AddressSection) (res *IPv6AddressSection, err addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) MatchesWithMask(other *IPv6AddressSection, mask *IPv6AddressSection) bool

+ func (section *IPv6AddressSection) MergeToPrefixBlocks(sections ...*IPv6AddressSection) ([]*IPv6AddressSection, addrerr.SizeMismatchError)

+ func (section *IPv6AddressSection) MergeToSequentialBlocks(sections ...*IPv6AddressSection) ([]*IPv6AddressSection, addrerr.SizeMismatchError)

+ func (section *IPv6AddressSection) PrefixBlockIterator() IPv6SectionIterator

+ func (section *IPv6AddressSection) PrefixContains(other AddressSectionType) bool

+ func (section *IPv6AddressSection) PrefixEqual(other AddressSectionType) bool

+ func (section *IPv6AddressSection) PrefixIterator() IPv6SectionIterator

+ func (section *IPv6AddressSection) Replace(index int, replacement *IPv6AddressSection) *IPv6AddressSection

+ func (section *IPv6AddressSection) ReplaceLen(startIndex, endIndex int, replacement *IPv6AddressSection, ...) *IPv6AddressSection

+ func (section *IPv6AddressSection) ReverseBits(perByte bool) (*IPv6AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) ReverseBytes() (*IPv6AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) ReverseSegments() *IPv6AddressSection

+ func (section *IPv6AddressSection) SequentialBlockIterator() IPv6SectionIterator

+ func (section *IPv6AddressSection) SetPrefixLen(prefixLen BitCount) *IPv6AddressSection

+ func (section *IPv6AddressSection) SetPrefixLenZeroed(prefixLen BitCount) (*IPv6AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) SpanWithPrefixBlocks() []*IPv6AddressSection

+ func (section *IPv6AddressSection) SpanWithPrefixBlocksTo(other *IPv6AddressSection) ([]*IPv6AddressSection, addrerr.SizeMismatchError)

+ func (section *IPv6AddressSection) SpanWithSequentialBlocks() []*IPv6AddressSection

+ func (section *IPv6AddressSection) SpanWithSequentialBlocksTo(other *IPv6AddressSection) ([]*IPv6AddressSection, addrerr.SizeMismatchError)

+ func (section *IPv6AddressSection) String() string

+ func (section *IPv6AddressSection) Subtract(other *IPv6AddressSection) (res []*IPv6AddressSection, err addrerr.SizeMismatchError)

+ func (section *IPv6AddressSection) TestBit(n BitCount) bool

+ func (section *IPv6AddressSection) ToBinaryString(with0bPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) ToBlock(segmentIndex int, lower, upper SegInt) *IPv6AddressSection

+ func (section *IPv6AddressSection) ToCanonicalString() string

+ func (section *IPv6AddressSection) ToCanonicalWildcardString() string

+ func (section *IPv6AddressSection) ToCompressedString() string

+ func (section *IPv6AddressSection) ToCompressedWildcardString() string

+ func (section *IPv6AddressSection) ToCustomString(stringOptions addrstr.IPv6StringOptions) (string, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) ToDivGrouping() *AddressDivisionGrouping

+ func (section *IPv6AddressSection) ToFullString() string

+ func (section *IPv6AddressSection) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) ToIP() *IPAddressSection

+ func (section *IPv6AddressSection) ToMaxHost() (*IPv6AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) ToMaxHostLen(prefixLength BitCount) (*IPv6AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) ToNormalizedString() string

+ func (section *IPv6AddressSection) ToNormalizedWildcardString() string

+ func (section *IPv6AddressSection) ToOctalString(with0Prefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) ToPrefixBlock() *IPv6AddressSection

+ func (section *IPv6AddressSection) ToPrefixBlockLen(prefLen BitCount) *IPv6AddressSection

+ func (section *IPv6AddressSection) ToPrefixLenString() string

+ func (section *IPv6AddressSection) ToReverseDNSString() (string, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) ToSQLWildcardString() string

+ func (section *IPv6AddressSection) ToSectionBase() *AddressSection

+ func (section *IPv6AddressSection) ToSegmentedBinaryString() string

+ func (section *IPv6AddressSection) ToSubnetString() string

+ func (section *IPv6AddressSection) ToZeroHost() (*IPv6AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) ToZeroHostLen(prefixLength BitCount) (*IPv6AddressSection, addrerr.IncompatibleAddressError)

+ func (section *IPv6AddressSection) ToZeroNetwork() *IPv6AddressSection

+ func (section *IPv6AddressSection) UpperBytes() []byte

+ func (section *IPv6AddressSection) WithoutPrefixLen() *IPv6AddressSection

+ func (section *IPv6AddressSection) Wrap() WrappedIPAddressSection

+ type IPv6AddressSegment struct

+ func NewIPv6PrefixedSegment(val IPv6SegInt, prefixLen PrefixLen) *IPv6AddressSegment

+ func NewIPv6RangePrefixedSegment(val, upperVal IPv6SegInt, prefixLen PrefixLen) *IPv6AddressSegment

+ func NewIPv6RangeSegment(val, upperVal IPv6SegInt) *IPv6AddressSegment

+ func NewIPv6Segment(val IPv6SegInt) *IPv6AddressSegment

+ func (seg *IPv6AddressSegment) Bytes() []byte

+ func (seg *IPv6AddressSegment) Compare(item AddressItem) int

+ func (seg *IPv6AddressSegment) Contains(other AddressSegmentType) bool

+ func (seg *IPv6AddressSegment) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (seg *IPv6AddressSegment) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (seg *IPv6AddressSegment) CopyBytes(bytes []byte) []byte

+ func (seg *IPv6AddressSegment) CopyUpperBytes(bytes []byte) []byte

+ func (seg *IPv6AddressSegment) Equal(other AddressSegmentType) bool

+ func (seg *IPv6AddressSegment) GetBitCount() BitCount

+ func (seg *IPv6AddressSegment) GetBlockMaskPrefixLen(network bool) PrefixLen

+ func (seg *IPv6AddressSegment) GetByteCount() int

+ func (seg *IPv6AddressSegment) GetCount() *big.Int

+ func (seg *IPv6AddressSegment) GetIPv6SegmentValue() IPv6SegInt

+ func (seg *IPv6AddressSegment) GetIPv6UpperSegmentValue() IPv6SegInt

+ func (seg *IPv6AddressSegment) GetLeadingBitCount(ones bool) BitCount

+ func (seg *IPv6AddressSegment) GetLower() *IPv6AddressSegment

+ func (seg *IPv6AddressSegment) GetMaxValue() IPv6SegInt

+ func (seg *IPv6AddressSegment) GetMinPrefixLenForBlock() BitCount

+ func (seg *IPv6AddressSegment) GetPrefixCountLen(segmentPrefixLength BitCount) *big.Int

+ func (seg *IPv6AddressSegment) GetPrefixLenForSingleBlock() PrefixLen

+ func (seg *IPv6AddressSegment) GetPrefixValueCount() SegIntCount

+ func (seg *IPv6AddressSegment) GetPrefixValueCountLen(segmentPrefixLength BitCount) SegIntCount

+ func (seg *IPv6AddressSegment) GetSegmentHostMask(networkBits BitCount) SegInt

+ func (seg *IPv6AddressSegment) GetSegmentNetworkMask(networkBits BitCount) SegInt

+ func (seg *IPv6AddressSegment) GetSegmentPrefixLen() PrefixLen

+ func (seg *IPv6AddressSegment) GetSegmentValue() SegInt

+ func (seg *IPv6AddressSegment) GetString() string

+ func (seg *IPv6AddressSegment) GetTrailingBitCount(ones bool) BitCount

+ func (seg *IPv6AddressSegment) GetUpper() *IPv6AddressSegment

+ func (seg *IPv6AddressSegment) GetUpperSegmentValue() SegInt

+ func (seg *IPv6AddressSegment) GetUpperValue() *BigDivInt

+ func (seg *IPv6AddressSegment) GetValue() *BigDivInt

+ func (seg *IPv6AddressSegment) GetValueCount() SegIntCount

+ func (seg *IPv6AddressSegment) GetWildcardString() string

+ func (seg *IPv6AddressSegment) IncludesMax() bool

+ func (seg *IPv6AddressSegment) IncludesZero() bool

+ func (seg *IPv6AddressSegment) IsFullRange() bool

+ func (seg *IPv6AddressSegment) IsMax() bool

+ func (seg *IPv6AddressSegment) IsMultiple() bool

+ func (seg *IPv6AddressSegment) IsOneBit(segmentBitIndex BitCount) bool

+ func (seg *IPv6AddressSegment) IsPrefixBlock() bool

+ func (seg *IPv6AddressSegment) IsPrefixed() bool

+ func (seg *IPv6AddressSegment) IsSinglePrefix(divisionPrefixLength BitCount) bool

+ func (seg *IPv6AddressSegment) IsSinglePrefixBlock() bool

+ func (seg *IPv6AddressSegment) IsZero() bool

+ func (seg *IPv6AddressSegment) Iterator() IPv6SegmentIterator

+ func (seg *IPv6AddressSegment) Matches(value SegInt) bool

+ func (seg *IPv6AddressSegment) MatchesValsWithMask(lowerValue, upperValue, mask SegInt) bool

+ func (seg *IPv6AddressSegment) MatchesWithMask(value, mask SegInt) bool

+ func (seg *IPv6AddressSegment) MatchesWithPrefixMask(value IPv6SegInt, networkBits BitCount) bool

+ func (seg *IPv6AddressSegment) PrefixBlockIterator() IPv6SegmentIterator

+ func (seg *IPv6AddressSegment) PrefixContains(other AddressSegmentType, prefixLength BitCount) bool

+ func (seg *IPv6AddressSegment) PrefixEqual(other AddressSegmentType, prefixLength BitCount) bool

+ func (seg *IPv6AddressSegment) PrefixIterator() IPv6SegmentIterator

+ func (seg *IPv6AddressSegment) PrefixedBlockIterator(segmentPrefixLen BitCount) IPv6SegmentIterator

+ func (seg *IPv6AddressSegment) ReverseBits(perByte bool) (res *IPv6AddressSegment, err addrerr.IncompatibleAddressError)

+ func (seg *IPv6AddressSegment) ReverseBytes() (res *IPv6AddressSegment, err addrerr.IncompatibleAddressError)

+ func (seg *IPv6AddressSegment) String() string

+ func (seg *IPv6AddressSegment) TestBit(n BitCount) bool

+ func (seg *IPv6AddressSegment) ToDiv() *AddressDivision

+ func (seg *IPv6AddressSegment) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (seg *IPv6AddressSegment) ToHostSegment(segmentPrefixLength PrefixLen) *IPv6AddressSegment

+ func (seg *IPv6AddressSegment) ToIP() *IPAddressSegment

+ func (seg *IPv6AddressSegment) ToNetworkSegment(segmentPrefixLength PrefixLen) *IPv6AddressSegment

+ func (seg *IPv6AddressSegment) ToNormalizedString() string

+ func (seg *IPv6AddressSegment) ToPrefixedHostSegment(segmentPrefixLength PrefixLen) *IPv6AddressSegment

+ func (seg *IPv6AddressSegment) ToPrefixedNetworkSegment(segmentPrefixLength PrefixLen) *IPv6AddressSegment

+ func (seg *IPv6AddressSegment) ToSegmentBase() *AddressSegment

+ func (seg *IPv6AddressSegment) UpperBytes() []byte

+ func (seg *IPv6AddressSegment) WithoutPrefixLen() *IPv6AddressSegment

+ type IPv6AddressSegmentSeries interface

+ CopySegments func(segs []*IPv6AddressSegment) (count int)

+ CopySubSegments func(start, end int, segs []*IPv6AddressSegment) (count int)

+ GetHostSection func() *IPv6AddressSection

+ GetHostSectionLen func(BitCount) *IPv6AddressSection

+ GetNetworkSection func() *IPv6AddressSection

+ GetNetworkSectionLen func(BitCount) *IPv6AddressSection

+ GetSegment func(index int) *IPv6AddressSegment

+ GetSegments func() []*IPv6AddressSegment

+ GetSubSection func(index, endIndex int) *IPv6AddressSection

+ GetTrailingSection func(index int) *IPv6AddressSection

+ type IPv6AddressSeqRange struct

+ func NewIPv6SeqRange(one, two *IPv6Address) *IPv6AddressSeqRange

+ func (rng *IPv6AddressSeqRange) Bytes() []byte

+ func (rng *IPv6AddressSeqRange) Compare(item AddressItem) int

+ func (rng *IPv6AddressSeqRange) CompareSize(other IPAddressSeqRangeType) int

+ func (rng *IPv6AddressSeqRange) Contains(other IPAddressType) bool

+ func (rng *IPv6AddressSeqRange) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (rng *IPv6AddressSeqRange) ContainsRange(other IPAddressSeqRangeType) bool

+ func (rng *IPv6AddressSeqRange) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (rng *IPv6AddressSeqRange) CopyBytes(bytes []byte) []byte

+ func (rng *IPv6AddressSeqRange) CopyNetIP(bytes net.IP) net.IP

+ func (rng *IPv6AddressSeqRange) CopyUpperBytes(bytes []byte) []byte

+ func (rng *IPv6AddressSeqRange) CopyUpperNetIP(bytes net.IP) net.IP

+ func (rng *IPv6AddressSeqRange) CoverWithPrefixBlock() *IPv6Address

+ func (rng *IPv6AddressSeqRange) Equal(other IPAddressSeqRangeType) bool

+ func (rng *IPv6AddressSeqRange) Extend(other *IPv6AddressSeqRange) *IPv6AddressSeqRange

+ func (rng *IPv6AddressSeqRange) GetBitCount() BitCount

+ func (rng *IPv6AddressSeqRange) GetByteCount() int

+ func (rng *IPv6AddressSeqRange) GetCount() *big.Int

+ func (rng *IPv6AddressSeqRange) GetLower() *IPv6Address

+ func (rng *IPv6AddressSeqRange) GetLowerIPAddress() *IPAddress

+ func (rng *IPv6AddressSeqRange) GetMinPrefixLenForBlock() BitCount

+ func (rng *IPv6AddressSeqRange) GetNetIP() net.IP

+ func (rng *IPv6AddressSeqRange) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (rng *IPv6AddressSeqRange) GetPrefixLenForSingleBlock() PrefixLen

+ func (rng *IPv6AddressSeqRange) GetUpper() *IPv6Address

+ func (rng *IPv6AddressSeqRange) GetUpperIPAddress() *IPAddress

+ func (rng *IPv6AddressSeqRange) GetUpperNetIP() net.IP

+ func (rng *IPv6AddressSeqRange) GetUpperValue() *big.Int

+ func (rng *IPv6AddressSeqRange) GetValue() *big.Int

+ func (rng *IPv6AddressSeqRange) IncludesMax() bool

+ func (rng *IPv6AddressSeqRange) IncludesZero() bool

+ func (rng *IPv6AddressSeqRange) Intersect(other *IPv6AddressSeqRange) *IPAddressSeqRange

+ func (rng *IPv6AddressSeqRange) IsFullRange() bool

+ func (rng *IPv6AddressSeqRange) IsMax() bool

+ func (rng *IPv6AddressSeqRange) IsMultiple() bool

+ func (rng *IPv6AddressSeqRange) IsSequential() bool

+ func (rng *IPv6AddressSeqRange) IsZero() bool

+ func (rng *IPv6AddressSeqRange) Iterator() IPv6AddressIterator

+ func (rng *IPv6AddressSeqRange) Join(ranges ...*IPv6AddressSeqRange) []*IPv6AddressSeqRange

+ func (rng *IPv6AddressSeqRange) JoinTo(other *IPv6AddressSeqRange) *IPv6AddressSeqRange

+ func (rng *IPv6AddressSeqRange) Overlaps(other *IPv6AddressSeqRange) bool

+ func (rng *IPv6AddressSeqRange) PrefixBlockIterator(prefLength BitCount) IPv6AddressIterator

+ func (rng *IPv6AddressSeqRange) PrefixIterator(prefLength BitCount) IPv6AddressSeqRangeIterator

+ func (rng *IPv6AddressSeqRange) SpanWithPrefixBlocks() []*IPv6Address

+ func (rng *IPv6AddressSeqRange) SpanWithSequentialBlocks() []*IPv6Address

+ func (rng *IPv6AddressSeqRange) String() string

+ func (rng *IPv6AddressSeqRange) Subtract(other *IPv6AddressSeqRange) []*IPv6AddressSeqRange

+ func (rng *IPv6AddressSeqRange) ToCanonicalString() string

+ func (rng *IPv6AddressSeqRange) ToIP() *IPAddressSeqRange

+ func (rng *IPv6AddressSeqRange) ToNormalizedString() string

+ func (rng *IPv6AddressSeqRange) ToString(lowerStringer func(*IPv6Address) string, separator string, ...) string

+ func (rng *IPv6AddressSeqRange) UpperBytes() []byte

+ func (rng IPv6AddressSeqRange) Format(state fmt.State, verb rune)

+ type IPv6AddressSeqRangeIterator interface

+ Next func() *IPv6AddressSeqRange

+ type IPv6Partition struct

+ func PartitionIPv6WithSingleBlockSize(newAddr *IPv6Address) IPv6Partition

+ func PartitionIpv6WithSpanningBlocks(newAddr *IPv6Address) IPv6Partition

+ func (p IPv6Partition) ForEach(action func(*IPv6Address))

+ func (p IPv6Partition) Iterator() IPv6AddressIterator

+ func (p IPv6Partition) PredicateForAny(predicate func(*IPv6Address) bool) bool

+ func (p IPv6Partition) PredicateForAnyEarly(predicate func(*IPv6Address) bool) bool

+ func (p IPv6Partition) PredicateForEach(predicate func(*IPv6Address) bool) bool

+ func (p IPv6Partition) PredicateForEachEarly(predicate func(*IPv6Address) bool) bool

+ type IPv6SectionIterator interface

+ Next func() *IPv6AddressSection

+ type IPv6SegInt = uint16

+ type IPv6SegmentIterator interface

+ Next func() *IPv6AddressSegment

+ type IPv6SegmentValueProvider func(segmentIndex int) IPv6SegInt

+ func WrappedSegmentValueProviderForIPv6(f SegmentValueProvider) IPv6SegmentValueProvider

+ type IPv6v4MixedAddressGrouping struct

+ func (grouping *IPv6v4MixedAddressGrouping) Bytes() []byte

+ func (grouping *IPv6v4MixedAddressGrouping) Compare(item AddressItem) int

+ func (grouping *IPv6v4MixedAddressGrouping) CompareSize(other StandardDivGroupingType) int

+ func (grouping *IPv6v4MixedAddressGrouping) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (grouping *IPv6v4MixedAddressGrouping) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (grouping *IPv6v4MixedAddressGrouping) CopyBytes(bytes []byte) []byte

+ func (grouping *IPv6v4MixedAddressGrouping) CopyUpperBytes(bytes []byte) []byte

+ func (grouping *IPv6v4MixedAddressGrouping) GetBlockCount(divisionCount int) *big.Int

+ func (grouping *IPv6v4MixedAddressGrouping) GetCount() *big.Int

+ func (grouping *IPv6v4MixedAddressGrouping) GetDivisionCount() int

+ func (grouping *IPv6v4MixedAddressGrouping) GetGenericDivision(index int) DivisionType

+ func (grouping *IPv6v4MixedAddressGrouping) GetIPv4AddressSection() *IPv4AddressSection

+ func (grouping *IPv6v4MixedAddressGrouping) GetIPv6AddressSection() *EmbeddedIPv6AddressSection

+ func (grouping *IPv6v4MixedAddressGrouping) GetMinPrefixLenForBlock() BitCount

+ func (grouping *IPv6v4MixedAddressGrouping) GetPrefixCount() *big.Int

+ func (grouping *IPv6v4MixedAddressGrouping) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (grouping *IPv6v4MixedAddressGrouping) GetPrefixLen() PrefixLen

+ func (grouping *IPv6v4MixedAddressGrouping) GetPrefixLenForSingleBlock() PrefixLen

+ func (grouping *IPv6v4MixedAddressGrouping) GetSequentialBlockCount() *big.Int

+ func (grouping *IPv6v4MixedAddressGrouping) GetSequentialBlockIndex() int

+ func (grouping *IPv6v4MixedAddressGrouping) GetUpperValue() *big.Int

+ func (grouping *IPv6v4MixedAddressGrouping) GetValue() *big.Int

+ func (grouping *IPv6v4MixedAddressGrouping) IncludesMax() bool

+ func (grouping *IPv6v4MixedAddressGrouping) IncludesZero() bool

+ func (grouping *IPv6v4MixedAddressGrouping) IsAdaptiveZero() bool

+ func (grouping *IPv6v4MixedAddressGrouping) IsFullRange() bool

+ func (grouping *IPv6v4MixedAddressGrouping) IsMax() bool

+ func (grouping *IPv6v4MixedAddressGrouping) IsMultiple() bool

+ func (grouping *IPv6v4MixedAddressGrouping) IsPrefixBlock() bool

+ func (grouping *IPv6v4MixedAddressGrouping) IsPrefixed() bool

+ func (grouping *IPv6v4MixedAddressGrouping) IsSequential() bool

+ func (grouping *IPv6v4MixedAddressGrouping) IsSinglePrefixBlock() bool

+ func (grouping *IPv6v4MixedAddressGrouping) IsZero() bool

+ func (grouping *IPv6v4MixedAddressGrouping) String() string

+ func (grouping *IPv6v4MixedAddressGrouping) ToDivGrouping() *AddressDivisionGrouping

+ func (grouping *IPv6v4MixedAddressGrouping) UpperBytes() []byte

+ func (grouping IPv6v4MixedAddressGrouping) Format(state fmt.State, verb rune)

+ func (grouping IPv6v4MixedAddressGrouping) GetBitCount() BitCount

+ func (grouping IPv6v4MixedAddressGrouping) GetByteCount() int

+ type IdentifierStr struct

+ type Inet_aton_radix int

+ const Inet_aton_radix_decimal

+ const Inet_aton_radix_hex

+ const Inet_aton_radix_octal

+ func (rad Inet_aton_radix) GetRadix() int

+ func (rad Inet_aton_radix) GetSegmentStrPrefix() string

+ func (rad Inet_aton_radix) String() string

+ type MACAddress struct

+ func NewMACAddress(section *MACAddressSection) (*MACAddress, addrerr.AddressValueError)

+ func NewMACAddressFromBytes(bytes net.HardwareAddr) (*MACAddress, addrerr.AddressValueError)

+ func NewMACAddressFromRange(vals, upperVals MACSegmentValueProvider) (addr *MACAddress)

+ func NewMACAddressFromRangeExt(vals, upperVals MACSegmentValueProvider, isExtended bool) (addr *MACAddress)

+ func NewMACAddressFromSegments(segments []*MACAddressSegment) (*MACAddress, addrerr.AddressValueError)

+ func NewMACAddressFromUint64Ext(val uint64, isExtended bool) *MACAddress

+ func NewMACAddressFromVals(vals MACSegmentValueProvider) (addr *MACAddress)

+ func NewMACAddressFromValsExt(vals MACSegmentValueProvider, isExtended bool) (addr *MACAddress)

+ func (addr *MACAddress) AdjustPrefixLen(prefixLen BitCount) *MACAddress

+ func (addr *MACAddress) AdjustPrefixLenZeroed(prefixLen BitCount) (*MACAddress, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) AssignMinPrefixForBlock() *MACAddress

+ func (addr *MACAddress) AssignPrefixForSingleBlock() *MACAddress

+ func (addr *MACAddress) BlockIterator(segmentCount int) MACAddressIterator

+ func (addr *MACAddress) Bytes() []byte

+ func (addr *MACAddress) Compare(item AddressItem) int

+ func (addr *MACAddress) CompareSize(other AddressType) int

+ func (addr *MACAddress) Contains(other AddressType) bool

+ func (addr *MACAddress) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (addr *MACAddress) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (addr *MACAddress) CopyBytes(bytes []byte) []byte

+ func (addr *MACAddress) CopyHardwareAddr(bytes net.HardwareAddr) net.HardwareAddr

+ func (addr *MACAddress) CopySegments(segs []*MACAddressSegment) (count int)

+ func (addr *MACAddress) CopySubSegments(start, end int, segs []*MACAddressSegment) (count int)

+ func (addr *MACAddress) CopyUpperBytes(bytes []byte) []byte

+ func (addr *MACAddress) CopyUpperHardwareAddr(bytes net.HardwareAddr) net.HardwareAddr

+ func (addr *MACAddress) Equal(other AddressType) bool

+ func (addr *MACAddress) GetBitCount() BitCount

+ func (addr *MACAddress) GetBitsPerSegment() BitCount

+ func (addr *MACAddress) GetBlockCount(segmentCount int) *big.Int

+ func (addr *MACAddress) GetByteCount() int

+ func (addr *MACAddress) GetBytesPerSegment() int

+ func (addr *MACAddress) GetCount() *big.Int

+ func (addr *MACAddress) GetDivisionCount() int

+ func (addr *MACAddress) GetDottedAddress() (*AddressDivisionGrouping, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) GetGenericDivision(index int) DivisionType

+ func (addr *MACAddress) GetGenericSegment(index int) AddressSegmentType

+ func (addr *MACAddress) GetHardwareAddr() net.HardwareAddr

+ func (addr *MACAddress) GetLower() *Address

+ func (addr *MACAddress) GetMaxSegmentValue() SegInt

+ func (addr *MACAddress) GetMinPrefixLenForBlock() BitCount

+ func (addr *MACAddress) GetODISection() *MACAddressSection

+ func (addr *MACAddress) GetOUISection() *MACAddressSection

+ func (addr *MACAddress) GetPrefixCount() *big.Int

+ func (addr *MACAddress) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (addr *MACAddress) GetPrefixLen() PrefixLen

+ func (addr *MACAddress) GetPrefixLenForSingleBlock() PrefixLen

+ func (addr *MACAddress) GetSection() *MACAddressSection

+ func (addr *MACAddress) GetSegment(index int) *MACAddressSegment

+ func (addr *MACAddress) GetSegmentCount() int

+ func (addr *MACAddress) GetSegmentStrings() []string

+ func (addr *MACAddress) GetSegments() []*MACAddressSegment

+ func (addr *MACAddress) GetSequentialBlockCount() *big.Int

+ func (addr *MACAddress) GetSequentialBlockIndex() int

+ func (addr *MACAddress) GetSubSection(index, endIndex int) *MACAddressSection

+ func (addr *MACAddress) GetTrailingSection(index int) *MACAddressSection

+ func (addr *MACAddress) GetUpper() *Address

+ func (addr *MACAddress) GetUpperHardwareAddr() net.HardwareAddr

+ func (addr *MACAddress) GetUpperValue() *big.Int

+ func (addr *MACAddress) GetValue() *big.Int

+ func (addr *MACAddress) IncludesMax() bool

+ func (addr *MACAddress) IncludesZero() bool

+ func (addr *MACAddress) Increment(increment int64) *MACAddress

+ func (addr *MACAddress) IncrementBoundary(increment int64) *MACAddress

+ func (addr *MACAddress) IsEUI64(asMAC bool) bool

+ func (addr *MACAddress) IsFullRange() bool

+ func (addr *MACAddress) IsLocal() bool

+ func (addr *MACAddress) IsMax() bool

+ func (addr *MACAddress) IsMulticast() bool

+ func (addr *MACAddress) IsMultiple() bool

+ func (addr *MACAddress) IsOneBit(bitIndex BitCount) bool

+ func (addr *MACAddress) IsPrefixBlock() bool

+ func (addr *MACAddress) IsPrefixed() bool

+ func (addr *MACAddress) IsSequential() bool

+ func (addr *MACAddress) IsSinglePrefixBlock() bool

+ func (addr *MACAddress) IsUnicast() bool

+ func (addr *MACAddress) IsUniversal() bool

+ func (addr *MACAddress) IsZero() bool

+ func (addr *MACAddress) Iterator() MACAddressIterator

+ func (addr *MACAddress) PrefixBlockIterator() MACAddressIterator

+ func (addr *MACAddress) PrefixContains(other AddressType) bool

+ func (addr *MACAddress) PrefixEqual(other AddressType) bool

+ func (addr *MACAddress) PrefixIterator() MACAddressIterator

+ func (addr *MACAddress) Replace(startIndex int, replacement *MACAddressSection) *MACAddress

+ func (addr *MACAddress) ReplaceLen(startIndex, endIndex int, replacement *MACAddress, replacementIndex int) *MACAddress

+ func (addr *MACAddress) ReverseBits(perByte bool) (*MACAddress, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) ReverseBytes() *MACAddress

+ func (addr *MACAddress) ReverseSegments() *MACAddress

+ func (addr *MACAddress) SequentialBlockIterator() MACAddressIterator

+ func (addr *MACAddress) SetPrefixLen(prefixLen BitCount) *MACAddress

+ func (addr *MACAddress) SetPrefixLenZeroed(prefixLen BitCount) (*MACAddress, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) String() string

+ func (addr *MACAddress) TestBit(n BitCount) bool

+ func (addr *MACAddress) ToAddressBase() *Address

+ func (addr *MACAddress) ToAddressString() *MACAddressString

+ func (addr *MACAddress) ToBinaryString(with0bPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) ToBlock(segmentIndex int, lower, upper SegInt) *MACAddress

+ func (addr *MACAddress) ToCanonicalString() string

+ func (addr *MACAddress) ToColonDelimitedString() string

+ func (addr *MACAddress) ToCompressedString() string

+ func (addr *MACAddress) ToCustomString(stringOptions addrstr.StringOptions) string

+ func (addr *MACAddress) ToDashedString() string

+ func (addr *MACAddress) ToDottedString() (string, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) ToEUI64(asMAC bool) (*MACAddress, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) ToEUI64IPv6() (*IPv6AddressSection, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) ToLinkLocalIPv6() (*IPv6Address, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) ToNormalizedString() string

+ func (addr *MACAddress) ToOUIPrefixBlock() *MACAddress

+ func (addr *MACAddress) ToOctalString(with0Prefix bool) (string, addrerr.IncompatibleAddressError)

+ func (addr *MACAddress) ToPrefixBlock() *MACAddress

+ func (addr *MACAddress) ToSpaceDelimitedString() string

+ func (addr *MACAddress) Uint64Value() uint64

+ func (addr *MACAddress) UpperBytes() []byte

+ func (addr *MACAddress) UpperUint64Value() uint64

+ func (addr *MACAddress) WithoutPrefixLen() *MACAddress

+ func (addr *MACAddress) Wrap() WrappedAddress

+ func (addr MACAddress) Format(state fmt.State, verb rune)

+ type MACAddressIterator interface

+ Next func() *MACAddress

+ type MACAddressSection struct

+ func NewMACSection(segments []*MACAddressSegment) *MACAddressSection

+ func NewMACSectionFromBytes(bytes []byte, segmentCount int) (res *MACAddressSection, err addrerr.AddressValueError)

+ func NewMACSectionFromRange(vals, upperVals MACSegmentValueProvider, segmentCount int) (res *MACAddressSection)

+ func NewMACSectionFromUint64(bytes uint64, segmentCount int) (res *MACAddressSection)

+ func NewMACSectionFromVals(vals MACSegmentValueProvider, segmentCount int) (res *MACAddressSection)

+ func (section *MACAddressSection) AdjustPrefixLen(prefixLen BitCount) *AddressSection

+ func (section *MACAddressSection) AdjustPrefixLenZeroed(prefixLen BitCount) (*AddressSection, addrerr.IncompatibleAddressError)

+ func (section *MACAddressSection) Append(other *MACAddressSection) *MACAddressSection

+ func (section *MACAddressSection) AssignMinPrefixForBlock() *MACAddressSection

+ func (section *MACAddressSection) AssignPrefixForSingleBlock() *MACAddressSection

+ func (section *MACAddressSection) Bytes() []byte

+ func (section *MACAddressSection) Compare(item AddressItem) int

+ func (section *MACAddressSection) CompareSize(other StandardDivGroupingType) int

+ func (section *MACAddressSection) Contains(other AddressSectionType) bool

+ func (section *MACAddressSection) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (section *MACAddressSection) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (section *MACAddressSection) CopyBytes(bytes []byte) []byte

+ func (section *MACAddressSection) CopySegments(segs []*MACAddressSegment) (count int)

+ func (section *MACAddressSection) CopySubSegments(start, end int, segs []*MACAddressSegment) (count int)

+ func (section *MACAddressSection) CopyUpperBytes(bytes []byte) []byte

+ func (section *MACAddressSection) Equal(other AddressSectionType) bool

+ func (section *MACAddressSection) GetBitCount() BitCount

+ func (section *MACAddressSection) GetBitsPerSegment() BitCount

+ func (section *MACAddressSection) GetBlockCount(segmentCount int) *big.Int

+ func (section *MACAddressSection) GetByteCount() int

+ func (section *MACAddressSection) GetBytesPerSegment() int

+ func (section *MACAddressSection) GetCount() *big.Int

+ func (section *MACAddressSection) GetDottedGrouping() (*AddressDivisionGrouping, addrerr.IncompatibleAddressError)

+ func (section *MACAddressSection) GetGenericSegment(index int) AddressSegmentType

+ func (section *MACAddressSection) GetLower() *MACAddressSection

+ func (section *MACAddressSection) GetMaxSegmentValue() SegInt

+ func (section *MACAddressSection) GetMinPrefixLenForBlock() BitCount

+ func (section *MACAddressSection) GetPrefixCount() *big.Int

+ func (section *MACAddressSection) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (section *MACAddressSection) GetPrefixLen() PrefixLen

+ func (section *MACAddressSection) GetPrefixLenForSingleBlock() PrefixLen

+ func (section *MACAddressSection) GetSegment(index int) *MACAddressSegment

+ func (section *MACAddressSection) GetSegmentCount() int

+ func (section *MACAddressSection) GetSegmentStrings() []string

+ func (section *MACAddressSection) GetSegments() (res []*MACAddressSegment)

+ func (section *MACAddressSection) GetSequentialBlockCount() *big.Int

+ func (section *MACAddressSection) GetSequentialBlockIndex() int

+ func (section *MACAddressSection) GetSubSection(index, endIndex int) *MACAddressSection

+ func (section *MACAddressSection) GetTrailingSection(index int) *MACAddressSection

+ func (section *MACAddressSection) GetUpper() *MACAddressSection

+ func (section *MACAddressSection) GetUpperValue() *big.Int

+ func (section *MACAddressSection) GetValue() *big.Int

+ func (section *MACAddressSection) IncludesMax() bool

+ func (section *MACAddressSection) IncludesZero() bool

+ func (section *MACAddressSection) Increment(incrementVal int64) *MACAddressSection

+ func (section *MACAddressSection) IncrementBoundary(increment int64) *MACAddressSection

+ func (section *MACAddressSection) Insert(index int, other *MACAddressSection) *MACAddressSection

+ func (section *MACAddressSection) IsAdaptiveZero() bool

+ func (section *MACAddressSection) IsFullRange() bool

+ func (section *MACAddressSection) IsMax() bool

+ func (section *MACAddressSection) IsMultiple() bool

+ func (section *MACAddressSection) IsOneBit(prefixBitIndex BitCount) bool

+ func (section *MACAddressSection) IsPrefixBlock() bool

+ func (section *MACAddressSection) IsPrefixed() bool

+ func (section *MACAddressSection) IsSequential() bool

+ func (section *MACAddressSection) IsSinglePrefixBlock() bool

+ func (section *MACAddressSection) IsZero() bool

+ func (section *MACAddressSection) Iterator() MACSectionIterator

+ func (section *MACAddressSection) PrefixBlockIterator() MACSectionIterator

+ func (section *MACAddressSection) PrefixContains(other AddressSectionType) (res bool)

+ func (section *MACAddressSection) PrefixEqual(other AddressSectionType) (res bool)

+ func (section *MACAddressSection) PrefixIterator() MACSectionIterator

+ func (section *MACAddressSection) Replace(index int, replacement *MACAddressSection) *MACAddressSection

+ func (section *MACAddressSection) ReplaceLen(startIndex, endIndex int, replacement *MACAddressSection, ...) *MACAddressSection

+ func (section *MACAddressSection) ReverseBits(perByte bool) (*MACAddressSection, addrerr.IncompatibleAddressError)

+ func (section *MACAddressSection) ReverseBytes() *MACAddressSection

+ func (section *MACAddressSection) ReverseSegments() *MACAddressSection

+ func (section *MACAddressSection) SetPrefixLen(prefixLen BitCount) *MACAddressSection

+ func (section *MACAddressSection) SetPrefixLenZeroed(prefixLen BitCount) (*MACAddressSection, addrerr.IncompatibleAddressError)

+ func (section *MACAddressSection) String() string

+ func (section *MACAddressSection) TestBit(n BitCount) bool

+ func (section *MACAddressSection) ToBinaryString(with0bPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *MACAddressSection) ToBlock(segmentIndex int, lower, upper SegInt) *MACAddressSection

+ func (section *MACAddressSection) ToCanonicalString() string

+ func (section *MACAddressSection) ToColonDelimitedString() string

+ func (section *MACAddressSection) ToCompressedString() string

+ func (section *MACAddressSection) ToDashedString() string

+ func (section *MACAddressSection) ToDivGrouping() *AddressDivisionGrouping

+ func (section *MACAddressSection) ToDottedString() (string, addrerr.IncompatibleAddressError)

+ func (section *MACAddressSection) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *MACAddressSection) ToNormalizedString() string

+ func (section *MACAddressSection) ToOctalString(with0Prefix bool) (string, addrerr.IncompatibleAddressError)

+ func (section *MACAddressSection) ToPrefixBlock() *MACAddressSection

+ func (section *MACAddressSection) ToPrefixBlockLen(prefLen BitCount) *MACAddressSection

+ func (section *MACAddressSection) ToSectionBase() *AddressSection

+ func (section *MACAddressSection) ToSpaceDelimitedString() string

+ func (section *MACAddressSection) Uint64Value() uint64

+ func (section *MACAddressSection) UpperBytes() []byte

+ func (section *MACAddressSection) UpperUint64Value() uint64

+ func (section *MACAddressSection) WithoutPrefixLen() *MACAddressSection

+ func (section *MACAddressSection) Wrap() WrappedAddressSection

+ func (section MACAddressSection) Format(state fmt.State, verb rune)

+ type MACAddressSegment struct

+ func NewMACRangeSegment(val, upperVal MACSegInt) *MACAddressSegment

+ func NewMACSegment(val MACSegInt) *MACAddressSegment

+ func (seg *MACAddressSegment) Bytes() []byte

+ func (seg *MACAddressSegment) Compare(item AddressItem) int

+ func (seg *MACAddressSegment) Contains(other AddressSegmentType) bool

+ func (seg *MACAddressSegment) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (seg *MACAddressSegment) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (seg *MACAddressSegment) CopyBytes(bytes []byte) []byte

+ func (seg *MACAddressSegment) CopyUpperBytes(bytes []byte) []byte

+ func (seg *MACAddressSegment) Equal(other AddressSegmentType) bool

+ func (seg *MACAddressSegment) GetBitCount() BitCount

+ func (seg *MACAddressSegment) GetByteCount() int

+ func (seg *MACAddressSegment) GetCount() *big.Int

+ func (seg *MACAddressSegment) GetLower() *MACAddressSegment

+ func (seg *MACAddressSegment) GetMACSegmentValue() MACSegInt

+ func (seg *MACAddressSegment) GetMACUpperSegmentValue() MACSegInt

+ func (seg *MACAddressSegment) GetMaxValue() MACSegInt

+ func (seg *MACAddressSegment) GetMinPrefixLenForBlock() BitCount

+ func (seg *MACAddressSegment) GetPrefixCountLen(segmentPrefixLength BitCount) *big.Int

+ func (seg *MACAddressSegment) GetPrefixLenForSingleBlock() PrefixLen

+ func (seg *MACAddressSegment) GetPrefixValueCountLen(segmentPrefixLength BitCount) SegIntCount

+ func (seg *MACAddressSegment) GetSegmentValue() SegInt

+ func (seg *MACAddressSegment) GetString() string

+ func (seg *MACAddressSegment) GetUpper() *MACAddressSegment

+ func (seg *MACAddressSegment) GetUpperSegmentValue() SegInt

+ func (seg *MACAddressSegment) GetUpperValue() *BigDivInt

+ func (seg *MACAddressSegment) GetValue() *BigDivInt

+ func (seg *MACAddressSegment) GetValueCount() SegIntCount

+ func (seg *MACAddressSegment) GetWildcardString() string

+ func (seg *MACAddressSegment) IncludesMax() bool

+ func (seg *MACAddressSegment) IncludesZero() bool

+ func (seg *MACAddressSegment) IsFullRange() bool

+ func (seg *MACAddressSegment) IsMax() bool

+ func (seg *MACAddressSegment) IsMultiple() bool

+ func (seg *MACAddressSegment) IsOneBit(segmentBitIndex BitCount) bool

+ func (seg *MACAddressSegment) IsSinglePrefix(divisionPrefixLength BitCount) bool

+ func (seg *MACAddressSegment) IsZero() bool

+ func (seg *MACAddressSegment) Iterator() MACSegmentIterator

+ func (seg *MACAddressSegment) Join(macSegment1 *MACAddressSegment, prefixLength PrefixLen) (*IPv6AddressSegment, addrerr.IncompatibleAddressError)

+ func (seg *MACAddressSegment) JoinAndFlip2ndBit(macSegment1 *MACAddressSegment, prefixLength PrefixLen) (*IPv6AddressSegment, addrerr.IncompatibleAddressError)

+ func (seg *MACAddressSegment) Matches(value SegInt) bool

+ func (seg *MACAddressSegment) MatchesValsWithMask(lowerValue, upperValue, mask SegInt) bool

+ func (seg *MACAddressSegment) MatchesWithMask(value, mask SegInt) bool

+ func (seg *MACAddressSegment) PrefixBlockIterator(segmentPrefixLen BitCount) MACSegmentIterator

+ func (seg *MACAddressSegment) PrefixContains(other AddressSegmentType, prefixLength BitCount) bool

+ func (seg *MACAddressSegment) PrefixEqual(other AddressSegmentType, prefixLength BitCount) bool

+ func (seg *MACAddressSegment) PrefixIterator(segmentPrefixLen BitCount) MACSegmentIterator

+ func (seg *MACAddressSegment) ReverseBits(_ bool) (res *MACAddressSegment, err addrerr.IncompatibleAddressError)

+ func (seg *MACAddressSegment) ReverseBytes() (*MACAddressSegment, addrerr.IncompatibleAddressError)

+ func (seg *MACAddressSegment) String() string

+ func (seg *MACAddressSegment) TestBit(n BitCount) bool

+ func (seg *MACAddressSegment) ToDiv() *AddressDivision

+ func (seg *MACAddressSegment) ToHexString(with0xPrefix bool) (string, addrerr.IncompatibleAddressError)

+ func (seg *MACAddressSegment) ToNormalizedString() string

+ func (seg *MACAddressSegment) ToSegmentBase() *AddressSegment

+ func (seg *MACAddressSegment) UpperBytes() []byte

+ type MACAddressSegmentSeries interface

+ CopySegments func(segs []*MACAddressSegment) (count int)

+ CopySubSegments func(start, end int, segs []*MACAddressSegment) (count int)

+ GetSegment func(index int) *MACAddressSegment

+ GetSegments func() []*MACAddressSegment

+ GetSubSection func(index, endIndex int) *MACAddressSection

+ GetTrailingSection func(index int) *MACAddressSection

+ type MACAddressString struct

+ func NewMACAddressString(str string) *MACAddressString

+ func NewMACAddressStringParams(str string, params addrstrparam.MACAddressStringParams) *MACAddressString

+ func (addrStr *MACAddressString) Compare(other *MACAddressString) int

+ func (addrStr *MACAddressString) Equal(other *MACAddressString) bool

+ func (addrStr *MACAddressString) GetAddress() *MACAddress

+ func (addrStr *MACAddressString) GetPrefixLen() PrefixLen

+ func (addrStr *MACAddressString) GetValidationOptions() addrstrparam.MACAddressStringParams

+ func (addrStr *MACAddressString) IsEmpty() bool

+ func (addrStr *MACAddressString) IsFullRange() bool

+ func (addrStr *MACAddressString) IsPrefixed() bool

+ func (addrStr *MACAddressString) IsValid() bool

+ func (addrStr *MACAddressString) IsZero() bool

+ func (addrStr *MACAddressString) String() string

+ func (addrStr *MACAddressString) ToAddress() (*MACAddress, addrerr.AddressError)

+ func (addrStr *MACAddressString) ToNormalizedString() string

+ func (addrStr *MACAddressString) Validate() addrerr.AddressStringError

+ func (addrStr *MACAddressString) Wrap() ExtendedIdentifierString

+ type MACSectionIterator interface

+ Next func() *MACAddressSection

+ type MACSegInt = uint8

+ type MACSegmentIterator interface

+ Next func() *MACAddressSegment

+ type MACSegmentValueProvider func(segmentIndex int) MACSegInt

+ func WrappedSegmentValueProviderForMAC(f SegmentValueProvider) MACSegmentValueProvider

+ type Masker interface

+ GetMaskedLower func(value, maskValue uint64) uint64

+ GetMaskedUpper func(upperValue, maskValue uint64) uint64

+ IsSequential func() bool

+ func MaskRange(value, upperValue, maskValue, maxValue uint64) Masker

+ type ParsedMACAddress struct

+ type Partition struct

+ func (p *Partition) ForEach(action func(*IPAddress))

+ func (p *Partition) Iterator() IPAddressIterator

+ func (p *Partition) PredicateForAny(predicate func(*IPAddress) bool) bool

+ func (p *Partition) PredicateForAnyEarly(predicate func(*IPAddress) bool) bool

+ func (p *Partition) PredicateForEach(predicate func(*IPAddress) bool) bool

+ func (p *Partition) PredicateForEachEarly(predicate func(*IPAddress) bool) bool

+ type Port = *PortNum

+ type PortInt = int

+ type PortNum uint16

+ func (p *PortNum) Compare(other Port) int

+ func (p *PortNum) Equal(other Port) bool

+ func (p *PortNum) Matches(other PortInt) bool

+ func (p *PortNum) Num() PortInt

+ func (p *PortNum) String() string

+ type PrefixBitCount uint8

+ func (p *PrefixBitCount) Compare(other PrefixLen) int

+ func (p *PrefixBitCount) Equal(other PrefixLen) bool

+ func (p *PrefixBitCount) IsNil() bool

+ func (p *PrefixBitCount) Len() BitCount

+ func (p *PrefixBitCount) Matches(other BitCount) bool

+ func (p *PrefixBitCount) String() string

+ type PrefixLen = *PrefixBitCount

+ func GetPrefixLenForSingleBlock(lower, upper DivInt, bitCount BitCount) PrefixLen

+ func ValidatePrefixLenStr(str string, version IPVersion) (prefixLen PrefixLen, err addrerr.AddressStringError)

+ type Range struct

+ type RangeList struct

+ type SectionIterator interface

+ Next func() *AddressSection

+ type SegInt = uint32

+ type SegIntCount = uint64

+ type SegmentIterator interface

+ Next func() *AddressSegment

+ type SegmentValueProvider func(segmentIndex int) SegInt

+ func WrappedIPv4SegmentValueProvider(f IPv4SegmentValueProvider) SegmentValueProvider

+ func WrappedIPv6SegmentValueProvider(f IPv6SegmentValueProvider) SegmentValueProvider

+ func WrappedMACSegmentValueProvider(f MACSegmentValueProvider) SegmentValueProvider

+ type SegmentsIterator interface

+ Next func() []*AddressDivision

+ type StandardDivGroupingType interface

+ CompareSize func(StandardDivGroupingType) int

+ IsAdaptiveZero func() bool

+ ToDivGrouping func() *AddressDivisionGrouping

+ type StandardDivisionType interface

+ ToDiv func() *AddressDivision

+ type StringIterator interface

+ Next func() string

+ func ParseDelimitedSegments(str string) StringIterator

+ type UnwrappedIPAddressIterator struct

+ func (iter UnwrappedIPAddressIterator) Next() *Address

+ type WrappedAddress struct

+ func WrapAddress(addr *Address) WrappedAddress

+ func (addr WrappedAddress) AdjustPrefixLen(prefixLen BitCount) ExtendedSegmentSeries

+ func (addr WrappedAddress) AdjustPrefixLenZeroed(prefixLen BitCount) (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedAddress) AssignMinPrefixForBlock() ExtendedSegmentSeries

+ func (addr WrappedAddress) AssignPrefixForSingleBlock() ExtendedSegmentSeries

+ func (addr WrappedAddress) CompareSize(other ExtendedSegmentSeries) int

+ func (addr WrappedAddress) Contains(other ExtendedSegmentSeries) bool

+ func (addr WrappedAddress) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (addr WrappedAddress) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (addr WrappedAddress) Equal(other ExtendedSegmentSeries) bool

+ func (addr WrappedAddress) GetBitCount() BitCount

+ func (addr WrappedAddress) GetBitsPerSegment() BitCount

+ func (addr WrappedAddress) GetBlockCount(segmentCount int) *big.Int

+ func (addr WrappedAddress) GetByteCount() int

+ func (addr WrappedAddress) GetBytesPerSegment() int

+ func (addr WrappedAddress) GetLower() ExtendedSegmentSeries

+ func (addr WrappedAddress) GetMinPrefixLenForBlock() BitCount

+ func (addr WrappedAddress) GetPrefixCount() *big.Int

+ func (addr WrappedAddress) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (addr WrappedAddress) GetPrefixLen() PrefixLen

+ func (addr WrappedAddress) GetPrefixLenForSingleBlock() PrefixLen

+ func (addr WrappedAddress) GetSection() *AddressSection

+ func (addr WrappedAddress) GetUpper() ExtendedSegmentSeries

+ func (addr WrappedAddress) IncludesZero() bool

+ func (addr WrappedAddress) Increment(i int64) ExtendedSegmentSeries

+ func (addr WrappedAddress) IncrementBoundary(i int64) ExtendedSegmentSeries

+ func (addr WrappedAddress) IsFullRange() bool

+ func (addr WrappedAddress) IsPrefixBlock() bool

+ func (addr WrappedAddress) IsSequential() bool

+ func (addr WrappedAddress) IsSinglePrefixBlock() bool

+ func (addr WrappedAddress) IsZero() bool

+ func (addr WrappedAddress) Iterator() ExtendedSegmentSeriesIterator

+ func (addr WrappedAddress) PrefixBlockIterator() ExtendedSegmentSeriesIterator

+ func (addr WrappedAddress) PrefixIterator() ExtendedSegmentSeriesIterator

+ func (addr WrappedAddress) ReverseBits(perByte bool) (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedAddress) ReverseBytes() (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedAddress) ReverseSegments() ExtendedSegmentSeries

+ func (addr WrappedAddress) SetPrefixLen(prefixLen BitCount) ExtendedSegmentSeries

+ func (addr WrappedAddress) SetPrefixLenZeroed(prefixLen BitCount) (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedAddress) ToBlock(segmentIndex int, lower, upper SegInt) ExtendedSegmentSeries

+ func (addr WrappedAddress) ToIP() IPAddressSegmentSeries

+ func (addr WrappedAddress) ToIPv4() IPv4AddressSegmentSeries

+ func (addr WrappedAddress) ToIPv6() IPv6AddressSegmentSeries

+ func (addr WrappedAddress) ToMAC() MACAddressSegmentSeries

+ func (addr WrappedAddress) ToPrefixBlock() ExtendedSegmentSeries

+ func (addr WrappedAddress) Unwrap() AddressSegmentSeries

+ func (addr WrappedAddress) WithoutPrefixLen() ExtendedSegmentSeries

+ type WrappedAddressSection struct

+ func WrapSection(section *AddressSection) WrappedAddressSection

+ func (section WrappedAddressSection) AdjustPrefixLen(adjustment BitCount) ExtendedSegmentSeries

+ func (section WrappedAddressSection) AdjustPrefixLenZeroed(adjustment BitCount) (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedAddressSection) AssignMinPrefixForBlock() ExtendedSegmentSeries

+ func (section WrappedAddressSection) AssignPrefixForSingleBlock() ExtendedSegmentSeries

+ func (section WrappedAddressSection) Bytes() []byte

+ func (section WrappedAddressSection) CompareSize(other ExtendedSegmentSeries) int

+ func (section WrappedAddressSection) Contains(other ExtendedSegmentSeries) bool

+ func (section WrappedAddressSection) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (section WrappedAddressSection) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (section WrappedAddressSection) CopyBytes(bytes []byte) []byte

+ func (section WrappedAddressSection) CopyUpperBytes(bytes []byte) []byte

+ func (section WrappedAddressSection) Equal(other ExtendedSegmentSeries) bool

+ func (section WrappedAddressSection) Format(state fmt.State, verb rune)

+ func (section WrappedAddressSection) GetBitCount() BitCount

+ func (section WrappedAddressSection) GetBitsPerSegment() BitCount

+ func (section WrappedAddressSection) GetByteCount() int

+ func (section WrappedAddressSection) GetBytesPerSegment() int

+ func (section WrappedAddressSection) GetGenericSegment(index int) AddressSegmentType

+ func (section WrappedAddressSection) GetLower() ExtendedSegmentSeries

+ func (section WrappedAddressSection) GetMaxSegmentValue() SegInt

+ func (section WrappedAddressSection) GetMinPrefixLenForBlock() BitCount

+ func (section WrappedAddressSection) GetPrefixLen() PrefixLen

+ func (section WrappedAddressSection) GetPrefixLenForSingleBlock() PrefixLen

+ func (section WrappedAddressSection) GetSection() *AddressSection

+ func (section WrappedAddressSection) GetSegment(index int) *AddressSegment

+ func (section WrappedAddressSection) GetSegmentCount() int

+ func (section WrappedAddressSection) GetSequentialBlockCount() *big.Int

+ func (section WrappedAddressSection) GetSequentialBlockIndex() int

+ func (section WrappedAddressSection) GetUpper() ExtendedSegmentSeries

+ func (section WrappedAddressSection) GetUpperValue() *big.Int

+ func (section WrappedAddressSection) GetValue() *big.Int

+ func (section WrappedAddressSection) IncludesMax() bool

+ func (section WrappedAddressSection) IncludesZero() bool

+ func (section WrappedAddressSection) Increment(i int64) ExtendedSegmentSeries

+ func (section WrappedAddressSection) IncrementBoundary(i int64) ExtendedSegmentSeries

+ func (section WrappedAddressSection) IsFullRange() bool

+ func (section WrappedAddressSection) IsMax() bool

+ func (section WrappedAddressSection) IsOneBit(prefixBitIndex BitCount) bool

+ func (section WrappedAddressSection) IsPrefixBlock() bool

+ func (section WrappedAddressSection) IsSequential() bool

+ func (section WrappedAddressSection) IsSinglePrefixBlock() bool

+ func (section WrappedAddressSection) IsZero() bool

+ func (section WrappedAddressSection) Iterator() ExtendedSegmentSeriesIterator

+ func (section WrappedAddressSection) PrefixBlockIterator() ExtendedSegmentSeriesIterator

+ func (section WrappedAddressSection) PrefixContains(other AddressSectionType) (res bool)

+ func (section WrappedAddressSection) PrefixEqual(other AddressSectionType) (res bool)

+ func (section WrappedAddressSection) PrefixIterator() ExtendedSegmentSeriesIterator

+ func (section WrappedAddressSection) ReverseBits(perByte bool) (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedAddressSection) ReverseBytes() (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedAddressSection) ReverseSegments() ExtendedSegmentSeries

+ func (section WrappedAddressSection) SetPrefixLen(prefixLen BitCount) ExtendedSegmentSeries

+ func (section WrappedAddressSection) SetPrefixLenZeroed(prefixLen BitCount) (ExtendedSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedAddressSection) TestBit(n BitCount) bool

+ func (section WrappedAddressSection) ToBlock(segmentIndex int, lower, upper SegInt) ExtendedSegmentSeries

+ func (section WrappedAddressSection) ToIP() IPAddressSegmentSeries

+ func (section WrappedAddressSection) ToIPv4() IPv4AddressSegmentSeries

+ func (section WrappedAddressSection) ToIPv6() IPv6AddressSegmentSeries

+ func (section WrappedAddressSection) ToMAC() MACAddressSegmentSeries

+ func (section WrappedAddressSection) ToPrefixBlock() ExtendedSegmentSeries

+ func (section WrappedAddressSection) Unwrap() AddressSegmentSeries

+ func (section WrappedAddressSection) UpperBytes() []byte

+ func (section WrappedAddressSection) WithoutPrefixLen() ExtendedSegmentSeries

+ type WrappedHostName struct

+ func (w WrappedHostName) GetAddress() AddressType

+ func (w WrappedHostName) ToAddress() (AddressType, error)

+ func (w WrappedHostName) Unwrap() HostIdentifierString

+ type WrappedIPAddress struct

+ func (addr WrappedIPAddress) AdjustPrefixLen(prefixLen BitCount) ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) AdjustPrefixLenZeroed(prefixLen BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedIPAddress) AssignMinPrefixForBlock() ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) AssignPrefixForSingleBlock() ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) BlockIterator(segmentCount int) ExtendedIPSegmentSeriesIterator

+ func (addr WrappedIPAddress) CompareSize(other ExtendedIPSegmentSeries) int

+ func (addr WrappedIPAddress) Contains(other ExtendedIPSegmentSeries) bool

+ func (addr WrappedIPAddress) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (addr WrappedIPAddress) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (addr WrappedIPAddress) CoverWithPrefixBlock() ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) Equal(other ExtendedIPSegmentSeries) bool

+ func (addr WrappedIPAddress) GetBlockCount(segmentCount int) *big.Int

+ func (addr WrappedIPAddress) GetBlockMaskPrefixLen(network bool) PrefixLen

+ func (addr WrappedIPAddress) GetHostMask() ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) GetLower() ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) GetMinPrefixLenForBlock() BitCount

+ func (addr WrappedIPAddress) GetNetworkMask() ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) GetNetworkPrefixLen() PrefixLen

+ func (addr WrappedIPAddress) GetPrefixCount() *big.Int

+ func (addr WrappedIPAddress) GetPrefixCountLen(prefixLen BitCount) *big.Int

+ func (addr WrappedIPAddress) GetPrefixLen() PrefixLen

+ func (addr WrappedIPAddress) GetPrefixLenForSingleBlock() PrefixLen

+ func (addr WrappedIPAddress) GetSection() *IPAddressSection

+ func (addr WrappedIPAddress) GetUpper() ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) IncludesMaxHost() bool

+ func (addr WrappedIPAddress) IncludesZeroHost() bool

+ func (addr WrappedIPAddress) Increment(i int64) ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) IncrementBoundary(i int64) ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) IsMaxHost() bool

+ func (addr WrappedIPAddress) IsPrefixBlock() bool

+ func (addr WrappedIPAddress) IsSingleNetwork() bool

+ func (addr WrappedIPAddress) IsSinglePrefixBlock() bool

+ func (addr WrappedIPAddress) IsZeroHost() bool

+ func (addr WrappedIPAddress) Iterator() ExtendedIPSegmentSeriesIterator

+ func (addr WrappedIPAddress) PrefixBlockIterator() ExtendedIPSegmentSeriesIterator

+ func (addr WrappedIPAddress) PrefixIterator() ExtendedIPSegmentSeriesIterator

+ func (addr WrappedIPAddress) ReverseBits(perByte bool) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedIPAddress) ReverseBytes() (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedIPAddress) ReverseSegments() ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) SequentialBlockIterator() ExtendedIPSegmentSeriesIterator

+ func (addr WrappedIPAddress) SetPrefixLen(prefixLen BitCount) ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) SetPrefixLenZeroed(prefixLen BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedIPAddress) SpanWithPrefixBlocks() []ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) SpanWithSequentialBlocks() []ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) ToBlock(segmentIndex int, lower, upper SegInt) ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) ToIPv4() IPv4AddressSegmentSeries

+ func (addr WrappedIPAddress) ToIPv6() IPv6AddressSegmentSeries

+ func (addr WrappedIPAddress) ToMaxHost() (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedIPAddress) ToMaxHostLen(bitCount BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedIPAddress) ToPrefixBlock() ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) ToPrefixBlockLen(bitCount BitCount) ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) ToZeroHost() (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedIPAddress) ToZeroHostLen(bitCount BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (addr WrappedIPAddress) ToZeroNetwork() ExtendedIPSegmentSeries

+ func (addr WrappedIPAddress) Unwrap() IPAddressSegmentSeries

+ func (addr WrappedIPAddress) WithoutPrefixLen() ExtendedIPSegmentSeries

+ type WrappedIPAddressSection struct

+ func (section WrappedIPAddressSection) AdjustPrefixLen(prefixLen BitCount) ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) AdjustPrefixLenZeroed(prefixLen BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedIPAddressSection) AssignMinPrefixForBlock() ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) AssignPrefixForSingleBlock() ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) BlockIterator(segmentCount int) ExtendedIPSegmentSeriesIterator

+ func (section WrappedIPAddressSection) Bytes() []byte

+ func (section WrappedIPAddressSection) CompareSize(other ExtendedIPSegmentSeries) int

+ func (section WrappedIPAddressSection) Contains(other ExtendedIPSegmentSeries) bool

+ func (section WrappedIPAddressSection) ContainsPrefixBlock(prefixLen BitCount) bool

+ func (section WrappedIPAddressSection) ContainsSinglePrefixBlock(prefixLen BitCount) bool

+ func (section WrappedIPAddressSection) CopyBytes(bytes []byte) []byte

+ func (section WrappedIPAddressSection) CopyUpperBytes(bytes []byte) []byte

+ func (section WrappedIPAddressSection) CoverWithPrefixBlock() ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) Equal(other ExtendedIPSegmentSeries) bool

+ func (section WrappedIPAddressSection) GetBitCount() BitCount

+ func (section WrappedIPAddressSection) GetBitsPerSegment() BitCount

+ func (section WrappedIPAddressSection) GetBlockMaskPrefixLen(network bool) PrefixLen

+ func (section WrappedIPAddressSection) GetByteCount() int

+ func (section WrappedIPAddressSection) GetBytesPerSegment() int

+ func (section WrappedIPAddressSection) GetGenericSegment(index int) AddressSegmentType

+ func (section WrappedIPAddressSection) GetHostMask() ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) GetIPVersion() IPVersion

+ func (section WrappedIPAddressSection) GetLeadingBitCount(ones bool) BitCount

+ func (section WrappedIPAddressSection) GetLower() ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) GetMaxSegmentValue() SegInt

+ func (section WrappedIPAddressSection) GetMinPrefixLenForBlock() BitCount

+ func (section WrappedIPAddressSection) GetNetworkMask() ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) GetNetworkPrefixLen() PrefixLen

+ func (section WrappedIPAddressSection) GetPrefixLenForSingleBlock() PrefixLen

+ func (section WrappedIPAddressSection) GetSection() *IPAddressSection

+ func (section WrappedIPAddressSection) GetSegment(index int) *IPAddressSegment

+ func (section WrappedIPAddressSection) GetSegmentCount() int

+ func (section WrappedIPAddressSection) GetSequentialBlockCount() *big.Int

+ func (section WrappedIPAddressSection) GetSequentialBlockIndex() int

+ func (section WrappedIPAddressSection) GetTrailingBitCount(ones bool) BitCount

+ func (section WrappedIPAddressSection) GetUpper() ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) GetUpperValue() *big.Int

+ func (section WrappedIPAddressSection) GetValue() *big.Int

+ func (section WrappedIPAddressSection) IncludesMax() bool

+ func (section WrappedIPAddressSection) IncludesMaxHost() bool

+ func (section WrappedIPAddressSection) IncludesMaxHostLen(networkPrefixLength BitCount) bool

+ func (section WrappedIPAddressSection) IncludesZero() bool

+ func (section WrappedIPAddressSection) IncludesZeroHost() bool

+ func (section WrappedIPAddressSection) IncludesZeroHostLen(networkPrefixLength BitCount) bool

+ func (section WrappedIPAddressSection) Increment(i int64) ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) IncrementBoundary(i int64) ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) IsFullRange() bool

+ func (section WrappedIPAddressSection) IsMax() bool

+ func (section WrappedIPAddressSection) IsMaxHost() bool

+ func (section WrappedIPAddressSection) IsMaxHostLen(prefLen BitCount) bool

+ func (section WrappedIPAddressSection) IsOneBit(prefixBitIndex BitCount) bool

+ func (section WrappedIPAddressSection) IsPrefixBlock() bool

+ func (section WrappedIPAddressSection) IsSequential() bool

+ func (section WrappedIPAddressSection) IsSingleNetwork() bool

+ func (section WrappedIPAddressSection) IsSinglePrefixBlock() bool

+ func (section WrappedIPAddressSection) IsZero() bool

+ func (section WrappedIPAddressSection) IsZeroHost() bool

+ func (section WrappedIPAddressSection) IsZeroHostLen(prefLen BitCount) bool

+ func (section WrappedIPAddressSection) Iterator() ExtendedIPSegmentSeriesIterator

+ func (section WrappedIPAddressSection) PrefixBlockIterator() ExtendedIPSegmentSeriesIterator

+ func (section WrappedIPAddressSection) PrefixContains(other AddressSectionType) bool

+ func (section WrappedIPAddressSection) PrefixEqual(other AddressSectionType) bool

+ func (section WrappedIPAddressSection) PrefixIterator() ExtendedIPSegmentSeriesIterator

+ func (section WrappedIPAddressSection) ReverseBits(perByte bool) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedIPAddressSection) ReverseBytes() (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedIPAddressSection) ReverseSegments() ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) SequentialBlockIterator() ExtendedIPSegmentSeriesIterator

+ func (section WrappedIPAddressSection) SetPrefixLen(prefixLen BitCount) ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) SetPrefixLenZeroed(prefixLen BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedIPAddressSection) SpanWithPrefixBlocks() []ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) SpanWithSequentialBlocks() []ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) TestBit(n BitCount) bool

+ func (section WrappedIPAddressSection) ToBlock(segmentIndex int, lower, upper SegInt) ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) ToIPv4() IPv4AddressSegmentSeries

+ func (section WrappedIPAddressSection) ToIPv6() IPv6AddressSegmentSeries

+ func (section WrappedIPAddressSection) ToMaxHost() (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedIPAddressSection) ToMaxHostLen(bitCount BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedIPAddressSection) ToPrefixBlock() ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) ToPrefixBlockLen(bitCount BitCount) ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) ToZeroHost() (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedIPAddressSection) ToZeroHostLen(bitCount BitCount) (ExtendedIPSegmentSeries, addrerr.IncompatibleAddressError)

+ func (section WrappedIPAddressSection) ToZeroNetwork() ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) Unwrap() IPAddressSegmentSeries

+ func (section WrappedIPAddressSection) UpperBytes() []byte

+ func (section WrappedIPAddressSection) WithoutPrefixLen() ExtendedIPSegmentSeries

+ func (section WrappedIPAddressSection) Wrap() WrappedIPAddressSection

+ type WrappedIPAddressString struct

+ func (w WrappedIPAddressString) GetAddress() AddressType

+ func (w WrappedIPAddressString) ToAddress() (AddressType, error)

+ func (w WrappedIPAddressString) Unwrap() HostIdentifierString

+ type WrappedIPSegmentIterator struct

+ func (iter WrappedIPSegmentIterator) Next() *AddressSegment

+ type WrappedMACAddressString struct

+ func (w WrappedMACAddressString) GetAddress() AddressType

+ func (w WrappedMACAddressString) ToAddress() (AddressType, error)

+ func (w WrappedMACAddressString) Unwrap() HostIdentifierString

+ type Zone string

+ func ValidateZoneStr(zoneStr string) (zone Zone, err addrerr.AddressStringError)

+ func (zone Zone) IsEmpty() bool

+ func (zone Zone) String() string

Other modules containing this package

github.com/seancfoley/ipaddress-go/ipaddr

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL