mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-05-30 10:56:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove types.Result

Browse Source
This commit is contained in:
Anton Kaliaev
2017-11-22 17:44:39 -06:00
parent f01f2bbf3a
commit 91efacfabc
3 changed files with 59 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
types/code.go
View File

@@ -1,3 +1,37 @@
package types
var (
code2string = map[CodeType]string{
CodeType_InternalError: "Internal error",
CodeType_EncodingError: "Encoding error",
CodeType_BadNonce: "Error bad nonce",
CodeType_Unauthorized: "Unauthorized",
CodeType_InsufficientFunds: "Insufficient funds",
CodeType_UnknownRequest: "Unknown request",
CodeType_BaseDuplicateAddress: "Error (base) duplicate address",
CodeType_BaseEncodingError: "Error (base) encoding error",
CodeType_BaseInsufficientFees: "Error (base) insufficient fees",
CodeType_BaseInsufficientFunds: "Error (base) insufficient funds",
CodeType_BaseInsufficientGasPrice: "Error (base) insufficient gas price",
CodeType_BaseInvalidInput: "Error (base) invalid input",
CodeType_BaseInvalidOutput: "Error (base) invalid output",
CodeType_BaseInvalidPubKey: "Error (base) invalid pubkey",
CodeType_BaseInvalidSequence: "Error (base) invalid sequence",
CodeType_BaseInvalidSignature: "Error (base) invalid signature",
CodeType_BaseUnknownAddress: "Error (base) unknown address",
CodeType_BaseUnknownPlugin: "Error (base) unknown plugin",
CodeType_BaseUnknownPubKey: "Error (base) unknown pubkey",
}
)
func (c CodeType) IsOK() bool { return c == CodeType_OK }
// HumanCode transforms code into a more humane format, such as "Internal error" instead of 0.
func HumanCode(code CodeType) string {
s, ok := code2string[code]
if !ok {
return "Unknown code"
}
return s
}

58
types/errors.go
View File

@@ -1,58 +0,0 @@
package types
var (
OK = NewResultOK(nil, "")
ErrInternalError = NewError(CodeType_InternalError, "Internal error")
ErrEncodingError = NewError(CodeType_EncodingError, "Encoding error")
ErrBadNonce = NewError(CodeType_BadNonce, "Error bad nonce")
ErrUnauthorized = NewError(CodeType_Unauthorized, "Unauthorized")
ErrInsufficientFunds = NewError(CodeType_InsufficientFunds, "Insufficient funds")
ErrUnknownRequest = NewError(CodeType_UnknownRequest, "Unknown request")
ErrBaseDuplicateAddress = NewError(CodeType_BaseDuplicateAddress, "Error (base) duplicate address")
ErrBaseEncodingError = NewError(CodeType_BaseEncodingError, "Error (base) encoding error")
ErrBaseInsufficientFees = NewError(CodeType_BaseInsufficientFees, "Error (base) insufficient fees")
ErrBaseInsufficientFunds = NewError(CodeType_BaseInsufficientFunds, "Error (base) insufficient funds")
ErrBaseInsufficientGasPrice = NewError(CodeType_BaseInsufficientGasPrice, "Error (base) insufficient gas price")
ErrBaseInvalidInput = NewError(CodeType_BaseInvalidInput, "Error (base) invalid input")
ErrBaseInvalidOutput = NewError(CodeType_BaseInvalidOutput, "Error (base) invalid output")
ErrBaseInvalidPubKey = NewError(CodeType_BaseInvalidPubKey, "Error (base) invalid pubkey")
ErrBaseInvalidSequence = NewError(CodeType_BaseInvalidSequence, "Error (base) invalid sequence")
ErrBaseInvalidSignature = NewError(CodeType_BaseInvalidSignature, "Error (base) invalid signature")
ErrBaseUnknownAddress = NewError(CodeType_BaseUnknownAddress, "Error (base) unknown address")
ErrBaseUnknownPlugin = NewError(CodeType_BaseUnknownPlugin, "Error (base) unknown plugin")
ErrBaseUnknownPubKey = NewError(CodeType_BaseUnknownPubKey, "Error (base) unknown pubkey")
code2string = map[CodeType]string{
CodeType_InternalError: "Internal error",
CodeType_EncodingError: "Encoding error",
CodeType_BadNonce: "Error bad nonce",
CodeType_Unauthorized: "Unauthorized",
CodeType_InsufficientFunds: "Insufficient funds",
CodeType_UnknownRequest: "Unknown request",
CodeType_BaseDuplicateAddress: "Error (base) duplicate address",
CodeType_BaseEncodingError: "Error (base) encoding error",
CodeType_BaseInsufficientFees: "Error (base) insufficient fees",
CodeType_BaseInsufficientFunds: "Error (base) insufficient funds",
CodeType_BaseInsufficientGasPrice: "Error (base) insufficient gas price",
CodeType_BaseInvalidInput: "Error (base) invalid input",
CodeType_BaseInvalidOutput: "Error (base) invalid output",
CodeType_BaseInvalidPubKey: "Error (base) invalid pubkey",
CodeType_BaseInvalidSequence: "Error (base) invalid sequence",
CodeType_BaseInvalidSignature: "Error (base) invalid signature",
CodeType_BaseUnknownAddress: "Error (base) unknown address",
CodeType_BaseUnknownPlugin: "Error (base) unknown plugin",
CodeType_BaseUnknownPubKey: "Error (base) unknown pubkey",
}
)
// HumanCode transforms code into a more humane format, such as "Internal error" instead of 0.
func HumanCode(code CodeType) string {
s, ok := code2string[code]
if !ok {
return "Unknown code"
}
return s
}

158
types/result.go
View File

@@ -6,107 +6,6 @@ import (
"github.com/tendermint/go-wire/data"
)
// Result is a common result object for ABCI calls.
// CONTRACT: a zero Result is OK.
// DEPRECATED: prefer raw types instead.
type Result struct {
Code CodeType `json:"code"`
Data data.Bytes `json:"data"`
Log string `json:"log"` // Can be non-deterministic
Tags []*KVPair `json:"tags"`
}
func NewResult(code CodeType, data []byte, log string) Result {
return Result{
Code: code,
Data: data,
Log: log,
}
}
func (res Result) IsOK() bool {
return res.Code == CodeType_OK
}
func (res Result) IsErr() bool {
return res.Code != CodeType_OK
}
func (res Result) IsSameCode(compare Result) bool {
return res.Code == compare.Code
}
func (res Result) Error() string {
return fmt.Sprintf("ABCI{code:%v, data:%X, log:%v}", res.Code, res.Data, res.Log)
}
func (res Result) String() string {
return fmt.Sprintf("ABCI{code:%v, data:%X, log:%v}", res.Code, res.Data, res.Log)
}
func (res Result) PrependLog(log string) Result {
return Result{
Code: res.Code,
Data: res.Data,
Log: log + ";" + res.Log,
}
}
func (res Result) AppendLog(log string) Result {
return Result{
Code: res.Code,
Data: res.Data,
Log: res.Log + ";" + log,
}
}
func (res Result) SetLog(log string) Result {
return Result{
Code: res.Code,
Data: res.Data,
Log: log,
}
}
func (res Result) SetData(data []byte) Result {
return Result{
Code: res.Code,
Data: data,
Log: res.Log,
}
}
//----------------------------------------
// NOTE: if data == nil and log == "", same as zero Result.
func NewResultOK(data []byte, log string) Result {
return Result{
Code: CodeType_OK,
Data: data,
Log: log,
}
}
func NewError(code CodeType, log string) Result {
return Result{
Code: code,
Log: log,
}
}
//----------------------------------------
// Convenience methods for turning the
// pb type into one using data.Bytes
// Convert ResponseCheckTx to standard Result
func (r *ResponseCheckTx) Result() Result {
return Result{
Code: r.Code,
Data: r.Data,
Log: r.Log,
}
}
// IsErr returns true if Code is something other than OK.
func (r ResponseCheckTx) IsErr() bool {
return r.Code != CodeType_OK
@@ -117,16 +16,6 @@ func (r ResponseCheckTx) Error() string {
return fmtError(r.Code, r.Log)
}
// Convert ResponseDeliverTx to standard Result
func (r *ResponseDeliverTx) Result() Result {
return Result{
Code: r.Code,
Data: r.Data,
Log: r.Log,
Tags: r.Tags,
}
}
// IsErr returns true if Code is something other than OK.
func (r ResponseDeliverTx) IsErr() bool {
return r.Code != CodeType_OK
@@ -137,28 +26,6 @@ func (r ResponseDeliverTx) Error() string {
return fmtError(r.Code, r.Log)
}
type ResultQuery struct {
Code CodeType `json:"code"`
Index int64 `json:"index"`
Key data.Bytes `json:"key"`
Value data.Bytes `json:"value"`
Proof data.Bytes `json:"proof"`
Height uint64 `json:"height"`
Log string `json:"log"`
}
func (r *ResponseQuery) Result() *ResultQuery {
return &ResultQuery{
Code: r.Code,
Index: r.Index,
Key: r.Key,
Value: r.Value,
Proof: r.Proof,
Height: r.Height,
Log: r.Log,
}
}
// IsErr returns true if Code is something other than OK.
func (r ResponseCommit) IsErr() bool {
return r.Code != CodeType_OK
@@ -177,3 +44,28 @@ func fmtError(code CodeType, log string) string {
return fmt.Sprintf("Unknown error (%v): %s", code, log)
}
}
// ResultQuery is a wrapper around ResponseQuery using data.Bytes instead of
// raw byte slices.
type ResultQuery struct {
Code CodeType `json:"code"`
Index int64 `json:"index"`
Key data.Bytes `json:"key"`
Value data.Bytes `json:"value"`
Proof data.Bytes `json:"proof"`
Height uint64 `json:"height"`
Log string `json:"log"`
}
// Result converts response query to ResultQuery.
func (r *ResponseQuery) Result() *ResultQuery {
return &ResultQuery{
Code: r.Code,
Index: r.Index,
Key: r.Key,
Value: r.Value,
Proof: r.Proof,
Height: r.Height,
Log: r.Log,
}
}