From f7d1d601e92d3498f0fab5e80e5825d71f5d48fb Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Fri, 20 Mar 2015 11:45:45 +0100
Subject: common: make Value encodable with package rlp
Value.{Encode,Decode} are gone. It implements rlp.Encoder and rlp.Decoder
instead, so Value can be decoded into directly.
---
common/rlp_test.go | 28 +++++++++++++++------------
common/value.go | 55 ++++++++++++++++++++++++++++++++++++++----------------
2 files changed, 55 insertions(+), 28 deletions(-)
(limited to 'common')
diff --git a/common/rlp_test.go b/common/rlp_test.go
index 16a3553d7..2a55da928 100644
--- a/common/rlp_test.go
+++ b/common/rlp_test.go
@@ -5,6 +5,8 @@ import (
"math/big"
"reflect"
"testing"
+
+ "github.com/ethereum/go-ethereum/rlp"
)
func TestNonInterfaceSlice(t *testing.T) {
@@ -19,13 +21,16 @@ func TestNonInterfaceSlice(t *testing.T) {
func TestRlpValueEncoding(t *testing.T) {
val := EmptyValue()
- val.AppendList().Append(1).Append(2).Append(3)
- val.Append("4").AppendList().Append(5)
+ val.AppendList().Append(byte(1)).Append(byte(2)).Append(byte(3))
+ val.Append("4").AppendList().Append(byte(5))
- res := val.Encode()
+ res, err := rlp.EncodeToBytes(val)
+ if err != nil {
+ t.Fatalf("encode error: %v", err)
+ }
exp := Encode([]interface{}{[]interface{}{1, 2, 3}, "4", []interface{}{5}})
if bytes.Compare(res, exp) != 0 {
- t.Errorf("expected %q, got %q", res, exp)
+ t.Errorf("expected %x, got %x", exp, res)
}
}
@@ -57,9 +62,7 @@ func TestValueSlice(t *testing.T) {
func TestLargeData(t *testing.T) {
data := make([]byte, 100000)
enc := Encode(data)
- value := NewValue(enc)
- value.Decode()
-
+ value := NewValueFromBytes(enc)
if value.Len() != len(data) {
t.Error("Expected data to be", len(data), "got", value.Len())
}
@@ -133,15 +136,16 @@ func TestEncodeDecodeBigInt(t *testing.T) {
}
func TestEncodeDecodeBytes(t *testing.T) {
- b := NewValue([]interface{}{[]byte{1, 2, 3, 4, 5}, byte(6)})
- val := NewValueFromBytes(b.Encode())
- if !b.Cmp(val) {
- t.Errorf("Expected %v, got %v", val, b)
+ bv := NewValue([]interface{}{[]byte{1, 2, 3, 4, 5}, []byte{6}})
+ b, _ := rlp.EncodeToBytes(bv)
+ val := NewValueFromBytes(b)
+ if !bv.Cmp(val) {
+ t.Errorf("Expected %#v, got %#v", bv, val)
}
}
func TestEncodeZero(t *testing.T) {
- b := NewValue(0).Encode()
+ b, _ := rlp.EncodeToBytes(NewValue(0))
exp := []byte{0xc0}
if bytes.Compare(b, exp) == 0 {
t.Error("Expected", exp, "got", b)
diff --git a/common/value.go b/common/value.go
index 72a123772..f6150cb82 100644
--- a/common/value.go
+++ b/common/value.go
@@ -3,14 +3,29 @@ package common
import (
"bytes"
"fmt"
+ "io"
"math/big"
"reflect"
"strconv"
+
+ "github.com/ethereum/go-ethereum/rlp"
)
-// Data values are returned by the rlp decoder. The data values represents
-// one item within the rlp data structure. It's responsible for all the casting
-// It always returns something valid
+// Value can hold values of certain basic types and provides ways to
+// convert between types without bothering to check whether the
+// conversion is actually meaningful.
+//
+// It currently supports the following types:
+//
+// - int{,8,16,32,64}
+// - uint{,8,16,32,64}
+// - *big.Int
+// - []byte, string
+// - []interface{}
+//
+// Value is useful whenever you feel that Go's types limit your
+// ability to express yourself. In these situations, use Value and
+// forget about this strong typing nonsense.
type Value struct {
Val interface{}
kind reflect.Value
@@ -260,26 +275,34 @@ func (self *Value) DeepCmp(o *Value) bool {
return bytes.Compare(self.Bytes(), o.Bytes()) == 0
}
-func (val *Value) Encode() []byte {
- return Encode(val.Val)
+func (self *Value) DecodeRLP(s *rlp.Stream) error {
+ var v interface{}
+ if err := s.Decode(&v); err != nil {
+ return err
+ }
+ self.Val = v
+ return nil
}
-// Assume that the data we have is encoded
-func (self *Value) Decode() {
- v, _ := Decode(self.Bytes(), 0)
- self.Val = v
- //self.Val = DecodeWithReader(bytes.NewBuffer(self.Bytes()))
+func (self *Value) EncodeRLP(w io.Writer) error {
+ if self == nil {
+ w.Write(rlp.EmptyList)
+ return nil
+ } else {
+ return rlp.Encode(w, self.Val)
+ }
}
+// NewValueFromBytes decodes RLP data.
+// The contained value will be nil if data contains invalid RLP.
func NewValueFromBytes(data []byte) *Value {
+ v := new(Value)
if len(data) != 0 {
- value := NewValue(data)
- value.Decode()
-
- return value
+ if err := rlp.DecodeBytes(data, v); err != nil {
+ v.Val = nil
+ }
}
-
- return NewValue(nil)
+ return v
}
// Value setters
--
cgit v1.2.3