Versions in this module Expand all Collapse all v1 v1.0.0 Dec 24, 2023 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 IPv6SegmentSeparatorStr + const IPv6StartBracket + const IPv6UncRangeSeparator + const IPv6UncRangeSeparatorStr + const IPv6UncSegmentSeparator + const IPv6UncSegmentSeparatorStr + const IPv6UncSuffix + const IPv6UncZoneSeparator + const IPv6UncZoneSeparatorStr + 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 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[T, U AddressType](addrs1 []T, addrs2 []U) (result bool) + func AddrsMatchUnordered[T, U AddressType](addrs1 []T, addrs2 []U) (result bool) + func AssociativeTreesString[T TrieKeyConstraint[T], V any](withNonAddedKeys bool, tries ...*AssociativeTrie[T, V]) string + func TreesString[T TrieKeyConstraint[T]](withNonAddedKeys bool, tries ...*Trie[T]) 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]) IsAdded() bool + func (node AddedTreeNode[T]) String() string + func (node AddedTreeNode[T]) TreeString() string + type Address struct + func (addr *Address) AdjustPrefixLen(prefixLen BitCount) *Address + func (addr *Address) AdjustPrefixLenZeroed(prefixLen BitCount) (*Address, address_error.IncompatibleAddressError) + func (addr *Address) AssignMinPrefixForBlock() *Address + func (addr *Address) AssignPrefixForSingleBlock() *Address + func (addr *Address) BlockIterator(segmentCount int) Iterator[*Address] + func (addr *Address) Bytes() []byte + func (addr *Address) Compare(item AddressItem) int + func (addr *Address) CompareSize(other AddressItem) 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) ForEachSegment(consumer func(segmentIndex int, segment *AddressSegment) (stop bool)) int + func (addr *Address) GetBitCount() BitCount + func (addr *Address) GetBitsPerSegment() BitCount + func (addr *Address) GetBlockCount(segments 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) GetLeadingBitCount(ones bool) BitCount + 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) GetTrailingBitCount(ones bool) BitCount + 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() Iterator[*Address] + func (addr *Address) PrefixBlockIterator() Iterator[*Address] + func (addr *Address) PrefixContains(other AddressType) bool + func (addr *Address) PrefixEqual(other AddressType) bool + func (addr *Address) PrefixIterator() Iterator[*Address] + func (addr *Address) ReverseBits(perByte bool) (*Address, address_error.IncompatibleAddressError) + func (addr *Address) ReverseBytes() (*Address, address_error.IncompatibleAddressError) + func (addr *Address) ReverseSegments() *Address + func (addr *Address) SequentialBlockIterator() Iterator[*Address] + func (addr *Address) SetPrefixLen(prefixLen BitCount) *Address + func (addr *Address) SetPrefixLenZeroed(prefixLen BitCount) (*Address, address_error.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, address_error.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 address_string.StringOptions) string + func (addr *Address) ToGenericKey() Key[*Address] + func (addr *Address) ToHexString(with0xPrefix bool) (string, address_error.IncompatibleAddressError) + func (addr *Address) ToIP() *IPAddress + func (addr *Address) ToIPv4() *IPv4Address + func (addr *Address) ToIPv6() *IPv6Address + func (addr *Address) ToKey() Key[*Address] + func (addr *Address) ToMAC() *MACAddress + func (addr *Address) ToNormalizedString() string + func (addr *Address) ToNormalizedWildcardString() string + func (addr *Address) ToOctalString(with0Prefix bool) (string, address_error.IncompatibleAddressError) + func (addr *Address) ToPrefixBlock() *Address + func (addr *Address) ToPrefixBlockLen(prefLen BitCount) *Address + func (addr *Address) ToSinglePrefixBlockOrAddress() *Address + func (addr *Address) TrieCompare(other *Address) (int, address_error.IncompatibleAddressError) + func (addr *Address) TrieDecrement() *Address + func (addr *Address) TrieIncrement() *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(index BitCount) bool + TestBit func(index BitCount) bool + ToHexString func(with0xPrefix bool) (string, address_error.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) CompareSize(other 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) *AddressDivisionGrouping + func (grouping *AddressDivisionGrouping) Bytes() []byte + func (grouping *AddressDivisionGrouping) Compare(item AddressItem) int + func (grouping *AddressDivisionGrouping) CompareSize(other AddressItem) 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) ForEachDivision(consumer func(divisionIndex int, division *AddressDivision) (stop bool)) int + func (grouping *AddressDivisionGrouping) GetBitCount() BitCount + func (grouping *AddressDivisionGrouping) GetBlockCount(divisionCount int) *big.Int + func (grouping *AddressDivisionGrouping) GetByteCount() 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) 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) 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) + type AddressDivisionSeries interface + GetBlockCount func(divisionCount int) *big.Int + GetDivisionCount func() int + GetGenericDivision func(index int) DivisionType + GetPrefixCount func() *big.Int + GetSequentialBlockCount func() *big.Int + GetSequentialBlockIndex func() int + IsSequential func() bool + type AddressItem interface + Bytes func() []byte + Compare func(AddressItem) int + CompareSize func(AddressItem) int + ContainsPrefixBlock func(BitCount) bool + ContainsSinglePrefixBlock func(BitCount) bool + CopyBytes func(bytes []byte) []byte + CopyUpperBytes func(bytes []byte) []byte + 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 AddressKey = Key[*Address] + type AddressSection struct + func (section *AddressSection) AdjustPrefixLen(prefixLen BitCount) *AddressSection + func (section *AddressSection) AdjustPrefixLenZeroed(prefixLen BitCount) (*AddressSection, address_error.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 AddressItem) 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) ForEachSegment(consumer func(segmentIndex int, segment *AddressSegment) (stop bool)) int + func (section *AddressSection) GetBitCount() BitCount + func (section *AddressSection) GetBitsPerSegment() BitCount + func (section *AddressSection) GetBlockCount(segments 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) GetLeadingBitCount(ones bool) BitCount + 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) GetTrailingBitCount(ones bool) BitCount + 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() Iterator[*AddressSection] + func (section *AddressSection) PrefixBlockIterator() Iterator[*AddressSection] + func (section *AddressSection) PrefixContains(other AddressSectionType) (res bool) + func (section *AddressSection) PrefixEqual(other AddressSectionType) (res bool) + func (section *AddressSection) PrefixIterator() Iterator[*AddressSection] + func (section *AddressSection) ReverseBits(perByte bool) (*AddressSection, address_error.IncompatibleAddressError) + func (section *AddressSection) ReverseBytes() (*AddressSection, address_error.IncompatibleAddressError) + func (section *AddressSection) ReverseSegments() *AddressSection + func (section *AddressSection) SetPrefixLen(prefixLen BitCount) *AddressSection + func (section *AddressSection) SetPrefixLenZeroed(prefixLen BitCount) (*AddressSection, address_error.IncompatibleAddressError) + func (section *AddressSection) String() string + func (section *AddressSection) TestBit(n BitCount) bool + func (section *AddressSection) ToBinaryString(with0bPrefix bool) (string, address_error.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 address_string.StringOptions) string + func (section *AddressSection) ToDivGrouping() *AddressDivisionGrouping + func (section *AddressSection) ToHexString(with0xPrefix bool) (string, address_error.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) ToNormalizedWildcardString() string + func (section *AddressSection) ToOctalString(with0Prefix bool) (string, address_error.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 + PrefixContains func(AddressSectionType) bool + PrefixEqual func(AddressSectionType) bool + ToSectionBase func() *AddressSection + type AddressSegment struct + func (seg *AddressSegment) Bytes() []byte + func (seg *AddressSegment) Compare(item AddressItem) int + func (seg *AddressSegment) CompareSize(other 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) GetLeadingBitCount(ones bool) BitCount + 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) GetSegmentHostMask(networkBits BitCount) SegInt + func (seg *AddressSegment) GetSegmentNetworkMask(networkBits BitCount) SegInt + func (seg *AddressSegment) GetSegmentValue() SegInt + func (seg *AddressSegment) GetString() string + func (seg *AddressSegment) GetTrailingBitCount(ones bool) BitCount + 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() Iterator[*AddressSegment] + 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 address_error.IncompatibleAddressError) + func (seg *AddressSegment) ReverseBytes() (res *AddressSegment, err address_error.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, address_error.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, address_error.IncompatibleAddressError) + ToCanonicalString func() string + ToCompressedString func() string + ToNormalizedWildcardString func() string + ToOctalString func(withPrefix bool) (string, address_error.IncompatibleAddressError) + type AddressSegmentType interface + Contains func(AddressSegmentType) bool + Equal func(AddressSegmentType) bool + GetSegmentValue func() SegInt + GetUpperSegmentValue func() SegInt + ToSegmentBase func() *AddressSegment + type AddressTrie = Trie[*Address] + type AddressType interface + 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 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]) IsAdded() bool + func (node AssociativeAddedTreeNode[T, V]) String() string + func (node AssociativeAddedTreeNode[T, V]) TreeString() string + type AssociativeAddressTrie = AssociativeTrie[*Address, any] + type AssociativeTrie struct + func NewAssociativeTrie[T TrieKeyConstraint[T], V any]() *AssociativeTrie[T, V] + func NewIPv4AddressAssociativeTrie() *AssociativeTrie[*IPv4Address, any] + func NewIPv6AddressAssociativeTrie() *AssociativeTrie[*IPv6Address, any] + func NewMACAddressAssociativeTrie(extended bool) *AssociativeTrie[*MACAddress, any] + 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]) Clear() + 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 BigDivInt = big.Int + type BitCount = int + type BitItem interface + GetBitCount func() BitCount + GetByteCount func() int + type BitwiseOrer interface + GetOredLower func(value, maskValue uint64) uint64 + GetOredUpper func(upperValue, maskValue uint64) uint64 + IsSequential func() bool + type Cached = tree.C + type CachingTrieIterator interface + CacheWithLowerSubNode func(Cached) bool + CacheWithUpperSubNode func(Cached) bool + GetCached func() Cached + type ContainmentPath struct + func (path *ContainmentPath[T]) Count() int + func (path *ContainmentPath[T]) LongestPrefixMatch() *ContainmentPathNode[T] + func (path *ContainmentPath[T]) ShortestPrefixMatch() *ContainmentPathNode[T] + func (path *ContainmentPath[T]) String() string + type ContainmentPathNode struct + func (node *ContainmentPathNode[T]) Count() int + func (node *ContainmentPathNode[T]) GetKey() T + func (node *ContainmentPathNode[T]) ListString() string + func (node *ContainmentPathNode[T]) Next() *ContainmentPathNode[T] + func (node *ContainmentPathNode[T]) Previous() *ContainmentPathNode[T] + func (node *ContainmentPathNode[T]) String() string + type ContainmentValuesPath struct + func (path *ContainmentValuesPath[T, V]) Count() int + func (path *ContainmentValuesPath[T, V]) LongestPrefixMatch() *ContainmentValuesPathNode[T, V] + func (path *ContainmentValuesPath[T, V]) ShortestPrefixMatch() *ContainmentValuesPathNode[T, V] + func (path *ContainmentValuesPath[T, V]) String() string + type ContainmentValuesPathNode struct + func (node *ContainmentValuesPathNode[T, V]) Count() int + func (node *ContainmentValuesPathNode[T, V]) GetKey() T + func (node *ContainmentValuesPathNode[T, V]) GetValue() V + func (node *ContainmentValuesPathNode[T, V]) ListString() string + func (node *ContainmentValuesPathNode[T, V]) Next() *ContainmentValuesPathNode[T, V] + func (node *ContainmentValuesPathNode[T, V]) Previous() *ContainmentValuesPathNode[T, V] + func (node *ContainmentValuesPathNode[T, V]) String() string + type DefaultAddressConverter struct + func (converter DefaultAddressConverter) IsIPv4Convertible(address *IPAddress) bool + func (converter DefaultAddressConverter) IsIPv6Convertible(address *IPAddress) bool + func (converter DefaultAddressConverter) ToIPv4(address *IPAddress) *IPv4Address + func (converter DefaultAddressConverter) ToIPv6(address *IPAddress) *IPv6Address + type DelimitedAddressString string + func (str DelimitedAddressString) CountDelimitedAddresses() int + func (str DelimitedAddressString) ParseDelimitedIPAddrSegments() Iterator[*IPAddressString] + func (str DelimitedAddressString) ParseDelimitedSegments() Iterator[string] + 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, address_error.IncompatibleAddressError) + AssignMinPrefixForBlock func() ExtendedIPSegmentSeries + AssignPrefixForSingleBlock func() ExtendedIPSegmentSeries + BlockIterator func(segmentCount int) Iterator[ExtendedIPSegmentSeries] + 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() Iterator[ExtendedIPSegmentSeries] + PrefixBlockIterator func() Iterator[ExtendedIPSegmentSeries] + PrefixIterator func() Iterator[ExtendedIPSegmentSeries] + ReverseBits func(perByte bool) (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + ReverseBytes func() (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + ReverseSegments func() ExtendedIPSegmentSeries + SequentialBlockIterator func() Iterator[ExtendedIPSegmentSeries] + SetPrefixLen func(BitCount) ExtendedIPSegmentSeries + SetPrefixLenZeroed func(BitCount) (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + SpanWithPrefixBlocks func() []ExtendedIPSegmentSeries + SpanWithSequentialBlocks func() []ExtendedIPSegmentSeries + ToBlock func(segmentIndex int, lower, upper SegInt) ExtendedIPSegmentSeries + ToCustomString func(stringOptions address_string.IPStringOptions) string + ToIPv4 func() IPv4AddressSegmentSeries + ToIPv6 func() IPv6AddressSegmentSeries + ToMaxHost func() (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + ToMaxHostLen func(BitCount) (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + ToPrefixBlock func() ExtendedIPSegmentSeries + ToPrefixBlockLen func(BitCount) ExtendedIPSegmentSeries + ToZeroHost func() (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + ToZeroHostLen func(BitCount) (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + ToZeroNetwork func() ExtendedIPSegmentSeries + Unwrap func() IPAddressSegmentSeries + WithoutPrefixLen 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 + func MaskExtendedRange(value, extendedValue, upperValue, extendedUpperValue, maskValue, ... uint64) ExtendedMasker + type ExtendedSegmentSeries interface + AdjustPrefixLen func(BitCount) ExtendedSegmentSeries + AdjustPrefixLenZeroed func(BitCount) (ExtendedSegmentSeries, address_error.IncompatibleAddressError) + AssignMinPrefixForBlock func() ExtendedSegmentSeries + AssignPrefixForSingleBlock func() ExtendedSegmentSeries + 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() Iterator[ExtendedSegmentSeries] + PrefixBlockIterator func() Iterator[ExtendedSegmentSeries] + PrefixIterator func() Iterator[ExtendedSegmentSeries] + ReverseBits func(perByte bool) (ExtendedSegmentSeries, address_error.IncompatibleAddressError) + ReverseBytes func() (ExtendedSegmentSeries, address_error.IncompatibleAddressError) + ReverseSegments func() ExtendedSegmentSeries + SetPrefixLen func(BitCount) ExtendedSegmentSeries + SetPrefixLenZeroed func(BitCount) (ExtendedSegmentSeries, address_error.IncompatibleAddressError) + ToBlock func(segmentIndex int, lower, upper SegInt) ExtendedSegmentSeries + ToCustomString func(stringOptions address_string.StringOptions) string + ToIP func() IPAddressSegmentSeries + ToIPv4 func() IPv4AddressSegmentSeries + ToIPv6 func() IPv6AddressSegmentSeries + ToMAC func() MACAddressSegmentSeries + ToPrefixBlock func() ExtendedSegmentSeries + ToPrefixBlockLen func(prefLen BitCount) ExtendedSegmentSeries + Unwrap func() AddressSegmentSeries + WithoutPrefixLen func() ExtendedSegmentSeries + type GenericKeyConstraint interface + type HostBitCount uint8 + func BitsForCount(count uint64) (result *HostBitCount) + func (hostBitCount *HostBitCount) BlockSize() *big.Int + func (hostBitCount *HostBitCount) IsNil() bool + func (hostBitCount *HostBitCount) Len() BitCount + func (hostBitCount *HostBitCount) String() string + type HostIdentifierString interface + IsValid func() bool + ToNormalizedString func() string + Wrap func() ExtendedIdentifierString + type HostName struct + func NewHostName(str string) *HostName + func NewHostNameFromAddr(addr *IPAddress) *HostName + func NewHostNameFromAddrPort(addr *IPAddress, port uint16) *HostName + func NewHostNameFromNetIP(bytes net.IP) (hostName *HostName, err address_error.AddressValueError) + func NewHostNameFromNetIPAddr(addr *net.IPAddr) (hostName *HostName, err address_error.AddressValueError) + func NewHostNameFromNetNetIPAddr(addr netip.Addr) *HostName + func NewHostNameFromNetNetIPAddrPort(addrPort netip.AddrPort) *HostName + func NewHostNameFromNetNetIPPrefix(addr netip.Prefix) (hostName *HostName, err address_error.AddressValueError) + func NewHostNameFromNetTCPAddr(addr *net.TCPAddr) (*HostName, address_error.AddressValueError) + func NewHostNameFromNetUDPAddr(addr *net.UDPAddr) (*HostName, address_error.AddressValueError) + func NewHostNameFromPrefixedNetIP(bytes net.IP, prefixLen PrefixLen) (hostName *HostName, err address_error.AddressValueError) + func NewHostNameFromPrefixedNetIPAddr(addr *net.IPAddr, prefixLen PrefixLen) (hostName *HostName, err address_error.AddressValueError) + func NewHostNameParams(str string, params address_string_param.HostNameParams) *HostName + func (addrStr HostName) Format(state fmt.State, verb rune) + 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() address_string_param.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) IsReverseDNS() bool + func (host *HostName) IsSelf() bool + func (host *HostName) IsUncIPv6Literal() bool + func (host *HostName) IsValid() bool + func (host *HostName) ResolvesToSelf() bool + func (host *HostName) String() string + func (host *HostName) ToAddress() (addr *IPAddress, err address_error.AddressError) + func (host *HostName) ToAddresses() (addrs []*IPAddress, err address_error.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() address_error.HostNameError + func (host *HostName) Wrap() ExtendedIdentifierString + type IPAddress struct + func NewIPAddressFromBytes(ip net.IP) (*IPAddress, address_error.AddressValueError) + func NewIPAddressFromNetIP(ip net.IP) (*IPAddress, address_error.AddressValueError) + func NewIPAddressFromNetIPAddr(addr *net.IPAddr) (*IPAddress, address_error.AddressValueError) + func NewIPAddressFromNetIPMask(ip net.IPMask) (*IPAddress, address_error.AddressValueError) + func NewIPAddressFromNetIPNet(ipnet *net.IPNet) (*IPAddress, address_error.AddressError) + func NewIPAddressFromNetNetIPAddr(addr netip.Addr) *IPAddress + func NewIPAddressFromNetNetIPPrefix(prefixedAddr netip.Prefix) (*IPAddress, address_error.AddressError) + func NewIPAddressFromPrefixedNetIP(ip net.IP, prefixLength PrefixLen) (*IPAddress, address_error.AddressValueError) + func NewIPAddressFromPrefixedNetIPAddr(addr *net.IPAddr, prefixLength PrefixLen) (*IPAddress, address_error.AddressValueError) + func NewIPAddressFromPrefixedSegments(segs []*IPAddressSegment, prefixLength PrefixLen) (res *IPAddress, err address_error.AddressValueError) + func NewIPAddressFromPrefixedVals(version IPVersion, lowerValueProvider, upperValueProvider SegmentValueProvider, ...) *IPAddress + func NewIPAddressFromPrefixedZonedVals(version IPVersion, lowerValueProvider, upperValueProvider SegmentValueProvider, ...) *IPAddress + func NewIPAddressFromSegs(segments []*IPAddressSegment) (res *IPAddress, err address_error.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, address_error.IncompatibleAddressError) + func (addr *IPAddress) AssignMinPrefixForBlock() *IPAddress + func (addr *IPAddress) AssignPrefixForSingleBlock() *IPAddress + func (addr *IPAddress) BitwiseOr(other *IPAddress) (masked *IPAddress, err address_error.IncompatibleAddressError) + func (addr *IPAddress) BlockIterator(segmentCount int) Iterator[*IPAddress] + func (addr *IPAddress) Bytes() []byte + func (addr *IPAddress) Compare(item AddressItem) int + func (addr *IPAddress) CompareSize(other AddressItem) 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) ForEachSegment(consumer func(segmentIndex int, segment *IPAddressSegment) (stop bool)) int + func (addr *IPAddress) GetBitCount() BitCount + func (addr *IPAddress) GetBlockCount(segments 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) GetNetNetIPAddr() netip.Addr + 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) GetUpperNetIPAddr() *net.IPAddr + func (addr *IPAddress) GetUpperNetNetIPAddr() netip.Addr + 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() Iterator[*IPAddress] + func (addr *IPAddress) Mask(other *IPAddress) (masked *IPAddress, err address_error.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() Iterator[*IPAddress] + func (addr *IPAddress) PrefixContains(other AddressType) bool + func (addr *IPAddress) PrefixEqual(other AddressType) bool + func (addr *IPAddress) PrefixIterator() Iterator[*IPAddress] + func (addr *IPAddress) ReverseBits(perByte bool) (*IPAddress, address_error.IncompatibleAddressError) + func (addr *IPAddress) ReverseBytes() (*IPAddress, address_error.IncompatibleAddressError) + func (addr *IPAddress) ReverseSegments() *IPAddress + func (addr *IPAddress) SequentialBlockIterator() Iterator[*IPAddress] + func (addr *IPAddress) SetPrefixLen(prefixLen BitCount) *IPAddress + func (addr *IPAddress) SetPrefixLenZeroed(prefixLen BitCount) (*IPAddress, address_error.IncompatibleAddressError) + func (addr *IPAddress) SpanWithPrefixBlocks() []*IPAddress + func (addr *IPAddress) SpanWithPrefixBlocksTo(other *IPAddress) []*IPAddress + func (addr *IPAddress) SpanWithRange(other *IPAddress) *SequentialRange[*IPAddress] + 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, address_error.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 address_string.IPStringOptions) string + func (addr *IPAddress) ToFullString() string + func (addr *IPAddress) ToGenericKey() Key[*IPAddress] + func (addr *IPAddress) ToHexString(with0xPrefix bool) (string, address_error.IncompatibleAddressError) + func (addr *IPAddress) ToHostName() *HostName + func (addr *IPAddress) ToIP() *IPAddress + func (addr *IPAddress) ToIPv4() *IPv4Address + func (addr *IPAddress) ToIPv6() *IPv6Address + func (addr *IPAddress) ToKey() Key[*IPAddress] + func (addr *IPAddress) ToMaxHost() (*IPAddress, address_error.IncompatibleAddressError) + func (addr *IPAddress) ToMaxHostLen(prefixLength BitCount) (*IPAddress, address_error.IncompatibleAddressError) + func (addr *IPAddress) ToNormalizedString() string + func (addr *IPAddress) ToNormalizedWildcardString() string + func (addr *IPAddress) ToOctalString(with0Prefix bool) (string, address_error.IncompatibleAddressError) + func (addr *IPAddress) ToPrefixBlock() *IPAddress + func (addr *IPAddress) ToPrefixBlockLen(prefLen BitCount) *IPAddress + func (addr *IPAddress) ToPrefixLenString() string + func (addr *IPAddress) ToReverseDNSString() (string, address_error.IncompatibleAddressError) + func (addr *IPAddress) ToSQLWildcardString() string + func (addr *IPAddress) ToSegmentedBinaryString() string + func (addr *IPAddress) ToSequentialRange() *SequentialRange[*IPAddress] + func (addr *IPAddress) ToSinglePrefixBlockOrAddress() *IPAddress + func (addr *IPAddress) ToSubnetString() string + func (addr *IPAddress) ToUNCHostName() string + func (addr *IPAddress) ToZeroHost() (*IPAddress, address_error.IncompatibleAddressError) + func (addr *IPAddress) ToZeroHostLen(prefixLength BitCount) (*IPAddress, address_error.IncompatibleAddressError) + func (addr *IPAddress) ToZeroNetwork() *IPAddress + func (addr *IPAddress) TrieCompare(other *IPAddress) (int, address_error.IncompatibleAddressError) + func (addr *IPAddress) TrieDecrement() *IPAddress + func (addr *IPAddress) TrieIncrement() *IPAddress + func (addr *IPAddress) UpperBytes() []byte + func (addr *IPAddress) WithoutPrefixLen() *IPAddress + func (addr *IPAddress) Wrap() WrappedIPAddress + func (addr *IPAddress) WrapAddress() WrappedAddress + 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 + func (creator IPAddressCreator) NewIPSectionFromPrefixedBytes(bytes []byte, segmentCount int, prefLen PrefixLen) (*IPAddressSection, address_error.AddressValueError) + func (creator IPAddressCreator) NewIPSectionFromSegmentedBytes(bytes []byte, segmentCount int) (*IPAddressSection, address_error.AddressValueError) + type IPAddressKey = Key[*IPAddress] + 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 + func (grouping IPAddressLargeDivisionGrouping) Format(state fmt.State, verb rune) + 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 + 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 + IsSequential func() bool + type IPAddressSection struct + func (section *IPAddressSection) AdjustPrefixLen(prefixLen BitCount) *IPAddressSection + func (section *IPAddressSection) AdjustPrefixLenZeroed(prefixLen BitCount) (*IPAddressSection, address_error.IncompatibleAddressError) + func (section *IPAddressSection) AssignMinPrefixForBlock() *IPAddressSection + func (section *IPAddressSection) AssignPrefixForSingleBlock() *IPAddressSection + func (section *IPAddressSection) BlockIterator(segmentCount int) Iterator[*IPAddressSection] + func (section *IPAddressSection) Bytes() []byte + func (section *IPAddressSection) Compare(item AddressItem) int + func (section *IPAddressSection) CompareSize(other AddressItem) 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) ForEachSegment(consumer func(segmentIndex int, segment *IPAddressSegment) (stop bool)) int + func (section *IPAddressSection) GetBitCount() BitCount + func (section *IPAddressSection) GetBitsPerSegment() BitCount + func (section *IPAddressSection) GetBlockCount(segments 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) 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) 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() Iterator[*IPAddressSection] + func (section *IPAddressSection) PrefixBlockIterator() Iterator[*IPAddressSection] + func (section *IPAddressSection) PrefixContains(other AddressSectionType) bool + func (section *IPAddressSection) PrefixEqual(other AddressSectionType) bool + func (section *IPAddressSection) PrefixIterator() Iterator[*IPAddressSection] + func (section *IPAddressSection) ReverseBits(perByte bool) (*IPAddressSection, address_error.IncompatibleAddressError) + func (section *IPAddressSection) ReverseBytes() (*IPAddressSection, address_error.IncompatibleAddressError) + func (section *IPAddressSection) ReverseSegments() *IPAddressSection + func (section *IPAddressSection) SequentialBlockIterator() Iterator[*IPAddressSection] + func (section *IPAddressSection) SetPrefixLen(prefixLen BitCount) *IPAddressSection + func (section *IPAddressSection) SetPrefixLenZeroed(prefixLen BitCount) (*IPAddressSection, address_error.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, address_error.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 address_string.IPStringOptions) string + func (section *IPAddressSection) ToDivGrouping() *AddressDivisionGrouping + func (section *IPAddressSection) ToFullString() string + func (section *IPAddressSection) ToHexString(with0xPrefix bool) (string, address_error.IncompatibleAddressError) + func (section *IPAddressSection) ToIPv4() *IPv4AddressSection + func (section *IPAddressSection) ToIPv6() *IPv6AddressSection + func (section *IPAddressSection) ToMaxHost() (res *IPAddressSection, err address_error.IncompatibleAddressError) + func (section *IPAddressSection) ToMaxHostLen(prefixLength BitCount) (*IPAddressSection, address_error.IncompatibleAddressError) + func (section *IPAddressSection) ToNormalizedString() string + func (section *IPAddressSection) ToNormalizedWildcardString() string + func (section *IPAddressSection) ToOctalString(with0Prefix bool) (string, address_error.IncompatibleAddressError) + func (section *IPAddressSection) ToPrefixBlock() *IPAddressSection + func (section *IPAddressSection) ToPrefixBlockLen(prefLen BitCount) *IPAddressSection + func (section *IPAddressSection) ToPrefixLenString() string + func (section *IPAddressSection) ToReverseDNSString() (string, address_error.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 address_error.IncompatibleAddressError) + func (section *IPAddressSection) ToZeroHostLen(prefixLength BitCount) (*IPAddressSection, address_error.IncompatibleAddressError) + func (section *IPAddressSection) ToZeroNetwork() *IPAddressSection + func (section *IPAddressSection) UpperBytes() []byte + func (section *IPAddressSection) WithoutPrefixLen() *IPAddressSection + func (section *IPAddressSection) Wrap() WrappedIPAddressSection + func (section *IPAddressSection) WrapSection() WrappedAddressSection + type IPAddressSegment struct + func (seg *IPAddressSegment) Bytes() []byte + func (seg *IPAddressSegment) Compare(item AddressItem) int + func (seg *IPAddressSegment) CompareSize(other 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) 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) GetSegmentPrefixLen() PrefixLen + func (seg *IPAddressSegment) GetSegmentValue() SegInt + func (seg *IPAddressSegment) GetString() string + 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() Iterator[*IPAddressSegment] + 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() Iterator[*IPAddressSegment] + func (seg *IPAddressSegment) PrefixContains(other AddressSegmentType, prefixLength BitCount) bool + func (seg *IPAddressSegment) PrefixEqual(other AddressSegmentType, prefixLength BitCount) bool + func (seg *IPAddressSegment) PrefixIterator() Iterator[*IPAddressSegment] + func (seg *IPAddressSegment) PrefixedBlockIterator(segmentPrefixLen BitCount) Iterator[*IPAddressSegment] + func (seg *IPAddressSegment) ReverseBits(perByte bool) (res *AddressSegment, err address_error.IncompatibleAddressError) + func (seg *IPAddressSegment) ReverseBytes() (res *AddressSegment, err address_error.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, address_error.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 + ToPrefixLenString func() string + ToReverseDNSString func() (string, address_error.IncompatibleAddressError) + ToSQLWildcardString func() string + ToSegmentedBinaryString func() string + ToSubnetString func() string + type IPAddressSeqRange = SequentialRange[*IPAddress] + type IPAddressSeqRangeKey = SequentialRangeKey[*IPAddress] + type IPAddressSeqRangeType interface + Contains func(IPAddressType) bool + ContainsRange func(IPAddressSeqRangeType) bool + Equal func(IPAddressSeqRangeType) bool + ToCanonicalString func() string + ToIP func() *SequentialRange[*IPAddress] + ToNormalizedString func() string + type IPAddressString struct + func NewIPAddressString(str string) *IPAddressString + func NewIPAddressStringParams(str string, params address_string_param.IPAddressStringParams) *IPAddressString + func (addrStr *IPAddressString) AdjustPrefixLen(adjustment BitCount) (*IPAddressString, address_error.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() address_string_param.IPAddressStringParams + func (addrStr *IPAddressString) GetVersionedAddress(version IPVersion) *IPAddress + func (addrStr *IPAddressString) IsAllAddresses() bool + func (addrStr *IPAddressString) IsBase85IPv6() bool + func (addrStr *IPAddressString) IsEmpty() bool + func (addrStr *IPAddressString) IsIPv4() bool + func (addrStr *IPAddressString) IsIPv4Mapped() 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, address_error.AddressError) + func (addrStr *IPAddressString) ToHostAddress() (*IPAddress, address_error.AddressError) + func (addrStr *IPAddressString) ToNormalizedString() string + func (addrStr *IPAddressString) ToSequentialRange() (*IPAddressSeqRange, address_error.AddressStringError) + func (addrStr *IPAddressString) ToVersionedAddress(version IPVersion) (*IPAddress, address_error.AddressError) + func (addrStr *IPAddressString) Validate() address_error.AddressStringError + func (addrStr *IPAddressString) ValidateIPv4() address_error.AddressStringError + func (addrStr *IPAddressString) ValidateIPv6() address_error.AddressStringError + func (addrStr *IPAddressString) ValidateVersion(version IPVersion) address_error.AddressStringError + func (addrStr *IPAddressString) Wrap() ExtendedIdentifierString + func (addrStr IPAddressString) Format(state fmt.State, verb rune) + 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 IPPrefixBlockAllocator = PrefixBlockAllocator[*IPAddress] + type IPVersion int + const IPv4 + const IPv6 + const IndeterminateIPVersion + const PrefixLenSeparator + const PrefixLenSeparatorStr + 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) GetNetwork() (network IPAddressNetwork) + 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, address_error.AddressValueError) + func NewIPv4AddressFromBytes(bytes []byte) (addr *IPv4Address, err address_error.AddressValueError) + func NewIPv4AddressFromPrefixedBytes(bytes []byte, prefixLength PrefixLen) (addr *IPv4Address, err address_error.AddressValueError) + func NewIPv4AddressFromPrefixedRange(vals, upperVals IPv4SegmentValueProvider, prefixLength PrefixLen) *IPv4Address + func NewIPv4AddressFromPrefixedSegs(segments []*IPv4AddressSegment, prefixLength PrefixLen) (*IPv4Address, address_error.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, address_error.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, address_error.IncompatibleAddressError) + func (addr *IPv4Address) AssignMinPrefixForBlock() *IPv4Address + func (addr *IPv4Address) AssignPrefixForSingleBlock() *IPv4Address + func (addr *IPv4Address) BitwiseOr(other *IPv4Address) (masked *IPv4Address, err address_error.IncompatibleAddressError) + func (addr *IPv4Address) BlockIterator(segmentCount int) Iterator[*IPv4Address] + func (addr *IPv4Address) Bytes() []byte + func (addr *IPv4Address) Compare(item AddressItem) int + func (addr *IPv4Address) CompareSize(other AddressItem) 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) ForEachSegment(consumer func(segmentIndex int, segment *IPv4AddressSegment) (stop bool)) int + func (addr *IPv4Address) GetBitCount() BitCount + func (addr *IPv4Address) GetBitsPerSegment() BitCount + func (addr *IPv4Address) GetBlockCount(segments 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) GetIPv4BlockCount(segmentCount int) uint64 + func (addr *IPv4Address) GetIPv4Count() uint64 + func (addr *IPv4Address) GetIPv4MappedAddress() (*IPv6Address, address_error.IncompatibleAddressError) + func (addr *IPv4Address) GetIPv4PrefixCount() uint64 + func (addr *IPv4Address) GetIPv4PrefixCountLen(prefixLength BitCount) uint64 + func (addr *IPv4Address) GetIPv6Address(section *IPv6AddressSection) (*IPv6Address, address_error.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) GetNetIPAddr() *net.IPAddr + func (addr *IPv4Address) GetNetNetIPAddr() netip.Addr + 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) GetUpperNetIPAddr() *net.IPAddr + func (addr *IPv4Address) GetUpperNetNetIPAddr() netip.Addr + 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) IsFullRange() 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() Iterator[*IPv4Address] + func (addr *IPv4Address) Mask(other *IPv4Address) (masked *IPv4Address, err address_error.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() Iterator[*IPv4Address] + func (addr *IPv4Address) PrefixContains(other AddressType) bool + func (addr *IPv4Address) PrefixEqual(other AddressType) bool + func (addr *IPv4Address) PrefixIterator() Iterator[*IPv4Address] + 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, address_error.IncompatibleAddressError) + func (addr *IPv4Address) ReverseBytes() *IPv4Address + func (addr *IPv4Address) ReverseSegments() *IPv4Address + func (addr *IPv4Address) SequentialBlockIterator() Iterator[*IPv4Address] + func (addr *IPv4Address) SetPrefixLen(prefixLen BitCount) *IPv4Address + func (addr *IPv4Address) SetPrefixLenZeroed(prefixLen BitCount) (*IPv4Address, address_error.IncompatibleAddressError) + func (addr *IPv4Address) SpanWithPrefixBlocks() []*IPv4Address + func (addr *IPv4Address) SpanWithPrefixBlocksTo(other *IPv4Address) []*IPv4Address + func (addr *IPv4Address) SpanWithRange(other *IPv4Address) *SequentialRange[*IPv4Address] + 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, address_error.IncompatibleAddressError) + func (addr *IPv4Address) ToBlock(segmentIndex int, lower, upper SegInt) *IPv4Address + func (addr *IPv4Address) ToBroadcastAddress() (*IPv4Address, address_error.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 address_string.IPStringOptions) string + func (addr *IPv4Address) ToFullString() string + func (addr *IPv4Address) ToGenericKey() Key[*IPv4Address] + func (addr *IPv4Address) ToHexString(with0xPrefix bool) (string, address_error.IncompatibleAddressError) + func (addr *IPv4Address) ToIP() *IPAddress + func (addr *IPv4Address) ToInetAtonJoinedString(radix InetAtonRadix, joinedCount int) (string, address_error.IncompatibleAddressError) + func (addr *IPv4Address) ToInetAtonString(radix InetAtonRadix) string + func (addr *IPv4Address) ToKey() IPv4AddressKey + func (addr *IPv4Address) ToMaxHost() (*IPv4Address, address_error.IncompatibleAddressError) + func (addr *IPv4Address) ToMaxHostLen(prefixLength BitCount) (*IPv4Address, address_error.IncompatibleAddressError) + func (addr *IPv4Address) ToNetworkAddress() (*IPv4Address, address_error.IncompatibleAddressError) + func (addr *IPv4Address) ToNormalizedString() string + func (addr *IPv4Address) ToNormalizedWildcardString() string + func (addr *IPv4Address) ToOctalString(with0Prefix bool) (string, address_error.IncompatibleAddressError) + func (addr *IPv4Address) ToPrefixBlock() *IPv4Address + func (addr *IPv4Address) ToPrefixBlockLen(prefLen BitCount) *IPv4Address + func (addr *IPv4Address) ToPrefixLenString() string + func (addr *IPv4Address) ToReverseDNSString() (string, address_error.IncompatibleAddressError) + func (addr *IPv4Address) ToSQLWildcardString() string + func (addr *IPv4Address) ToSegmentedBinaryString() string + func (addr *IPv4Address) ToSequentialRange() *SequentialRange[*IPv4Address] + func (addr *IPv4Address) ToSinglePrefixBlockOrAddress() *IPv4Address + func (addr *IPv4Address) ToSubnetString() string + func (addr *IPv4Address) ToUNCHostName() string + func (addr *IPv4Address) ToZeroHost() (*IPv4Address, address_error.IncompatibleAddressError) + func (addr *IPv4Address) ToZeroHostLen(prefixLength BitCount) (*IPv4Address, address_error.IncompatibleAddressError) + func (addr *IPv4Address) ToZeroNetwork() *IPv4Address + func (addr *IPv4Address) TrieCompare(other *IPv4Address) int + func (addr *IPv4Address) TrieDecrement() *IPv4Address + func (addr *IPv4Address) TrieIncrement() *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) WrapAddress() WrappedAddress + func (addr IPv4Address) Format(state fmt.State, verb rune) + type IPv4AddressAssociativeTrie = AssociativeTrie[*IPv4Address, any] + type IPv4AddressConverter interface + ToIPv4 func(address *IPAddress) *IPv4Address + type IPv4AddressKey struct + func (key IPv4AddressKey) String() string + func (key IPv4AddressKey) ToAddress() *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) *IPv4AddressSection + func NewIPv4SectionFromPrefixedBytes(bytes []byte, segmentCount int, prefixLength PrefixLen) (res *IPv4AddressSection, err address_error.AddressValueError) + func NewIPv4SectionFromPrefixedRange(vals, upperVals IPv4SegmentValueProvider, segmentCount int, ...) (res *IPv4AddressSection) + func NewIPv4SectionFromPrefixedUint32(value 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 address_error.AddressValueError) + func NewIPv4SectionFromUint32(value 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, address_error.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 address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) BlockIterator(segmentCount int) Iterator[*IPv4AddressSection] + func (section *IPv4AddressSection) Bytes() []byte + func (section *IPv4AddressSection) Compare(item AddressItem) int + func (section *IPv4AddressSection) CompareSize(other AddressItem) 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, address_error.SizeMismatchError) + func (section *IPv4AddressSection) Equal(other AddressSectionType) bool + func (section *IPv4AddressSection) ForEachSegment(consumer func(segmentIndex int, segment *IPv4AddressSegment) (stop bool)) int + 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) 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) 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 address_error.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() Iterator[*IPv4AddressSection] + func (section *IPv4AddressSection) Mask(other *IPv4AddressSection) (res *IPv4AddressSection, err address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) MatchesWithMask(other *IPv4AddressSection, mask *IPv4AddressSection) bool + func (section *IPv4AddressSection) MergeToPrefixBlocks(sections ...*IPv4AddressSection) ([]*IPv4AddressSection, address_error.SizeMismatchError) + func (section *IPv4AddressSection) MergeToSequentialBlocks(sections ...*IPv4AddressSection) ([]*IPv4AddressSection, address_error.SizeMismatchError) + func (section *IPv4AddressSection) PrefixBlockIterator() Iterator[*IPv4AddressSection] + func (section *IPv4AddressSection) PrefixContains(other AddressSectionType) bool + func (section *IPv4AddressSection) PrefixEqual(other AddressSectionType) bool + func (section *IPv4AddressSection) PrefixIterator() Iterator[*IPv4AddressSection] + 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, address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) ReverseBytes() *IPv4AddressSection + func (section *IPv4AddressSection) ReverseSegments() *IPv4AddressSection + func (section *IPv4AddressSection) SequentialBlockIterator() Iterator[*IPv4AddressSection] + func (section *IPv4AddressSection) SetPrefixLen(prefixLen BitCount) *IPv4AddressSection + func (section *IPv4AddressSection) SetPrefixLenZeroed(prefixLen BitCount) (*IPv4AddressSection, address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) SpanWithPrefixBlocks() []*IPv4AddressSection + func (section *IPv4AddressSection) SpanWithPrefixBlocksTo(other *IPv4AddressSection) ([]*IPv4AddressSection, address_error.SizeMismatchError) + func (section *IPv4AddressSection) SpanWithSequentialBlocks() []*IPv4AddressSection + func (section *IPv4AddressSection) SpanWithSequentialBlocksTo(other *IPv4AddressSection) ([]*IPv4AddressSection, address_error.SizeMismatchError) + func (section *IPv4AddressSection) String() string + func (section *IPv4AddressSection) Subtract(other *IPv4AddressSection) (res []*IPv4AddressSection, err address_error.SizeMismatchError) + func (section *IPv4AddressSection) TestBit(n BitCount) bool + func (section *IPv4AddressSection) ToBinaryString(with0bPrefix bool) (string, address_error.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, address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) ToIP() *IPAddressSection + func (section *IPv4AddressSection) ToInetAtonJoinedString(radix InetAtonRadix, joinedCount int) (string, address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) ToInetAtonString(radix InetAtonRadix) string + func (section *IPv4AddressSection) ToJoinedSegments(joinCount int) (AddressDivisionSeries, address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) ToMaxHost() (*IPv4AddressSection, address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) ToMaxHostLen(prefixLength BitCount) (*IPv4AddressSection, address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) ToNormalizedJoinedString(stringParams address_string.IPStringOptions, joinedCount int) (string, address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) ToNormalizedString() string + func (section *IPv4AddressSection) ToNormalizedWildcardString() string + func (section *IPv4AddressSection) ToOctalString(with0Prefix bool) (string, address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) ToPrefixBlock() *IPv4AddressSection + func (section *IPv4AddressSection) ToPrefixBlockLen(prefLen BitCount) *IPv4AddressSection + func (section *IPv4AddressSection) ToPrefixLenString() string + func (section *IPv4AddressSection) ToReverseDNSString() (string, address_error.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, address_error.IncompatibleAddressError) + func (section *IPv4AddressSection) ToZeroHostLen(prefixLength BitCount) (*IPv4AddressSection, address_error.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 + func (section *IPv4AddressSection) WrapSection() WrappedAddressSection + 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) CompareSize(other 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) 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() Iterator[*IPv4AddressSegment] + func (seg *IPv4AddressSegment) Join(low *IPv4AddressSegment) (*IPv6AddressSegment, address_error.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() Iterator[*IPv4AddressSegment] + func (seg *IPv4AddressSegment) PrefixContains(other AddressSegmentType, prefixLength BitCount) bool + func (seg *IPv4AddressSegment) PrefixEqual(other AddressSegmentType, prefixLength BitCount) bool + func (seg *IPv4AddressSegment) PrefixIterator() Iterator[*IPv4AddressSegment] + func (seg *IPv4AddressSegment) PrefixedBlockIterator(segmentPrefixLen BitCount) Iterator[*IPv4AddressSegment] + func (seg *IPv4AddressSegment) ReverseBits(_ bool) (res *IPv4AddressSegment, err address_error.IncompatibleAddressError) + func (seg *IPv4AddressSegment) ReverseBytes() (*IPv4AddressSegment, address_error.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, address_error.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 + func (seg IPv4AddressSegment) Format(state fmt.State, verb rune) + 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 = SequentialRange[*IPv4Address] + type IPv4AddressSeqRangeKey = SequentialRangeKey[*IPv4Address] + type IPv4AddressTrie = Trie[*IPv4Address] + type IPv4PrefixBlockAllocator = PrefixBlockAllocator[*IPv4Address] + type IPv4SegInt = uint8 + type IPv4SegmentValueProvider func(segmentIndex int) IPv4SegInt + func WrapSegmentValueProviderForIPv4(f SegmentValueProvider) IPv4SegmentValueProvider + type IPv6Address struct + func NewIPv6Address(section *IPv6AddressSection) (*IPv6Address, address_error.AddressValueError) + func NewIPv6AddressFromBytes(bytes []byte) (addr *IPv6Address, err address_error.AddressValueError) + func NewIPv6AddressFromInt(val *big.Int) (addr *IPv6Address, err address_error.AddressValueError) + func NewIPv6AddressFromMAC(prefix *IPv6Address, suffix *MACAddress) (*IPv6Address, address_error.IncompatibleAddressError) + func NewIPv6AddressFromMACSection(prefix *IPv6AddressSection, suffix *MACAddressSection) (*IPv6Address, address_error.AddressError) + func NewIPv6AddressFromPrefixedBytes(bytes []byte, prefixLength PrefixLen) (addr *IPv6Address, err address_error.AddressValueError) + func NewIPv6AddressFromPrefixedInt(val *big.Int, prefixLength PrefixLen) (addr *IPv6Address, err address_error.AddressValueError) + func NewIPv6AddressFromPrefixedRange(vals, upperVals IPv6SegmentValueProvider, prefixLength PrefixLen) *IPv6Address + func NewIPv6AddressFromPrefixedSegs(segments []*IPv6AddressSegment, prefixLength PrefixLen) (addr *IPv6Address, err address_error.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 address_error.AddressValueError) + func NewIPv6AddressFromPrefixedZonedInt(val *big.Int, prefixLength PrefixLen, zone string) (addr *IPv6Address, err address_error.AddressValueError) + func NewIPv6AddressFromPrefixedZonedRange(vals, upperVals IPv6SegmentValueProvider, prefixLength PrefixLen, zone string) *IPv6Address + func NewIPv6AddressFromPrefixedZonedSegs(segments []*IPv6AddressSegment, prefixLength PrefixLen, zone string) (addr *IPv6Address, err address_error.AddressValueError) + func NewIPv6AddressFromPrefixedZonedUint64(highBytes, lowBytes uint64, prefixLength PrefixLen, zone string) *IPv6Address + func NewIPv6AddressFromRange(vals, upperVals IPv6SegmentValueProvider) *IPv6Address + func NewIPv6AddressFromSegs(segments []*IPv6AddressSegment) (addr *IPv6Address, err address_error.AddressValueError) + func NewIPv6AddressFromUint64(highBytes, lowBytes uint64) *IPv6Address + func NewIPv6AddressFromVals(vals IPv6SegmentValueProvider) *IPv6Address + func NewIPv6AddressFromZonedBytes(bytes []byte, zone string) (addr *IPv6Address, err address_error.AddressValueError) + func NewIPv6AddressFromZonedInt(val *big.Int, zone string) (addr *IPv6Address, err address_error.AddressValueError) + func NewIPv6AddressFromZonedMACSection(prefix *IPv6AddressSection, suffix *MACAddressSection, zone string) (*IPv6Address, address_error.AddressError) + func NewIPv6AddressFromZonedRange(vals, upperVals IPv6SegmentValueProvider, zone string) *IPv6Address + func NewIPv6AddressFromZonedSegs(segments []*IPv6AddressSegment, zone string) (addr *IPv6Address, err address_error.AddressValueError) + func NewIPv6AddressFromZonedUint64(highBytes, lowBytes uint64, zone string) *IPv6Address + func NewIPv6AddressZoned(section *IPv6AddressSection, zone string) (*IPv6Address, address_error.AddressValueError) + func (addr *IPv6Address) AdjustPrefixLen(prefixLen BitCount) *IPv6Address + func (addr *IPv6Address) AdjustPrefixLenZeroed(prefixLen BitCount) (*IPv6Address, address_error.IncompatibleAddressError) + func (addr *IPv6Address) AssignMinPrefixForBlock() *IPv6Address + func (addr *IPv6Address) AssignPrefixForSingleBlock() *IPv6Address + func (addr *IPv6Address) BitwiseOr(other *IPv6Address) (masked *IPv6Address, err address_error.IncompatibleAddressError) + func (addr *IPv6Address) BlockIterator(segmentCount int) Iterator[*IPv6Address] + func (addr *IPv6Address) Bytes() []byte + func (addr *IPv6Address) Compare(item AddressItem) int + func (addr *IPv6Address) CompareSize(other AddressItem) 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) ForEachSegment(consumer func(segmentIndex int, segment *IPv6AddressSegment) (stop bool)) int + func (addr *IPv6Address) Get6To4IPv4Address() (*IPv4Address, address_error.IncompatibleAddressError) + func (addr *IPv6Address) GetBitCount() BitCount + func (addr *IPv6Address) GetBitsPerSegment() BitCount + func (addr *IPv6Address) GetBlockCount(segments 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, address_error.IncompatibleAddressError) + func (addr *IPv6Address) GetEmbeddedIPv4AddressAt(byteIndex int) (*IPv4Address, address_error.IncompatibleAddressError) + func (addr *IPv6Address) GetEmbeddedIPv4AddressSection() (*IPv4AddressSection, address_error.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, address_error.IncompatibleAddressError) + func (addr *IPv6Address) GetIPv6Address(embedded IPv4Address) (*IPv6Address, address_error.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, address_error.IncompatibleAddressError) + func (addr *IPv6Address) GetNetIP() net.IP + func (addr *IPv6Address) GetNetIPAddr() *net.IPAddr + func (addr *IPv6Address) GetNetNetIPAddr() netip.Addr + 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) GetUpperNetIPAddr() *net.IPAddr + func (addr *IPv6Address) GetUpperNetNetIPAddr() netip.Addr + 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) IsFullRange() 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() Iterator[*IPv6Address] + func (addr *IPv6Address) Mask(other *IPv6Address) (masked *IPv6Address, err address_error.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() Iterator[*IPv6Address] + func (addr *IPv6Address) PrefixContains(other AddressType) bool + func (addr *IPv6Address) PrefixEqual(other AddressType) bool + func (addr *IPv6Address) PrefixIterator() Iterator[*IPv6Address] + 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, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ReverseBytes() (*IPv6Address, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ReverseSegments() *IPv6Address + func (addr *IPv6Address) SequentialBlockIterator() Iterator[*IPv6Address] + func (addr *IPv6Address) SetPrefixLen(prefixLen BitCount) *IPv6Address + func (addr *IPv6Address) SetPrefixLenZeroed(prefixLen BitCount) (*IPv6Address, address_error.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) *SequentialRange[*IPv6Address] + 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) ToBase85String() (string, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ToBinaryString(with0bPrefix bool) (string, address_error.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 address_string.IPv6StringOptions) (string, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ToEUI(extended bool) (*MACAddress, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ToFullString() string + func (addr *IPv6Address) ToGenericKey() Key[*IPv6Address] + func (addr *IPv6Address) ToHexString(with0xPrefix bool) (string, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ToIP() *IPAddress + func (addr *IPv6Address) ToKey() IPv6AddressKey + func (addr *IPv6Address) ToMaxHost() (*IPv6Address, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ToMaxHostLen(prefixLength BitCount) (*IPv6Address, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ToMixedString() (string, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ToNormalizedString() string + func (addr *IPv6Address) ToNormalizedWildcardString() string + func (addr *IPv6Address) ToOctalString(with0Prefix bool) (string, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ToPrefixBlock() *IPv6Address + func (addr *IPv6Address) ToPrefixBlockLen(prefLen BitCount) *IPv6Address + func (addr *IPv6Address) ToPrefixLenString() string + func (addr *IPv6Address) ToReverseDNSString() (string, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ToSQLWildcardString() string + func (addr *IPv6Address) ToSegmentedBinaryString() string + func (addr *IPv6Address) ToSequentialRange() *SequentialRange[*IPv6Address] + func (addr *IPv6Address) ToSinglePrefixBlockOrAddress() *IPv6Address + func (addr *IPv6Address) ToSubnetString() string + func (addr *IPv6Address) ToUNCHostName() string + func (addr *IPv6Address) ToZeroHost() (*IPv6Address, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ToZeroHostLen(prefixLength BitCount) (*IPv6Address, address_error.IncompatibleAddressError) + func (addr *IPv6Address) ToZeroNetwork() *IPv6Address + func (addr *IPv6Address) TrieCompare(other *IPv6Address) int + func (addr *IPv6Address) TrieDecrement() *IPv6Address + func (addr *IPv6Address) TrieIncrement() *IPv6Address + func (addr *IPv6Address) Uint64Values() (high, low uint64) + func (addr *IPv6Address) UpperBytes() []byte + func (addr *IPv6Address) UpperUint64Values() (high, low uint64) + func (addr *IPv6Address) WithoutPrefixLen() *IPv6Address + func (addr *IPv6Address) WithoutZone() *IPv6Address + func (addr *IPv6Address) Wrap() WrappedIPAddress + func (addr *IPv6Address) WrapAddress() WrappedAddress + func (addr IPv6Address) Format(state fmt.State, verb rune) + type IPv6AddressAssociativeTrie = AssociativeTrie[*IPv6Address, any] + type IPv6AddressConverter interface + ToIPv6 func(address *IPAddress) *IPv6Address + type IPv6AddressKey struct + func (key IPv6AddressKey) String() string + func (key IPv6AddressKey) ToAddress() *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 address_error.AddressValueError) + func NewIPv6SectionFromBytes(bytes []byte) *IPv6AddressSection + func NewIPv6SectionFromMAC(eui *MACAddress) (res *IPv6AddressSection, err address_error.IncompatibleAddressError) + func NewIPv6SectionFromPrefixedBigInt(val *big.Int, segmentCount int, prefixLen PrefixLen) (res *IPv6AddressSection, err address_error.AddressValueError) + func NewIPv6SectionFromPrefixedBytes(bytes []byte, segmentCount int, prefixLength PrefixLen) (res *IPv6AddressSection, err address_error.AddressValueError) + func NewIPv6SectionFromPrefixedRange(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 NewIPv6SectionFromRange(vals, upperVals IPv6SegmentValueProvider, segmentCount int) (res *IPv6AddressSection) + func NewIPv6SectionFromSegmentedBytes(bytes []byte, segmentCount int) (res *IPv6AddressSection, err address_error.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, address_error.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 address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) BlockIterator(segmentCount int) Iterator[*IPv6AddressSection] + func (section *IPv6AddressSection) Bytes() []byte + func (section *IPv6AddressSection) Compare(item AddressItem) int + func (section *IPv6AddressSection) CompareSize(other AddressItem) 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, address_error.SizeMismatchError) + func (section *IPv6AddressSection) Equal(other AddressSectionType) bool + func (section *IPv6AddressSection) ForEachSegment(consumer func(segmentIndex int, segment *IPv6AddressSegment) (stop bool)) int + func (section *IPv6AddressSection) GetBitCount() BitCount + func (section *IPv6AddressSection) GetBitsPerSegment() BitCount + func (section *IPv6AddressSection) GetBlockCount(segments 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, address_error.IncompatibleAddressError) + 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) 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() SegmentSequenceList + func (section *IPv6AddressSection) GetZeroSegments() SegmentSequenceList + 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 address_error.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() Iterator[*IPv6AddressSection] + func (section *IPv6AddressSection) Mask(other *IPv6AddressSection) (res *IPv6AddressSection, err address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) MatchesWithMask(other *IPv6AddressSection, mask *IPv6AddressSection) bool + func (section *IPv6AddressSection) MergeToPrefixBlocks(sections ...*IPv6AddressSection) ([]*IPv6AddressSection, address_error.SizeMismatchError) + func (section *IPv6AddressSection) MergeToSequentialBlocks(sections ...*IPv6AddressSection) ([]*IPv6AddressSection, address_error.SizeMismatchError) + func (section *IPv6AddressSection) PrefixBlockIterator() Iterator[*IPv6AddressSection] + func (section *IPv6AddressSection) PrefixContains(other AddressSectionType) bool + func (section *IPv6AddressSection) PrefixEqual(other AddressSectionType) bool + func (section *IPv6AddressSection) PrefixIterator() Iterator[*IPv6AddressSection] + 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, address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) ReverseBytes() (*IPv6AddressSection, address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) ReverseSegments() *IPv6AddressSection + func (section *IPv6AddressSection) SequentialBlockIterator() Iterator[*IPv6AddressSection] + func (section *IPv6AddressSection) SetPrefixLen(prefixLen BitCount) *IPv6AddressSection + func (section *IPv6AddressSection) SetPrefixLenZeroed(prefixLen BitCount) (*IPv6AddressSection, address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) SpanWithPrefixBlocks() []*IPv6AddressSection + func (section *IPv6AddressSection) SpanWithPrefixBlocksTo(other *IPv6AddressSection) ([]*IPv6AddressSection, address_error.SizeMismatchError) + func (section *IPv6AddressSection) SpanWithSequentialBlocks() []*IPv6AddressSection + func (section *IPv6AddressSection) SpanWithSequentialBlocksTo(other *IPv6AddressSection) ([]*IPv6AddressSection, address_error.SizeMismatchError) + func (section *IPv6AddressSection) String() string + func (section *IPv6AddressSection) Subtract(other *IPv6AddressSection) (res []*IPv6AddressSection, err address_error.SizeMismatchError) + func (section *IPv6AddressSection) TestBit(n BitCount) bool + func (section *IPv6AddressSection) ToBase85String() (string, address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) ToBinaryString(with0bPrefix bool) (string, address_error.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 address_string.IPv6StringOptions) (string, address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) ToDivGrouping() *AddressDivisionGrouping + func (section *IPv6AddressSection) ToFullString() string + func (section *IPv6AddressSection) ToHexString(with0xPrefix bool) (string, address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) ToIP() *IPAddressSection + func (section *IPv6AddressSection) ToMaxHost() (*IPv6AddressSection, address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) ToMaxHostLen(prefixLength BitCount) (*IPv6AddressSection, address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) ToNormalizedString() string + func (section *IPv6AddressSection) ToNormalizedWildcardString() string + func (section *IPv6AddressSection) ToOctalString(with0Prefix bool) (string, address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) ToPrefixBlock() *IPv6AddressSection + func (section *IPv6AddressSection) ToPrefixBlockLen(prefLen BitCount) *IPv6AddressSection + func (section *IPv6AddressSection) ToPrefixLenString() string + func (section *IPv6AddressSection) ToReverseDNSString() (string, address_error.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, address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) ToZeroHostLen(prefixLength BitCount) (*IPv6AddressSection, address_error.IncompatibleAddressError) + func (section *IPv6AddressSection) ToZeroNetwork() *IPv6AddressSection + func (section *IPv6AddressSection) Uint64Values() (high, low uint64) + func (section *IPv6AddressSection) UpperBytes() []byte + func (section *IPv6AddressSection) UpperUint64Values() (high, low uint64) + func (section *IPv6AddressSection) WithoutPrefixLen() *IPv6AddressSection + func (section *IPv6AddressSection) Wrap() WrappedIPAddressSection + func (section *IPv6AddressSection) WrapSection() WrappedAddressSection + 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) CompareSize(other 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) 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() Iterator[*IPv6AddressSegment] + 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() Iterator[*IPv6AddressSegment] + func (seg *IPv6AddressSegment) PrefixContains(other AddressSegmentType, prefixLength BitCount) bool + func (seg *IPv6AddressSegment) PrefixEqual(other AddressSegmentType, prefixLength BitCount) bool + func (seg *IPv6AddressSegment) PrefixIterator() Iterator[*IPv6AddressSegment] + func (seg *IPv6AddressSegment) PrefixedBlockIterator(segmentPrefixLen BitCount) Iterator[*IPv6AddressSegment] + func (seg *IPv6AddressSegment) ReverseBits(perByte bool) (res *IPv6AddressSegment, err address_error.IncompatibleAddressError) + func (seg *IPv6AddressSegment) ReverseBytes() (res *IPv6AddressSegment, err address_error.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, address_error.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 = SequentialRange[*IPv6Address] + type IPv6AddressSeqRangeKey = SequentialRangeKey[*IPv6Address] + type IPv6AddressTrie = Trie[*IPv6Address] + type IPv6PrefixBlockAllocator = PrefixBlockAllocator[*IPv6Address] + type IPv6SegInt = uint16 + type IPv6SegmentValueProvider func(segmentIndex int) IPv6SegInt + func WrapSegmentValueProviderForIPv6(f SegmentValueProvider) IPv6SegmentValueProvider + type IPv6v4MixedAddressGrouping struct + func (grouping *IPv6v4MixedAddressGrouping) Bytes() []byte + func (grouping *IPv6v4MixedAddressGrouping) Compare(item AddressItem) int + func (grouping *IPv6v4MixedAddressGrouping) CompareSize(other AddressItem) 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) GetBitCount() BitCount + func (grouping *IPv6v4MixedAddressGrouping) GetBlockCount(divisionCount int) *big.Int + func (grouping *IPv6v4MixedAddressGrouping) GetByteCount() 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) 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) 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) + type InetAtonRadix int + const InetAtonRadixHex + const InetAtonRadixOctal + const InetAtonRadix_decimal + func (rad InetAtonRadix) GetRadix() int + func (rad InetAtonRadix) GetSegmentStrPrefix() string + func (rad InetAtonRadix) String() string + type IteratePartitionConstraint interface + AssignMinPrefixForBlock func() T + Iterator func() Iterator[T] + PrefixBlockIterator func() Iterator[T] + type Iterator interface + HasNext func() bool + Next func() T + func NewFilteredAddrIterator(iter Iterator[*Address], skip func(*Address) bool) Iterator[*Address] + func NewFilteredIPAddrIterator(iter Iterator[*IPAddress], skip func(*IPAddress) bool) Iterator[*IPAddress] + type IteratorWithRemove interface + Remove func() T + type Key struct + func (key Key[T]) String() string + func (key Key[T]) ToAddress() T + type KeyConstraint interface + type KeyGeneratorConstraint interface + ToGenericKey func() Key[T] + type MACAddress struct + func NewMACAddress(section *MACAddressSection) (*MACAddress, address_error.AddressValueError) + func NewMACAddressFromBytes(bytes net.HardwareAddr) (*MACAddress, address_error.AddressValueError) + func NewMACAddressFromRange(vals, upperVals MACSegmentValueProvider) (addr *MACAddress) + func NewMACAddressFromRangeExt(vals, upperVals MACSegmentValueProvider, isExtended bool) (addr *MACAddress) + func NewMACAddressFromSegs(segments []*MACAddressSegment) (*MACAddress, address_error.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, address_error.IncompatibleAddressError) + func (addr *MACAddress) AssignMinPrefixForBlock() *MACAddress + func (addr *MACAddress) AssignPrefixForSingleBlock() *MACAddress + func (addr *MACAddress) BlockIterator(segmentCount int) Iterator[*MACAddress] + func (addr *MACAddress) Bytes() []byte + func (addr *MACAddress) Compare(item AddressItem) int + func (addr *MACAddress) CompareSize(other AddressItem) 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) ForEachSegment(consumer func(segmentIndex int, segment *MACAddressSegment) (stop bool)) int + func (addr *MACAddress) GetBitCount() BitCount + func (addr *MACAddress) GetBitsPerSegment() BitCount + func (addr *MACAddress) GetBlockCount(segments 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, address_error.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() *MACAddress + 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() *MACAddress + 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() Iterator[*MACAddress] + func (addr *MACAddress) PrefixBlockIterator() Iterator[*MACAddress] + func (addr *MACAddress) PrefixContains(other AddressType) bool + func (addr *MACAddress) PrefixEqual(other AddressType) bool + func (addr *MACAddress) PrefixIterator() Iterator[*MACAddress] + 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, address_error.IncompatibleAddressError) + func (addr *MACAddress) ReverseBytes() *MACAddress + func (addr *MACAddress) ReverseSegments() *MACAddress + func (addr *MACAddress) SequentialBlockIterator() Iterator[*MACAddress] + func (addr *MACAddress) SetPrefixLen(prefixLen BitCount) *MACAddress + func (addr *MACAddress) SetPrefixLenZeroed(prefixLen BitCount) (*MACAddress, address_error.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, address_error.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 address_string.StringOptions) string + func (addr *MACAddress) ToDashedString() string + func (addr *MACAddress) ToDottedString() (string, address_error.IncompatibleAddressError) + func (addr *MACAddress) ToEUI64(asMAC bool) (*MACAddress, address_error.IncompatibleAddressError) + func (addr *MACAddress) ToEUI64IPv6() (*IPv6AddressSection, address_error.IncompatibleAddressError) + func (addr *MACAddress) ToGenericKey() Key[*MACAddress] + func (addr *MACAddress) ToHexString(with0xPrefix bool) (string, address_error.IncompatibleAddressError) + func (addr *MACAddress) ToKey() MACAddressKey + func (addr *MACAddress) ToLinkLocalIPv6() (*IPv6Address, address_error.IncompatibleAddressError) + func (addr *MACAddress) ToNormalizedString() string + func (addr *MACAddress) ToNormalizedWildcardString() string + func (addr *MACAddress) ToOUIPrefixBlock() *MACAddress + func (addr *MACAddress) ToOctalString(with0Prefix bool) (string, address_error.IncompatibleAddressError) + func (addr *MACAddress) ToPrefixBlock() *MACAddress + func (addr *MACAddress) ToPrefixBlockLen(prefLen BitCount) *MACAddress + func (addr *MACAddress) ToSinglePrefixBlockOrAddress() *MACAddress + func (addr *MACAddress) ToSpaceDelimitedString() string + func (addr *MACAddress) TrieCompare(other *MACAddress) (int, address_error.IncompatibleAddressError) + func (addr *MACAddress) TrieDecrement() *MACAddress + func (addr *MACAddress) TrieIncrement() *MACAddress + 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 MACAddressKey struct + func (key MACAddressKey) String() string + func (key MACAddressKey) ToAddress() *MACAddress + type MACAddressSection struct + func NewMACSection(segments []*MACAddressSegment) *MACAddressSection + func NewMACSectionFromBytes(bytes []byte, segmentCount int) (res *MACAddressSection, err address_error.AddressValueError) + func NewMACSectionFromRange(vals, upperVals MACSegmentValueProvider, segmentCount int) (res *MACAddressSection) + func NewMACSectionFromUint64(val 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, address_error.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 AddressItem) 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) ForEachSegment(consumer func(segmentIndex int, segment *MACAddressSegment) (stop bool)) int + func (section *MACAddressSection) GetBitCount() BitCount + func (section *MACAddressSection) GetBitsPerSegment() BitCount + func (section *MACAddressSection) GetBlockCount(segments int) *big.Int + func (section *MACAddressSection) GetByteCount() int + func (section *MACAddressSection) GetBytesPerSegment() int + func (section *MACAddressSection) GetCount() *big.Int + func (section *MACAddressSection) GetDottedGrouping() (*AddressDivisionGrouping, address_error.IncompatibleAddressError) + func (section *MACAddressSection) GetGenericSegment(index int) AddressSegmentType + func (section *MACAddressSection) GetLeadingBitCount(ones bool) BitCount + 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) GetTrailingBitCount(ones bool) BitCount + 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() Iterator[*MACAddressSection] + func (section *MACAddressSection) PrefixBlockIterator() Iterator[*MACAddressSection] + func (section *MACAddressSection) PrefixContains(other AddressSectionType) (res bool) + func (section *MACAddressSection) PrefixEqual(other AddressSectionType) (res bool) + func (section *MACAddressSection) PrefixIterator() Iterator[*MACAddressSection] + 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, address_error.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, address_error.IncompatibleAddressError) + func (section *MACAddressSection) String() string + func (section *MACAddressSection) TestBit(n BitCount) bool + func (section *MACAddressSection) ToBinaryString(with0bPrefix bool) (string, address_error.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, address_error.IncompatibleAddressError) + func (section *MACAddressSection) ToHexString(with0xPrefix bool) (string, address_error.IncompatibleAddressError) + func (section *MACAddressSection) ToNormalizedString() string + func (section *MACAddressSection) ToNormalizedWildcardString() string + func (section *MACAddressSection) ToOctalString(with0Prefix bool) (string, address_error.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) CompareSize(other 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) GetLeadingBitCount(ones bool) BitCount + 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) GetSegmentHostMask(networkBits BitCount) SegInt + func (seg *MACAddressSegment) GetSegmentNetworkMask(networkBits BitCount) SegInt + func (seg *MACAddressSegment) GetSegmentValue() SegInt + func (seg *MACAddressSegment) GetString() string + func (seg *MACAddressSegment) GetTrailingBitCount(ones bool) BitCount + 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() Iterator[*MACAddressSegment] + func (seg *MACAddressSegment) Join(macSegment1 *MACAddressSegment, prefixLength PrefixLen) (*IPv6AddressSegment, address_error.IncompatibleAddressError) + func (seg *MACAddressSegment) JoinAndFlip2ndBit(macSegment1 *MACAddressSegment, prefixLength PrefixLen) (*IPv6AddressSegment, address_error.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) Iterator[*MACAddressSegment] + func (seg *MACAddressSegment) PrefixContains(other AddressSegmentType, prefixLength BitCount) bool + func (seg *MACAddressSegment) PrefixEqual(other AddressSegmentType, prefixLength BitCount) bool + func (seg *MACAddressSegment) PrefixIterator(segmentPrefixLen BitCount) Iterator[*MACAddressSegment] + func (seg *MACAddressSegment) ReverseBits(_ bool) (res *MACAddressSegment, err address_error.IncompatibleAddressError) + func (seg *MACAddressSegment) ReverseBytes() (*MACAddressSegment, address_error.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, address_error.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 address_string_param.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() address_string_param.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, address_error.AddressError) + func (addrStr *MACAddressString) ToNormalizedString() string + func (addrStr *MACAddressString) Validate() address_error.AddressStringError + func (addrStr *MACAddressString) Wrap() ExtendedIdentifierString + func (addrStr MACAddressString) Format(state fmt.State, verb rune) + type MACSegInt = uint8 + type MACSegmentValueProvider func(segmentIndex int) MACSegInt + func WrapSegmentValueProviderForMAC(f SegmentValueProvider) MACSegmentValueProvider + type MappedPartition map[Key[T]]V + func ApplyForEachConditionally[T GenericKeyConstraint[T], V any](part *Partition[T], action func(T) (V, bool)) MappedPartition[T, V] + func ApplyForEach[T GenericKeyConstraint[T], V any](part *Partition[T], action func(T) V) MappedPartition[T, V] + 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 NodeValue = any + type Partition struct + func PartitionIPv4WithSingleBlockSize(newAddr *IPv4Address) *Partition[*IPv4Address] + func PartitionIPv6WithSingleBlockSize(newAddr *IPv6Address) *Partition[*IPv6Address] + func PartitionIpv4WithSpanningBlocks(newAddr *IPv4Address) *Partition[*IPv4Address] + func PartitionIpv6WithSpanningBlocks(newAddr *IPv6Address) *Partition[*IPv6Address] + func PartitionWithSingleBlockSize[T IteratePartitionConstraint[T]](newAddr T) *Partition[T] + func PartitionWithSpanningBlocks[T SpanPartitionConstraint[T]](newAddr T) *Partition[T] + func (part *Partition[T]) ForEach(action func(T)) + func (part *Partition[T]) Iterator() Iterator[T] + func (part *Partition[T]) PredicateForAny(predicate func(T) bool) bool + func (part *Partition[T]) PredicateForAnyEarly(predicate func(T) bool) bool + func (part *Partition[T]) PredicateForEach(predicate func(T) bool) bool + func (part *Partition[T]) PredicateForEachEarly(predicate func(T) bool) bool + type Port = *PortNum + type PortInt = int + type PortNum uint16 + func (portNum *PortNum) Compare(other Port) int + func (portNum *PortNum) Equal(other Port) bool + func (portNum *PortNum) Matches(other PortInt) bool + func (portNum *PortNum) Num() PortInt + func (portNum *PortNum) Port() PortNum + func (portNum *PortNum) String() string + type PrefixBitCount uint8 + func (prefixBitCount *PrefixBitCount) Compare(other PrefixLen) int + func (prefixBitCount *PrefixBitCount) Equal(other PrefixLen) bool + func (prefixBitCount *PrefixBitCount) IsNil() bool + func (prefixBitCount *PrefixBitCount) Len() BitCount + func (prefixBitCount *PrefixBitCount) Matches(other BitCount) bool + func (prefixBitCount *PrefixBitCount) String() string + 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] + type PrefixKey struct + IsPrefixed bool + PrefixLen PrefixBitCount + func PrefixKeyFrom(addr AddressType) PrefixKey + func (pref PrefixKey) ToPrefixLen() PrefixLen + type PrefixLen = *PrefixBitCount + func ToPrefixLen(i int) PrefixLen + func ValidatePrefixLenStr(str string, version IPVersion) (prefixLen PrefixLen, err address_error.AddressStringError) + 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 SegInt = uint32 + type SegIntCount = uint64 + type SegmentSequence struct + type SegmentSequenceList struct + type SegmentValueProvider func(segmentIndex int) SegInt + func WrapIPv4SegmentValueProvider(f IPv4SegmentValueProvider) SegmentValueProvider + func WrapIPv6SegmentValueProvider(f IPv6SegmentValueProvider) SegmentValueProvider + func WrapMACSegmentValueProvider(f MACSegmentValueProvider) SegmentValueProvider + type SequentialRange struct + func NewIPSeqRange(lower, upper *IPAddress) *SequentialRange[*IPAddress] + func NewIPv4SeqRange(lower, upper *IPv4Address) *SequentialRange[*IPv4Address] + func NewIPv6SeqRange(lower, upper *IPv6Address) *SequentialRange[*IPv6Address] + func NewSequentialRange[T SequentialRangeConstraint[T]](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 + type SequentialRangeKey struct + func (key SequentialRangeKey[T]) String() string + func (key SequentialRangeKey[T]) ToSeqRange() *SequentialRange[T] + type SpanPartitionConstraint interface + SpanWithPrefixBlocks func() []T + type StandardDivGroupingType interface + IsAdaptiveZero func() bool + ToDivGrouping func() *AddressDivisionGrouping + type StandardDivisionType interface + ToDiv func() *AddressDivision + type Trie struct + func NewIPv4AddressTrie() *Trie[*IPv4Address] + func NewIPv6AddressTrie() *Trie[*IPv6Address] + func NewMACAddressTrie(extended bool) *Trie[*MACAddress] + func NewTrie[T TrieKeyConstraint[T]]() *Trie[T] + 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]) Clear() + 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]) ShortestPrefixMatch(addr T) T + func (trie *Trie[T]) ShortestPrefixMatchNode(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 + IsOneBit func(index BitCount) bool + 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) + type WrappedAddress struct + func (addr WrappedAddress) AdjustPrefixLen(prefixLen BitCount) ExtendedSegmentSeries + func (addr WrappedAddress) AdjustPrefixLenZeroed(prefixLen BitCount) (ExtendedSegmentSeries, address_error.IncompatibleAddressError) + func (addr WrappedAddress) AssignMinPrefixForBlock() ExtendedSegmentSeries + func (addr WrappedAddress) AssignPrefixForSingleBlock() ExtendedSegmentSeries + 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(segments 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() Iterator[ExtendedSegmentSeries] + func (addr WrappedAddress) PrefixBlockIterator() Iterator[ExtendedSegmentSeries] + func (addr WrappedAddress) PrefixIterator() Iterator[ExtendedSegmentSeries] + func (addr WrappedAddress) ReverseBits(perByte bool) (ExtendedSegmentSeries, address_error.IncompatibleAddressError) + func (addr WrappedAddress) ReverseBytes() (ExtendedSegmentSeries, address_error.IncompatibleAddressError) + func (addr WrappedAddress) ReverseSegments() ExtendedSegmentSeries + func (addr WrappedAddress) SetPrefixLen(prefixLen BitCount) ExtendedSegmentSeries + func (addr WrappedAddress) SetPrefixLenZeroed(prefixLen BitCount) (ExtendedSegmentSeries, address_error.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) ToPrefixBlockLen(prefLen BitCount) ExtendedSegmentSeries + func (addr WrappedAddress) Unwrap() AddressSegmentSeries + func (addr WrappedAddress) WithoutPrefixLen() ExtendedSegmentSeries + type WrappedAddressSection struct + func (section WrappedAddressSection) AdjustPrefixLen(adjustment BitCount) ExtendedSegmentSeries + func (section WrappedAddressSection) AdjustPrefixLenZeroed(adjustment BitCount) (ExtendedSegmentSeries, address_error.IncompatibleAddressError) + func (section WrappedAddressSection) AssignMinPrefixForBlock() ExtendedSegmentSeries + func (section WrappedAddressSection) AssignPrefixForSingleBlock() ExtendedSegmentSeries + func (section WrappedAddressSection) Bytes() []byte + 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) ForEachSegment(consumer func(segmentIndex int, segment *AddressSegment) (stop bool)) int + 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) GetLeadingBitCount(ones bool) BitCount + 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) GetTrailingBitCount(ones bool) BitCount + 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() Iterator[ExtendedSegmentSeries] + func (section WrappedAddressSection) PrefixBlockIterator() Iterator[ExtendedSegmentSeries] + func (section WrappedAddressSection) PrefixContains(other AddressSectionType) (res bool) + func (section WrappedAddressSection) PrefixEqual(other AddressSectionType) (res bool) + func (section WrappedAddressSection) PrefixIterator() Iterator[ExtendedSegmentSeries] + func (section WrappedAddressSection) ReverseBits(perByte bool) (ExtendedSegmentSeries, address_error.IncompatibleAddressError) + func (section WrappedAddressSection) ReverseBytes() (ExtendedSegmentSeries, address_error.IncompatibleAddressError) + func (section WrappedAddressSection) ReverseSegments() ExtendedSegmentSeries + func (section WrappedAddressSection) SetPrefixLen(prefixLen BitCount) ExtendedSegmentSeries + func (section WrappedAddressSection) SetPrefixLenZeroed(prefixLen BitCount) (ExtendedSegmentSeries, address_error.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) ToPrefixBlockLen(prefLen BitCount) ExtendedSegmentSeries + func (section WrappedAddressSection) Unwrap() AddressSegmentSeries + func (section WrappedAddressSection) UpperBytes() []byte + func (section WrappedAddressSection) WithoutPrefixLen() ExtendedSegmentSeries + type WrappedHostName struct + func (host WrappedHostName) GetAddress() AddressType + func (host WrappedHostName) ToAddress() (AddressType, error) + func (host WrappedHostName) Unwrap() HostIdentifierString + type WrappedIPAddress struct + func (addr WrappedIPAddress) AdjustPrefixLen(prefixLen BitCount) ExtendedIPSegmentSeries + func (addr WrappedIPAddress) AdjustPrefixLenZeroed(prefixLen BitCount) (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + func (addr WrappedIPAddress) AssignMinPrefixForBlock() ExtendedIPSegmentSeries + func (addr WrappedIPAddress) AssignPrefixForSingleBlock() ExtendedIPSegmentSeries + func (addr WrappedIPAddress) BlockIterator(segmentCount int) Iterator[ExtendedIPSegmentSeries] + 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(segments 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() Iterator[ExtendedIPSegmentSeries] + func (addr WrappedIPAddress) PrefixBlockIterator() Iterator[ExtendedIPSegmentSeries] + func (addr WrappedIPAddress) PrefixIterator() Iterator[ExtendedIPSegmentSeries] + func (addr WrappedIPAddress) ReverseBits(perByte bool) (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + func (addr WrappedIPAddress) ReverseBytes() (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + func (addr WrappedIPAddress) ReverseSegments() ExtendedIPSegmentSeries + func (addr WrappedIPAddress) SequentialBlockIterator() Iterator[ExtendedIPSegmentSeries] + func (addr WrappedIPAddress) SetPrefixLen(prefixLen BitCount) ExtendedIPSegmentSeries + func (addr WrappedIPAddress) SetPrefixLenZeroed(prefixLen BitCount) (ExtendedIPSegmentSeries, address_error.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, address_error.IncompatibleAddressError) + func (addr WrappedIPAddress) ToMaxHostLen(bitCount BitCount) (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + func (addr WrappedIPAddress) ToPrefixBlock() ExtendedIPSegmentSeries + func (addr WrappedIPAddress) ToPrefixBlockLen(bitCount BitCount) ExtendedIPSegmentSeries + func (addr WrappedIPAddress) ToZeroHost() (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + func (addr WrappedIPAddress) ToZeroHostLen(bitCount BitCount) (ExtendedIPSegmentSeries, address_error.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, address_error.IncompatibleAddressError) + func (section WrappedIPAddressSection) AssignMinPrefixForBlock() ExtendedIPSegmentSeries + func (section WrappedIPAddressSection) AssignPrefixForSingleBlock() ExtendedIPSegmentSeries + func (section WrappedIPAddressSection) BlockIterator(segmentCount int) Iterator[ExtendedIPSegmentSeries] + func (section WrappedIPAddressSection) Bytes() []byte + 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) ForEachSegment(consumer func(segmentIndex int, segment *IPAddressSegment) (stop bool)) int + 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) 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) 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() Iterator[ExtendedIPSegmentSeries] + func (section WrappedIPAddressSection) PrefixBlockIterator() Iterator[ExtendedIPSegmentSeries] + func (section WrappedIPAddressSection) PrefixContains(other AddressSectionType) bool + func (section WrappedIPAddressSection) PrefixEqual(other AddressSectionType) bool + func (section WrappedIPAddressSection) PrefixIterator() Iterator[ExtendedIPSegmentSeries] + func (section WrappedIPAddressSection) ReverseBits(perByte bool) (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + func (section WrappedIPAddressSection) ReverseBytes() (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + func (section WrappedIPAddressSection) ReverseSegments() ExtendedIPSegmentSeries + func (section WrappedIPAddressSection) SequentialBlockIterator() Iterator[ExtendedIPSegmentSeries] + func (section WrappedIPAddressSection) SetPrefixLen(prefixLen BitCount) ExtendedIPSegmentSeries + func (section WrappedIPAddressSection) SetPrefixLenZeroed(prefixLen BitCount) (ExtendedIPSegmentSeries, address_error.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, address_error.IncompatibleAddressError) + func (section WrappedIPAddressSection) ToMaxHostLen(bitCount BitCount) (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + func (section WrappedIPAddressSection) ToPrefixBlock() ExtendedIPSegmentSeries + func (section WrappedIPAddressSection) ToPrefixBlockLen(bitCount BitCount) ExtendedIPSegmentSeries + func (section WrappedIPAddressSection) ToZeroHost() (ExtendedIPSegmentSeries, address_error.IncompatibleAddressError) + func (section WrappedIPAddressSection) ToZeroHostLen(bitCount BitCount) (ExtendedIPSegmentSeries, address_error.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 + func (section WrappedIPAddressSection) WrapSection() WrappedAddressSection + type WrappedIPAddressString struct + func (str WrappedIPAddressString) GetAddress() AddressType + func (str WrappedIPAddressString) ToAddress() (AddressType, error) + func (str WrappedIPAddressString) Unwrap() HostIdentifierString + type WrappedMACAddressString struct + func (str WrappedMACAddressString) GetAddress() AddressType + func (str WrappedMACAddressString) ToAddress() (AddressType, error) + func (str WrappedMACAddressString) Unwrap() HostIdentifierString + type Zone string + func ValidateZoneStr(zoneStr string) (zone Zone, err address_error.AddressStringError) + func (zone Zone) IsEmpty() bool + func (zone Zone) String() string
Go to main page