switched key type to interface{}

Author: umpc

README.md

@@ -2,7 +2,7 @@
 
 [![Build Status](https://travis-ci.org/umpc/go-sortedmap.svg?branch=master)](https://travis-ci.org/umpc/go-sortedmap) [![Coverage Status](https://codecov.io/github/umpc/go-sortedmap/badge.svg?branch=master)](https://codecov.io/github/umpc/go-sortedmap?branch=master) [![GoDoc](https://godoc.org/github.com/umpc/go-sortedmap?status.svg)](https://godoc.org/github.com/umpc/go-sortedmap)
 
-Sorted Map is a small library that provides a value-sorted ```map[string]interface``` type and methods combined from Go 1 map and slice primitives.
+SortedMap is a small library that provides a value-sorted ```map[interface{}]interface{}``` type and methods combined from Go 1 map and slice primitives.
 
 This data structure allows for roughly constant-time reads and for efficiently iterating over only a subsection of the stored values. While this works for the project it was built for, because of the structure's reliance on a sorted slice of keys, worst-case delete operations are roughly ```O(n)```, where ```n``` is the number of items in the collection.
 

asc/error.go

@@ -1,3 +1,3 @@
 package asc
 
-const greaterThanErr = "the lesser value was greater than the higher value"
+const greaterThanErr = "the higher value was less than the lesser value!"

delete.go

@@ -1,6 +1,6 @@
 package sortedmap
 
-func (sm *SortedMap) delete(key string) bool {
+func (sm *SortedMap) delete(key interface{}) bool {
 	if _, ok := sm.idx[key]; ok {
 		delete(sm.idx, key)
 
@@ -9,7 +9,7 @@ func (sm *SortedMap) delete(key string) bool {
 
 		for i := 0; i < smLen - deleted; i++ {
 			if sm.sorted[i] == key {
-				sm.sorted = deleteString(sm.sorted, i)
+				sm.sorted = deleteInterface(sm.sorted, i)
 				deleted++
 			}
 		}
@@ -21,12 +21,12 @@ func (sm *SortedMap) delete(key string) bool {
 
 // Delete removes a value from the collection, using the given key.
 // Because the index position of each sorted key changes on each insert and a simpler structure was ideal, deletes can have a worse-case complexity of O(n), meaning the goroutine must loop through the sorted slice to find and delete the given key.
-func (sm *SortedMap) Delete(key string) bool {
+func (sm *SortedMap) Delete(key interface{}) bool {
 	return sm.delete(key)
 }
 
 // BatchDelete removes values from the collection, using the given keys, returning a slice of the results.
-func (sm *SortedMap) BatchDelete(keys ...string) []bool {
+func (sm *SortedMap) BatchDelete(keys []interface{}) []bool {
 	results := make([]bool, len(keys))
 	for i, key := range keys {
 		results[i] = sm.delete(key)

desc/error.go

@@ -1,3 +1,3 @@
 package desc
 
-const greaterThanErr = "the lesser value was greater than the higher value"
+const greaterThanErr = "the lesser value was greater than the higher value!"

get.go

@@ -1,13 +1,13 @@
 package sortedmap
 
 // Get retrieves a value from the collection, using the given key.
-func (sm *SortedMap) Get(key string) (interface{}, bool) {
+func (sm *SortedMap) Get(key interface{}) (interface{}, bool) {
 	val, ok := sm.idx[key]
 	return val, ok
 }
 
 // BatchGet retrieves values with their read statuses from the collection, using the given keys.
-func (sm *SortedMap) BatchGet(keys ...string) ([]interface{}, []bool) {
+func (sm *SortedMap) BatchGet(keys []interface{}) ([]interface{}, []bool) {
 	vals := make([]interface{}, len(keys))
 	results := make([]bool, len(keys))
 

has.go

@@ -1,13 +1,13 @@
 package sortedmap
 
 // Has checks if the key exists in the collection.
-func (sm *SortedMap) Has(key string) bool {
+func (sm *SortedMap) Has(key interface{}) bool {
 	_, ok := sm.idx[key]
 	return ok
 }
 
 // BatchHas checks if the keys exist in the collection and returns a slice containing the results.
-func (sm *SortedMap) BatchHas(keys ...string) []bool {
+func (sm *SortedMap) BatchHas(keys []interface{}) []bool {
 	results := make([]bool, len(keys))
 	for i, key := range keys {
 		_, results[i] = sm.idx[key]

insert.go

@@ -1,6 +1,6 @@
 package sortedmap
 
-func (sm *SortedMap) insert(key string, val interface{}) bool {
+func (sm *SortedMap) insert(key, val interface{}) bool {
 	if _, ok := sm.idx[key]; !ok {
 		sm.idx[key] = val
 		sm.sorted = sm.insertSort(key, val)
@@ -11,13 +11,13 @@ func (sm *SortedMap) insert(key string, val interface{}) bool {
 
 // Insert uses the provided 'less than' function to insert sort and add the value to the collection and returns a value containing the record's insert status.
 // If the key already exists, the value will not be inserted. Use Replace for the alternative functionality.
-func (sm *SortedMap) Insert(key string, val interface{}) bool {
+func (sm *SortedMap) Insert(key, val interface{}) bool {
 	return sm.insert(key, val)
 }
 
 // BatchInsert adds all given records to the collection and returns a slice containing each record's insert status.
 // If a key already exists, the value will not be inserted. Use BatchReplace for the alternative functionality.
-func (sm *SortedMap) BatchInsert(recs ...*Record) []bool {
+func (sm *SortedMap) BatchInsert(recs []*Record) []bool {
 	results := make([]bool, len(recs))
 	for i, rec := range recs {
 		results[i] = sm.insert(rec.Key, rec.Val)

insertsort.go

@@ -2,13 +2,12 @@ package sortedmap
 
 import "sort"
 
-func (sm *SortedMap) insertSort(key string, val interface{}) []string {
+func (sm *SortedMap) insertSort(key, val interface{}) []interface{} {
 	smLen := len(sm.sorted)
 	if smLen == 0 {
-		return []string{key}
+		return []interface{}{key}
 	}
-	i := sort.Search(smLen, func(i int) bool {
+	return insertInterface(sm.sorted, key, sort.Search(smLen, func(i int) bool {
 		return sm.lessFn(val, sm.idx[sm.sorted[i]])
-	})
-	return insertString(sm.sorted, i, key)
+	}))
 }

replace.go

@@ -1,6 +1,6 @@
 package sortedmap
 
-func (sm *SortedMap) replace(key string, val interface{}) {
+func (sm *SortedMap) replace(key, val interface{}) {
 	if _, ok := sm.idx[key]; ok {
 	    sm.delete(key)
     }
@@ -10,13 +10,13 @@ func (sm *SortedMap) replace(key string, val interface{}) {
 
 // Replace uses the provided 'less than' function to insert sort.
 // Even if the key already exists, the value will be inserted. Use Insert for the alternative functionality.
-func (sm *SortedMap) Replace(key string, val interface{}) {
+func (sm *SortedMap) Replace(key, val interface{}) {
 	sm.replace(key, val)
 }
 
 // BatchReplace adds all given records to the collection.
 // Even if a key already exists, the value will be inserted. Use BatchInsert for the alternative functionality.	
-func (sm *SortedMap) BatchReplace(recs ...*Record) {
+func (sm *SortedMap) BatchReplace(recs []*Record) {
 	for _, rec := range recs {
 		sm.replace(rec.Key, rec.Val)
 	}

sliceutils.go

@@ -1,16 +1,16 @@
 package sortedmap
 
-func insertString(s []string, i int, str string) []string {
-	s = append(s, "")
+func insertInterface(s []interface{}, v interface{}, i int) []interface{} {
+	s = append(s, nil)
 	copy(s[i + 1:], s[i:])
-	s[i] = str
+	s[i] = v
 
 	return s
 }
 
-func deleteString(s []string, i int) []string {
+func deleteInterface(s []interface{}, i int) []interface{} {
 	copy(s[i:], s[i + 1:])
-	s[len(s) - 1] = ""
+	s[len(s) - 1] = nil
 
 	return s[:len(s) - 1]
 }