diff options
Diffstat (limited to 'common')
| -rw-r--r-- | common/rlp.go | 2 | ||||
| -rw-r--r-- | common/rlp_test.go | 28 | ||||
| -rw-r--r-- | common/value.go | 69 | ||||
| -rw-r--r-- | common/value_test.go | 2 |
4 files changed, 58 insertions, 43 deletions
diff --git a/common/rlp.go b/common/rlp.go index 602f13202..06ac410e9 100644 --- a/common/rlp.go +++ b/common/rlp.go @@ -112,7 +112,7 @@ func Encode(object interface{}) []byte { if object != nil { switch t := object.(type) { case *Value: - buff.Write(Encode(t.Raw())) + buff.Write(Encode(t.Val)) case RlpEncodable: buff.Write(Encode(t.RlpData())) // Code dup :-/ 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..c3893d565 100644 --- a/common/value.go +++ b/common/value.go @@ -3,18 +3,30 @@ 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 -type Value struct { - Val interface{} - kind reflect.Value -} +// 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{} } func (val *Value) String() string { return fmt.Sprintf("%x", val.Val) @@ -38,7 +50,6 @@ func (val *Value) IsNil() bool { } func (val *Value) Len() int { - //return val.kind.Len() if data, ok := val.Val.([]interface{}); ok { return len(data) } @@ -46,14 +57,6 @@ func (val *Value) Len() int { return len(val.Bytes()) } -func (val *Value) Raw() interface{} { - return val.Val -} - -func (val *Value) Interface() interface{} { - return val.Val -} - func (val *Value) Uint() uint64 { if Val, ok := val.Val.(uint8); ok { return uint64(Val) @@ -260,26 +263,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 diff --git a/common/value_test.go b/common/value_test.go index 09d37802d..38a0e9843 100644 --- a/common/value_test.go +++ b/common/value_test.go @@ -35,7 +35,7 @@ func (s *ValueSuite) TestValueTypes(c *checker.C) { c.Assert(str.Str(), checker.Equals, strExp) c.Assert(num.Uint(), checker.Equals, numExp) - c.Assert(NewValue(inter.Interface()).Cmp(NewValue(interExp)), checker.Equals, true) + c.Assert(NewValue(inter.Val).Cmp(NewValue(interExp)), checker.Equals, true) c.Assert(byt.Bytes(), checker.DeepEquals, bytExp) c.Assert(bigInt.BigInt(), checker.DeepEquals, bigExp) } |