Removed RlpValue in favour of Value

2 files changed, 9 insertions, 250 deletions

diff --git a/ethutil/rlp.go b/ethutil/rlp.go
index 0f88933b3..025d269a0 100644
--- a/ethutil/rlp.go
+++ b/ethutil/rlp.go
@@ -7,19 +7,8 @@ import (
 	_ "log"
 	_ "math"
 	"math/big"
-	"reflect"
 )
 
-///////////////////////////////////////
-type EthEncoder interface {
-	EncodeData(rlpData interface{}) []byte
-}
-type EthDecoder interface {
-	Get(idx int) *RlpValue
-}
-
-//////////////////////////////////////
-
 type RlpEncoder struct {
 	rlpData []byte
 }
@@ -33,180 +22,6 @@ func (coder *RlpEncoder) EncodeData(rlpData interface{}) []byte {
 	return Encode(rlpData)
 }
 
-// Data rlpValueutes are returned by the rlp decoder. The data rlpValueutes represents
-// one item within the rlp data structure. It's responsible for all the casting
-// It always returns something rlpValueid
-type RlpValue struct {
-	Value interface{}
-	kind  reflect.Value
-}
-
-func (rlpValue *RlpValue) String() string {
-	return fmt.Sprintf("%q", rlpValue.Value)
-}
-
-func Conv(rlpValue interface{}) *RlpValue {
-	return &RlpValue{Value: rlpValue, kind: reflect.ValueOf(rlpValue)}
-}
-
-func NewRlpValue(rlpValue interface{}) *RlpValue {
-	return &RlpValue{Value: rlpValue}
-}
-
-func (rlpValue *RlpValue) Type() reflect.Kind {
-	return reflect.TypeOf(rlpValue.Value).Kind()
-}
-
-func (rlpValue *RlpValue) IsNil() bool {
-	return rlpValue.Value == nil
-}
-
-func (rlpValue *RlpValue) Length() int {
-	//return rlpValue.kind.Len()
-	if data, ok := rlpValue.Value.([]interface{}); ok {
-		return len(data)
-	}
-
-	return 0
-}
-
-func (rlpValue *RlpValue) AsRaw() interface{} {
-	return rlpValue.Value
-}
-
-func (rlpValue *RlpValue) AsUint() uint64 {
-	if Value, ok := rlpValue.Value.(uint8); ok {
-		return uint64(Value)
-	} else if Value, ok := rlpValue.Value.(uint16); ok {
-		return uint64(Value)
-	} else if Value, ok := rlpValue.Value.(uint32); ok {
-		return uint64(Value)
-	} else if Value, ok := rlpValue.Value.(uint64); ok {
-		return Value
-	}
-
-	return 0
-}
-
-func (rlpValue *RlpValue) AsByte() byte {
-	if Value, ok := rlpValue.Value.(byte); ok {
-		return Value
-	}
-
-	return 0x0
-}
-
-func (rlpValue *RlpValue) AsBigInt() *big.Int {
-	if a, ok := rlpValue.Value.([]byte); ok {
-		b := new(big.Int)
-		b.SetBytes(a)
-		return b
-	}
-
-	return big.NewInt(0)
-}
-
-func (rlpValue *RlpValue) AsString() string {
-	if a, ok := rlpValue.Value.([]byte); ok {
-		return string(a)
-	} else if a, ok := rlpValue.Value.(string); ok {
-		return a
-	} else {
-		//panic(fmt.Sprintf("not string %T: %v", rlpValue.Value, rlpValue.Value))
-	}
-
-	return ""
-}
-
-func (rlpValue *RlpValue) AsBytes() []byte {
-	if a, ok := rlpValue.Value.([]byte); ok {
-		return a
-	}
-
-	return make([]byte, 0)
-}
-
-func (rlpValue *RlpValue) AsSlice() []interface{} {
-	if d, ok := rlpValue.Value.([]interface{}); ok {
-		return d
-	}
-
-	return []interface{}{}
-}
-
-func (rlpValue *RlpValue) AsSliceFrom(from int) *RlpValue {
-	slice := rlpValue.AsSlice()
-
-	return NewRlpValue(slice[from:])
-}
-
-func (rlpValue *RlpValue) AsSliceTo(to int) *RlpValue {
-	slice := rlpValue.AsSlice()
-
-	return NewRlpValue(slice[:to])
-}
-
-func (rlpValue *RlpValue) AsSliceFromTo(from, to int) *RlpValue {
-	slice := rlpValue.AsSlice()
-
-	return NewRlpValue(slice[from:to])
-}
-
-// Threat the rlpValueute as a slice
-func (rlpValue *RlpValue) Get(idx int) *RlpValue {
-	if d, ok := rlpValue.Value.([]interface{}); ok {
-		// Guard for oob
-		if len(d) <= idx {
-			return NewRlpValue(nil)
-		}
-
-		if idx < 0 {
-			panic("negative idx for Rlp Get")
-		}
-
-		return NewRlpValue(d[idx])
-	}
-
-	// If this wasn't a slice you probably shouldn't be using this function
-	return NewRlpValue(nil)
-}
-
-func (rlpValue *RlpValue) Cmp(o *RlpValue) bool {
-	return reflect.DeepEqual(rlpValue.Value, o.Value)
-}
-
-func (rlpValue *RlpValue) Encode() []byte {
-	return Encode(rlpValue.Value)
-}
-
-func NewRlpValueFromBytes(rlpData []byte) *RlpValue {
-	if len(rlpData) != 0 {
-		data, _ := Decode(rlpData, 0)
-		return NewRlpValue(data)
-	}
-
-	return NewRlpValue(nil)
-}
-
-// RlpValue value setters
-// An empty rlp value is always a list
-func EmptyRlpValue() *RlpValue {
-	return NewRlpValue([]interface{}{})
-}
-
-func (rlpValue *RlpValue) AppendList() *RlpValue {
-	list := EmptyRlpValue()
-	rlpValue.Value = append(rlpValue.AsSlice(), list)
-
-	return list
-}
-
-func (rlpValue *RlpValue) Append(v interface{}) *RlpValue {
-	rlpValue.Value = append(rlpValue.AsSlice(), v)
-
-	return rlpValue
-}
-
 /*
 func FromBin(data []byte) uint64 {
 	if len(data) == 0 {
@@ -351,8 +166,8 @@ func Encode(object interface{}) []byte {
 
 	if object != nil {
 		switch t := object.(type) {
-		case *RlpValue:
-			buff.Write(Encode(t.AsRaw()))
+		case *Value:
+			buff.Write(Encode(t.Raw()))
 		// Code dup :-/
 		case int:
 			buff.Write(Encode(big.NewInt(int64(t))))
diff --git a/ethutil/trie.go b/ethutil/trie.go
index 44d2d5774..0a3f73136 100644
--- a/ethutil/trie.go
+++ b/ethutil/trie.go
@@ -82,7 +82,12 @@ func (cache *Cache) Undo() {
 	}
 }
 
-// A (modified) Radix Trie implementation
+// A (modified) Radix Trie implementation. The Trie implements
+// a caching mechanism and will used cached values if they are
+// present. If a node is not present in the cache it will try to
+// fetch it from the database and store the cached value.
+// Please note that the data isn't persisted unless `Sync` is
+// explicitly called.
 type Trie struct {
 	Root interface{}
 	//db   Database
@@ -93,6 +98,7 @@ func NewTrie(db Database, Root interface{}) *Trie {
 	return &Trie{cache: NewCache(db), Root: Root}
 }
 
+// Save the cached value to the database.
 func (t *Trie) Sync() {
 	t.cache.Commit()
 }
@@ -157,20 +163,8 @@ func (t *Trie) GetNode(node interface{}) *Value {
 	} else if len(str) < 32 {
 		return NewValueFromBytes([]byte(str))
 	}
-	/*
-		else {
-			// Fetch the encoded node from the db
-			o, err := t.db.Get(n.Bytes())
-			if err != nil {
-				fmt.Println("Error InsertState", err)
-				return NewValue("")
-			}
 
-			return NewValueFromBytes(o)
-		}
-	*/
 	return t.cache.Get(n.Bytes())
-
 }
 
 func (t *Trie) UpdateState(node interface{}, key []int, value string) interface{} {
@@ -302,53 +296,3 @@ func (t *Trie) Copy() *Trie {
 
 	return trie
 }
-
-/*
- * Trie helper functions
- */
-// Helper function for printing out the raw contents of a slice
-func PrintSlice(slice []string) {
-	fmt.Printf("[")
-	for i, val := range slice {
-		fmt.Printf("%q", val)
-		if i != len(slice)-1 {
-			fmt.Printf(",")
-		}
-	}
-	fmt.Printf("]\n")
-}
-
-func PrintSliceT(slice interface{}) {
-	c := Conv(slice)
-	for i := 0; i < c.Length(); i++ {
-		val := c.Get(i)
-		if val.Type() == reflect.Slice {
-			PrintSliceT(val.AsRaw())
-		} else {
-			fmt.Printf("%q", val)
-			if i != c.Length()-1 {
-				fmt.Printf(",")
-			}
-		}
-	}
-}
-
-// RLP Decodes a node in to a [2] or [17] string slice
-func DecodeNode(data []byte) []string {
-	dec, _ := Decode(data, 0)
-	if slice, ok := dec.([]interface{}); ok {
-		strSlice := make([]string, len(slice))
-
-		for i, s := range slice {
-			if str, ok := s.([]byte); ok {
-				strSlice[i] = string(str)
-			}
-		}
-
-		return strSlice
-	} else {
-		fmt.Printf("It wasn't a []. It's a %T\n", dec)
-	}
-
-	return nil
-}