Improve performance of node reading

This replaces the runtime check on record size and unrolls the node
calculation.

Before:

```
goos: linux
goarch: amd64
pkg: github.com/oschwald/maxminddb-golang
BenchmarkLookup-8          	 1000000	     15928 ns/op
BenchmarkLookupNetwork-8   	 1000000	     16638 ns/op
BenchmarkCountryCode-8     	10000000	      1244 ns/op
PASS
ok  	github.com/oschwald/maxminddb-golang	46.654s
```

After:

```
goos: linux
goarch: amd64
pkg: github.com/oschwald/maxminddb-golang
BenchmarkLookup-8          	 1000000	     14918 ns/op
BenchmarkLookupNetwork-8   	 1000000	     15681 ns/op
BenchmarkCountryCode-8     	20000000	      1137 ns/op
PASS
ok  	github.com/oschwald/maxminddb-golang	54.967s
```

Author: oschwald

node.go

@@ -0,0 +1,42 @@
+package maxminddb
+
+type nodeReader interface {
+	readLeft(uint) uint
+	readRight(uint) uint
+}
+
+type nodeReader24 struct {
+	buffer []byte
+}
+
+func (n nodeReader24) readLeft(nodeNumber uint) uint {
+	return (uint(n.buffer[nodeNumber]) << 16) | (uint(n.buffer[nodeNumber+1]) << 8) | uint(n.buffer[nodeNumber+2])
+}
+
+func (n nodeReader24) readRight(nodeNumber uint) uint {
+	return (uint(n.buffer[nodeNumber+3]) << 16) | (uint(n.buffer[nodeNumber+4]) << 8) | uint(n.buffer[nodeNumber+5])
+}
+
+type nodeReader28 struct {
+	buffer []byte
+}
+
+func (n nodeReader28) readLeft(nodeNumber uint) uint {
+	return ((uint(n.buffer[nodeNumber+3]) & 0xF0) << 20) | (uint(n.buffer[nodeNumber]) << 16) | (uint(n.buffer[nodeNumber+1]) << 8) | uint(n.buffer[nodeNumber+2])
+}
+
+func (n nodeReader28) readRight(nodeNumber uint) uint {
+	return ((uint(n.buffer[nodeNumber+3]) & 0x0F) << 24) | (uint(n.buffer[nodeNumber+4]) << 16) | (uint(n.buffer[nodeNumber+5]) << 8) | uint(n.buffer[nodeNumber+6])
+}
+
+type nodeReader32 struct {
+	buffer []byte
+}
+
+func (n nodeReader32) readLeft(nodeNumber uint) uint {
+	return (uint(n.buffer[nodeNumber]) << 24) | (uint(n.buffer[nodeNumber+1]) << 16) | (uint(n.buffer[nodeNumber+2]) << 8) | uint(n.buffer[nodeNumber+3])
+}
+
+func (n nodeReader32) readRight(nodeNumber uint) uint {
+	return (uint(n.buffer[nodeNumber+4]) << 24) | (uint(n.buffer[nodeNumber+5]) << 16) | (uint(n.buffer[nodeNumber+6]) << 8) | uint(n.buffer[nodeNumber+7])
+}

reader.go

@@ -23,6 +23,7 @@ var metadataStartMarker = []byte("\xAB\xCD\xEFMaxMind.com")
 type Reader struct {
 	hasMappedFile     bool
 	buffer            []byte
+	nodeReader        nodeReader
 	decoder           decoder
 	Metadata          Metadata
 	ipv4Start         uint
@@ -75,37 +76,46 @@ func FromBytes(buffer []byte) (*Reader, error) {
 		buffer[searchTreeSize+dataSectionSeparatorSize : metadataStart-len(metadataStartMarker)],
 	}
 
+	nodeBuffer := buffer[:searchTreeSize]
+	var nodeReader nodeReader
+	switch metadata.RecordSize {
+	case 24:
+		nodeReader = nodeReader24{buffer: nodeBuffer}
+	case 28:
+		nodeReader = nodeReader28{buffer: nodeBuffer}
+	case 32:
+		nodeReader = nodeReader32{buffer: nodeBuffer}
+	default:
+		return nil, newInvalidDatabaseError("unknown record size: %d", metadata.RecordSize)
+	}
+
 	reader := &Reader{
-		buffer:    buffer,
-		decoder:   d,
-		Metadata:  metadata,
-		ipv4Start: 0,
+		buffer:     buffer,
+		nodeReader: nodeReader,
+		decoder:    d,
+		Metadata:   metadata,
+		ipv4Start:  0,
 	}
 
-	err = reader.setIPv4Start()
+	reader.setIPv4Start()
 
 	return reader, err
 }
 
-func (r *Reader) setIPv4Start() error {
+func (r *Reader) setIPv4Start() {
 	if r.Metadata.IPVersion != 6 {
-		return nil
+		return
 	}
 
 	nodeCount := r.Metadata.NodeCount
 
 	node := uint(0)
-	var err error
 	i := 0
 	for ; i < 96 && node < nodeCount; i++ {
-		node, err = r.readNode(node, 0)
-		if err != nil {
-			return err
-		}
+		node = r.nodeReader.readLeft(r.nodeOffset(node))
 	}
 	r.ipv4Start = node
 	r.ipv4StartBitDepth = i
-	return err
 }
 
 // Lookup retrieves the database record for ip and stores it in the value
@@ -241,10 +251,11 @@ func (r *Reader) lookupPointer(ip net.IP) (uint, int, net.IP, error) {
 	for ; i < bitCount && node < nodeCount; i++ {
 		bit := uint(1) & (uint(ip[i>>3]) >> (7 - (i % 8)))
 
-		var err error
-		node, err = r.readNode(node, bit)
-		if err != nil {
-			return 0, int(i), ip, err
+		offset := r.nodeOffset(node)
+		if bit == 0 {
+			node = r.nodeReader.readLeft(offset)
+		} else {
+			node = r.nodeReader.readRight(offset)
 		}
 	}
 	if node == nodeCount {
@@ -257,33 +268,8 @@ func (r *Reader) lookupPointer(ip net.IP) (uint, int, net.IP, error) {
 	return 0, int(i), ip, newInvalidDatabaseError("invalid node in search tree")
 }
 
-func (r *Reader) readNode(nodeNumber uint, index uint) (uint, error) {
-	RecordSize := r.Metadata.RecordSize
-
-	baseOffset := nodeNumber * RecordSize / 4
-
-	var nodeBytes []byte
-	var prefix uint
-	switch RecordSize {
-	case 24:
-		offset := baseOffset + index*3
-		nodeBytes = r.buffer[offset : offset+3]
-	case 28:
-		prefix = uint(r.buffer[baseOffset+3])
-		if index != 0 {
-			prefix &= 0x0F
-		} else {
-			prefix = (0xF0 & prefix) >> 4
-		}
-		offset := baseOffset + index*4
-		nodeBytes = r.buffer[offset : offset+3]
-	case 32:
-		offset := baseOffset + index*4
-		nodeBytes = r.buffer[offset : offset+4]
-	default:
-		return 0, newInvalidDatabaseError("unknown record size: %d", RecordSize)
-	}
-	return uintFromBytes(prefix, nodeBytes), nil
+func (r *Reader) nodeOffset(node uint) uint {
+	return node * r.Metadata.RecordSize / 4
 }
 
 func (r *Reader) retrieveData(pointer uint, result interface{}) error {

traverse.go

@@ -60,11 +60,8 @@ func (n *Networks) Next() bool {
 			}
 			ipRight[node.bit>>3] |= 1 << (7 - (node.bit % 8))
 
-			rightPointer, err := n.reader.readNode(node.pointer, 1)
-			if err != nil {
-				n.err = err
-				return false
-			}
+			offset := n.reader.nodeOffset(node.pointer)
+			rightPointer := n.reader.nodeReader.readRight(offset)
 
 			node.bit++
 			n.nodes = append(n.nodes, netNode{
@@ -73,11 +70,7 @@ func (n *Networks) Next() bool {
 				bit:     node.bit,
 			})
 
-			node.pointer, err = n.reader.readNode(node.pointer, 0)
-			if err != nil {
-				n.err = err
-				return false
-			}
+			node.pointer = n.reader.nodeReader.readLeft(offset)
 		}
 	}