aboutsummaryrefslogtreecommitdiffstats
path: root/ethutil
diff options
context:
space:
mode:
Diffstat (limited to 'ethutil')
-rw-r--r--ethutil/rlp.go189
-rw-r--r--ethutil/trie.go70
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
-}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-05 21:28:13 +0800