init

Author: IncSW

README.md

@@ -0,0 +1,44 @@
+Device Detection based on 51Degrees Trie. Golang version of [51Degrees/Device-Detection](https://github.com/51Degrees/Device-Detection) without cgo.
+
+## Installation
+
+`go get github.com/IncSW/go-51degrees`
+
+```go
+import fiftyonedegrees "github.com/IncSW/go-51degrees"
+```
+
+## Quick Start
+
+```go
+reader, err := fiftyonedegrees.NewReaderFromFile("path/to/51DegreesV3.4.trie")
+if err != nil {
+	panic(err)
+}
+device := reader.MatchDevice("UserAgent")
+fmt.Println(device.GetValue("BrowserName"), device.GetValue("BrowserVersion"))
+```
+
+## Performance
+
+### Go 1.13.1, Debian 9.1, i7-7700
+
+fixed ua: `Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0`
+
+```
+go/fixed-8               1279998    927 ns/op     0 B/op    0 allocs/op
+cgo/fixed-8               533149   2214 ns/op   224 B/op   19 allocs/op
+
+go/fixed-parallel-8      6197949    195 ns/op     0 B/op    0 allocs/op
+cgo/fixed-parallel-8     2119233    566 ns/op   224 B/op   19 allocs/op
+
+go/range-8                422196   2720 ns/op     0 B/op    0 allocs/op
+cgo/range-8               400407   2989 ns/op   235 B/op   18 allocs/op
+
+go/range-parallel-8      2709638    437 ns/op     0 B/op    0 allocs/op
+cgo/range-parallel-8     1702524    681 ns/op   235 B/op   18 allocs/op
+```
+
+## License
+
+[MIT License](LICENSE).

device.go

@@ -0,0 +1,17 @@
+package fiftyonedegrees
+
+type Device struct {
+	reader *Reader
+	offset int
+}
+
+func (d *Device) GetValue(propertyName string) string {
+	for i, name := range d.reader.requiredPropertiesNames {
+		if name == propertyName {
+			property := d.reader.properties[d.reader.requiredProperties[i]]
+			profile := d.reader.profiles[d.reader.devices[(d.offset+property.ComponentIndex)*4]+property.SubIndex*4]
+			return d.reader.strings[profile]
+		}
+	}
+	return ""
+}

matcher.go

@@ -0,0 +1,157 @@
+package fiftyonedegrees
+
+type Matcher struct {
+	reader       *Reader
+	userAgent    string
+	currentNode  *Node
+	hash         uint32
+	power        uint32
+	firstIndex   int
+	lastIndex    int
+	currentIndex int
+	deviceIndex  int
+}
+
+func (m *Matcher) getMatchingHashFromListNodeSearch() *NodeHash {
+	hashes := m.currentNode.Hashes
+	lower := int32(0)
+	upper := m.currentNode.HashesCount - 1
+	middle := int32(0)
+	for lower <= upper {
+		middle = lower + (upper-lower)/2
+		if hashes[middle].HashCode == m.hash {
+			return &hashes[middle]
+		} else if hashes[middle].HashCode > m.hash {
+			upper = middle - 1
+		} else {
+			lower = middle + 1
+		}
+	}
+	return nil
+}
+
+func (m *Matcher) getMatchingHashFromListNodeTable() *NodeHash {
+	hashes := m.currentNode.Hashes
+	index := int(m.hash % m.currentNode.Modulo)
+	if m.hash == hashes[index].HashCode {
+		return &hashes[index]
+	}
+	if hashes[index].HashCode == 0 && hashes[index].NodeOffset > 0 {
+		index = int(hashes[index].NodeOffset)
+		for hashes[index].HashCode != 0 {
+			if m.hash == hashes[index].HashCode {
+				return &hashes[index]
+			}
+			index++
+		}
+	}
+	return nil
+}
+
+func (m *Matcher) getMatchingHashFromListNode() *NodeHash {
+	if m.currentNode.Modulo == 0 {
+		return m.getMatchingHashFromListNodeSearch()
+	}
+	return m.getMatchingHashFromListNodeTable()
+}
+
+func (m *Matcher) advanceHash() bool {
+	nextAddIndex := 0
+	if m.currentIndex < m.lastIndex {
+		nextAddIndex = m.currentIndex + m.currentNode.Length
+		if nextAddIndex < len(m.userAgent) {
+			m.hash *= rkPrime
+			m.hash += uint32(m.userAgent[nextAddIndex])
+			m.hash -= m.power * uint32(m.userAgent[m.currentIndex])
+			m.currentIndex++
+			return true
+		}
+	}
+	return false
+}
+
+func (m *Matcher) setInitialHash() bool {
+	m.hash = 0
+	if m.firstIndex+m.currentNode.Length <= len(m.userAgent) {
+		m.power = POWERS[m.currentNode.Length]
+		for i := m.firstIndex; i < m.firstIndex+m.currentNode.Length; i++ {
+			m.hash *= rkPrime
+			m.hash += uint32(m.userAgent[i])
+		}
+		m.currentIndex = m.firstIndex
+		return true
+	}
+	return false
+}
+
+func (m *Matcher) setNextNode(offset int32) {
+	if offset > 0 {
+		index, ok := m.reader.nodeIndexByOffset[int(offset)]
+		if !ok {
+			m.currentNode = nil
+			return
+		}
+		m.currentNode = &m.reader.nodes[index]
+		m.firstIndex += int(m.currentNode.FirstIndex)
+		m.lastIndex += int(m.currentNode.LastIndex)
+	} else if offset <= 0 {
+		m.deviceIndex = -int(offset)
+		m.currentNode = nil
+	}
+}
+
+func (m *Matcher) evaluateBinaryNode() {
+	nodeHash := m.currentNode.Hashes[0]
+	found := false
+	if m.setInitialHash() {
+		for m.hash != nodeHash.HashCode && m.advanceHash() {
+		}
+	}
+	if m.hash == nodeHash.HashCode {
+		found = true
+	}
+	if found {
+		m.setNextNode(nodeHash.NodeOffset)
+	} else {
+		m.setNextNode(m.currentNode.UnmatchedNodeOffset)
+	}
+}
+
+func (m *Matcher) evaluateListNode() {
+	var nodeHash *NodeHash
+	if m.setInitialHash() {
+		for {
+			nodeHash = m.getMatchingHashFromListNode()
+			if nodeHash != nil || !m.advanceHash() {
+				break
+			}
+		}
+	}
+	if nodeHash != nil {
+		m.setNextNode(nodeHash.NodeOffset)
+	} else {
+		m.setNextNode(m.currentNode.UnmatchedNodeOffset)
+	}
+}
+
+func (m *Matcher) Match() Device {
+	for m.currentNode != nil {
+		if m.currentNode.HashesCount == 1 {
+			m.evaluateBinaryNode()
+		} else {
+			m.evaluateListNode()
+		}
+	}
+	return Device{
+		reader: m.reader,
+		offset: m.deviceIndex * (m.reader.devicePropertiesCount + m.reader.componentsCount),
+	}
+}
+
+func NewMatcher(reader *Reader, userAgent string) Matcher {
+	return Matcher{
+		reader:      reader,
+		userAgent:   userAgent,
+		currentNode: &reader.nodes[0],
+	}
+}