Simplify public interface (potentially temporarily) to simplify code

Author: PatrickCronin

cmd/routesum/main.go

@@ -32,7 +32,7 @@ func main() {
 }
 
 func summarize(in io.Reader, out, memStatsOut io.Writer) error {
-	rs := routesum.NewRouteSum()
+	rs := routesum.New()
 	scanner := bufio.NewScanner(in)
 	for scanner.Scan() {
 		line := bytes.TrimSpace(scanner.Bytes())
@@ -62,7 +62,12 @@ Total size of data structure: %d
 		)
 	}
 
-	for _, s := range rs.SummaryStrings() {
+	strs, err := rs.SummaryStrings()
+	if err != nil {
+		return err //nolint: wrapcheck
+	}
+
+	for _, s := range strs {
 		if _, err := out.Write([]byte(s + "\n")); err != nil {
 			return fmt.Errorf("write output: %w", err)
 		}

pkg/routesum/routesum.go

@@ -2,153 +2,79 @@
 package routesum
 
 import (
-	"fmt"
-	"net/netip"
 	"strings"
 
-	"github.com/PatrickCronin/routesum/pkg/routesum/bitslice"
+	"github.com/PatrickCronin/routesum/pkg/routesum/routetype"
 	"github.com/PatrickCronin/routesum/pkg/routesum/rstrie"
-	"github.com/pkg/errors"
-	"inet.af/netaddr"
 )
 
 // RouteSum has methods supporting route summarization of networks and hosts
 type RouteSum struct {
-	ipv4, ipv6 *rstrie.RSTrie
+	v4 *rstrie.RSTrie[*routetype.V4]
+	v6 *rstrie.RSTrie[*routetype.V6]
 }
 
-// NewRouteSum returns an initialized RouteSum object
-func NewRouteSum() *RouteSum {
+// New returns an initialized RouteSum object
+func New() *RouteSum {
 	rs := new(RouteSum)
-	rs.ipv4 = rstrie.NewRSTrie()
-	rs.ipv6 = rstrie.NewRSTrie()
+	rs.v4 = rstrie.New[*routetype.V4]()
+	rs.v6 = rstrie.New[*routetype.V6]()
 
 	return rs
 }
 
 // InsertFromString adds either a string-formatted network or IP to the summary
 func (rs *RouteSum) InsertFromString(s string) error {
-	var ip netip.Addr
-	var ipBits bitslice.BitSlice
-	var err error
-
-	if strings.Contains(s, "/") {
-		ipPrefix, err := netip.ParsePrefix(s)
+	if strings.Contains(s, ":") {
+		r, err := routetype.ParseV6String(s)
 		if err != nil {
-			return fmt.Errorf("parse network: %w", err)
-		}
-		if !ipPrefix.IsValid() {
-			return errors.Errorf("%s is not valid CIDR", s)
+			return err //nolint: wrapcheck
 		}
 
-		ip = ipPrefix.Addr()
-		ipBits, err = ipBitsForIPPrefix(ipPrefix)
-		if err != nil {
-			return err
-		}
+		rs.v6.InsertRoute(r)
 	} else {
-		ip, err = netip.ParseAddr(s)
-		if err != nil {
-			return fmt.Errorf("parse IP: %w", err)
-		}
-		if !ip.IsValid() {
-			return errors.Errorf("%s is not a valid IP", s)
-		}
-
-		ipBits, err = ipBitsForIP(ip)
+		r, err := routetype.ParseV4String(s)
 		if err != nil {
-			return err
+			return err //nolint: wrapcheck
 		}
-	}
 
-	if ip.Is4() {
-		rs.ipv4.InsertRoute(ipBits)
-	} else {
-		rs.ipv6.InsertRoute(ipBits)
+		rs.v4.InsertRoute(r)
 	}
 
 	return nil
 }
 
-func ipBitsForIPPrefix(ipPrefix netip.Prefix) (bitslice.BitSlice, error) {
-	ipBytes, err := ipPrefix.Addr().MarshalBinary()
-	if err != nil {
-		return nil, errors.Wrapf(err, "express %s as bytes", ipPrefix.Addr().String())
-	}
-
-	ipBits, err := bitslice.NewFromBytes(ipBytes)
-	if err != nil {
-		return nil, fmt.Errorf("express %s as bits: %w", ipPrefix.Addr().String(), err)
-	}
-
-	return ipBits[:ipPrefix.Bits()], nil
-}
-
-func ipBitsForIP(ip netip.Addr) (bitslice.BitSlice, error) {
-	ipBytes, err := ip.MarshalBinary()
-	if err != nil {
-		return nil, errors.Wrapf(err, "express %s as bytes", ip.String())
-	}
-
-	ipBits, err := bitslice.NewFromBytes(ipBytes)
-	if err != nil {
-		return nil, fmt.Errorf("express %s as bits: %w", ip.String(), err)
-	}
-
-	return ipBits, nil
-}
-
 // SummaryStrings returns a summary of all received routes as a string slice.
-func (rs *RouteSum) SummaryStrings() []string {
+func (rs *RouteSum) SummaryStrings() ([]string, error) {
 	strs := []string{}
 
-	ipv4BitSlices := rs.ipv4.Contents()
-	for _, bits := range ipv4BitSlices {
-		ip := ipv4FromBits(bits)
-
-		if len(bits) == 8*4 {
-			strs = append(strs, ip.String())
-		} else {
-			ipPrefix := netaddr.IPPrefixFrom(ip, uint8(len(bits)))
-			strs = append(strs, ipPrefix.String())
+	for _, r := range rs.v4.Contents() {
+		str, err := r.String()
+		if err != nil {
+			return nil, err //nolint: wrapcheck
 		}
-	}
-
-	ipv6BitSlices := rs.ipv6.Contents()
-	for _, bits := range ipv6BitSlices {
-		ip := ipv6FromBits(bits)
 
-		if len(bits) == 8*16 {
-			strs = append(strs, ip.String())
-		} else {
-			ipPrefix := netaddr.IPPrefixFrom(ip, uint8(len(bits)))
-			strs = append(strs, ipPrefix.String())
-		}
+		strs = append(strs, str)
 	}
 
-	return strs
-}
+	for _, r := range rs.v6.Contents() {
+		str, err := r.String()
+		if err != nil {
+			return nil, err //nolint: wrapcheck
+		}
 
-func ipv4FromBits(bits bitslice.BitSlice) netaddr.IP {
-	bytes := bits.ToBytes(4)
-	byteArray := [4]byte{}
-	copy(byteArray[:], bytes[0:4])
-	return netaddr.IPFrom4(byteArray)
-}
+		strs = append(strs, str)
+	}
 
-func ipv6FromBits(bits bitslice.BitSlice) netaddr.IP {
-	bytes := bits.ToBytes(16)
-	byteArray := [16]byte{}
-	copy(byteArray[:], bytes[0:16])
-	return netaddr.IPv6Raw(byteArray)
+	return strs, nil
 }
 
 // MemUsage provides information about memory usage.
 func (rs *RouteSum) MemUsage() (uint, uint, uintptr, uintptr) {
-	ipv4NumInternalNodes, ipv4NumLeafNodes, ipv4InternalNodesTotalSize, ipv4LeafNodesTotalSize := rs.ipv4.MemUsage()
-	ipv6NumInternalNodes, ipv6NumLeafNodes, ipv6InternalNodesTotalSize, ipv6LeafNodesTotalSize := rs.ipv6.MemUsage()
-	return ipv4NumInternalNodes + ipv6NumInternalNodes,
-		ipv4NumLeafNodes + ipv6NumLeafNodes,
-		ipv4InternalNodesTotalSize + ipv6InternalNodesTotalSize,
-		ipv4LeafNodesTotalSize + ipv6LeafNodesTotalSize
+	v4NumInternalNodes, v4NumLeafNodes, v4InternalNodesTotalSize, v4LeafNodesTotalSize := rs.v4.MemUsage()
+	v6NumInternalNodes, v6NumLeafNodes, v6InternalNodesTotalSize, v6LeafNodesTotalSize := rs.v6.MemUsage()
+	return v4NumInternalNodes + v6NumInternalNodes,
+		v4NumLeafNodes + v6NumLeafNodes,
+		v4InternalNodesTotalSize + v6InternalNodesTotalSize,
+		v4LeafNodesTotalSize + v6LeafNodesTotalSize
 }