From 4f12f0697e645a567fac9f13ed8cdb25e1218b84 Mon Sep 17 00:00:00 2001
From: Felix Lange <fjl@twurst.com>
Date: Tue, 9 Dec 2014 10:39:39 +0100
Subject: [PATCH] rlp: move decoder type switch to decode.go
---
rlp/decode.go | 33 +++++++++++++++++++++++++++++++++
rlp/typecache.go | 35 +++--------------------------------
2 files changed, 36 insertions(+), 32 deletions(-)
diff --git a/rlp/decode.go b/rlp/decode.go
index 7d95af02b..7acbbfa0d 100644
--- a/rlp/decode.go
+++ b/rlp/decode.go
@@ -81,6 +81,39 @@ func (err decodeError) Error() string {
return fmt.Sprintf("rlp: %s for %v", err.msg, err.typ)
}
+var (
+ decoderInterface = reflect.TypeOf(new(Decoder)).Elem()
+ bigInt = reflect.TypeOf(big.Int{})
+)
+
+func makeDecoder(typ reflect.Type) (dec decoder, err error) {
+ kind := typ.Kind()
+ switch {
+ case typ.Implements(decoderInterface):
+ return decodeDecoder, nil
+ case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(decoderInterface):
+ return decodeDecoderNoPtr, nil
+ case typ.AssignableTo(reflect.PtrTo(bigInt)):
+ return decodeBigInt, nil
+ case typ.AssignableTo(bigInt):
+ return decodeBigIntNoPtr, nil
+ case isInteger(kind):
+ return makeNumDecoder(typ), nil
+ case kind == reflect.String:
+ return decodeString, nil
+ case kind == reflect.Slice || kind == reflect.Array:
+ return makeListDecoder(typ)
+ case kind == reflect.Struct:
+ return makeStructDecoder(typ)
+ case kind == reflect.Ptr:
+ return makePtrDecoder(typ)
+ case kind == reflect.Interface && typ.NumMethod() == 0:
+ return decodeInterface, nil
+ default:
+ return nil, fmt.Errorf("rlp: type %v is not RLP-serializable", typ)
+ }
+}
+
func makeNumDecoder(typ reflect.Type) decoder {
kind := typ.Kind()
switch {
diff --git a/rlp/typecache.go b/rlp/typecache.go
index 75dbb43c2..f2595dac8 100644
--- a/rlp/typecache.go
+++ b/rlp/typecache.go
@@ -1,8 +1,6 @@
package rlp
import (
- "fmt"
- "math/big"
"reflect"
"sync"
)
@@ -51,39 +49,12 @@ func cachedTypeInfo1(typ reflect.Type) (*typeinfo, error) {
return typeCache[typ], err
}
-var (
- decoderInterface = reflect.TypeOf(new(Decoder)).Elem()
- bigInt = reflect.TypeOf(big.Int{})
-)
-
func genTypeInfo(typ reflect.Type) (info *typeinfo, err error) {
info = new(typeinfo)
- kind := typ.Kind()
- switch {
- case typ.Implements(decoderInterface):
- info.decoder = decodeDecoder
- case kind != reflect.Ptr && reflect.PtrTo(typ).Implements(decoderInterface):
- info.decoder = decodeDecoderNoPtr
- case typ.AssignableTo(reflect.PtrTo(bigInt)):
- info.decoder = decodeBigInt
- case typ.AssignableTo(bigInt):
- info.decoder = decodeBigIntNoPtr
- case isInteger(kind):
- info.decoder = makeNumDecoder(typ)
- case kind == reflect.String:
- info.decoder = decodeString
- case kind == reflect.Slice || kind == reflect.Array:
- info.decoder, err = makeListDecoder(typ)
- case kind == reflect.Struct:
- info.decoder, err = makeStructDecoder(typ)
- case kind == reflect.Ptr:
- info.decoder, err = makePtrDecoder(typ)
- case kind == reflect.Interface && typ.NumMethod() == 0:
- info.decoder = decodeInterface
- default:
- err = fmt.Errorf("rlp: type %v is not RLP-serializable", typ)
+ if info.decoder, err = makeDecoder(typ); err != nil {
+ return nil, err
}
- return info, err
+ return info, nil
}
func isInteger(k reflect.Kind) bool {
--
GitLab