delete the unused (#323)

[bytom/vapor.git] / vendor / github.com / tendermint / go-wire / data / wrapper.go

diff --git a/vendor/github.com/tendermint/go-wire/data/wrapper.go b/vendor/github.com/tendermint/go-wire/data/wrapper.go
deleted file mode 100644 (file)
index 280ed89..0000000
--- a/vendor/github.com/tendermint/go-wire/data/wrapper.go
+++ /dev/null
@@ -1,88 +0,0 @@
-package data
-
-import "fmt"
-
-/*
-Mapper is the main entry point in the package.
-
-On init, you should call NewMapper() for each interface type you want
-to support flexible de-serialization, and then
-RegisterImplementation() in the init() function for each implementation of these
-interfaces.
-
-Note that unlike go-wire, you can call RegisterImplementation separately from
-different locations with each implementation, not all in one place.
-Just be careful not to use the same key or byte, of init will *panic*
-*/
-type Mapper struct {
-       *jsonMapper
-       *binaryMapper
-}
-
-// NewMapper creates a Mapper.
-//
-// If you have:
-//   type Foo interface {....}
-//   type FooS struct { Foo }
-// then you should pass in FooS{} in NewMapper, and implementations of Foo
-// in RegisterImplementation
-func NewMapper(base interface{}) Mapper {
-       return Mapper{
-               jsonMapper:   newJsonMapper(base),
-               binaryMapper: newBinaryMapper(base),
-       }
-}
-
-// RegisterImplementation should be called once for each implementation of the
-// interface that we wish to support.
-//
-// kind is the type string used in the json representation, while b is the
-// type byte used in the go-wire representation. data is one instance of this
-// concrete type, like Bar{}
-func (m Mapper) RegisterImplementation(data interface{}, kind string, b byte) Mapper {
-       m.jsonMapper.registerImplementation(data, kind, b)
-       m.binaryMapper.registerImplementation(data, kind, b)
-       return m
-}
-
-// ToText is a rather special-case serialization for cli, especially for []byte
-// interfaces
-//
-// It tries to serialize as json, and the result looks like:
-//   { "type": "string", "data": "string" }
-// Then it will return "<type>:<data>"
-//
-// Main usecase is serializing eg. crypto.PubKeyS as "ed25119:a1b2c3d4..."
-// for displaying in cli tools.
-//
-// It also supports encoding data.Bytes to a string using the proper codec
-// (or anything else that has a marshals to a string)
-func ToText(o interface{}) (string, error) {
-       d, err := ToJSON(o)
-       if err != nil {
-               return "", err
-       }
-
-       // try to recover as a string (data.Bytes case)
-       var s string
-       err = FromJSON(d, &s)
-       if err == nil {
-               return s, nil
-       }
-
-       // if not, then try to recover as an interface (crypto.*S case)
-       text := textEnv{}
-       err = FromJSON(d, &text)
-       if err != nil {
-               return "", err
-       }
-       res := fmt.Sprintf("%s:%s", text.Kind, text.Data)
-       return res, nil
-}
-
-// textEnv lets us parse an envelope if the data was output as string
-// (either text, or a serialized []byte)
-type textEnv struct {
-       Kind string `json:"type"`
-       Data string `json:"data"`
-}