refactored keyspace Adjusted -> Bytes

routing/kbucket/util.go

@@ -25,8 +25,8 @@ func (id ID) equal(other ID) bool {
 }
 
 func (id ID) less(other ID) bool {
-	a := ks.Key{Space: ks.XORKeySpace, Adjusted: id}
-	b := ks.Key{Space: ks.XORKeySpace, Adjusted: other}
+	a := ks.Key{Space: ks.XORKeySpace, Bytes: id}
+	b := ks.Key{Space: ks.XORKeySpace, Bytes: other}
 	return a.Less(b)
 }
 

routing/keyspace/keyspace.go

@@ -8,7 +8,7 @@ import (
 
 // Key represents an identifier in a KeySpace. It holds a reference to the
 // associated KeySpace, as well references to both the Original identifier,
-// as well as the new, KeySpace Adjusted one.
+// as well as the new, KeySpace Bytes one.
 type Key struct {
 
 	// Space is the KeySpace this Key is related to.
@@ -17,8 +17,8 @@ type Key struct {
 	// Original is the original value of the identifier
 	Original []byte
 
-	// Adjusted is the new value of the identifier, in the KeySpace.
-	Adjusted []byte
+	// Bytes is the new value of the identifier, in the KeySpace.
+	Bytes []byte
 }
 
 // Equal returns whether this key is equal to another.

routing/keyspace/xor.go

@@ -21,19 +21,19 @@ func (s *xorKeySpace) Key(id []byte) Key {
 	return Key{
 		Space:    s,
 		Original: id,
-		Adjusted: key,
+		Bytes:    key,
 	}
 }
 
 // Equal returns whether keys are equal in this key space
 func (s *xorKeySpace) Equal(k1, k2 Key) bool {
-	return bytes.Equal(k1.Adjusted, k2.Adjusted)
+	return bytes.Equal(k1.Bytes, k2.Bytes)
 }
 
 // Distance returns the distance metric in this key space
 func (s *xorKeySpace) Distance(k1, k2 Key) *big.Int {
 	// XOR the keys
-	k3 := XOR(k1.Adjusted, k2.Adjusted)
+	k3 := XOR(k1.Bytes, k2.Bytes)
 
 	// interpret it as an integer
 	dist := big.NewInt(0).SetBytes(k3)
@@ -42,8 +42,8 @@ func (s *xorKeySpace) Distance(k1, k2 Key) *big.Int {
 
 // Less returns whether the first key is smaller than the second.
 func (s *xorKeySpace) Less(k1, k2 Key) bool {
-	a := k1.Adjusted
-	b := k2.Adjusted
+	a := k1.Bytes
+	b := k2.Bytes
 	for i := 0; i < len(a); i++ {
 		if a[i] != b[i] {
 			return a[i] < b[i]

routing/keyspace/xor_test.go

@@ -69,16 +69,16 @@ func TestXorKeySpace(t *testing.T) {
 			t.Errorf("Key not eq. %v != %v", set[0], set[1])
 		}
 
-		if !bytes.Equal(set[0].Adjusted, set[1].Adjusted) {
-			t.Errorf("Key gen failed. %v != %v", set[0].Adjusted, set[1].Adjusted)
+		if !bytes.Equal(set[0].Bytes, set[1].Bytes) {
+			t.Errorf("Key gen failed. %v != %v", set[0].Bytes, set[1].Bytes)
 		}
 
 		if !bytes.Equal(set[0].Original, ids[i]) {
 			t.Errorf("ptrs to original. %v != %v", set[0].Original, ids[i])
 		}
 
-		if len(set[0].Adjusted) != 32 {
-			t.Errorf("key length incorrect. 32 != %d", len(set[0].Adjusted))
+		if len(set[0].Bytes) != 32 {
+			t.Errorf("key length incorrect. 32 != %d", len(set[0].Bytes))
 		}
 	}
 
@@ -110,7 +110,7 @@ func TestDistancesAndCenterSorting(t *testing.T) {
 
 	keys := make([]Key, len(adjs))
 	for i, a := range adjs {
-		keys[i] = Key{Space: XORKeySpace, Adjusted: a}
+		keys[i] = Key{Space: XORKeySpace, Bytes: a}
 	}
 
 	cmp := func(a int, b *big.Int) int {
@@ -126,8 +126,8 @@ func TestDistancesAndCenterSorting(t *testing.T) {
 	}
 
 	d1 := keys[2].Distance(keys[5])
-	d2 := XOR(keys[2].Adjusted, keys[5].Adjusted)
-	d2 = d2[len(keys[2].Adjusted)-len(d1.Bytes()):] // skip empty space for big
+	d2 := XOR(keys[2].Bytes, keys[5].Bytes)
+	d2 = d2[len(keys[2].Bytes)-len(d1.Bytes()):] // skip empty space for big
 	if !bytes.Equal(d1.Bytes(), d2) {
 		t.Errorf("bytes should be the same. %v == %v", d1.Bytes(), d2)
 	}
@@ -139,7 +139,7 @@ func TestDistancesAndCenterSorting(t *testing.T) {
 	keys2 := SortByDistance(XORKeySpace, keys[2], keys)
 	order := []int{2, 3, 4, 5, 1, 0}
 	for i, o := range order {
-		if !bytes.Equal(keys[o].Adjusted, keys2[i].Adjusted) {
+		if !bytes.Equal(keys[o].Bytes, keys2[i].Bytes) {
 			t.Errorf("order is wrong. %d?? %v == %v", o, keys[o], keys2[i])
 		}
 	}