refactor to use AddressSpec objects

convert.go

@@ -101,6 +101,13 @@ func DialArgs(m ma.Multiaddr) (string, string, error) {
 	return network, host, nil
 }
 
+var tcpAddrSpec = &AddressSpec{
+	Key:              "tcp",
+	NetNames:         []string{"tcp", "tcp4", "tcp6"},
+	ParseNetAddr:     parseTcpNetAddr,
+	ConvertMultiaddr: parseBasicNetMaddr,
+}
+
 func parseTcpNetAddr(a net.Addr) (ma.Multiaddr, error) {
 	ac, ok := a.(*net.TCPAddr)
 	if !ok {
@@ -123,6 +130,13 @@ func parseTcpNetAddr(a net.Addr) (ma.Multiaddr, error) {
 	return ipm.Encapsulate(tcpm), nil
 }
 
+var udpAddrSpec = &AddressSpec{
+	Key:              "udp",
+	NetNames:         []string{"udp", "udp4", "udp6"},
+	ParseNetAddr:     parseUdpNetAddr,
+	ConvertMultiaddr: parseBasicNetMaddr,
+}
+
 func parseUdpNetAddr(a net.Addr) (ma.Multiaddr, error) {
 	ac, ok := a.(*net.UDPAddr)
 	if !ok {
@@ -145,6 +159,13 @@ func parseUdpNetAddr(a net.Addr) (ma.Multiaddr, error) {
 	return ipm.Encapsulate(udpm), nil
 }
 
+var utpAddrSpec = &AddressSpec{
+	Key:              "utp",
+	NetNames:         []string{"utp", "utp4", "utp6"},
+	ParseNetAddr:     parseUtpNetAddr,
+	ConvertMultiaddr: parseBasicNetMaddr,
+}
+
 func parseUtpNetAddr(a net.Addr) (ma.Multiaddr, error) {
 	acc, ok := a.(*utp.Addr)
 	if !ok {
@@ -173,6 +194,20 @@ func parseUtpNetAddr(a net.Addr) (ma.Multiaddr, error) {
 	return ipm.Encapsulate(utpm), nil
 }
 
+var ip4AddrSpec = &AddressSpec{
+	Key:              "ip4",
+	NetNames:         []string{"ip4"},
+	ParseNetAddr:     parseIpNetAddr,
+	ConvertMultiaddr: parseBasicNetMaddr,
+}
+
+var ip6AddrSpec = &AddressSpec{
+	Key:              "ip6",
+	NetNames:         []string{"ip6"},
+	ParseNetAddr:     parseIpNetAddr,
+	ConvertMultiaddr: parseBasicNetMaddr,
+}
+
 func parseIpNetAddr(a net.Addr) (ma.Multiaddr, error) {
 	ac, ok := a.(*net.IPAddr)
 	if !ok {

registry.go

@@ -15,32 +15,43 @@ var maddrParsers map[string]MaddrParser
 var addrParsers map[string]AddrParser
 var addrParsersLock sync.Mutex
 
-func RegisterAddressType(netname, maname string, ap AddrParser, mp MaddrParser) {
+type AddressSpec struct {
+	// NetNames is an array of strings that may be returned
+	// by net.Addr.Network() calls on addresses belonging to this type
+	NetNames []string
+
+	// Key is the string value for Multiaddr address keys
+	Key string
+
+	// ParseNetAddr parses a net.Addr belonging to this type into a multiaddr
+	ParseNetAddr AddrParser
+
+	// ConvertMultiaddr converts a multiaddr of this type back into a net.Addr
+	ConvertMultiaddr MaddrParser
+
+	// Protocol returns the multiaddr protocol struct for this type
+	Protocol ma.Protocol
+}
+
+func RegisterAddressType(a *AddressSpec) {
 	addrParsersLock.Lock()
 	defer addrParsersLock.Unlock()
-	addrParsers[netname] = ap
-	maddrParsers[maname] = mp
+	for _, n := range a.NetNames {
+		addrParsers[n] = a.ParseNetAddr
+	}
+
+	maddrParsers[a.Key] = a.ConvertMultiaddr
 }
 
 func init() {
 	addrParsers = make(map[string]AddrParser)
 	maddrParsers = make(map[string]MaddrParser)
 
-	funcs := map[string]AddrParser{
-		"tcp": parseTcpNetAddr,
-		"udp": parseUdpNetAddr,
-		"utp": parseUtpNetAddr,
-	}
-
-	for k, v := range funcs {
-		RegisterAddressType(k, k, v, parseBasicNetMaddr)
-		RegisterAddressType(k+"4", k, v, parseBasicNetMaddr)
-		RegisterAddressType(k+"6", k, v, parseBasicNetMaddr)
-	}
-
-	for _, i := range []string{"ip", "ip4", "ip6"} {
-		RegisterAddressType(i, i, parseIpNetAddr, parseBasicNetMaddr)
-	}
+	RegisterAddressType(tcpAddrSpec)
+	RegisterAddressType(udpAddrSpec)
+	RegisterAddressType(utpAddrSpec)
+	RegisterAddressType(ip4AddrSpec)
+	RegisterAddressType(ip6AddrSpec)
 
 	addrParsers["ip+net"] = parseIpPlusNetAddr
 }