Removed RlpValue in favour of Value
This commit is contained in:
obscuren
189
ethutil/rlp.go
189
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))))
|
||||
|
||||
@ -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
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user