1 files changed, 412 insertions, 0 deletions
diff --git a/common/value.go b/common/value.go
new file mode 100644
index 000000000..c3893d565
--- /dev/null
+++ b/common/value.go
@@ -0,0 +1,412 @@
+package common
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"math/big"
+	"reflect"
+	"strconv"
+
+	"github.com/ethereum/go-ethereum/rlp"
+)
+
+// 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)
+}
+
+func NewValue(val interface{}) *Value {
+	t := val
+	if v, ok := val.(*Value); ok {
+		t = v.Val
+	}
+
+	return &Value{Val: t}
+}
+
+func (val *Value) Type() reflect.Kind {
+	return reflect.TypeOf(val.Val).Kind()
+}
+
+func (val *Value) IsNil() bool {
+	return val.Val == nil
+}
+
+func (val *Value) Len() int {
+	if data, ok := val.Val.([]interface{}); ok {
+		return len(data)
+	}
+
+	return len(val.Bytes())
+}
+
+func (val *Value) Uint() uint64 {
+	if Val, ok := val.Val.(uint8); ok {
+		return uint64(Val)
+	} else if Val, ok := val.Val.(uint16); ok {
+		return uint64(Val)
+	} else if Val, ok := val.Val.(uint32); ok {
+		return uint64(Val)
+	} else if Val, ok := val.Val.(uint64); ok {
+		return Val
+	} else if Val, ok := val.Val.(float32); ok {
+		return uint64(Val)
+	} else if Val, ok := val.Val.(float64); ok {
+		return uint64(Val)
+	} else if Val, ok := val.Val.(int); ok {
+		return uint64(Val)
+	} else if Val, ok := val.Val.(uint); ok {
+		return uint64(Val)
+	} else if Val, ok := val.Val.([]byte); ok {
+		return new(big.Int).SetBytes(Val).Uint64()
+	} else if Val, ok := val.Val.(*big.Int); ok {
+		return Val.Uint64()
+	}
+
+	return 0
+}
+
+func (val *Value) Int() int64 {
+	if Val, ok := val.Val.(int8); ok {
+		return int64(Val)
+	} else if Val, ok := val.Val.(int16); ok {
+		return int64(Val)
+	} else if Val, ok := val.Val.(int32); ok {
+		return int64(Val)
+	} else if Val, ok := val.Val.(int64); ok {
+		return Val
+	} else if Val, ok := val.Val.(int); ok {
+		return int64(Val)
+	} else if Val, ok := val.Val.(float32); ok {
+		return int64(Val)
+	} else if Val, ok := val.Val.(float64); ok {
+		return int64(Val)
+	} else if Val, ok := val.Val.([]byte); ok {
+		return new(big.Int).SetBytes(Val).Int64()
+	} else if Val, ok := val.Val.(*big.Int); ok {
+		return Val.Int64()
+	} else if Val, ok := val.Val.(string); ok {
+		n, _ := strconv.Atoi(Val)
+		return int64(n)
+	}
+
+	return 0
+}
+
+func (val *Value) Byte() byte {
+	if Val, ok := val.Val.(byte); ok {
+		return Val
+	}
+
+	return 0x0
+}
+
+func (val *Value) BigInt() *big.Int {
+	if a, ok := val.Val.([]byte); ok {
+		b := new(big.Int).SetBytes(a)
+
+		return b
+	} else if a, ok := val.Val.(*big.Int); ok {
+		return a
+	} else if a, ok := val.Val.(string); ok {
+		return Big(a)
+	} else {
+		return big.NewInt(int64(val.Uint()))
+	}
+
+	return big.NewInt(0)
+}
+
+func (val *Value) Str() string {
+	if a, ok := val.Val.([]byte); ok {
+		return string(a)
+	} else if a, ok := val.Val.(string); ok {
+		return a
+	} else if a, ok := val.Val.(byte); ok {
+		return string(a)
+	}
+
+	return ""
+}
+
+func (val *Value) Bytes() []byte {
+	if a, ok := val.Val.([]byte); ok {
+		return a
+	} else if s, ok := val.Val.(byte); ok {
+		return []byte{s}
+	} else if s, ok := val.Val.(string); ok {
+		return []byte(s)
+	} else if s, ok := val.Val.(*big.Int); ok {
+		return s.Bytes()
+	} else {
+		return big.NewInt(val.Int()).Bytes()
+	}
+
+	return []byte{}
+}
+
+func (val *Value) Err() error {
+	if err, ok := val.Val.(error); ok {
+		return err
+	}
+
+	return nil
+}
+
+func (val *Value) Slice() []interface{} {
+	if d, ok := val.Val.([]interface{}); ok {
+		return d
+	}
+
+	return []interface{}{}
+}
+
+func (val *Value) SliceFrom(from int) *Value {
+	slice := val.Slice()
+
+	return NewValue(slice[from:])
+}
+
+func (val *Value) SliceTo(to int) *Value {
+	slice := val.Slice()
+
+	return NewValue(slice[:to])
+}
+
+func (val *Value) SliceFromTo(from, to int) *Value {
+	slice := val.Slice()
+
+	return NewValue(slice[from:to])
+}
+
+// TODO More type checking methods
+func (val *Value) IsSlice() bool {
+	return val.Type() == reflect.Slice
+}
+
+func (val *Value) IsStr() bool {
+	return val.Type() == reflect.String
+}
+
+func (self *Value) IsErr() bool {
+	_, ok := self.Val.(error)
+	return ok
+}
+
+// Special list checking function. Something is considered
+// a list if it's of type []interface{}. The list is usually
+// used in conjunction with rlp decoded streams.
+func (val *Value) IsList() bool {
+	_, ok := val.Val.([]interface{})
+
+	return ok
+}
+
+func (val *Value) IsEmpty() bool {
+	return val.Val == nil || ((val.IsSlice() || val.IsStr()) && val.Len() == 0)
+}
+
+// Threat the value as a slice
+func (val *Value) Get(idx int) *Value {
+	if d, ok := val.Val.([]interface{}); ok {
+		// Guard for oob
+		if len(d) <= idx {
+			return NewValue(nil)
+		}
+
+		if idx < 0 {
+			return NewValue(nil)
+		}
+
+		return NewValue(d[idx])
+	}
+
+	// If this wasn't a slice you probably shouldn't be using this function
+	return NewValue(nil)
+}
+
+func (self *Value) Copy() *Value {
+	switch val := self.Val.(type) {
+	case *big.Int:
+		return NewValue(new(big.Int).Set(val))
+	case []byte:
+		return NewValue(CopyBytes(val))
+	default:
+		return NewValue(self.Val)
+	}
+
+	return nil
+}
+
+func (val *Value) Cmp(o *Value) bool {
+	return reflect.DeepEqual(val.Val, o.Val)
+}
+
+func (self *Value) DeepCmp(o *Value) bool {
+	return bytes.Compare(self.Bytes(), o.Bytes()) == 0
+}
+
+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
+}
+
+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 {
+		if err := rlp.DecodeBytes(data, v); err != nil {
+			v.Val = nil
+		}
+	}
+	return v
+}
+
+// Value setters
+func NewSliceValue(s interface{}) *Value {
+	list := EmptyValue()
+
+	if s != nil {
+		if slice, ok := s.([]interface{}); ok {
+			for _, val := range slice {
+				list.Append(val)
+			}
+		} else if slice, ok := s.([]string); ok {
+			for _, val := range slice {
+				list.Append(val)
+			}
+		}
+	}
+
+	return list
+}
+
+func EmptyValue() *Value {
+	return NewValue([]interface{}{})
+}
+
+func (val *Value) AppendList() *Value {
+	list := EmptyValue()
+	val.Val = append(val.Slice(), list)
+
+	return list
+}
+
+func (val *Value) Append(v interface{}) *Value {
+	val.Val = append(val.Slice(), v)
+
+	return val
+}
+
+const (
+	valOpAdd = iota
+	valOpDiv
+	valOpMul
+	valOpPow
+	valOpSub
+)
+
+// Math stuff
+func (self *Value) doOp(op int, other interface{}) *Value {
+	left := self.BigInt()
+	right := NewValue(other).BigInt()
+
+	switch op {
+	case valOpAdd:
+		self.Val = left.Add(left, right)
+	case valOpDiv:
+		self.Val = left.Div(left, right)
+	case valOpMul:
+		self.Val = left.Mul(left, right)
+	case valOpPow:
+		self.Val = left.Exp(left, right, Big0)
+	case valOpSub:
+		self.Val = left.Sub(left, right)
+	}
+
+	return self
+}
+
+func (self *Value) Add(other interface{}) *Value {
+	return self.doOp(valOpAdd, other)
+}
+
+func (self *Value) Sub(other interface{}) *Value {
+	return self.doOp(valOpSub, other)
+}
+
+func (self *Value) Div(other interface{}) *Value {
+	return self.doOp(valOpDiv, other)
+}
+
+func (self *Value) Mul(other interface{}) *Value {
+	return self.doOp(valOpMul, other)
+}
+
+func (self *Value) Pow(other interface{}) *Value {
+	return self.doOp(valOpPow, other)
+}
+
+type ValueIterator struct {
+	value        *Value
+	currentValue *Value
+	idx          int
+}
+
+func (val *Value) NewIterator() *ValueIterator {
+	return &ValueIterator{value: val}
+}
+
+func (it *ValueIterator) Len() int {
+	return it.value.Len()
+}
+
+func (it *ValueIterator) Next() bool {
+	if it.idx >= it.value.Len() {
+		return false
+	}
+
+	it.currentValue = it.value.Get(it.idx)
+	it.idx++
+
+	return true
+}
+
+func (it *ValueIterator) Value() *Value {
+	return it.currentValue
+}
+
+func (it *ValueIterator) Idx() int {
+	return it.idx - 1
+}