Add Parse*List and MustParse*List variants, replace ParseCIDRs

Author: danwinship

net/v2/net.go

@@ -25,20 +25,6 @@ import (
 	"strconv"
 )
 
-// ParseCIDRs parses a list of cidrs and return error if any is invalid.
-// order is maintained
-func ParseCIDRs(cidrsString []string) ([]*net.IPNet, error) {
-	cidrs := make([]*net.IPNet, 0, len(cidrsString))
-	for i, cidrString := range cidrsString {
-		cidr, err := ParseIPNet(cidrString)
-		if err != nil {
-			return nil, fmt.Errorf("invalid CIDR[%d]: %v (%v)", i, cidr, err)
-		}
-		cidrs = append(cidrs, cidr)
-	}
-	return cidrs, nil
-}
-
 // ParsePort parses a string representing an IP port.  If the string is not a
 // valid port number, this returns an error.
 func ParsePort(port string, allowZero bool) (int, error) {

net/v2/net_test.go

@@ -20,49 +20,6 @@ import (
 	"testing"
 )
 
-func TestParseCIDRs(t *testing.T) {
-	testCases := []struct {
-		cidrs         []string
-		errString     string
-		errorExpected bool
-	}{
-		{
-			cidrs:         []string{},
-			errString:     "should not return an error for an empty slice",
-			errorExpected: false,
-		},
-		{
-			cidrs:         []string{"10.0.0.0/8", "not-a-valid-cidr", "2000::/10"},
-			errString:     "should return error for bad cidr",
-			errorExpected: true,
-		},
-		{
-			cidrs:         []string{"10.0.0.0/8", "2000::/10"},
-			errString:     "should not return error for good  cidrs",
-			errorExpected: false,
-		},
-	}
-
-	for _, tc := range testCases {
-		cidrs, err := ParseCIDRs(tc.cidrs)
-		if tc.errorExpected {
-			if err == nil {
-				t.Errorf("%v", tc.errString)
-			}
-			continue
-		}
-		if err != nil {
-			t.Errorf("%v error:%v", tc.errString, err)
-		}
-
-		// validate lengths
-		if len(cidrs) != len(tc.cidrs) {
-			t.Errorf("cidrs should be of the same lengths %v != %v", len(cidrs), len(tc.cidrs))
-		}
-
-	}
-}
-
 func TestParsePort(t *testing.T) {
 	var tests = []struct {
 		name          string

net/v2/parse.go

@@ -195,3 +195,65 @@ var MustParseIPAsIPNet = must(ParseIPAsIPNet)
 
 // MustParseAddrAsPrefix is like ParseAddrAsPrefix, but it panics on error instead of returning an error value.
 var MustParseAddrAsPrefix = must(ParseAddrAsPrefix)
+
+type listParser[T any] func(...string) ([]T, error)
+
+func list[T any](parse parser[T]) listParser[T] {
+	return func(strs ...string) ([]T, error) {
+		var err error
+		ret := make([]T, len(strs))
+		for i, str := range strs {
+			ret[i], err = parse(str)
+			if err != nil {
+				return nil, err
+			}
+		}
+		return ret, nil
+	}
+}
+
+// ParseIPList parses a list of strings with ParseIP and returns a []net.IP or an error.
+var ParseIPList = list(ParseIP)
+
+// ParseIPNetList parses a list of strings with ParseIPNet and returns a []*net.IPNet or an error.
+var ParseIPNetList = list(ParseIPNet)
+
+// ParseAddrList parses a list of strings with ParseAddr and returns a []netip.Addr or an error.
+var ParseAddrList = list(ParseAddr)
+
+// ParsePrefixList parses a list of strings with ParsePrefix and returns a []netip.Prefix or an error.
+var ParsePrefixList = list(ParsePrefix)
+
+// ParseIPAsIPNetList parses a list of strings with ParseIPAsIPNet and returns a []*net.IPNet or an error.
+var ParseIPAsIPNetList = list(ParseIPAsIPNet)
+
+// ParseAddrAsPrefixList parses a list of strings with ParseAddrAsPrefix and returns a []netip.Prefix or an error.
+var ParseAddrAsPrefixList = list(ParseAddrAsPrefix)
+
+func mustlist[T any](parse listParser[T]) func(...string) []T {
+	return func(strs ...string) []T {
+		ret, err := parse(strs...)
+		if err != nil {
+			panic(err)
+		}
+		return ret
+	}
+}
+
+// MustParseIPList parses a list of strings with ParseIP and returns a []net.IP or else panics on error.
+var MustParseIPList = mustlist(ParseIPList)
+
+// MustParseIPNetList parses a list of strings with ParseIPNet and returns a []*net.IPNet or else panics on error.
+var MustParseIPNetList = mustlist(ParseIPNetList)
+
+// MustParseAddrList parses a list of strings with ParseAddr and returns a []netip.Addr or else panics on error.
+var MustParseAddrList = mustlist(ParseAddrList)
+
+// MustParsePrefixList parses a list of strings with ParsePrefix and returns a []netip.Prefix or else panics on error.
+var MustParsePrefixList = mustlist(ParsePrefixList)
+
+// MustParseIPAsIPNetList parses a list of strings with ParseIPAsIPNet and returns a []*net.IPNet or else panics on error.
+var MustParseIPAsIPNetList = mustlist(ParseIPAsIPNetList)
+
+// MustParseAddrAsPrefixList parses a list of strings with ParseAddrAsPrefix and returns a []netip.Prefix or else panics on error.
+var MustParseAddrAsPrefixList = mustlist(ParseAddrAsPrefixList)